@wildorder/nightshift 0.16.0 → 0.18.0

package/README.md

@@ -136,6 +136,20 @@ the first agent spawns and refuses to start if they are red, so the first
 failure you debug is the environment's, named as such, not eight
 workstreams' worth of budget spent on it.
 
+Within one run, the runner may skip a verify pass when the tree it is about
+to check is byte-identical to one it already proved green earlier in the same
+run — the common case is a fix pass that changed nothing after a decider
+declined every finding. The comparison ignores six files the runner writes
+for itself under `docs/programs/<program-id>-*` (the manifest, decision
+ledger, memory, run report, and analytics snapshot); every other file,
+including another program's own artifacts, is part of the comparison. Two
+things follow for your own `verify` commands: if any of them read those six
+files (a lint over `docs/**/*.json`, a test that snapshots the ledger), a
+green skip could stand in for a check that would have gone red — narrow
+enough that it rarely matters, but worth knowing. And if any of them rewrite
+tracked files (a formatter with `--write`, a codegen step), that pass simply
+never caches — verification still runs in full, every time.
+
 **3. Plan a program** — in your agent tool (e.g. Claude Code), run:
 
 ```text
@@ -192,11 +206,26 @@ every run.
 ```text
   /plan-program        HUMAN   design, scope, decompose (interactive)
     nightshift run ┬ author            one clean agent per workstream, by dependency level
