laws · eukhe · Tangled

Coding agent with a memory of all things

eukhe laws

1 folder · 79 files

at bend/stackfix

gildrb.com · Merge branch 'bend/p2-small' into bend/all · 2w ago

command laws: after a word that names a child, the rest of the line is pinned in every table (spaces, a child, or argument text and unknown words by the named entry's own flags)

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

approvals: each session's decision on a question decided by the compiled core (new approvals entry id 53)

auth_flight.bend

laws: flight_store_terms_exact (the store's accessors are its fields; a mutant Sto.fresh made flight_after_end_served vacuous)

aux_fallback.bend

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

laws: a Nat on the wire is its decimal digits (every entry); the command reply readers read the spelled reply grammar; every command answer but the malformed error comes from an input that begins with a request

stream: the tool output bounder's window, counts, store/drop/trim and notice run as compiled Bend (new bound entry id 76, a call and a Stepper); its Rust copy and bridge go

catalog_union.bend

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

codemode_id.bend

codemode: the identifier of a tool and the identifier test run as compiled Bend (new entry codemode_id id 260)

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

compactor: a line's steps and the failure cap run as compiled Bend (new compactor entry id 70); the Rust copy, its bridge and the law-covered tests go

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

dash_access.bend

laws: universal laws for long ports and capped waits, so --verdict runs to the end

dash_policy.bend

dashboard: the command policy and the Host/Origin checks run as the compiled core (entries 200 dash_policy, 201 dash_access)

dashboard: the pairing gate's choices run as the compiled core (new entry dash id 101)

default_model.bend

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

doc_commit.bend

docs: the writer's choices run as the compiled core (new entry doc_commit id 103)

glob: ranking and pages run as the compiled Bend core (entry 42 doc_glob)

laws: persist_writes_with_carry, edit_exact, load_holds_first_end (a fresh adversary's persist that started the carry from LF passed every doc_lines law)

durable: the retry note's text and a staged document's content and publication run as compiled Bend (new entries retry_note id 263, doc_plan id 264)

read: a gap marker before every span that does not start right after the one before (doc_rows)

doc_search.bend

laws: search_scope_rule (a fresh adversary's model scope that ignored directory roots passed every doc_search law, since the entry computes the scope inline)

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

docs: grep's tag choice for each shown file runs as the compiled core (new entry doc_tags id 102)

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

facts: the rulebook flags, adaptive thinking, the Bedrock effort and the tier price row run as compiled Bend (new model_facts entry id 71); the Rust copies and the facts bridge go

fsmode: the model's own terms are pinned (fsmode_socket_dir_exact, fsmode_safe_exact, fsmode_modes_exact): a blind adversary's socket_dir that ignored the owner passed socket_dir_owned through its own Seen.safe

gateway_answer.bend

gateway: what a settled event tells the phone runs as the compiled core (entry 202 gateway_answer)

gateway_backoff.bend

laws: universal laws for long ports and capped waits, so --verdict runs to the end

gateway_commands.bend

gateway: the phone commands parse as the compiled core (entry 205 gateway_commands)

gateway_width.bend

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

infer_force.bend

infer: the forced call, the repetition guard and early compaction run as compiled Bend (entries 73 infer_force, 74 infer_guard a Stepper, 75 infer_threshold); the Rust copies, bridge_infer and the law-covered tests go

infer_guard.bend

infer: the forced call, the repetition guard and early compaction run as compiled Bend (entries 73 infer_force, 74 infer_guard a Stepper, 75 infer_threshold); the Rust copies, bridge_infer and the law-covered tests go

infer_threshold.bend

infer: the forced call, the repetition guard and early compaction run as compiled Bend (entries 73 infer_force, 74 infer_guard a Stepper, 75 infer_threshold); the Rust copies, bridge_infer and the law-covered tests go

infer: the forced call, the repetition guard and early compaction run as compiled Bend (entries 73 infer_force, 74 infer_guard a Stepper, 75 infer_threshold); the Rust copies, bridge_infer and the law-covered tests go

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

kernel_local.bend

kernel_local, launcher: the models' own terms are pinned (kernel_terms_exact, kernel_sweep_terms_exact, launcher_adoption_exact), so the laws that read them say what they claim

kernel_local, launcher: the models' own terms are pinned (kernel_terms_exact, kernel_sweep_terms_exact, launcher_adoption_exact), so the laws that read them say what they claim

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

staging: runs as compiled Bend (ffi_staging, spec-speller entry laws); the Rust copy, its bridge and the law-covered tests go

log: the entry reads only numbers that fit the wire (log_ffi_reads_only_fitting_requests, log_stepper_reads_only_fitting_commits): a blind adversary read a 15-digit length

model_facts.bend

facts: the rulebook flags, adaptive thinking, the Bedrock effort and the tier price row run as compiled Bend (new model_facts entry id 71); the Rust copies and the facts bridge go

notice: runs as compiled Bend (ffi_notice, spec-speller entry laws); the Rust copy, its bridge and the law-covered tests go

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

path_policy.bend

approvals: nothing asks but a secret, like omp (default shell.autoEffects = read, write, exec, net, outside, protected; secret never grantable)

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

retry_note.bend

durable: the retry note's text and a staged document's content and publication run as compiled Bend (new entries retry_note id 263, doc_plan id 264)

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

laws: close the adversaries' gaps in revive, timeouts and auth_flight (the entries' freshness and values are the models', the refresh model's every step pinned)

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

runners: the ipython gate and the registry decided by the compiled core (new runners entry id 52)

laws: frames_verdict_serve_exact (a verdict serves its frame exactly when it is Serve; a fresh blind adversary's Verdict.serve of Duplicate and Kindless passed frames_admit_serves_accepted)

laws: scan_ffi_malformed_exact, scan_ffi_read_example, submission_ffi_malformed_exact, submission_ffi_read_example

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

selection: a copied line drops its trailing blanks wherever its soft wrap falls

semver: the entry reads only lengths and counts that fit the wire (semver_ffi_exact_fits), the gap a blind adversary found in the log entry

shell: the approval gate of a step decided by the compiled core (new shell entry id 50)

skill_load.bend

skill_load: the loaded list is pinned (skill_loaded_exact) and the membership the reporting law reads has witnesses (skill_in_first_example, skill_in_later_example): a blind adversary's empty membership made skill_failure_reported vacuous

slash_suggest.bend

slash commands: the suggestion for a mistyped name runs as the compiled core (entry 204 slash_suggest)

staging: runs as compiled Bend (ffi_staging, spec-speller entry laws); the Rust copy, its bridge and the law-covered tests go

submission.bend

laws: scan_ffi_malformed_exact, scan_ffi_read_example, submission_ffi_malformed_exact, submission_ffi_read_example

life: supervise timeouts, revival veto and auth flight decisions run as compiled Bend (new entries timeouts 90, revive 91, auth_flight 92); the Rust copies and the timeouts/revival bridges go

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

laws: close the adversaries' gaps in revive, timeouts and auth_flight (the entries' freshness and values are the models', the refresh model's every step pinned)

tiny: each choice of a process's worker election runs as the compiled core (new entry tiny_elect id 100)

laws: tokens_type_in_range (a fresh gap search passed type sizes past the largest font size a browser renders)

tool_surface.bend

tools: the schema the harness sends and what dyn reaches decided by the compiled core (new tool_surface entry id 51)

approvals: nothing asks but a secret, like omp (default shell.autoEffects = read, write, exec, net, outside, protected; secret never grantable)

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only

laws: a Nat on the wire is its decimal digits (every entry); the command reply readers read the spelled reply grammar; every command answer but the malformed error comes from an input that begins with a request

laws: one comment form, # LAW <name>: <plain words> (requirement ids and tags in parentheses after the name); comment lines only