From e2b4245b4800b1898220a312b7b254c1a8c25872 Mon Sep 17 00:00:00 2001 From: Rach Pradhan <54503978+justrach@users.noreply.github.com> Date: Thu, 16 Jul 2026 08:04:15 +0800 Subject: [PATCH 1/3] fix(agent): mid-turn compact gate fires on the server meter, not just the local estimate MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The #193 pre-send gate (inputOverCompactThreshold) trusted only the local byte/4 estimate (fullInputEstimateTokens). On codex/.responses that estimate structurally under-counts retained encrypted-reasoning items — they're billed large server-side but are compact base64 handles locally — so on a long single turn the local estimate stayed under the threshold while the server had already reported ~511k via last_context_tokens (refreshed mid-turn by recordUsageResponses). The next resend was then rejected for "input exceeds the context window" before any compaction ran — the gate had the right answer in hand and ignored it. The mid-turn gate now also trips on last_context_tokens — the same accurate server meter the between-turns gates (mainloop.zig:683/734) already trust: if (self.last_context_tokens >= threshold) return true; Supporting changes: - The #193 test builds Agent = undefined, so the new last_context_tokens read was uninitialized-memory UB; explicitly zero it and add a meter-only case that trips the gate with an empty local history. - fullInputEstimateTokens now falls back to the bytes counted so far on a serialize failure (catch return d.fullCount()/4) instead of a spurious 0, so a failed serialize can't blind the pre-send gate and the #202 meter floor at once. zig build clean; 195/195 unit + 19/19 REPL tests green. Co-authored-by: Codegraff --- src/agent_request.zig | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/src/agent_request.zig b/src/agent_request.zig index a2adf26..4014aa0 100644 --- a/src/agent_request.zig +++ b/src/agent_request.zig @@ -838,7 +838,11 @@ pub fn fullInputEstimateTokens(self: *Agent) u64 { var buf: [512]u8 = undefined; var d: Io.Writer.Discarding = .init(&buf); var s: std.json.Stringify = .{ .writer = &d.writer }; - s.write(Value{ .array = self.messages }) catch return 0; + // On a serialize failure, fall back to the bytes counted so far, never a + // spurious 0 — a 0 here would blind the pre-send gate (inputOverCompactThreshold) + // AND the #202 meter floor (recordUsageResponses) at once. The Discarding sink is + // infallible today so this catch is unreachable; it future-proofs a stricter sink. + s.write(Value{ .array = self.messages }) catch return d.fullCount() / 4; return d.fullCount() / 4; } @@ -853,6 +857,15 @@ pub fn fullInputEstimateTokens(self: *Agent) u64 { pub fn inputOverCompactThreshold(self: *Agent) bool { const threshold = self.provider.compactAt(); if (threshold == 0) return false; + // The server-reported meter (the same last_context_tokens the between-turns + // gates at mainloop.zig:683/734 already trust) is refreshed mid-turn by + // recordUsageResponses (agent_request.zig:905/924). On codex/.responses it can + // sit far above the local byte/4 estimate — retained encrypted-reasoning items + // are billed server-side but the local serialize under-counts them — so on a + // long turn it held ~511k while fullInputEstimateTokens stayed under the wall + // and the next resend was rejected for "input exceeds the context window" + // before any compaction ran. Trip a pre-send compact on the accurate meter too. + if (self.last_context_tokens >= threshold) return true; // #203: fullInputEstimateTokens omits the ever-present system prompt + tool // schemas, so it undercounts the real input and this gate under-fires. Add a // baseline for that fixed prefill, clamped to 1/8 of the window so it can never @@ -870,6 +883,7 @@ test "inputOverCompactThreshold (#193): local estimate gates a pre-send compact" var msgs = std.json.Array.init(a); var agent: Agent = undefined; agent.messages = msgs; + agent.last_context_tokens = 0; // the gate now reads this too; `= undefined` won't apply the field default // small window: compactAt() = 10_000/10*8 = 8_000 tokens ≈ 32_000 serialized bytes agent.provider = .{ .id = "codex", .kind = .responses, .auth = .bearer, .url = "", .api_key = "", .model = "gpt-5", .context = 10_000 }; try std.testing.expect(!inputOverCompactThreshold(&agent)); // empty history → under @@ -878,6 +892,12 @@ test "inputOverCompactThreshold (#193): local estimate gates a pre-send compact" try msgs.append(try std.json.parseFromSliceLeaky(Value, a, big, .{})); agent.messages = msgs; try std.testing.expect(inputOverCompactThreshold(&agent)); // burst → over → compact before send + // the server-reported meter alone trips the gate even with an empty local history — + // the codex mid-turn case where retained reasoning items undercount the byte/4 estimate + agent.messages = std.json.Array.init(a); + agent.last_context_tokens = agent.provider.compactAt(); + try std.testing.expect(inputOverCompactThreshold(&agent)); + agent.last_context_tokens = 0; // unknown window (context 0) never gates agent.provider.context = 0; try std.testing.expect(!inputOverCompactThreshold(&agent)); From 278e70428e54e20f423731fd397b8e0f195f353a Mon Sep 17 00:00:00 2001 From: Rach Pradhan <54503978+justrach@users.noreply.github.com> Date: Thu, 16 Jul 2026 15:17:41 +0800 Subject: [PATCH 2/3] release: prepare v0.0.205 --- .github/workflows/ci.yml | 6 + .gitignore | 1 + Agentic_Operating_System.md | 452 ++++++++++ graff-dgm.md | 166 ++++ phase2-escalation.md | 114 +++ scripts/check-zig-lines.sh | 25 + scripts/codex_ws_mock.py | 88 +- scripts/test-pty-codex-ws.py | 563 +++++++++++- scripts/test-pty-repl.py | 20 +- social/graff-launch-01-size.png | Bin 0 -> 2566987 bytes social/graff-launch-02-dogfood.png | Bin 0 -> 2506569 bytes social/graff-launch-02-learning.png | Bin 0 -> 2018904 bytes social/graff-launch-03-models-oauth.png | Bin 0 -> 1914271 bytes .../graff-launch-04-fanout-worktree-sdk.png | Bin 0 -> 1739037 bytes social/graff-launch-06-oauth.png | Bin 0 -> 2075262 bytes social/graff-launch-07-sdks.png | Bin 0 -> 2378587 bytes social/graff-launch-08-surfaces-cta.png | Bin 0 -> 2345244 bytes social/graff-launch-09-credits.png | Bin 0 -> 2383285 bytes socials/release-post/linkedin.md | 43 + socials/release-post/linkedin2.md | 61 ++ socials/release-post/twitter.md | 122 +++ src/agent.zig | 43 +- src/agent_compact.zig | 689 ++++----------- src/agent_compact_test.zig | 377 ++++++++ src/agent_context.zig | 461 ++++++++++ src/agent_eval.zig | 211 +++++ src/agent_request.zig | 816 ++---------------- src/agent_request_body.zig | 184 ++++ src/agent_request_policy.zig | 294 +++++++ src/agent_responses.zig | 162 ++++ src/agent_steps.zig | 53 +- src/agent_ws_test.zig | 103 +++ src/commands_misc.zig | 2 + src/commands_model.zig | 5 +- src/commands_session.zig | 4 + src/main.zig | 6 +- src/mainloop.zig | 158 +--- src/mainloop_score.zig | 112 +++ src/oauth.zig | 107 +-- src/oauth_helpers.zig | 107 +++ src/picker_auth.zig | 214 +++++ src/pickers.zig | 192 +---- src/pricing.zig | 30 +- src/provider.zig | 19 + src/providers.zig | 67 +- src/repl.zig | 468 +--------- src/repl_markdown.zig | 469 ++++++++++ src/repl_util.zig | 2 + src/session.zig | 122 ++- src/session_run.zig | 18 +- src/subagent.zig | 2 +- vision.md | 45 + 52 files changed, 4951 insertions(+), 2252 deletions(-) create mode 100644 Agentic_Operating_System.md create mode 100644 graff-dgm.md create mode 100644 phase2-escalation.md create mode 100755 scripts/check-zig-lines.sh create mode 100644 social/graff-launch-01-size.png create mode 100644 social/graff-launch-02-dogfood.png create mode 100644 social/graff-launch-02-learning.png create mode 100644 social/graff-launch-03-models-oauth.png create mode 100644 social/graff-launch-04-fanout-worktree-sdk.png create mode 100644 social/graff-launch-06-oauth.png create mode 100644 social/graff-launch-07-sdks.png create mode 100644 social/graff-launch-08-surfaces-cta.png create mode 100644 social/graff-launch-09-credits.png create mode 100644 socials/release-post/linkedin.md create mode 100644 socials/release-post/linkedin2.md create mode 100644 socials/release-post/twitter.md create mode 100644 src/agent_compact_test.zig create mode 100644 src/agent_context.zig create mode 100644 src/agent_eval.zig create mode 100644 src/agent_request_body.zig create mode 100644 src/agent_request_policy.zig create mode 100644 src/agent_responses.zig create mode 100644 src/agent_ws_test.zig create mode 100644 src/mainloop_score.zig create mode 100644 src/oauth_helpers.zig create mode 100644 src/picker_auth.zig create mode 100644 src/repl_markdown.zig create mode 100644 vision.md diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ca00ca7..7c00664 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -42,6 +42,9 @@ jobs: - name: zig fmt --check run: zig fmt --check src/main.zig src/mcp.zig build.zig + - name: Zig source size guard + run: bash scripts/check-zig-lines.sh + - name: zig build test run: zig build test --summary all @@ -60,6 +63,9 @@ jobs: - name: PTY model preference and fallback test run: python3 scripts/test-model-preference.py zig-out/bin/graff + - name: Codex WS/SSE transport and mid-turn compaction test + run: python3 scripts/test-pty-codex-ws.py zig-out/bin/graff + - name: Stream stall/drop is not a user Esc (#134/#132) run: python3 scripts/test-stall-drop.py zig-out/bin/graff diff --git a/.gitignore b/.gitignore index ad81a53..722dae9 100644 --- a/.gitignore +++ b/.gitignore @@ -27,6 +27,7 @@ __pycache__/ .wrangler/ # local agent/IDE config (not project source) +.codex/ .devin/ # release artifacts diff --git a/Agentic_Operating_System.md b/Agentic_Operating_System.md new file mode 100644 index 0000000..70d6d59 --- /dev/null +++ b/Agentic_Operating_System.md @@ -0,0 +1,452 @@ +# The Agentic Operating System +## From Generative AI to Autonomous Orchestration + +**Status:** Working architectural draft +**Scope:** A general framework for agent runtimes, grounded in Codegraff's current architecture +**Core claim:** The next useful abstraction is not “a chatbot with tools.” It is an operating system for agentic execution. + +--- + +## Abstract + +Large language models are powerful reasoning engines, but an LLM by itself is not an agent. A model call is stateless: it receives bytes, predicts bytes, and returns. Agency emerges only when that model is embedded inside a runtime that can preserve state, execute tools, observe results, recover from failure, manage memory, spawn workers, and improve its own behavior over time. + +This document calls that runtime an **Agentic Operating System** (**AOS**). + +An AOS is the layer that turns a passive model into an active computational process. It is responsible for converting human intent into coordinated action. In the same way that a traditional operating system turns CPU instructions into files, processes, devices, sockets, permissions, and persistence, an Agentic Operating System turns model intelligence into tasks, tool calls, subagents, traces, memory, evaluations, and self-improving behavioral policies. + +Codegraff is an early concrete example of this pattern. Its core agent loop, subagent/workflow system, tool and MCP layer, context compaction, trace files, trajectory archive, and Darwin-Gödel-style prompt evolution together form the skeleton of an AOS. + +--- + +## 1. Why the chatbot abstraction is too small + +The default interface for LLMs is still the chatbot: a user writes a message, the model writes a response. This is useful, but it hides the more important architectural question: **what is responsible for turning a response into progress?** + +A chatbot can suggest a command. An agentic runtime can run it, inspect the output, decide whether it succeeded, and continue. + +A chatbot can summarize a bug. An agentic runtime can search the repository, open the relevant files, patch the code, run tests, inspect failures, and retry. + +A chatbot can describe a plan. An agentic runtime can maintain that plan as live state, distribute pieces to subagents, merge their reports, and verify the result. + +The chatbot paradigm has four major constraints: + +1. **Statelessness** — The model does not persist state on its own. Conversation history is simulated state, not durable memory. +2. **Passivity** — The model cannot act unless an external runtime executes its tool-use intent. +3. **Linear context** — Long sessions eventually collide with the context window unless the runtime compacts, persists, or retrieves memory. +4. **No native self-improvement loop** — The model may produce better answers, but the runtime does not automatically preserve and redeploy better behaviors. + +An AOS addresses these constraints by making orchestration a first-class system responsibility. + +--- + +## 2. Definition: what an Agentic OS is and is not + +An **Agentic Operating System** is not the LLM itself. + +It is the runtime around the LLM that provides: + +- an execution loop, +- tool dispatch, +- state and memory management, +- process/subagent orchestration, +- permission boundaries, +- tracing and profiling, +- persistence and recovery, +- evaluation and scoring, +- and, eventually, self-modification. + +A concise definition: + +> An Agentic Operating System is a runtime that turns stateless model calls into persistent, tool-using, multi-process, self-profiling, self-improving computational agents. + +The LLM supplies cognition. The AOS supplies embodiment. + +```mermaid +flowchart LR + U[Human intent] --> AOS[Agentic Operating System] + AOS --> LLM[LLM / reasoning engine] + LLM --> AOS + AOS --> Tools[Tools, files, shell, browser, MCP] + Tools --> AOS + AOS --> Memory[Memory, trace, trajectory] + Memory --> AOS + AOS --> Result[Verified accomplishment] +``` + +--- + +## 3. Codegraff as an AOS case study + +Codegraff's design maps naturally onto operating-system concepts. + +| Traditional OS concept | Agentic OS concept | Codegraff example | +|---|---|---| +| Kernel | Agent execution loop | `Agent.runTurn` | +| Process | Agent instance | root agent or subagent | +| Child process | Isolated worker agent | `subagent`, `workflowTask` | +| Syscall | Tool call | `bash`, `read_file`, `edit_file`, MCP tools | +| Device driver | Tool/MCP adapter | built-in tools, `mcp.zig` | +| Scheduler | Workflow/fanout orchestration | `workflow`, parallel subagents | +| Memory manager | Context/history manager | compaction, session save/resume | +| Filesystem | Durable context substrate | repo files, `.harness/`, trace files | +| Profiler | Execution trace | `harness.trace.jsonl` | +| Process tree | Agent trajectory | `harness.trajectory.jsonl` | +| Program binary | Agent genome | system prompt / persona prompt | +| Package update | Fleet elite pull | `pullElites` | + +This framing matters because it gives us a vocabulary for improving agent systems. Instead of asking only “is the model smart enough?”, we can ask: + +- Is the scheduler good? +- Are tool results represented cleanly? +- Is memory stable and cheap? +- Are failures observable? +- Can the agent recover from transport errors? +- Can better policies be evaluated and promoted? +- Can we evolve specialized behaviors per niche and model class? + +Those are operating-system questions. + +--- + +## 4. The cognitive kernel + +The kernel of an AOS is the loop that repeatedly gives the model state, receives intent, executes that intent, observes the result, and continues until the task is complete. + +In Codegraff, this is structurally the `Agent` loop: + +1. Build a provider-specific request body from the current message history and tool schema. +2. Send the request to the model provider. +3. Parse the response. +4. If the response is final text, complete the turn. +5. If the response contains tool calls, execute them. +6. Append tool results to history. +7. Re-enter the loop. + +```mermaid +sequenceDiagram + participant User + participant Kernel as AOS Kernel / Agent.runTurn + participant Model as LLM Provider + participant Tools as Tool Layer + participant Trace as Trace / Trajectory + + User->>Kernel: objective + Kernel->>Trace: record user turn + + loop until final answer + Kernel->>Model: current state + tool schema + Model-->>Kernel: text or tool calls + Kernel->>Trace: record API call + + alt tool calls requested + Kernel->>Tools: execute selected tools + Tools-->>Kernel: observations / errors + Kernel->>Trace: record tool calls + Kernel->>Kernel: append observations to history + else final response + Kernel-->>User: result + end + end +``` + +This is why a single visible “answer” may require many hidden model calls. The user experiences one task. The kernel executes a state machine. + +--- + +## 5. Processes, subagents, and workflows + +A chatbot has one stream of thought. An AOS can spawn workers. + +In Codegraff, a subagent is not a magical separate species. It is the same `Agent` abstraction instantiated with: + +- a fresh arena, +- an empty history, +- a self-contained task prompt, +- an optional system-prompt override, +- inherited provider/client configuration, +- and restricted capabilities. + +That gives Codegraff a process model. + +```mermaid +graph TD + Root[Root agent] --> T1[Tool call] + Root --> S1[Subagent: reviewer] + Root --> S2[Subagent: researcher] + Root --> S3[Subagent: implementer] + + S1 --> R1[Report: risks / bugs] + S2 --> R2[Report: context / evidence] + S3 --> R3[Report: patch / implementation] + + R1 --> Merge[Root synthesizes] + R2 --> Merge + R3 --> Merge + Merge --> Final[Final answer / action] +``` + +This is a major reason smaller or cheaper models can appear more capable inside a good harness. The model does not need to hold every branch of reasoning in one context. The AOS can externalize work into isolated subprocesses and feed back only the useful reports. + +The tradeoff is overhead: subagents require additional model calls and duplicated context. So the scheduler matters. A good AOS should know when to fan out and when to stay single-threaded. + +--- + +## 6. Tools as peripherals + +An operating system is useful because it mediates access to devices. An Agentic OS is useful because it mediates access to tools. + +For an LLM, a tool call is only a prediction. The runtime must turn that prediction into action. + +Tool handling requires: + +- schema exposure, +- argument parsing, +- permission checks, +- execution, +- timeout handling, +- cancellation, +- result capture, +- error normalization, +- and history reinsertion. + +```mermaid +flowchart TD + Model[Model predicts tool call] --> Parser[Parse and validate arguments] + Parser --> Gate{Permission / policy gate} + Gate -->|allowed| Exec[Execute tool] + Gate -->|needs approval| Human[Ask user] + Human --> Exec + Gate -->|denied| Denied[Return denial observation] + Exec --> Result[Capture stdout / stderr / structured result] + Result --> History[Append observation to agent history] + Denied --> History +``` + +MCP extends this idea by making external tools look like standardized drivers. The AOS does not need to know every possible capability ahead of time. It needs a protocol for discovering and invoking capabilities safely. + +--- + +## 7. Memory architecture + +The LLM's context window is not memory. It is working memory. + +An AOS needs multiple memory tiers: + +| Tier | Role | Example | +|---|---|---| +| L1 working memory | Current prompt/history inside the model context | active messages | +| L2 session memory | Durable state for the current run | `last.session.json` | +| L3 trace memory | Profiling and debugging history | `harness.trace.jsonl` | +| L4 trajectory memory | Evolutionary lineage and scores | `harness.trajectory.jsonl` | +| L5 project/user memory | Cross-session task knowledge | proposed `.harness/memory/` | +| L6 fleet memory | Shared behavioral improvements | promoted personas/elites | + +```mermaid +graph TB + L1[L1: active context] --> C[Compaction] + C --> L2[L2: session summary] + L2 --> Resume[resume / restore] + + Agent[Agent runtime] --> Trace[L3: trace log] + Agent --> Traj[L4: trajectory archive] + Agent --> Project[L5: project memory] + + Traj --> Eval[Evaluation / scoring] + Eval --> Fleet[L6: fleet memory] + Fleet --> Agent +``` + +A key design rule from Codegraff's memory docs is that memory should not mutate the cached prefix every turn. Retrieved memory should enter as append-only context, usually through a tool result or user-turn appendage. That preserves provider KV-cache efficiency and avoids making every turn pay for a changing system prompt. + +--- + +## 8. Tracing, profiling, and self-debugging + +An AOS must be observable. If the agent is a process, then we need process telemetry. + +Codegraff writes a session trace to `harness.trace.jsonl`. The trace records API calls, tool calls, latency, byte counts, context token counts, and errors. This lets the agent inspect its own execution behavior. + +That creates a feedback loop: + +```mermaid +sequenceDiagram + participant Agent + participant Trace as harness.trace.jsonl + participant User + + Agent->>Trace: record API/tool events + User->>Agent: why did that stall? + Agent->>Trace: read recent events + Trace-->>Agent: latencies, result sizes, errors + Agent-->>User: diagnosis + fix +``` + +This is an important AOS property: the runtime gives the model evidence about its own behavior. Without that, the model can only guess why it failed. + +A practical note: trace integrity matters. If trace files become malformed or binary, the self-debugging loop fails. For an AOS, logs are not auxiliary. They are part of the cognitive substrate. + +--- + +## 9. The evolutionary layer: Darwin-Gödel agents + +The most interesting extension of the AOS idea is self-improvement. + +Traditional neural evolution, such as NEAT, evolves weights and topology. That becomes expensive at modern model scale because model weights are huge and evaluation is costly. + +An Agentic OS can move evolution to a cheaper layer: **the behavioral program around the model**. + +In Codegraff, the simplest genome is the system prompt or persona prompt. A prompt can be fingerprinted, archived, mutated, evaluated, scored, and promoted. + +```mermaid +graph LR + Seed[Seed persona / prompt] --> Mutate[Mutate prompt] + Mutate --> Child[Run child agent] + Child --> Judge[Replay judge / evaluator] + Judge --> Score[Signed score] + Score --> Archive[Trajectory archive] + Archive --> Select[Parent selection] + Select --> Mutate +``` + +The Darwin-Gödel framing has two sides: + +- **Darwinian search:** generate behavioral variants and keep the ones that perform better. +- **Gödelian self-modification:** make improvements explicit, durable, and redeployable as part of the agent's own operating logic. + +The crucial move is that we are not evolving billions of weights. We are evolving compact, high-level behavioral policies. + +--- + +## 10. Fleet evolution and MAP-Elites + +A single machine can evolve prompts locally, but a fleet can do something stronger. Every installation can generate and score variants during normal use. A central worker can aggregate only the cheap metadata: prompt hash, score, niche, provider class, eval-set hash, and signed provenance. + +The expensive inference stays with each user's provider. The central system does ranking, not reasoning. + +```mermaid +graph TD + I1[Install A] --> S1[Signed score + genome hash] + I2[Install B] --> S2[Signed score + genome hash] + I3[Install C] --> S3[Signed score + genome hash] + + S1 --> Worker[Fusion worker] + S2 --> Worker + S3 --> Worker + + Worker --> Group[Group by niche × provider_class × eval_set_hash] + Group --> Rank[Rank with confidence / LCB] + Rank --> Promote[Promote elite] + Promote --> Pull[Clients pull elite at startup] + Pull --> Better[Better built-in persona] +``` + +MAP-Elites prevents one global prompt from dominating every use case. Instead, the archive keeps separate champions per behavioral niche and model tier. + +Examples of niches: + +- reviewer, +- researcher, +- implementer, +- skeptic, +- debugging specialist, +- documentation writer, +- benchmark runner. + +This is the AOS equivalent of speciation in NEAT: protect useful specialization instead of forcing all innovations to compete in one undifferentiated population. + +--- + +## 11. NEAT to AOS: the conceptual bridge + +The NEAT paper is useful here because it explains why open-ended improvement needs more than naive mutation. + +| NEAT idea | AOS / Codegraff analogue | +|---|---| +| Genome | System prompt / persona / behavioral policy | +| Historical marking | Prompt fingerprint / lineage hash | +| Mutation | Prompt rewrite or policy change | +| Crossover | Future recombination of structured prompt/policy sections | +| Speciation | Niches, provider classes, eval-set cells | +| Fitness | Replay judge, tests, task success, efficiency | +| Innovation protection | Do not promote from one lucky score; aggregate by cell and confidence | +| Minimal start | Seed prompt, then incremental behavioral additions | +| Complexification | Evolve richer tool policies, memory policies, and workflows | + +The compute advantage comes from moving evolution upward. Instead of searching over model weights, the AOS searches over instructions, workflows, memory designs, and tool-use strategies. + +--- + +## 12. Failure modes and design cautions + +The AOS framing is powerful, but it also exposes real failure modes. + +### 12.1 Tool-output overload + +A broad search can return hundreds of thousands of bytes. If the runtime dumps all of that into context, the next model call may become slow, expensive, or unstable. A good AOS needs output caps, summarization, and search discipline. + +### 12.2 Weak or missing eval identity + +Evolution only works if scores are comparable. A score without a stable `eval_set_hash` is hard to aggregate. Fleet promotion should prefer pinned, deterministic evaluation suites over vague organic success signals. + +### 12.3 Prompt-only genomes may plateau + +Prompt mutation is a good base case, but eventually the genome should become structured: + +```text +genome = + prompt policy + tool-use policy + memory design + decomposition policy + verification policy + communication policy +``` + +Structured genomes make crossover and targeted mutation easier. + +### 12.4 Logs are part of cognition + +If traces are missing, malformed, or unreadable, the agent loses self-observation. Observability is not just a developer feature; it is part of the runtime's intelligence loop. + +### 12.5 The scheduler can waste intelligence + +Subagents are powerful but not free. Over-fanout burns tokens. Under-fanout overloads the root context. Scheduling policy is one of the core optimization surfaces for an AOS. + +--- + +## 13. Roadmap: from prompt evolution to full AOS evolution + +The base case is prompt evolution. The broader target is runtime evolution. + +A staged roadmap: + +1. **Prompt genome** — evolve system prompts/personas. +2. **Pinned evaluation** — require stable eval identities for promotable scores. +3. **Structured prompt genome** — split prompts into behavior sections. +4. **Tool policy genome** — evolve when and how tools are used. +5. **Memory design genome** — evolve retrieval/update policies. +6. **Scheduler genome** — evolve when to spawn subagents or workflows. +7. **Crossover** — recombine successful policies across lineages. +8. **Fleet promotion** — promote reliable elites per niche/model/eval cell. +9. **Self-hosted improvement** — let agents propose, test, and deploy runtime changes under strict evaluation gates. + +The long-term goal is not merely an agent that answers better. It is an execution environment that improves how agents are constructed. + +--- + +## 14. Conclusion + +The Agentic Operating System is the missing abstraction between raw model intelligence and real digital work. + +A model can reason. An AOS can execute. + +A model can propose. An AOS can verify. + +A model can remember within a context window. An AOS can persist, compact, retrieve, and resume. + +A model can be prompted. An AOS can evolve prompts, policies, workflows, and memory designs over time. + +This reframes the central question. The future is not only about larger models. It is also about better runtimes around models: kernels for cognition, schedulers for subagents, drivers for tools, filesystems for memory, profilers for self-observation, and evolutionary mechanisms for improvement. + +In that sense, Codegraff is not just a coding assistant. It is a prototype of an Agentic Operating System: a runtime where LLM cognition becomes persistent, inspectable, executable, and eventually self-improving. diff --git a/graff-dgm.md b/graff-dgm.md new file mode 100644 index 0000000..5dcd065 --- /dev/null +++ b/graff-dgm.md @@ -0,0 +1,166 @@ +# graff DGM — federated fleet evolution (read me) + +A map of how graff's self-improvement loop works end-to-end, what's wired right +now, the two repos it spans, and how to operate it. Working note for you — not +committed, not published. + +> One line: **thousands of installs generate + score prompt-persona variants +> during normal use; a central worker ranks them per (niche × model-tier × +> eval-suite) cell over signed scores with no central inference; the winner ships +> back to everyone as a better built-in persona.** Single-tenant DGM → federated +> DGM. Full design: `docs/hyperagents.md §9`. + +--- + +## The loop (A->E) + +| phase | who runs it | what happens | +|---|---|---| +| **A - Harvest** | every install (fleet on) | signed pinned-eval scores + variant fingerprints accumulate in D1 | +| **B - Propose** | the user's own provider | mine local failures -> mutate a niche's elite -> run the eval -> sign(score, eval_set_hash, provider_class) -> **submit** (the genome text rides along on `propose`) | +| **C - Rank** | central worker (SQL, no inference) | per cell: HMAC-verify, group by (niche x provider_class x eval_set_hash), K-install floor, Wilson LCB | +| **D - Promote** | central worker (cron / `POST /v1/promote`) | best-LCB candidate beats the incumbent by a margin -> flip `live=1` in `harness_elites`, emit `fleet:promote` | +| **E - Distribute** | graff startup | graff GETs `/v1/elites` for its tier; `loadAgentTypes` prefers a live champion's prompt over the baked built-in | + +The load-bearing rule: **"let the provider be me."** Every expensive step +(mutating, evaluating) runs on each user's own provider during their session. +Central infra does only cheap deterministic SQL. No central inference -> it runs +at fleet scale for free. **Task/user content never leaves the machine** - only +the genome (persona prompt text), the score float, `eval_set_hash`, +`provider_class`, and the deterministic eval artifact. + +--- + +## Where the code lives (two repos) + +| piece | repo / path | branch | +|---|---|---| +| **Harness** (CLI) - emits the signals, pulls elites | `~/codegraff` / `src/main.zig` | (local working tree) | +| **Backend** (Cloudflare worker) - ingest, stats, rank, promote, serve elites | `~/zigrepper/services/harness-telemetry` | `feat/agent-archive-and-tier` | + +The worker shares D1 (`codegraff-db`) with the trajectory/agent archive. `main` +of zigrepper is **pre-fleet**; all the fleet work is on +`feat/agent-archive-and-tier` (that's what's deployed). Backend edits in this +pass were made on an isolated **worktree** at `/tmp/htel-fleet-wt` so the +zigrepper `main` checkout (with its uncommitted `codedbpro/` changes) was never +touched. + +--- + +## What's wired now + +### Harness (`src/main.zig`) +- `Telemetry.fleetEvent(...)` -> OTLP `body:"fleet"` record with a `kind` attr - + **propose** (variant spawn, in `runSub`), **submit** (score write-back), + **elite_pull** (startup). Matches the SDK `_fleet_signal` byte-for-byte. +- `providerClass(model)` -> `frontier | mid | small`: a curated model-family + table, falling back to the models.dev output-price graff already carries. +- `pullElites(...)` at startup -> GET `/v1/elites?provider_class&eval_set_hash`, + emit `fleet:elite_pull`, override a niche's prompt with a live champion. +- **Genome-send (new):** `fleet:propose` now carries `prompt_text` (the persona + genome = the subagent's `sys_override`), capped at 8 KB. This is what lets the + backend ship a champion's prompt later. Submit/elite_pull send no text (the + genome is already stored, keyed by `prompt_sha`). +- `GRAFF_FLEET=off` env + `/fleet [on|off]` REPL command - a fleet opt-out + independent of the telemetry opt-out. Gates `fleetEvent` + `pullElites`. + +### Backend (`services/harness-telemetry/src/index.ts`) +- `POST /v1/logs` (OTLP ingest, queue-buffered) -> `unpack`: `session`-> + `harness_sessions`, `score`->`harness_scores` (with `provider_class`, + `eval_set_hash`, `niche`), everything else -> `harness_events`. +- **Genome capture (new):** a `fleet` record carrying `prompt_text` upserts + `harness_genomes(prompt_sha -> text)` - deduped, so the genome rides the wire + once per variant, not once per score. +- `GET /v1/stats` -> totals + per-suite leaderboards + the `fleet` block + (`proposes/submits/elite_pulls/promotes/live_cells`). +- `GET /v1/elites` -> live champions for a tier; falls back to best-mean + candidate per niche over the K-install floor when nothing's promoted yet. +- **Promote pass (new) - `runPromote()`:** the piece that was missing. Per cell, + over a trailing 7-day window, joins `harness_scores` -> `harness_genomes` + (only genomes we hold can ship), applies the K-install floor, ranks by + **Wilson LCB** of the mean score, and flips the winner `live=1` if it beats + the incumbent's LCB by the margin. Emits `fleet:promote`. Triggered by a + **cron** (`triggers.crons: ["0 */6 * * *"]`) and an admin **`POST /v1/promote`**. + +### Data model (D1) +- `harness_scores` - one row per score; carries `provider_class`, + `eval_set_hash`, `niche` (migration `0005`). +- `harness_genomes` - `prompt_sha -> prompt_text` (migration **`0006`**, new). +- `harness_elites` - one row per grid cell; `live=1` is the shipped champion. +- `harness_fleet_fitness` - view rolling scores up per cell with a distinct- + install count (the K-floor input). + +Knobs (in `index.ts`): `K_INSTALLS=3`, `MARGIN=0.02`, `WINDOW_DAYS=7`, `Z=1.96`. + +--- + +## How to operate it + +```bash +# Backend (on the worktree, or after merging feat/agent-archive-and-tier) +cd ~/zigrepper/services/harness-telemetry +npm run migrate:remote # applies 0003..0006 (adds harness_genomes) +npm run deploy # publishes the worker incl. the cron + /v1/promote +curl -XPOST https:///v1/promote # manual promote pass (or wait for cron) + +# Harness - opt out of fleet contribution for a run/session +GRAFF_FLEET=off graff ... # or /fleet off in the REPL +``` + +`POST /v1/promote` returns `{ evaluated, promoted: [...] }`. After a promote, +`/v1/stats` `promotes`/`live_cells` move and `/v1/elites` returns +`source:"promoted"` with `prompt_text`, which graff then prefers at startup. + +--- + +## What actually makes it evolve (current state) + +The signals flow and the counters climb, but a champion only emerges once the +feedback is **groupable + repeated**: + +1. **Pin `eval_set_hash` on every score.** Today organic scores are often + `eval_set_hash: null` -> they never form a cell. Route scoring through a fixed + suite (wire `--eval`/`--judge` to stamp a stable hash). *This is the remaining + harness lever.* +2. **Score each genome more than once** so the Wilson LCB has data (n=1 is + meaningless). +3. With (1)+(2), the 24+ installs accumulate per cell -> cross the K-floor -> + `runPromote` flips a champion -> it ships fleet-wide. + +Order of effect: pin the hash -> cells fill -> LCB tightens -> promote -> the +baked persona is superseded for that (niche, tier). + +--- + +## Defense stack (why the backend can decide unattended) + +1. **Signed, artifact-bound scores** - HMAC over the canonical message + (Step 0); with `SCORE_KEY` set, unsigned/forged rows are dropped on ingest. +2. **Sybil floor** - a cell promotes only with >=K distinct `install_id`s. +3. **LCB, not mean** - a 1.0 from 3 installs loses to a 0.95 from 4,000. +4. **Genome-gated** - only a genome we actually hold (`harness_genomes`) can be + promoted, so a champion always has shippable text. +5. **Reversible** - what ships is *a prompt*; demote = flip `live=0`. Keep a + "last N champions" changelog for one-tap revert. + +--- + +## Tests + +- **Harness unit** (`zig build test`): `providerClass` tiering + fleet OTLP + serialization. +- **Keyless e2e** (`scripts/e2e_fleet.sh` + `scripts/otlp_mock.py`): drives the + real binary against a capturing collector, asserts the emitted records. +- **Backend**: `tsc --noEmit` clean. For a live promote test: `npm run + migrate:local` + `wrangler dev`, seed >=3 installs of one pinned-hash genome, + `POST /v1/promote`, check `/v1/elites` returns `source:"promoted"`. + +--- + +## Status of this pass + +- Harness genome-send: **done**, builds + tests green (`~/codegraff`, uncommitted). +- Backend promote pass + genome store + cron + `0006` migration: **done**, + `tsc` clean (`/tmp/htel-fleet-wt`, uncommitted - review, then merge + `feat/agent-archive-and-tier` and deploy). +- Nothing committed or deployed. Remaining harness lever: pin `eval_set_hash`. diff --git a/phase2-escalation.md b/phase2-escalation.md new file mode 100644 index 0000000..bf23f8c --- /dev/null +++ b/phase2-escalation.md @@ -0,0 +1,114 @@ +# Phase 2, slice 1: Dynamic escalation / de-escalation (design) + +Working note, not committed. First slice of vision.md Phase 2 (the Smart +Router). Scope: failure-triggered tier promotion at subagent boundaries. +Explicitly NOT in this slice: mid-turn model switching, complexity +profiling, the cache-switching predictor. + +## Why this slice first + +- It is the smallest closed loop: run -> detect failure -> rerun one tier + up -> score both -> emit the trace. +- It sidesteps the Cache-Switching Paradox entirely. A subagent respawn is + a fresh context anyway, so there is no cache momentum to lose. Mid-turn + switching (the hard economic problem) waits until we have data. +- Its traces ARE the training data for the rest of Phase 2. The predictor + needs (task, tier, outcome, cost) tuples; nothing produces those today. + +## What exists to build on (all in src/main.zig unless noted) + +| piece | where | role in this slice | +|---|---|---| +| `runSub(ctx, kind, label, prompt, sys_override, niche)` | ~L15900 | the seam: every subagent + workflow task passes through it | +| `providerClass(model)` -> frontier/mid/small | main.zig (19 refs) | the tier ladder | +| pricing catalog | `src/pricing.zig` | cost of a retry, cost delta in the trace | +| fitness scores + `scoreVariants` | main.zig | the success/failure signal for eval'd runs | +| `Telemetry.fleetEvent` (propose/submit/elite_pull) | main.zig | pattern to copy for the new `escalate` event | +| `/effort`, `/fast`, `/fleet` REPL toggles | main.zig / repl.zig | pattern for `/escalate on|off` | + +## Design + +### Failure signal (v1, cheap and unambiguous) + +A subagent run counts as FAILED when any of: +1. the run errored (tool loop died, provider error after retries); +2. an eval/judge score exists for the run and is below `ESCALATE_FLOOR` + (default 0.5, matches the fleet score scale); +3. the run hit the turn cap without producing a result. + +No LLM-judge-of-everything in v1. If nothing scored the run and it did +not error, it is a success. Keep the signal deterministic so traces are +trustworthy. + +### Escalation rule + +- Ladder: small -> mid -> frontier (reuse `providerClass` ordering). +- On FAILED and tier < frontier and escalation enabled: rerun the same + `runSub` args once at the next tier up. One rung per failure, max one + retry per subagent (a frontier failure is just a failure). +- The rerun replaces the failed result for the caller; the failed + attempt still scores/submits as itself (its genome earned its score). + +### De-escalation rule (shadow, cheap) + +- Per (niche, tier): after `DEESCALATE_STREAK` (default 5) consecutive + successes at a tier, mark the niche "try one tier down next time". +- The downgraded run is live, not shadowed (shadowing doubles cost, which + is the thing we are minimizing). If it fails, the escalation rule + already catches it and the streak resets. Worst case cost = one cheap + failed attempt + the escalated rerun. + +### Telemetry: the `escalate` fleet event + +New `fleetEvent` kind `escalate`, emitted on every escalation AND every +deliberate de-escalated run: + +``` +{ kind: "escalate", niche, from_class, to_class, reason: "error"|"score"|"cap"|"deescalate", + failed_score, rerun_score, cost_delta_usd, ms_delta } +``` + +Same privacy posture as the rest of the fleet loop: no task content, no +prompt text; scores + tiers + deltas only. Backend just needs an events +passthrough (harness_events already captures unknown kinds; no migration). + +### Controls + +- `GRAFF_ESCALATE=off` env + `/escalate [on|off]` REPL command, mirroring + the `/fleet` pattern. Default: ON for subagents (it only ever spends + money to rescue a failure), OFF for de-escalation until traces say the + streak heuristic is safe. +- Knobs as consts next to the fleet knobs: `ESCALATE_FLOOR=0.5`, + `DEESCALATE_STREAK=5`. + +## Implementation order + +1. Tier ladder helper: `nextClassUp(class)` / `nextClassDown(class)` + + pick a concrete model for a class (cheapest in class from pricing.zig; + respects the user's provider config). +2. Wrap the `runSub` call sites (workflowTask + the Task tool path) with + the retry-one-rung-up loop. Keep `runSub` itself untouched. +3. `fleetEvent("escalate", ...)` + the env/REPL toggles. +4. Unit tests: ladder ordering, failure classification, one-rung cap. + E2e: extend `scripts/e2e_fleet.sh` mock to assert an escalate record + when a forced-fail subagent reruns. +5. (later, own slice) de-escalation streak tracking, persisted per niche + in the session state file. + +## Exit criteria for the slice + +- A forced-failure subagent on a small-class model visibly reruns on mid, + the caller gets the mid result, and the collector sees one `escalate` + record with both scores and the cost delta. +- `zig build test` green; e2e green; `GRAFF_ESCALATE=off` produces + byte-identical behavior to today. + +## What the traces unlock next + +- Cache-Switching Predictor (vision.md P2): needs P(success | tier, + niche) priors -> read them off accumulated escalate records per cell. +- Complexity profiling: label = "did small tier succeed"; the escalate + stream is the labeled dataset, no separate collection pass. +- Intelligence arbitrage (P3): success-per-dollar per (niche, tier) falls + out of rerun_score / cost_delta aggregation, SQL only, same + no-central-inference rule as the DGM loop. diff --git a/scripts/check-zig-lines.sh b/scripts/check-zig-lines.sh new file mode 100755 index 0000000..89db51e --- /dev/null +++ b/scripts/check-zig-lines.sh @@ -0,0 +1,25 @@ +#!/usr/bin/env bash +set -euo pipefail + +repo_root=$(git -C "$(dirname "${BASH_SOURCE[0]}")/.." rev-parse --show-toplevel) +cd "$repo_root" + +# Keep every checked-in Zig source below the agreed 700-line ceiling. Include +# untracked, non-ignored files locally so a newly split module is checked before +# it is staged; CI sees the same files once they are committed. +max_lines=699 +failed=0 + +while IFS= read -r -d '' file; do + lines=$(awk 'END { print NR }' "$file") + if (( lines > max_lines )); then + printf 'Zig source exceeds %d lines: %s (%d)\n' "$max_lines" "$file" "$lines" >&2 + failed=1 + fi +done < <(git ls-files -z --cached --others --exclude-standard -- '*.zig') + +if (( failed != 0 )); then + exit 1 +fi + +printf 'All Zig sources are at most %d lines.\n' "$max_lines" diff --git a/scripts/codex_ws_mock.py b/scripts/codex_ws_mock.py index ca8170a..da3610c 100644 --- a/scripts/codex_ws_mock.py +++ b/scripts/codex_ws_mock.py @@ -35,6 +35,7 @@ import threading import time from dataclasses import dataclass, field +from typing import Callable WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" @@ -71,11 +72,14 @@ def assistant_item() -> dict: } -def turn_events() -> list[dict]: +def turn_events(response_id: str = "resp_mock_1") -> list[dict]: """The two events one mocked turn produces, in send order.""" return [ {"type": "response.output_item.done", "item": assistant_item()}, - {"type": "response.completed", "response": {"usage": dict(USAGE)}}, + { + "type": "response.completed", + "response": {"id": response_id, "usage": dict(USAGE)}, + }, ] @@ -86,6 +90,20 @@ class Frame: fin: bool +@dataclass(frozen=True) +class RecordedRequest: + """One decoded Responses request, in server-observed order. + + ``connection_id`` is populated for WebSocket requests so tests can prove a + post-compaction request re-anchored on a new socket. SSE requests use None. + """ + + ordinal: int + transport: str + connection_id: int | None + body: dict + + class _SockReader: """Buffered exact-read wrapper so bytes recv'd past a boundary (e.g. the HTTP head) still feed later frame/body reads.""" @@ -169,7 +187,9 @@ def _read_message(reader: _SockReader, sock: socket.socket) -> Frame: raise ConnectionError("message too long") parts.append(frame.payload) if frame.fin: - return Frame(opcode if opcode is not None else OP_TEXT, b"".join(parts), True) + return Frame( + opcode if opcode is not None else OP_TEXT, b"".join(parts), True + ) def ws_accept_value(key: str) -> str: @@ -181,13 +201,22 @@ def ws_accept_value(key: str) -> str: @dataclass class CodexMock: """Threaded fake codex backend: start() binds and returns the real port, - stop() tears it down. ws_turns/sse_turns count served turns per transport.""" + stop() tears it down. ws_turns/sse_turns count served turns per transport. + + ``events_for_request`` optionally scripts replies from the decoded request; + the default remains the fixed mock reply used by the transport smoke tests. + """ host: str = "127.0.0.1" port: int = 0 verbose: bool = False ws_turns: int = 0 sse_turns: int = 0 + ws_connections: int = 0 + events_for_request: Callable[[RecordedRequest], list[dict]] | None = field( + default=None, repr=False + ) + requests: list[RecordedRequest] = field(default_factory=list, repr=False) _sock: socket.socket | None = field(default=None, repr=False) _threads: list[threading.Thread] = field(default_factory=list, repr=False) _lock: threading.Lock = field(default_factory=threading.Lock, repr=False) @@ -217,12 +246,32 @@ def stop(self) -> None: thread.join(timeout=1.0) self._threads.clear() + def recorded_requests(self) -> list[RecordedRequest]: + """Return a stable snapshot for assertions after a scenario completes.""" + with self._lock: + return list(self.requests) + # ── internals ───────────────────────────────────────────────────────── def _log(self, message: str) -> None: if self.verbose: print(f"[codex-mock] {message}", file=sys.stderr, flush=True) + def _events( + self, transport: str, connection_id: int | None, body: dict + ) -> list[dict]: + with self._lock: + request = RecordedRequest( + ordinal=len(self.requests) + 1, + transport=transport, + connection_id=connection_id, + body=body, + ) + self.requests.append(request) + if self.events_for_request is not None: + return self.events_for_request(request) + return turn_events(f"resp_mock_{request.ordinal}") + def _accept_loop(self) -> None: srv = self._sock assert srv is not None @@ -275,7 +324,12 @@ def _handle(self, conn: socket.socket) -> None: pass conn.close() - def _serve_ws(self, conn: socket.socket, reader: _SockReader, headers: dict[str, str]) -> None: + def _serve_ws( + self, conn: socket.socket, reader: _SockReader, headers: dict[str, str] + ) -> None: + with self._lock: + self.ws_connections += 1 + connection_id = self.ws_connections accept = ws_accept_value(headers.get("sec-websocket-key", "")) conn.sendall( ( @@ -286,7 +340,7 @@ def _serve_ws(self, conn: socket.socket, reader: _SockReader, headers: dict[str, "\r\n" ).encode("ascii") ) - self._log("ws upgraded") + self._log(f"ws upgraded (connection {connection_id})") while True: message = _read_message(reader, conn) if message.opcode == OP_CLOSE: @@ -304,17 +358,27 @@ def _serve_ws(self, conn: socket.socket, reader: _SockReader, headers: dict[str, self._log(f"ws <- {etype} ({len(message.payload)}b)") if etype != "response.create": continue - for ev in turn_events(): - _send_frame(conn, OP_TEXT, json.dumps(ev, separators=(",", ":")).encode("utf-8")) + for ev in self._events("ws", connection_id, event): + _send_frame( + conn, OP_TEXT, json.dumps(ev, separators=(",", ":")).encode("utf-8") + ) self._log(f"ws -> {ev['type']}") with self._lock: self.ws_turns += 1 - def _serve_sse(self, conn: socket.socket, reader: _SockReader, headers: dict[str, str]) -> None: + def _serve_sse( + self, conn: socket.socket, reader: _SockReader, headers: dict[str, str] + ) -> None: length = int(headers.get("content-length", "0") or 0) body = reader.read_exact(length) if length else b"" self._log(f"sse <- POST ({len(body)}b)") - events = turn_events() + try: + parsed = json.loads(body.decode("utf-8")) + except (UnicodeDecodeError, ValueError): + parsed = {} + if not isinstance(parsed, dict): + parsed = {} + events = self._events("sse", None, parsed) payload = "".join( f"data: {json.dumps(ev, separators=(',', ':'))}\n\n" for ev in events ).encode("utf-8") @@ -338,7 +402,9 @@ def main() -> None: parser = argparse.ArgumentParser( description="Fake codex Responses backend (WebSocket + SSE) for manual debugging." ) - parser.add_argument("--port", type=int, default=0, help="TCP port to bind (default: ephemeral)") + parser.add_argument( + "--port", type=int, default=0, help="TCP port to bind (default: ephemeral)" + ) args = parser.parse_args() mock = CodexMock(port=args.port, verbose=True) port = mock.start() diff --git a/scripts/test-pty-codex-ws.py b/scripts/test-pty-codex-ws.py index 630763a..e794a7a 100644 --- a/scripts/test-pty-codex-ws.py +++ b/scripts/test-pty-codex-ws.py @@ -1,8 +1,12 @@ #!/usr/bin/env python3 -"""Deterministic real-PTY test for codex transport: WebSocket primary, forced -SSE fallback, and GRAFF_CODEX_WS=off — each against a local fake backend -(codex_ws_mock) whose ws_turns/sse_turns counters prove which transport -actually served the turn, so a silent fallback cannot fake a pass.""" +"""Deterministic real-PTY tests for Codex transport and mid-turn compaction. + +The transport smokes cover WebSocket primary, forced SSE fallback, and +GRAFF_CODEX_WS=off. The regression scenarios drive real tool loops whose +server-reported usage crosses compact@ while local history stays tiny. They +prove both successful compaction and transactional rollback after an empty +summary across WS -> quiet SSE compaction -> fresh WS. +""" import json import os @@ -10,18 +14,186 @@ import sys import tempfile -from codex_ws_mock import REPLY_TEXT, CodexMock +from codex_ws_mock import REPLY_TEXT, CodexMock, RecordedRequest from pty_harness import PtySession, terminal_text _arg = sys.argv[1] if len(sys.argv) > 1 else "graff" GRAFF = os.path.abspath(_arg) if os.sep in _arg else _arg -# Mock usage total is 1500; compactTokenCount (src/agent.zig) renders that as -# "1k" (integer division), and 1500 tokens is 0% of any realistic window. The -# window itself tracks the baked codex catalog (pricing.zig), which moves -# between releases — so assert the meter SHAPE plus the compactAt invariant -# (compact = context/10*8, src/provider.zig) instead of a frozen window size. -METER_RE = re.compile(r"1k/(\d+)k ctx \(0% · compact@(\d+)k\)") + +# The reported 1500-token usage is conservatively floored by graff's serialized +# request estimate, so the displayed used count can move with the built-in tool +# schema. Assert the meter shape and invariants rather than freezing either the +# prefill estimate or the Codex catalog window. +METER_RE = re.compile(r"(\d+)(k?)/(\d+)k ctx \((\d+)% · compact@(\d+)k\)") +COMPACTING_RE = re.compile(r"compacting ~(\d+) tokens") + +MIDTURN_PROMPT = "exercise the server-side context meter" +MIDTURN_SUMMARY = "The user asked to exercise the server-side context meter." +MIDTURN_FINAL = "done after mid-turn compact" +# Cross compact@ (80%) but stay below the destructive recovery boundary (95%). +# The smoke scenarios set this from the context meter emitted after the runtime +# Codex catalog has loaded, rather than the static --schema catalog. +MIDTURN_TOTAL_TOKENS = 0 +MIDTURN_CONTEXT_TOKENS = 0 +MIDTURN_REASONING_MARKER = "retained-active-reasoning:" +MIDTURN_REASONING_BYTES = 128 * 1024 + +TRANSACTIONAL_PROMPT = "prove failed compaction keeps the live tool loop" +TRANSACTIONAL_FINAL = "done after transactional compaction failure" +TRANSACTIONAL_REASONING_MARKER = "transactional-active-reasoning:" +TRANSACTIONAL_CALL_ID = "call_transactional_1" + + +def response_events( + item: dict | list[dict], response_id: str, total_tokens: int +) -> list[dict]: + """Build the two Responses events parseResponses consumes.""" + output_tokens = 1_000 if total_tokens > 2_000 else 100 + items = item if isinstance(item, list) else [item] + return [ + *( + {"type": "response.output_item.done", "item": output_item} + for output_item in items + ), + { + "type": "response.completed", + "response": { + "id": response_id, + "usage": { + "input_tokens": total_tokens - output_tokens, + "input_tokens_details": {"cached_tokens": 0}, + "output_tokens": output_tokens, + "total_tokens": total_tokens, + }, + }, + }, + ] + + +def message_item(text: str, item_id: str) -> dict: + return { + "type": "message", + "id": item_id, + "status": "completed", + "role": "assistant", + "content": [{"type": "output_text", "text": text, "annotations": []}], + } + + +def active_reasoning_item() -> dict: + """A large current-loop item that compact() must prune before full resend.""" + encrypted = MIDTURN_REASONING_MARKER + "R" * ( + MIDTURN_REASONING_BYTES - len(MIDTURN_REASONING_MARKER) + ) + return { + "type": "reasoning", + "id": "rs_midturn_1", + "summary": [], + "encrypted_content": encrypted, + } + + +def midturn_events(request: RecordedRequest) -> list[dict]: + """Script tool call -> compaction summary -> final answer.""" + if request.ordinal == 1: + item = { + "type": "function_call", + "id": "fc_midturn_1", + "call_id": "call_midturn_1", + "name": "todo_read", + "arguments": "{}", + "status": "completed", + } + # Real high-effort Responses tool loops return reasoning immediately + # before the function call. It is current-turn history here, but once + # compact() appends its synthetic user turn it must be pruned before the + # full SSE summary resend. + return response_events( + [active_reasoning_item(), item], + "resp_midturn_1", + MIDTURN_TOTAL_TOKENS, + ) + if request.ordinal == 2: + return response_events( + message_item(MIDTURN_SUMMARY, "msg_midturn_summary"), + "resp_midturn_summary", + 1_100, + ) + return response_events( + message_item(MIDTURN_FINAL, "msg_midturn_final"), + f"resp_midturn_{request.ordinal}", + 1_300, + ) + + +def transactional_reasoning_item() -> dict: + encrypted = TRANSACTIONAL_REASONING_MARKER + "R" * ( + MIDTURN_REASONING_BYTES - len(TRANSACTIONAL_REASONING_MARKER) + ) + return { + "type": "reasoning", + "id": "rs_transactional_1", + "summary": [], + "encrypted_content": encrypted, + } + + +def transactional_events(request: RecordedRequest) -> list[dict]: + """Script tool call -> empty summary -> answer from restored live history.""" + if request.ordinal == 1: + call = { + "type": "function_call", + "id": "fc_transactional_1", + "call_id": TRANSACTIONAL_CALL_ID, + "name": "todo_read", + "arguments": "{}", + "status": "completed", + } + return response_events( + [transactional_reasoning_item(), call], + "resp_transactional_1", + MIDTURN_TOTAL_TOKENS, + ) + if request.ordinal == 2: + # A syntactically valid Responses answer with no summary text exercises + # compact()'s EmptySummary rollback, rather than a transport failure. + return response_events( + message_item("", "msg_transactional_empty_summary"), + "resp_transactional_empty_summary", + 1_100, + ) + return response_events( + message_item(TRANSACTIONAL_FINAL, "msg_transactional_final"), + f"resp_transactional_{request.ordinal}", + 1_300, + ) + + +def user_text(item: object) -> str | None: + if not isinstance(item, dict) or item.get("role") != "user": + return None + content = item.get("content") + return content if isinstance(content, str) else None + + +def assert_compaction_meter(label: str, rendered: str) -> None: + match = COMPACTING_RE.search(rendered) + if match is None: + raise AssertionError( + f"{label}: server-reported usage did not trigger pre-send " + f"compaction:\n{rendered}" + ) + observed = int(match.group(1)) + # The provider sample is the lower bound. A tool result appended after that + # sample should increase the anchored effective meter slightly, while the + # compaction still runs before the advertised context wall. + if not MIDTURN_TOTAL_TOKENS <= observed < MIDTURN_CONTEXT_TOKENS: + raise AssertionError( + f"{label}: compacted at {observed} tokens, expected at least the " + f"{MIDTURN_TOTAL_TOKENS} provider sample and below the " + f"{MIDTURN_CONTEXT_TOKENS} context window" + ) def run_scenario( @@ -34,7 +206,7 @@ def run_scenario( expect_ws: int, expect_sse: int, health: str, -) -> None: +) -> int: env = { "HOME": tmp, "CODEX_HOME": codex_home, @@ -70,10 +242,15 @@ def run_scenario( session.wait_for_literal(REPLY_TEXT, start=cursor) session.wait_for(METER_RE, start=cursor) meter = METER_RE.search(terminal_text(bytes(session.raw[cursor:]))) - ctx_k, compact_k = int(meter.group(1)), int(meter.group(2)) - if compact_k != ctx_k * 8 // 10: + used = int(meter.group(1)) * (1000 if meter.group(2) == "k" else 1) + ctx_k, pct, compact_k = map(int, meter.group(3, 4, 5)) + if used <= 0 or not 0 <= pct <= 100: + raise AssertionError( + f"{label}: invalid context meter values used={used} pct={pct}" + ) + if ctx_k <= 0 or not 79 * ctx_k <= 100 * compact_k <= 81 * ctx_k: raise AssertionError( - f"{label}: meter compact@{compact_k}k is not 80% of {ctx_k}k ctx" + f"{label}: inconsistent meter context={ctx_k}k compact@={compact_k}k" ) if mock.ws_turns != expect_ws or mock.sse_turns != expect_sse: raise AssertionError( @@ -91,15 +268,329 @@ def run_scenario( f"{label}: REPL did not exit cleanly: " f"exit={result.exit_code} timed_out={result.timed_out}" ) + return ctx_k * 1000 + + +def assert_midturn_requests(mock: CodexMock) -> None: + requests = mock.recorded_requests() + if len(requests) != 3: + raise AssertionError( + f"midturn: expected exactly 3 model requests, got {len(requests)}: {requests!r}" + ) + first, compact, final = requests + transports = [request.transport for request in requests] + if transports != ["ws", "sse", "ws"]: + raise AssertionError(f"midturn: expected WS -> SSE -> WS, got {transports!r}") + if mock.ws_turns != 2 or mock.sse_turns != 1 or mock.ws_connections != 2: + raise AssertionError( + "midturn: expected two turns on two fresh WS connections plus one SSE " + f"turn; ws_turns={mock.ws_turns} sse_turns={mock.sse_turns} " + f"ws_connections={mock.ws_connections}" + ) + if first.connection_id == final.connection_id: + raise AssertionError("midturn: final request reused the pre-compaction WS") + for request in requests: + if "previous_response_id" in request.body: + raise AssertionError( + f"midturn: request {request.ordinal} carried stale previous_response_id: " + f"{request.body['previous_response_id']!r}" + ) + + first_input = first.body.get("input") + if ( + first.body.get("type") != "response.create" + or not isinstance(first_input, list) + or not any(user_text(item) == MIDTURN_PROMPT for item in first_input) + or "tools" not in first.body + ): + raise AssertionError( + f"midturn: first WS request was not full tool-enabled input: {first.body!r}" + ) + + compact_input = compact.body.get("input") + compact_texts = ( + [text for item in compact_input if (text := user_text(item)) is not None] + if isinstance(compact_input, list) + else [] + ) + compact_types = ( + [item.get("type") for item in compact_input if isinstance(item, dict)] + if isinstance(compact_input, list) + else [] + ) + compact_json = json.dumps(compact.body, separators=(",", ":")) + if "reasoning" in compact_types or MIDTURN_REASONING_MARKER in compact_json: + raise AssertionError( + "midturn: SSE compaction request retained the active-loop reasoning item" + ) + if ( + compact.connection_id is not None + or "tools" in compact.body + or MIDTURN_PROMPT not in compact_texts + or "function_call" not in compact_types + or "function_call_output" not in compact_types + or not any( + text.startswith("Summarize this entire conversation") + for text in compact_texts + ) + ): + raise AssertionError( + f"midturn: compaction request was not a full, tool-free SSE summary request: {compact.body!r}" + ) + + final_input = final.body.get("input") + final_texts = ( + [text for item in final_input if (text := user_text(item)) is not None] + if isinstance(final_input, list) + else [] + ) + if ( + final.body.get("type") != "response.create" + or not isinstance(final_input, list) + or len(final_input) != 1 + or len(final_texts) != 1 + or not final_texts[0].startswith( + "Context: the prior conversation was compacted" + ) + or MIDTURN_SUMMARY not in final_texts[0] + or "tools" not in final.body + ): + raise AssertionError( + "midturn: final WS request did not fully re-anchor on the handoff: " + f"{final.body!r}" + ) + + +def assert_transactional_requests(mock: CodexMock) -> None: + requests = mock.recorded_requests() + if len(requests) != 3: + raise AssertionError( + "transactional: expected exactly 3 model requests, " + f"got {len(requests)}: {requests!r}" + ) + first, compact, final = requests + transports = [request.transport for request in requests] + if transports != ["ws", "sse", "ws"]: + raise AssertionError( + f"transactional: expected WS -> SSE -> WS, got {transports!r}" + ) + if mock.ws_turns != 2 or mock.sse_turns != 1 or mock.ws_connections != 2: + raise AssertionError( + "transactional: expected two turns on two fresh WS connections plus " + f"one SSE turn; ws_turns={mock.ws_turns} sse_turns={mock.sse_turns} " + f"ws_connections={mock.ws_connections}" + ) + if first.connection_id == final.connection_id: + raise AssertionError( + "transactional: final request reused the pre-compaction WS" + ) + for request in requests: + if "previous_response_id" in request.body: + raise AssertionError( + f"transactional: request {request.ordinal} carried stale " + f"previous_response_id: {request.body['previous_response_id']!r}" + ) + + first_input = first.body.get("input") + if ( + first.body.get("type") != "response.create" + or not isinstance(first_input, list) + or not any(user_text(item) == TRANSACTIONAL_PROMPT for item in first_input) + or "tools" not in first.body + ): + raise AssertionError( + "transactional: first WS request was not full tool-enabled input: " + f"{first.body!r}" + ) + + compact_input = compact.body.get("input") + compact_texts = ( + [text for item in compact_input if (text := user_text(item)) is not None] + if isinstance(compact_input, list) + else [] + ) + compact_json = json.dumps(compact.body, separators=(",", ":")) + if ( + compact.connection_id is not None + or "tools" in compact.body + or TRANSACTIONAL_PROMPT not in compact_texts + or TRANSACTIONAL_REASONING_MARKER in compact_json + or not any( + text.startswith("Summarize this entire conversation") + for text in compact_texts + ) + ): + raise AssertionError( + "transactional: second request was not the pruned, synthetic SSE " + f"summary request: {compact.body!r}" + ) + + final_input = final.body.get("input") + final_texts = ( + [text for item in final_input if (text := user_text(item)) is not None] + if isinstance(final_input, list) + else [] + ) + final_objects = ( + [item for item in final_input if isinstance(item, dict)] + if isinstance(final_input, list) + else [] + ) + reasoning = [ + item + for item in final_objects + if item.get("type") == "reasoning" and item.get("id") == "rs_transactional_1" + ] + calls = [ + item + for item in final_objects + if item.get("type") == "function_call" + and item.get("id") == "fc_transactional_1" + and item.get("call_id") == TRANSACTIONAL_CALL_ID + ] + outputs = [ + item + for item in final_objects + if item.get("type") == "function_call_output" + and item.get("call_id") == TRANSACTIONAL_CALL_ID + and isinstance(item.get("output"), str) + and len(item["output"]) > 0 + ] + leaked_summary_response = any( + item.get("id") == "msg_transactional_empty_summary" for item in final_objects + ) + if ( + final.body.get("type") != "response.create" + or not isinstance(final_input, list) + or "tools" not in final.body + or TRANSACTIONAL_PROMPT not in final_texts + or any( + text.startswith("Summarize this entire conversation") + for text in final_texts + ) + or not any( + isinstance(item.get("encrypted_content"), str) + and item["encrypted_content"].startswith(TRANSACTIONAL_REASONING_MARKER) + and len(item["encrypted_content"]) == MIDTURN_REASONING_BYTES + for item in reasoning + ) + or len(calls) != 1 + or len(outputs) != 1 + or leaked_summary_response + ): + raise AssertionError( + "transactional: final WS request did not restore the original prompt, " + "reasoning, function call, and output without the synthetic compact " + f"instruction: {final.body!r}" + ) + + +def run_midturn_compaction_scenario( + tmp: str, codex_home: str, port: int, mock: CodexMock +) -> None: + env = { + "HOME": tmp, + "CODEX_HOME": codex_home, + "CODEGRAFF_API_KEY": "local-pty-test", + "GRAFF_FLEET": "off", + "GRAFF_NO_TELEMETRY": "1", + "GRAFF_CODEX_URL": f"http://127.0.0.1:{port}/backend-api/codex/responses", + } + ambient = tuple( + key + for key in os.environ + if (key.startswith("GRAFF_") or key.startswith("CODEX_") or key == "NO_COLOR") + and key not in env + ) + with PtySession( + GRAFF, + ["--model", "codex", "--no-telemetry"], + cwd=tmp, + env=env, + unset_env=ambient, + timeout=20.0, + ) as session: + session.wait_for_literal("] ›") + cursor = len(session.raw) + session.send_line(MIDTURN_PROMPT) + session.wait_for_literal(MIDTURN_FINAL, start=cursor) + session.wait_for_literal("history compacted to a", start=cursor) + session.pump_for(0.1) + rendered = terminal_text(bytes(session.raw[cursor:])) + assert_compaction_meter("midturn", rendered) + assert_midturn_requests(mock) + session.send_key("ctrl-d") + result = session.read_until_exit(5.0) + if result.timed_out or result.exit_code != 0: + raise SystemExit( + "midturn: REPL did not exit cleanly: " + f"exit={result.exit_code} timed_out={result.timed_out}" + ) + + +def run_transactional_compaction_scenario( + tmp: str, codex_home: str, port: int, mock: CodexMock +) -> None: + env = { + "HOME": tmp, + "CODEX_HOME": codex_home, + "CODEGRAFF_API_KEY": "local-pty-test", + "GRAFF_FLEET": "off", + "GRAFF_NO_TELEMETRY": "1", + "GRAFF_CODEX_URL": f"http://127.0.0.1:{port}/backend-api/codex/responses", + } + ambient = tuple( + key + for key in os.environ + if (key.startswith("GRAFF_") or key.startswith("CODEX_") or key == "NO_COLOR") + and key not in env + ) + with PtySession( + GRAFF, + ["--model", "codex", "--no-telemetry"], + cwd=tmp, + env=env, + unset_env=ambient, + timeout=20.0, + ) as session: + session.wait_for_literal("] ›") + cursor = len(session.raw) + session.send_line(TRANSACTIONAL_PROMPT) + session.wait_for_literal( + "compaction failed: empty summary, history unchanged", start=cursor + ) + session.wait_for_literal(TRANSACTIONAL_FINAL, start=cursor) + session.pump_for(0.1) + rendered = terminal_text(bytes(session.raw[cursor:])) + assert_compaction_meter("transactional", rendered) + if "history compacted to a" in rendered: + raise AssertionError( + f"transactional: empty summary was incorrectly installed:\n{rendered}" + ) + assert_transactional_requests(mock) + session.send_key("ctrl-d") + result = session.read_until_exit(5.0) + if result.timed_out or result.exit_code != 0: + raise SystemExit( + "transactional: REPL did not exit cleanly: " + f"exit={result.exit_code} timed_out={result.timed_out}" + ) def main() -> None: + global MIDTURN_CONTEXT_TOKENS, MIDTURN_TOTAL_TOKENS + with tempfile.TemporaryDirectory(prefix="graff-pty-codex-") as tmp: codex_home = os.path.join(tmp, "codex-home") os.makedirs(codex_home, exist_ok=True) with open(os.path.join(codex_home, "auth.json"), "w", encoding="utf-8") as fh: json.dump( - {"tokens": {"access_token": "pty-mock-token", "account_id": "acct-pty-mock"}}, + { + "tokens": { + "access_token": "pty-mock-token", + "account_id": "acct-pty-mock", + } + }, fh, ) @@ -109,7 +600,9 @@ def main() -> None: # the session cwd's .harness/settings.json. harness_dir = os.path.join(tmp, ".harness") os.makedirs(harness_dir, exist_ok=True) - with open(os.path.join(harness_dir, "settings.json"), "w", encoding="utf-8") as fh: + with open( + os.path.join(harness_dir, "settings.json"), "w", encoding="utf-8" + ) as fh: json.dump({"ai_title": False}, fh) scenarios = [ @@ -138,11 +631,12 @@ def main() -> None: "ok codex WS disabled: SSE reply + ctx meter + forced-off health", ), ] + runtime_context = None for label, extra_env, expect_ws, expect_sse, health, ok_line in scenarios: mock = CodexMock() port = mock.start() try: - run_scenario( + observed_context = run_scenario( label, tmp, codex_home, @@ -155,8 +649,41 @@ def main() -> None: ) finally: mock.stop() + if runtime_context is not None and observed_context != runtime_context: + raise AssertionError( + f"{label}: runtime context changed from {runtime_context} " + f"to {observed_context} across smoke scenarios" + ) + runtime_context = observed_context print(ok_line) + if runtime_context is None: + raise AssertionError("no smoke scenario reported a runtime context") + MIDTURN_CONTEXT_TOKENS = runtime_context + MIDTURN_TOTAL_TOKENS = runtime_context * 9 // 10 + + mock = CodexMock(events_for_request=midturn_events) + port = mock.start() + try: + run_midturn_compaction_scenario(tmp, codex_home, port, mock) + finally: + mock.stop() + print( + "ok codex server meter + reasoning prune: WS tool call -> " + "SSE compaction -> fresh full-input WS" + ) + + mock = CodexMock(events_for_request=transactional_events) + port = mock.start() + try: + run_transactional_compaction_scenario(tmp, codex_home, port, mock) + finally: + mock.stop() + print( + "ok empty mid-turn summary: transactional rollback -> " + "fresh full-input WS" + ) + if __name__ == "__main__": main() diff --git a/scripts/test-pty-repl.py b/scripts/test-pty-repl.py index 28cf523..fedeaa5 100755 --- a/scripts/test-pty-repl.py +++ b/scripts/test-pty-repl.py @@ -46,16 +46,18 @@ def command( raise AssertionError(f"missing colored badge {color_bytes!r} after {line}") base = "deepseek-v4-pro · Extra high · codegraff" + # Match through cwd but not the closing bracket: the live context + # meter is appended after cwd and changes as the session evolves. command( "/effort xhigh", "reasoning effort: Extra high", - f"[{base} · cwd {tmp}]", + f"[{base} · cwd {tmp}", b"\x1b[35mExtra high\x1b[0m", ) command( "/model definitely-not-a-model", "unknown model 'definitely-not-a-model'", - f"[{base} · cwd {tmp}]", + f"[{base} · cwd {tmp}", None, ) cursor = len(session.raw) @@ -63,7 +65,7 @@ def command( session.wait_for_literal("/models [health]", start=cursor) session.wait_for_literal("/fallback [allow|remove|off]", start=cursor) session.wait_for_literal("/login [codegraff|codex|kimi]", start=cursor) - session.wait_for_literal(f"[{base} · cwd {tmp}]", start=cursor) + session.wait_for_literal(f"[{base} · cwd {tmp}", start=cursor) cursor = len(session.raw) session.send_line("/models health") session.wait_for_literal("active: deepseek-v4-pro via codegraff", start=cursor) @@ -74,31 +76,31 @@ def command( ) session.wait_for(r"✓\s+codegraff\s+environment", start=cursor) session.wait_for(r"·\s+codex\s+missing", start=cursor) - session.wait_for_literal(f"[{base} · cwd {tmp}]", start=cursor) + session.wait_for_literal(f"[{base} · cwd {tmp}", start=cursor) if b"local-pty-test" in bytes(session.raw[cursor:]): raise AssertionError("/models health exposed a credential value") command( "/plan", "plan mode on", - f"[{base} · Plan · cwd {tmp}]", + f"[{base} · Plan · cwd {tmp}", b"\x1b[33mPlan\x1b[0m", ) command( "/strict", "strict mode ON", - f"[{base} · Plan · Strict · cwd {tmp}]", + f"[{base} · Plan · Strict · cwd {tmp}", b"\x1b[31mStrict\x1b[0m", ) command( "/ultracode on", "ultracode mode: on", - f"[{base} · Plan · Strict · Ultracode · cwd {tmp}]", + f"[{base} · Plan · Strict · Ultracode · cwd {tmp}", b"\x1b[35mUltracode\x1b[0m", ) command( "/yolo", "yolo mode ON", - f"[{base} · Plan · Strict · Ultracode · cwd {tmp}]", + f"[{base} · Plan · Strict · Ultracode · cwd {tmp}", None, ) if b"\x1b[31mYOLO\x1b[0m" in bytes(session.raw): @@ -106,7 +108,7 @@ def command( cursor = len(session.raw) session.send_line("/key no-such-provider supersecret") session.wait_for_literal("unknown provider 'no-such-provider'", start=cursor) - session.wait_for_literal(f"cwd {tmp}]", start=cursor) + session.wait_for_literal(f"cwd {tmp}", start=cursor) if b"supersecret" in bytes(session.raw[cursor:]): raise AssertionError("/key secret was echoed to the terminal") session.send_key("ctrl-d") diff --git a/social/graff-launch-01-size.png b/social/graff-launch-01-size.png new file mode 100644 index 0000000000000000000000000000000000000000..f9f74c063bea13f450914615b12cdac108861013 GIT binary patch literal 2566987 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 z%0A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