-                   ├ review            critic→writer rounds (2–3), fail-open into the ledger
+                   ├ review            critic → triage → one fix, fail-open into the ledger
                    ├ build             implement, verify, commit; decisions journaled
                    └ report            run report + decision ledger on the draft PR
 ```
 
+Each critique loop — spec and test alike — is one reviewer read, one decider
+triage, and one fix pass per cycle: no reviewer re-reads the fix. Test
+critique runs one cycle for every workstream size; spec critique runs one
+cycle for S and M workstreams and two for L. Findings the fixer declines, and
+findings it fixes, both reach the decision ledger — the run report says which
+by name rather than implying every raised finding was checked twice.
+
+A spec revision resumes the author's own session, and a fix pass resumes the
+implementer's, so the seat that wrote the artifact applies the fix instead of
+rediscovering the codebase from a fresh spawn. Reviewer, decider, and
+recovery seats never resume — that is what keeps no-self-grading intact. When
+no session was captured, or the seat's configuration changed since it wrote
+the artifact, the run falls back to today's fresh spawn, and the run report
+says which happened.
+
 Five agent roles, five jobs (`nightshift.config.json`):
 
 | Block | Job |
@@ -222,6 +251,245 @@ Core rules, inherited from hard experience:
 - **Every artifact is written for a human first.** Specs are narrative
   documents; machine data lives in the manifest.
 
+## Choosing models and effort per seat
+
+The five agent roles above are ordinary configuration: `args` in
+`nightshift.config.json` is passed to each spawn untouched (`src/config.ts`),
+and nightshift neither validates nor interprets it. Anything the provider's
+CLI accepts headlessly — a model name, an effort level, a reasoning-effort
+config key — is available to set per seat. There is no `effort` key to look
+for in nightshift itself; the knob lives on the CLI you configured.
+
+On claude, effort is `--effort <level>`, with levels `low`, `medium`, `high`,
+`xhigh`, and `max` (verified on claude 2.1.241 — check `claude --help`). On
+codex there is no top-level flag; express it as a `-c` config override, e.g.
+`-c model_reasoning_effort="low"` (verified on codex 0.149.0 — check
+`codex exec --help`). **Use the `-c` form, never `--profile`**: session-resume
+derivation passes `-c`/`--config` through unchanged on a fix pass, but refuses
+`-p`/`--profile` outright and falls back to a fresh spawn — a profile-based
+effort setting would silently cost a full rediscovery on every fix instead of
+resuming the session that wrote the code.
+
+Two facts worth stating plainly because they are not guessable:
+
+- **`--effort` and `--model` do not change the derived permission posture.**
+  `src/permits.ts` only ever detects `--permission-mode`/`--allowedTools`/
+  `--disallowedTools` (and siblings) on claude and `--sandbox` on codex —
+  adding an effort or model flag does not flip a role to
+  `operator-configured`, and nightshift's derived posture still applies on
+  top of it.
+- **Mixed configurations affect session resume.** When two seats differ in
+  model or effort, a fix pass that would have resumed the seat that produced
+  the commit falls back to a fresh spawn instead — correct, since resuming
+  under a posture the seat was not configured for would be worse — and the
+  run report says which happened.
+
+**The recommendation**, from a measured program where roughly half of every
+agent's output tokens were thinking tokens:
+
+| Seat | Reason |
+| --- | --- |
+| `agent` | The largest share of a run's tokens, and checked hardest downstream — runner verification, test critique, decider ratification, whole-program review. The first seat to try a lower effort, and the first to look at when quality slips. |
+| `authorAgent` | Writing a spec is design reasoning; a sparse spec costs a whole workstream. The last seat to economise on. |
+| `reviewerAgent` / `deciderAgent` | Small token volume, high leverage per token. Lowering effort here saves little and risks the second opinion no-self-grading exists to protect. |
+| `recoveryAgent` | Runs rarely, on the hardest input in the run — a red tree with a diagnosis. Economising here pays for the good case with the bad one. |
+
+An illustrative example — not this repository's own configuration above —
+showing the implementer seat at a lower effort, in both provider forms:
+
+```json
+{ "agent": { "command": "claude", "args": ["-p", "--model", "sonnet", "--effort", "low"], "promptMode": "stdin" } }
+```
+
+```json
+{ "agent": { "command": "codex", "args": ["exec", "-c", "model_reasoning_effort=\"low\""], "promptMode": "stdin" } }
+```
+
+**A fast tier is a different knob, not a smaller effort.** Where a provider
+exposes one headlessly, a fast tier is a latency setting — the same model,
+emitted faster — not a smaller model and not a lower effort, so it carries no
+quality bet and needs none of the one-change-at-a-time discipline the effort
+recommendation above does. It is worth configuring exactly where output
+latency sits on the critical path: `authorAgent`, because every pipelined
+chain begins with a spec, and `agent`, because builds are the longest legs.
+It buys almost nothing on `reviewerAgent`, `deciderAgent`, or
+`recoveryAgent` — short, rare, or both. Check for one with `<cli> --help`
+(look for a tier or fast flag), then confirm the provider accepts it
+headlessly in the exact argv nightshift will spawn with
+`nightshift doctor --agents`. As of the versions checked here — claude
+2.1.241 and codex 0.149.0 — **neither exposes a fast tier headlessly**:
+claude's fast mode is an interactive `/fast` toggle with no `--help` flag
+behind it, and codex documents no fast-tier flag or config key at all.
+Re-run both `--help` commands before trusting this — if a fast flag has
+appeared since, put it on `authorAgent` and `agent` first.
+
+**Verify the roster before trusting it.** `nightshift doctor --agents` spawns
+each distinct agent once with the same derived posture a run would use and
+prints the exact argv — effort flag included — the permission label, and
+whether the seat can write and run the verify commands. A tier or effort
+level the provider refuses headlessly shows up as one failed line here,
+before a run has spent anything on it.
+
+**Judging whether a lower effort hurt** uses signals already in the run
+report: attempt counts and durations by disposition (a retried or failed
+implementer attempt is the loudest signal), critique findings — more of
+them, or more routed `fix-now`, means the first pass was worse — and parked
+workstreams or recovery attempts, the expensive tail. Change one seat at a
+time, compare runs of comparable programs, and never change effort and
+`--max-parallel` in the same run — the report cannot tell you which one
+moved the number.
+
+## Running programs concurrently
+
+The runner builds every workstream whose dependencies have landed and whose
+spec is finished, concurrently, bounded by `--max-parallel`. A workstream's
+build starts as soon as its own spec is finished and its dependencies are
+integrated — it does not wait for every other workstream to finish
+authoring. That second half is what pays even on a program with no width at
+all: a chain of workstreams overlaps each spec's authoring with the previous
+workstream's build, so pipelining pays on chains, not only on programs with
+independent branches.
+
+What did not change: the runner still owns verification and commits, the
+program branch is still linear with one green runner-owned commit per
+workstream, replay still works, a failed workstream still parks its
+downstream cone while everything else keeps building, and a run still
+always terminates.
+
+Every line a workstream's flow logs is prefixed `[WS-xx]`; scheduler lines
+are prefixed `[run]`. An interleaved log of several workstreams building at
+once is readable because of this prefix — look for it first when a
+concurrent run's log looks tangled.
+
+### Worktrees
+
+Every workstream builds in its own git worktree, outside your tracked
+checkout, under `.nightshift-worktrees` next to the repository (falling back
+to the OS temp directory when the repository's parent is not writable; the
+run logs the chosen base once at start). One worktree exists per in-flight
+workstream, and each one installs dependencies through the detected package
+manager when a lockfile is present — n concurrent workstreams means n
+dependency trees on disk, worth checking before raising `--max-parallel` on
+a laptop.
+
+**Uncommitted work in your root checkout is not picked up by any build** —
+every build starts from the program branch's tip, not your working tree. If
+you resume a run with uncommitted changes sitting in the root, the runner
+warns you; commit or stash first.
+
+A worktree is removed after its workstream integrates successfully. When a
+workstream does not integrate, its worktree is retained and its path is
+named in the run report, so the failure can be inspected — the next run
+reaps every worktree and branch a program left behind before it does
+anything else, so retained state is forensic, never an input a later run
+builds on. Reaping never destroys the only copy of an attempt: before a
+leftover worktree is removed, whatever it holds beyond the program branch
+(committed or not) is committed and pinned under
+`refs/nightshift/<program-id>/<workstream-id>-wip`, and the run's console
+names every ref it salvaged. After a complete run, `git worktree list`
+should show nothing belonging to the program; that one command is the check.
+
+### Integration, failure, and salvage
+
+A green worktree is squashed onto the program branch as one runner-owned
+commit, and the integrated tree is re-verified — skipped only when the
+program-branch tip has not moved since the workstream started, because then
+the two trees are identical.
+
+A merge conflict or a red integration verify is a bounded, journaled
+recovery event, never a silent discard: the verified commit is retained
+under `refs/nightshift/<program-id>/<workstream-id>`, one recovery attempt
+runs in a fresh worktree from the current tip briefed with both commits and
+the conflict or verify output, and — if that also fails — the workstream
+fails with a diagnosis naming both commits, the retained ref, and the
+retained worktree path. Its downstream cone parks exactly as it would for
+any other build failure.
+
+Salvage a retained commit by hand from the root checkout:
+
+```sh
+git log --oneline refs/nightshift/<program-id>/<workstream-id>
+git diff <program-branch>...refs/nightshift/<program-id>/<workstream-id>
+git cherry-pick refs/nightshift/<program-id>/<workstream-id>   # or merge, or re-run
+```
+
+That commit **verified green against the tip it was built from** — it is a
+real, tested change that could not be reconciled with a branch that moved
+underneath it, not broken work. The ref survives until you delete it:
+reaping removes worktrees and their branches, never `refs/nightshift/`.
+
+### `--max-parallel`
+
+```sh
+nightshift run <program-id> --max-parallel <n>
+```
+
+Default: unbounded — the dependency graph is the only serializer. `1`
+reproduces the pre-concurrency serial runner's *execution*: the same
+dispatch order, one workstream at a time, one runner-owned commit each, the
+same report sections — it is also what turns pipelining off. It reproduces
+the runner's behaviour, not the agents': running the same program twice,
+serially, will not produce the same diffs, because the agents are not
+deterministic.
+
+One budget covers both stages — authoring and building share the same cap,
+not one each. A bad value is refused at the CLI, loudly, as a
+could-not-start (exit 3), never silently reinterpreted as unbounded. The
+report's resume command carries whatever value you ran with, so a run
+bounded to 2 resumes bounded to 2.
+
+Verify commands are CPU-heavy, so on a small machine several concurrent
+suites can slow each other down or trip test timeouts. The run report's
+wait-by-cause table — `spec-pending`, `author-concurrency-cap`,
+`concurrency-cap`, `integration-mutex`, and the derived `dependency-landing`
+— is the evidence for choosing a value: a workstream waiting a long time on
+`concurrency-cap` or `author-concurrency-cap` is the case for raising it; a
+verify pass that fails and then passes on retry is the case for lowering it.
+See [docs/run-analytics.md](docs/run-analytics.md#reading-a-concurrent-run)
+for what each figure means and how to act on it.
+
+### Your first concurrent run
+
+**Before.** Commit or stash work in the root checkout — builds start from
+the program branch's tip and will not pick it up. Check disk space for one
+dependency tree per concurrent workstream. Run `nightshift doctor --agents`
+if the agent roster changed. Start with a deliberate, small
+`--max-parallel` on a laptop rather than unbounded, so the first concurrent
+run is one you can watch.
+
+**During.** The `[WS-xx]` and `[run]` prefixes make an interleaved log
+readable. `git worktree list` is the live inventory of what is building.
+
+**After.** Read "Where the time went" first: the parallelism ratio says
+whether concurrency happened at all, the critical path says what determined
+the run's length, and the waits by cause say what to change. Confirm
+`git worktree list` shows nothing belonging to the program — any retained
+worktree path or `refs/nightshift/` ref named in the report belongs to a
+workstream that did not finish.
+
+**When something looks wrong**, re-run with `--max-parallel 1`. This is a
+*diagnostic* step, not merely a retreat to "give up and go slow" — it makes
+concurrency the leading suspect, but it does not replay the failed run:
+`--max-parallel 1` removes concurrency from the run's *execution* (the same
+dispatch order, one workstream at a time, no overlap between authoring and
+building); it does not reproduce the agents' behaviour, and two agentic runs
+of the same program can differ for reasons that have nothing to do with
+scheduling — nondeterministic model output, a transient provider or network
+failure, a flaky test, state outside the repository that moved between runs.
+
+- **A serial run that is also red is the informative outcome.** It largely
+  rules concurrency out and points at the change itself, the spec, or the
+  environment.
+- **A serial run that is green is evidence, not proof.** It makes
+  concurrency the leading suspect and worth investigating as a concurrency
+  bug — it does not isolate the cause, since the green run may simply be a
+  different roll of the same dice. Repeat it if it's cheap, and look for a
+  mechanism in the report (an integration conflict, a verify pass that
+  failed and passed on retry, a retained worktree) rather than resting on
+  the pair of outcomes alone.
+
+Attach both run reports to the bug report either way.
+
 ## Authoring specs
 
 `nightshift run` authors every missing workstream spec before it builds
@@ -277,6 +545,26 @@ ref and never loses a ledger event. It ends by telling you the one command
 to re-run — the rebuilt work honors your ruling, since the next run's
 implementer brief carries it as binding.
 
+## Where the time went
+
+Every run report ends with a "Where the time went" section: total elapsed
+time, reconciled bucket durations (preflight, authoring, implementation,
+verification, review, recovery/fixes, git/persistence, whole-program review,
+reporting, and an explicit unattributed residual), the largest measured
+contributors, attempt and rerun counts by trigger, and observability gaps.
+It is descriptive arithmetic over the run's own recorded observations, never
+a score. See [docs/run-analytics.md](docs/run-analytics.md) for the full
+contract, including how to read each figure and the limits of what it
+claims.
+
+Right after it, a report may carry `## Why the time went there`: an
+optional, independent, read-only pass that traces those numbers toward
+planner-actionable causes, citing retained evidence for every step and
+saying plainly when it cannot close a chain. It never grades the run, never
+gates anything, and needs no configuration beyond `reviewerAgent`. See
+[docs/run-analytics.md](docs/run-analytics.md#reading-the-causal-analysis)
+for the four layers and what the evidence gate does and does not prove.
+
 ## Development
 
 Requires Node.js 22+.

package/dist/agent-runner.d.ts

@@ -1,5 +1,8 @@
 import type { AgentConfig, NightshiftConfig } from "./config.js";
-import type { AgentRole, PermitsContext } from "./permits.js";
+import { type AgentRole, type PermitsContext } from "./permits.js";
+import { type NormalizedTelemetry } from "./provider-telemetry.js";
+import { type Dimensions, type SpanScope } from "./run-analytics.js";
+import { type AgentSessionHandle, type SessionContinuity, type SessionContinuityRequest } from "./agent-session.js";
 /** A Bash command a Claude spawn actually ran, observed from its stream-json `tool_use` block. */
 export interface TranscriptCommand {
     command: string;
@@ -30,6 +33,16 @@ export interface AgentTranscript {
      * never be silently blessed as fully authoritative alongside `observed: true`.
      */
     corrupted?: boolean;
+    /**
+     * WS-03's provider-neutral normalization of this spawn's stream, when one
+     * was demultiplexed. Absent only for a spawn that never asked for
+     * stream-json output in the first place (`AgentTranscript` itself is
+     * absent then, so this field never needs to distinguish that case).
+     */
+    telemetry?: NormalizedTelemetry;
+    /** The session id observed on this spawn's stream (Claude only — a codex
+     *  spawn produces no transcript at all). WS-08. */
+    sessionId?: string;
 }
 export interface CommandResult {
     exitCode: number;
@@ -38,6 +51,31 @@ export interface CommandResult {
     inputError?: string;
     /** Present only for a Claude spawn whose args requested stream-json output. */
     transcript?: AgentTranscript;
+    /** The provider session id this spawn reported, when it reported one
+     *  (WS-08). Set by the `AgentRunner` — the raw observation. */
+    sessionId?: string;
+    /** The same id assembled into a resumable handle. Set by `invokeAgent`,
+     *  never by the runner, because only `invokeAgent` knows the derived
+     *  invocation and the cwd that go with it (WS-08). This is the field
+     *  every caller reads to advance its lineage's handle. */
+    session?: AgentSessionHandle;
+    /** How this spawn's session continuity resolved (WS-08). Present **only**
+     *  when the caller passed a `SessionContinuityRequest` — absent entirely
+     *  for the seats that never resume, which is what makes "no request" and
+     *  "requested but nothing captured" distinguishable downstream. */
+    continuity?: SessionContinuity;
+}
+/**
+ * Retains a spawn's raw stdout, gitignored, for SC-08's raw-source-event
+ * requirement — never throws; a failure is routed to `onError` and the
+ * caller omits the raw evidence reference rather than losing the spawn.
+ */
+export interface RawTranscriptSink {
+    /** Appends one raw stdout chunk, in arrival order. */
+    write(chunk: string): void;
+    /** Flushes and closes; resolves once the bytes are durable (or the sink gave up). */
+    close(): Promise<void>;
+    onError(err: unknown): void;
 }
 export interface AgentInvocation {
     command: string;
@@ -46,6 +84,8 @@ export interface AgentInvocation {
     promptMode: "stdin" | "argument";
     cwd: string;
     onOutput?: (chunk: string) => void;
+    /** Teed a copy of this spawn's raw stdout, when the caller wants one retained (WS-03). */
+    rawTranscript?: RawTranscriptSink;
 }
 export type AgentRunner = (invocation: AgentInvocation) => Promise<CommandResult>;
 export type VerifyRunner = (command: string, cwd: string) => Promise<CommandResult>;
@@ -73,8 +113,21 @@ export declare function runProcess(command: string, args: string[], options: {
      * fallback even though stdout was itself well-formed NDJSON.
      */
     onStdout?: (chunk: string) => void;
+    /**
+     * Stderr-only chunks, symmetric with `onStdout` (WS-08). Codex writes its
+     * startup header — including the `session id:` line — and its entire
+     * running transcript to stderr, writing only the agent's final message to
+     * stdout; a scanner fed from `onOutput` would also see the agent's own
+     * prose, which can contain any text at all.
+     */
+    onStderr?: (chunk: string) => void;
     env?: NodeJS.ProcessEnv;
 }): Promise<CommandResult>;
+/** The demultiplexer's telemetry inputs — the derived invocation's argv and command, for model precedence and the provider fallback (SC-05). */
+export interface TelemetryInputs {
+    configuredArgs: readonly string[];
+    command: string;
+}
 /**
  * Demultiplexes a whole captured stream-json string in one call — what
  * fixture-replay tests exercise. `undefined` means the input did not parse as
@@ -84,6 +137,13 @@ export declare function demultiplexClaudeStreamJson(raw: string): {
     output: string;
     transcript: AgentTranscript;
 } | undefined;
+/** The session id from one codex stderr line, when it is the anchored
+ *  `session id: <uuid>` header line — an embedded or prefixed occurrence
+ *  inside ordinary prose does not match. */
+export declare function captureCodexSessionIdFromStderr(line: string): string | undefined;
+/** The `thread_id` from one codex `--json`-mode stdout line, when it is a
+ *  well-formed `thread.started` event. */
+export declare function captureCodexSessionIdFromStdout(line: string): string | undefined;
 export declare const defaultAgentRunner: AgentRunner;
 export declare const defaultVerifyRunner: VerifyRunner;
 export declare function tail(output: string, limit?: number): string;
@@ -106,9 +166,15 @@ export interface TranscriptSink {
  * invocation and so cannot go through `invokeAgent` itself). A no-op when the
  * result carries no transcript at all (a non-Claude spawn, an operator-
  * configured or operator-`--output-format` role — never asked to be
- * observed).
+ * observed). Returns the repo-relative path actually written, so a caller
+ * (WS-03) can cite it as evidence; `undefined` when nothing was written.
+ *
+ * `nonce`, when given, names the file so it shares its stem with a raw
+ * sidecar `invokeAgent` allocated up front (WS-03); the probe has no such
+ * sidecar and lets this mint its own, exactly as it did before this
+ * parameter existed.
  */
-export declare function recordAgentTranscript(observe: TranscriptSink, role: string, result: CommandResult): Promise<void>;
+export declare function recordAgentTranscript(observe: TranscriptSink, role: string, result: CommandResult, nonce?: string): Promise<string | undefined>;
 /**
  * Spawns a configured agent role with a prompt; shared by every brief
  * spawner. `permits` derives the posture for this role/agent/host before the
@@ -119,9 +185,33 @@ export declare function recordAgentTranscript(observe: TranscriptSink, role: str
  *
  * `observe`, when given, writes the spawn's transcript (if one was observed)
  * as JSONL under `build-logs/<programId>/` and logs the path — the one place
- * this happens, rather than duplicated across every spawning call site.
+ * this happens, rather than duplicated across every spawning call site. It
+ * also names a raw stdout sidecar (WS-03, SC-08), teed during the spawn and
+ * `close()`-awaited before any evidence reference resolves to it.
+ *
+ * `recorder`, when given, opens a span around the spawn (WS-01) and — after
+ * the spawn returns — receives one `provider-telemetry` point per
+ * SC-08-enumerated metric (WS-03), correlated by the `role` dimension and
+ * the normalized/raw transcript paths as evidence. A caller with no
+ * run-scoped recorder to hand gets a shared, permanently disarmed default
+ * that buffers harmlessly and performs no I/O — telemetry emission is then
+ * simply a no-op, never a thrown error.
+ *
+ * `spanDims`, when given, overrides the role-derived default stage/dimensions
+ * (WS-02) — the call site is the only party that knows which of a reused
+ * role's several stages (e.g. `reviewerAgent` driving `test-critique`,
+ * `failure-diagnosis`, or `whole-program-review`) this particular spawn is,
+ * plus the workstream/attempt dimensions. A caller that passes nothing keeps
+ * today's `STAGE_FOR_ROLE` default, so every pre-WS-02 call site (the doctor
+ * probe, standalone tests) is unaffected.
  */
-export declare function invokeAgent(runner: AgentRunner, agent: AgentConfig, prompt: string, cwd: string, permits: PermitsContext, role: AgentRole, observe?: TranscriptSink): Promise<CommandResult>;
+export declare function invokeAgent(runner: AgentRunner, agent: AgentConfig, prompt: string, cwd: string, permits: PermitsContext, role: AgentRole, observe?: TranscriptSink, recorder?: SpanScope, spanDims?: Partial<Dimensions>, 
+/** Present only for the three seats that may continue a session (SC-13,
+ *  WS-08); its presence is the permission and its `handle` is the
+ *  candidate. Omitted everywhere else, which is how reviewer, decider,
+ *  recovery and informed-retry seats are structurally incapable of
+ *  resuming — not by a runtime check they could forget. */
+continuityRequest?: SessionContinuityRequest): Promise<CommandResult>;
 /**
  * The implementer: the `agent` block, or the environment fallback for hosts
  * that have no config file yet.

package/dist/agent-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-runner.d.ts","sourceRoot":"","sources":["../src/agent-runner.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9D,kGAAkG;AAClG,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,yFAAyF;AACzF,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAC9B,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,+EAA+E;IAC/E,UAAU,CAAC,EAAE,eAAe,CAAC;CAC9B;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,OAAO,GAAG,UAAU,CAAC;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,UAAU,EAAE,eAAe,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;AAClF,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;AAMpF;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,GAAE,MAAM,CAAC,UAAwB,GACpC,MAAM,CAAC,UAAU,CAQnB;AAED,wBAAgB,UAAU,CACxB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE;IACP,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB,GACA,OAAO,CAAC,aAAa,CAAC,CA+CxB;AAwRD;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,MAAM,GACV;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,eAAe,CAAA;CAAE,GAAG,SAAS,CAI7D;AAED,eAAO,MAAM,kBAAkB,EAAE,WAiDhC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,YACa,CAAC;AAEhD,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,SAAO,GAAG,MAAM,CAEzD;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7B;AAqBD;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,IAAI,CAAC,CAef;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,SAAS,EACf,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,aAAa,CAAC,CAWxB;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,gBAAgB,GAAG,WAAW,GAAG,SAAS,CAO9E;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,WAAW,CAAC;IACnB,4DAA4D;IAC5D,mBAAmB,EAAE,OAAO,CAAC;CAC9B;AAED,kEAAkE;AAClE,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,gBAAgB,GACvB,qBAAqB,GAAG,SAAS,CAOnC;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,WAAW,CAAC;IACnB,0DAA0D;IAC1D,mBAAmB,EAAE,OAAO,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,gBAAgB,GACvB,mBAAmB,GAAG,SAAS,CAOjC;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,gBAAgB,GACvB,WAAW,GAAG,SAAS,CAEzB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,gBAAgB,GACvB,WAAW,GAAG,SAAS,CAOzB;AAED,2EAA2E;AAC3E,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAExD"}
+{"version":3,"file":"agent-runner.d.ts","sourceRoot":"","sources":["../src/agent-runner.ts"],"names":[],"mappings":"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"}