@dpeek/codeless 0.1.1 → 0.1.2

package/README.md

@@ -97,7 +97,7 @@ the runner does not generate or copy project instructions.
 The package-owned planner extension activates every planner session. Before its
 first project prompt, it requires the exact `<slug>-planner` Pi name, establishes
 and verifies the `<slug>_planner` Herdr identity, and confirms `approve_stream_change`,
-`dispatch_stream_implementer`, and `next_stream_change` are active. Missing or
+`dispatch_stream_implementer`, `rework_stream_implementer`, `finish_stream_implementer`, and `next_stream_change` are active. Missing or
 incompatible activation, identity mismatch, or inactive tools stops before
 `/change`; global Pi extension installation is unnecessary.
 The approval tool has no arguments. Its extension derives the active
@@ -182,6 +182,8 @@ codeless open <slug>
 codeless planner <slug>
 codeless approve <planner-session>
 codeless dispatch <numbered-change-file>
+codeless rework <numbered-change-file> <feedback>
+codeless finish <numbered-change-file>
 codeless land <slug>
 codeless next <numbered-change-file> <landed-commit>
 codeless metrics
@@ -199,9 +201,15 @@ starts Pi in an existing stream's lone shell after the same role preflight. Its
 activation establishes the same identity as creation and reopening.
 Dispatch validates the implementer selection before touching the planner's
 right-hand pane, starts a fresh ephemeral implementer with Codeless's reporting
-extension and its explicit Pi extension flag, and waits for completion. Its JSON
-result is a normalized attempt report, which the planner tool exposes before
-queueing review. It includes the actual settled model/thinking selection,
+extension and its explicit Pi extension flag, and waits for completion. Rework verifies
+that same change's idle implementer and worktree, invokes one package-owned Pi command
+that verifies its immutable stream/change scope, arms reporting, and submits one feedback
+turn with the same one-hour limit, records a `rework`
+attempt, and returns it before review is queued again. Finish verifies that identity,
+gracefully exits it, and waits for the right pane's stream-worktree shell. Neither operation
+replaces the agent, changes its selection, retries, or continues after a mismatch, timeout,
+blocked agent, or ambiguous pane. Its JSON result is a normalized attempt report, which the
+planner tool exposes before queueing review. It includes the actual settled model/thinking selection,
 terminal text and outcome, full-session Pi usage and available Pi cost estimate,
 timestamps, and tool/error counts; prompts, source, thinking, credentials, and
 transcripts are not retained.
@@ -216,11 +224,17 @@ integration fast-forward, Codeless records the landed time and commit on that
 change's canonical record, creating a landed record without elapsed time when
 dispatch collection was unavailable; collection warnings never alter dispatch or
 landing.
-`codeless metrics` prints every recorded stream and a project total. Its elapsed
-columns are dispatch-to-land wall-clock time; among landed changes, records
+`codeless metrics` prints every recorded stream and a project total. Its first
+table reports dispatch-to-land wall-clock time; among landed changes, records
 without a measured duration are explicitly unavailable. Dispatched-but-unlanded
-changes remain a separate count. Metrics are prospective local observations, not
-journal state or a recovery mechanism.
+changes remain a separate count. Its second table reports implementer attempts:
+distinct changes with rework, initial and rework turns, incomplete collection,
+exact stored terminal outcomes, and tool errors. Usage and cost coverage count
+measured attempts separately from unavailable collection; token totals include
+only measured usage, and cost totals remain grouped by recorded currency without
+conversion. These counts do not establish implementation quality or review
+success. Metrics are prospective local observations, not journal state or a
+recovery mechanism.
 
 Landing requires clean stream and integration worktrees and exactly one stream
 commit outside their merge base. It acquires `.land-lock` atomically, recording

package/extension/implementer-reporting.js

@@ -74,23 +74,89 @@ function write(path, value) {
 export default function implementerReportingExtension(pi) {
   pi.registerFlag("codeless-attempt", { type: "string" });
   let configuration;
+  let startupScope;
+  let rearm;
   let startedAt;
+  let entryOffset = 0;
   let toolCalls = 0;
   let errorCount = 0;
+
+  function configure(value, offset = 0) {
+    if (
+      typeof value?.path !== "string" ||
+      typeof value?.id !== "string" ||
+      typeof value?.stream !== "string" ||
+      typeof value?.change !== "string" ||
+      !["initial", "rework"].includes(value?.kind)
+    )
+      throw new Error("Codeless attempt configuration is invalid");
+    return { value, offset };
+  }
   pi.on("session_start", () => {
     try {
       const value = JSON.parse(pi.getFlag("codeless-attempt") ?? "");
-      if (
-        typeof value?.path === "string" &&
-        typeof value?.id === "string" &&
-        typeof value?.stream === "string" &&
-        typeof value?.change === "string"
-      )
-        configuration = value;
+      configuration = configure(value).value;
+      startupScope = { stream: configuration.stream, change: configuration.change };
     } catch {}
   });
+  function requireScope(value) {
+    if (
+      startupScope === undefined ||
+      value?.stream !== startupScope.stream ||
+      value?.change !== startupScope.change
+    )
+      throw new Error("Codeless stream/change scope does not match this implementer session");
+  }
+
+  pi.registerCommand("codeless-rework", {
+    description: "Submit one scope-verified Codeless implementer rework turn",
+    handler: async (args, ctx) => {
+      let value;
+      try {
+        value = JSON.parse(args);
+      } catch {
+        throw new Error("Codeless rework requires one JSON-quoted request");
+      }
+      requireScope(value);
+      if (typeof value?.feedback !== "string" || value.feedback.trim().length === 0)
+        throw new Error("Codeless rework requires concise non-empty feedback");
+      const next = configure(value, ctx.sessionManager.getEntries().length);
+      if (next.value.kind !== "rework") throw new Error("Codeless rework attempt must be rework");
+      configuration = undefined;
+      rearm = next;
+      try {
+        pi.sendUserMessage(`Review feedback: ${value.feedback.trim()}`, { deliverAs: "followUp" });
+      } catch (error) {
+        rearm = undefined;
+        throw error;
+      }
+    },
+  });
+
+  pi.registerCommand("codeless-finish", {
+    description: "Gracefully finish a scope-verified Codeless implementer",
+    handler: async (args, ctx) => {
+      let value;
+      try {
+        value = JSON.parse(args);
+      } catch {
+        throw new Error("Codeless finish requires one JSON-quoted scope");
+      }
+      requireScope(value);
+      await ctx.shutdown();
+    },
+  });
   pi.on("agent_start", () => {
-    startedAt ??= new Date().toISOString();
+    if (rearm !== undefined) {
+      configuration = rearm.value;
+      entryOffset = rearm.offset;
+      rearm = undefined;
+      startedAt = new Date().toISOString();
+      toolCalls = 0;
+      errorCount = 0;
+    } else {
+      startedAt ??= new Date().toISOString();
+    }
   });
   pi.on("tool_execution_end", (event) => {
     toolCalls += 1;
@@ -100,9 +166,10 @@ export default function implementerReportingExtension(pi) {
     if (configuration === undefined) return;
     const report = configuration;
     configuration = undefined;
-    const settledMessages = messages(ctx.sessionManager.getEntries());
+    const entries = ctx.sessionManager.getEntries().slice(entryOffset);
+    const settledMessages = messages(entries);
     const final = [...settledMessages].reverse().find((message) => message.role === "assistant");
-    const totals = sessionUsage(ctx.sessionManager.getEntries());
+    const totals = sessionUsage(entries);
     const model = final?.responseModel ?? final?.model ?? ctx.model?.id;
     const provider = final?.provider ?? ctx.model?.provider;
     const selection =
@@ -123,6 +190,7 @@ export default function implementerReportingExtension(pi) {
       stream: report.stream,
       change: report.change,
       role: "implementer",
+      kind: report.kind,
       startedAt: startedAt ?? new Date().toISOString(),
       endedAt: new Date().toISOString(),
       ...(selection === undefined ? {} : { selection }),

package/extension/planner.js

@@ -6,6 +6,8 @@ const thinkingLevels = new Set(["off", "minimal", "low", "medium", "high", "xhig
 const requiredTools = [
   "approve_stream_change",
   "dispatch_stream_implementer",
+  "rework_stream_implementer",
+  "finish_stream_implementer",
   "next_stream_change",
 ];
 
@@ -290,6 +292,98 @@ export default function plannerExtension(pi) {
       },
     });
 
+    pi.registerTool({
+      name: "rework_stream_implementer",
+      label: "Remediate stream implementation",
+      description:
+        "Reuse the idle implementer for this approved change, submit one actionable feedback turn, collect its rework attempt, and queue review again.",
+      promptSnippet: "Send one concise remediation request to the existing stream implementer",
+      promptGuidelines: [
+        "Call rework_stream_implementer only when review finds actionable defects in the approved change. Use its approved changePath and concise feedback; never reproduce Herdr commands.",
+        "The tool queues review only after a settled rework attempt. Stop on any error and do not retry automatically.",
+      ],
+      parameters: {
+        type: "object",
+        properties: {
+          changePath: {
+            type: "string",
+            description: "Absolute path to the approved changes/NNN.md file",
+          },
+          feedback: { type: "string", description: "Concise actionable review feedback" },
+        },
+        required: ["changePath", "feedback"],
+        additionalProperties: false,
+      },
+      async execute(_toolCallId, params, signal) {
+        const changePath = params.changePath.replace(/^@/, "");
+        const execution = await pi.exec("bun", [codeless, "rework", changePath, params.feedback], {
+          signal,
+          timeout: 3_700_000,
+        });
+        const output = [execution.stdout.trim(), execution.stderr.trim()]
+          .filter(Boolean)
+          .join("\n");
+        if (execution.code !== 0)
+          throw new Error(output || `codeless rework failed with exit code ${execution.code}`);
+        let attempt;
+        try {
+          attempt = JSON.parse(execution.stdout);
+        } catch {
+          throw new Error("Codeless returned an invalid rework attempt");
+        }
+        if (!validAttempt(attempt, attempt?.stream, attempt?.change) || attempt.kind !== "rework")
+          throw new Error("Codeless returned an invalid rework attempt");
+        pi.sendUserMessage(`/review ${JSON.stringify(changePath)}`, {
+          deliverAs: "steer",
+          expandPromptTemplates: true,
+        });
+        return {
+          content: [{ type: "text", text: attempt.text || "Implementer rework settled." }],
+          details: { changePath, attempt },
+        };
+      },
+    });
+
+    pi.registerTool({
+      name: "finish_stream_implementer",
+      label: "Finish stream implementer",
+      description:
+        "Gracefully exit the verified idle implementer after review approval and confirm its right-hand pane returned to the stream shell.",
+      promptSnippet: "Finish the approved stream implementer before commit and landing",
+      promptGuidelines: [
+        "Call finish_stream_implementer exactly once after recording review approval and before following commit-and-land instructions.",
+        "Stop on failure; do not use Herdr commands or continue to commit and land.",
+      ],
+      parameters: {
+        type: "object",
+        properties: {
+          changePath: {
+            type: "string",
+            description: "Absolute path to the approved changes/NNN.md file",
+          },
+        },
+        required: ["changePath"],
+        additionalProperties: false,
+      },
+      async execute(_toolCallId, params, signal) {
+        const changePath = params.changePath.replace(/^@/, "");
+        const execution = await pi.exec("bun", [codeless, "finish", changePath], {
+          signal,
+          timeout: 35_000,
+        });
+        const output = [execution.stdout.trim(), execution.stderr.trim()]
+          .filter(Boolean)
+          .join("\n");
+        if (execution.code !== 0)
+          throw new Error(output || `codeless finish failed with exit code ${execution.code}`);
+        return {
+          content: [
+            { type: "text", text: "Implementer exited and its pane returned to the stream shell." },
+          ],
+        };
+      },
+    });
+
     pi.registerTool({
       name: "dispatch_stream_implementer",
       label: "Dispatch stream implementer",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dpeek/codeless",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "An attended planner and implementer workflow for parallel capability development",
   "homepage": "https://github.com/dpeek/codeless#readme",
   "bugs": {

package/spec/workflow.md

@@ -103,8 +103,8 @@ post-landing replacement—uses the package-owned extension as its activation
 boundary. Before its first project prompt, activation requires the exact
 `<slug>-planner` Pi session name, establishes and verifies Herdr reports
 `<slug-with-hyphens-replaced>_planner`, and verifies
-`approve_stream_change`, `dispatch_stream_implementer`, and
-`next_stream_change` are active. Missing or incompatible activation, identity
+`approve_stream_change`, `dispatch_stream_implementer`, `rework_stream_implementer`,
+`finish_stream_implementer`, and `next_stream_change` are active. Missing or incompatible activation, identity
 mismatch, or an incomplete tool set stops visibly before `/change`. A direct
 restart may begin with Herdr's `pi` fallback identity; activation renames and
 rereads only that fallback. Any other identity mismatch stops. Implementers use
@@ -139,13 +139,22 @@ repeating a settled implementation.
 
 The planner inspects the full diff and relevant code, checks the approved
 acceptance criteria, and runs focused checks when the implementation output is
-insufficient. Remediation reuses the same implementer context. Once approved,
-the planner records the review result, exits the implementer so its pane returns
-to a shell, and follows the commit-and-land prompt without another approval
-round.
-
-Dispatch and remediation do not retry automatically. Remediation and implementer
-shutdown are still performed through prompt-owned Herdr commands.
+insufficient. The planner-only `rework_stream_implementer` tool accepts that
+approved path and concise feedback, verifies the expected idle implementer, its
+right-hand pane and worktree, then invokes one package-owned Pi command. That command
+verifies the immutable startup stream/change scope, arms package reporting in the existing
+conversation, and submits one bounded feedback turn. It records
+and returns one `rework` attempt before queueing review again; missing or malformed
+reports warn and yield an incomplete attempt after settlement. Prompt rejection,
+timeout, blocked state, identity/worktree/change mismatch, or ambiguous pane stops
+without a completed attempt or queued review. The separate planner-only
+`finish_stream_implementer` tool first verifies that immutable stream/change scope in the
+same idle implementer, then gracefully exits it and waits for its pane to become the
+stream-worktree shell. Its failure
+stops before commit or landing instructions continue.
+
+Dispatch, remediation, and shutdown do not retry automatically or replace an
+implementer session or its selected model.
 
 ## Commit and landing
 
@@ -194,16 +203,21 @@ unchanged. Successful landing adds its timestamp and commit, or creates a landed
 record with unavailable elapsed time when dispatch collection was unavailable.
 Collection warnings do not change dispatch or landing outcomes.
 
-`codeless metrics` reports every recorded stream and a project total with:
-
-- landed and dispatched-but-unlanded change counts;
-- measured versus unavailable elapsed coverage; and
-- total and average dispatch-to-land wall-clock time.
-
-The measurements are prospective, local observations. They are not journal
-state, an approval source, or a recovery mechanism. Attempt usage and cost are
-stored for later aggregation; `codeless metrics`, review rework, and failure
-breakdowns do not yet report them.
+`codeless metrics` reports every recorded stream and a project total in two
+tables. The elapsed table reports landed and dispatched-but-unlanded change
+counts, measured versus unavailable elapsed coverage, and total and average
+dispatch-to-land wall-clock time. The attempt table aggregates only validated
+canonical attempt records and reports distinct changes with rework, initial and
+rework turns, incomplete collection, exact stored terminal-outcome labels, and
+summed tool errors.
+
+Usage coverage is measured versus unavailable attempts; input, output,
+cache-read, and cache-write totals include only attempts with recorded usage.
+Cost coverage follows the same rule, and totals are grouped by recorded currency
+without conversion. Missing usage or cost is unavailable, never zero. These
+measurements do not establish implementation quality or review success. They
+are prospective local observations, not journal state, an approval source, or a
+recovery mechanism.
 
 ## Limits
 

package/src/attempt.ts

@@ -3,6 +3,7 @@ export type Attempt = {
   stream: string;
   change: string;
   role: "implementer";
+  kind: "initial" | "rework";
   startedAt: string;
   endedAt: string;
   selection?: { provider: string; model: string; thinking: string };
@@ -23,6 +24,7 @@ export function validAttempt(value: unknown, stream: string, change: string): va
     "stream",
     "change",
     "role",
+    "kind",
     "startedAt",
     "endedAt",
     "selection",
@@ -34,7 +36,7 @@ export function validAttempt(value: unknown, stream: string, change: string): va
     "errorCount",
     "incomplete",
   ]);
-  const strings = ["id", "stream", "change", "role", "startedAt", "endedAt", "outcome"];
+  const strings = ["id", "stream", "change", "role", "kind", "startedAt", "endedAt", "outcome"];
   if (
     !Object.keys(attempt).every((key) => allowed.has(key)) ||
     !strings.every((key) => typeof attempt[key] === "string" && attempt[key].length > 0) ||
@@ -43,6 +45,7 @@ export function validAttempt(value: unknown, stream: string, change: string): va
     attempt["stream"] !== stream ||
     attempt["change"] !== change ||
     attempt["role"] !== "implementer" ||
+    !["initial", "rework"].includes(attempt["kind"] as string) ||
     !Number.isSafeInteger(attempt["toolCalls"]) ||
     (attempt["toolCalls"] as number) < 0 ||
     !Number.isSafeInteger(attempt["errorCount"]) ||

package/src/cli.ts

@@ -28,6 +28,8 @@ const usage = `Usage:
   codeless planner <slug>
   codeless approve <planner-session>
   codeless dispatch <numbered-change-file>
+  codeless rework <numbered-change-file> <feedback>
+  codeless finish <numbered-change-file>
   codeless land <slug>
   codeless next <numbered-change-file> <landed-commit>
   codeless metrics`;
@@ -386,9 +388,9 @@ export async function runCodeless(args: string[]): Promise<void> {
         return Number(rect["x"]) >= rightEdge && candidateTop < bottom && candidateBottom > top;
       })
       .sort((left, right) => Number(left["rect"]["x"]) - Number(right["rect"]["x"]));
-    return candidates.length === 0
-      ? undefined
-      : string(candidates[0]!.pane["pane_id"], "right-hand pane id");
+    if (candidates.length === 0) return undefined;
+    if (candidates.length > 1) throw new Error("Planner layout has an ambiguous right-hand pane");
+    return string(candidates[0]!.pane["pane_id"], "right-hand pane id");
   }
 
   function requirePaneShell(pane: string, worktree: string): void {
@@ -443,7 +445,8 @@ export async function runCodeless(args: string[]): Promise<void> {
     id: string,
     slug: string,
     number: string,
-    selection: { provider: string; model: string; thinking: string },
+    selection: { provider: string; model: string; thinking: string } | undefined,
+    kind: "initial" | "rework",
   ): Attempt {
     const timestamp = new Date().toISOString();
     return {
@@ -451,9 +454,10 @@ export async function runCodeless(args: string[]): Promise<void> {
       stream: slug,
       change: number,
       role: "implementer",
+      kind,
       startedAt: timestamp,
       endedAt: timestamp,
-      selection,
+      ...(selection === undefined ? {} : { selection }),
       outcome: "unknown",
       toolCalls: 0,
       errorCount: 0,
@@ -469,6 +473,7 @@ export async function runCodeless(args: string[]): Promise<void> {
       attempt.stream !== fallback.stream ||
       attempt.change !== fallback.change ||
       attempt.role !== "implementer" ||
+      attempt.kind !== fallback.kind ||
       typeof attempt.startedAt !== "string" ||
       typeof attempt.endedAt !== "string" ||
       typeof attempt.outcome !== "string" ||
@@ -708,7 +713,7 @@ export async function runCodeless(args: string[]): Promise<void> {
     const selection = readProject(worktree).implementer;
     const attemptId = crypto.randomUUID();
     const reportPath = join(workspaceRoot, "metrics", slug, `.attempt-${attemptId}.json`);
-    const fallbackAttempt = incompleteAttempt(attemptId, slug, number, selection);
+    const fallbackAttempt = incompleteAttempt(attemptId, slug, number, selection, "initial");
     observe("dispatch metrics", () => recordDispatch(workspaceRoot, slug, number));
     await validateRoleSelection("implementer", selection, worktree);
 
@@ -766,6 +771,7 @@ export async function runCodeless(args: string[]): Promise<void> {
       id: attemptId,
       stream: slug,
       change: number,
+      kind: "initial",
       path: reportPath,
     });
     const started = herdr([
@@ -822,6 +828,108 @@ export async function runCodeless(args: string[]): Promise<void> {
     console.log(JSON.stringify(attempt));
   }
 
+  function activeImplementer(changeArgument: string): {
+    change: string;
+    slug: string;
+    number: string;
+    worktree: string;
+    implementerName: string;
+    pane: string;
+  } {
+    if (process.env["HERDR_ENV"] !== "1")
+      throw new Error("Implementer control must run from a Herdr-managed planner");
+    const { change, slug, number, worktree, branch } = requireChange(changeArgument);
+    if (canonicalPath(process.cwd()) !== worktree)
+      throw new Error(`Implementer control cwd is ${process.cwd()}, expected ${worktree}`);
+    if (run("git", ["branch", "--show-current"], worktree).trim() !== branch)
+      throw new Error(`${worktree} is not on ${branch}`);
+    const plannerPane = string(process.env["HERDR_PANE_ID"], "HERDR_PANE_ID");
+    const plannerProcesses = foregroundProcesses(paneProcessInfo(plannerPane));
+    if (
+      !plannerProcesses.some(
+        (process) => canonicalPath(string(process["cwd"], "planner cwd")) === worktree,
+      )
+    )
+      throw new Error(`Planner pane ${plannerPane} is not running in ${worktree}`);
+    const layout = object(
+      result(herdr(["pane", "layout", "--pane", plannerPane]))["layout"],
+      "result.layout",
+    );
+    const pane = rightPane(layout, plannerPane);
+    if (pane === undefined) throw new Error("Planner has no right-hand implementer pane");
+    const implementerName = `${slug.replaceAll("-", "_")}_impl`;
+    const agent = object(result(herdr(["agent", "get", pane]))["agent"], "result.agent");
+    if (string(agent["name"], "result.agent.name") !== implementerName)
+      throw new Error(`Right-hand pane ${pane} is not implementer ${implementerName}`);
+    if (!["idle", "done"].includes(string(agent["agent_status"], "result.agent.agent_status")))
+      throw new Error(`Implementer ${implementerName} is not settled`);
+    const agentCwd = string(agent["foreground_cwd"] ?? agent["cwd"], "result.agent.foreground_cwd");
+    if (canonicalPath(agentCwd) !== worktree)
+      throw new Error(`Implementer ${implementerName} is in ${agentCwd}, expected ${worktree}`);
+    const processes = foregroundProcesses(paneProcessInfo(pane));
+    if (
+      !processes.some(
+        (process) => canonicalPath(string(process["cwd"], "implementer cwd")) === worktree,
+      )
+    )
+      throw new Error(`Implementer pane ${pane} is not running in ${worktree}`);
+    return { change, slug, number, worktree, implementerName, pane };
+  }
+
+  async function rework(changeArgument: string, feedback: string): Promise<void> {
+    if (feedback.trim().length === 0 || feedback.trim().length > 2_000)
+      throw new Error("Rework feedback must be concise non-empty text");
+    const { slug, number, implementerName } = activeImplementer(changeArgument);
+    const attemptId = crypto.randomUUID();
+    const reportPath = join(workspaceRoot, "metrics", slug, `.attempt-${attemptId}.json`);
+    const fallbackAttempt = incompleteAttempt(attemptId, slug, number, undefined, "rework");
+    const collection = JSON.stringify({
+      id: attemptId,
+      stream: slug,
+      change: number,
+      kind: "rework",
+      path: reportPath,
+      feedback: feedback.trim(),
+    });
+    run("herdr", [
+      "agent",
+      "prompt",
+      implementerName,
+      `/codeless-rework ${collection}`,
+      "--wait",
+      "--timeout",
+      "3600000",
+    ]);
+    let attempt = fallbackAttempt;
+    try {
+      attempt = collectedAttempt(JSON.parse(readFileSync(reportPath, "utf8")), fallbackAttempt);
+      if (attempt === fallbackAttempt) throw new Error("report did not match its rework attempt");
+    } catch (error) {
+      console.error(
+        `codeless: warning: could not collect implementer attempt: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    } finally {
+      if (existsSync(reportPath)) unlinkSync(reportPath);
+    }
+    observe("implementer attempt", () => recordAttempt(workspaceRoot, slug, number, attempt));
+    console.log(JSON.stringify(attempt));
+  }
+
+  function finish(changeArgument: string): void {
+    const { slug, number, worktree, implementerName, pane } = activeImplementer(changeArgument);
+    run("herdr", [
+      "agent",
+      "prompt",
+      implementerName,
+      `/codeless-finish ${JSON.stringify({ stream: slug, change: number })}`,
+      "--wait",
+      "--timeout",
+      "30000",
+    ]);
+    requirePaneShell(pane, worktree);
+    console.log(JSON.stringify({ pane, worktree }));
+  }
+
   async function launchPlanner(slug: string): Promise<void> {
     if (process.env["HERDR_ENV"] !== "1") {
       throw new Error("Run codeless planner from the stream's Herdr-managed shell");
@@ -997,6 +1105,16 @@ export async function runCodeless(args: string[]): Promise<void> {
     await dispatch(target);
     return;
   }
+  if (action === "rework") {
+    if (target === undefined || details.length !== 1) throw new Error(usage);
+    await rework(target, details[0]!);
+    return;
+  }
+  if (action === "finish") {
+    if (target === undefined || details.length > 0) throw new Error(usage);
+    finish(target);
+    return;
+  }
   if (action === "next") {
     if (target === undefined || details.length !== 1) throw new Error(usage);
     await nextChange(target, details[0]!);

package/src/metrics.ts

@@ -201,12 +201,98 @@ export function metricReport(workspaceRoot: string): string[] {
     return `${name}\t${value.landed}\t${value.unlanded}\t${value.coverage}\t${value.total}\t${value.average}`;
   };
   const rows = [...byStream.entries()].map(([stream, records]) => ({ stream, records }));
+  const allRecords = rows.flatMap(({ records }) => records);
+  const formatCost = (amounts: number[]) => {
+    const parts = amounts.map((amount) => {
+      const [coefficient, exponent = "0"] = String(amount).toLowerCase().split("e");
+      const [whole, fraction = ""] = coefficient!.split(".");
+      return { digits: BigInt(`${whole}${fraction}`), scale: fraction.length - Number(exponent) };
+    });
+    const scale = Math.max(0, ...parts.map((part) => part.scale));
+    const total = parts.reduce(
+      (sum, part) => sum + part.digits * 10n ** BigInt(scale - part.scale),
+      0n,
+    );
+    const digits = total.toString().padStart(scale + 1, "0");
+    if (scale === 0) return digits;
+    const fraction = digits.slice(-scale).replace(/0+$/, "");
+    return fraction.length === 0
+      ? digits.slice(0, -scale)
+      : `${digits.slice(0, -scale)}.${fraction}`;
+  };
+  const attemptSummary = (records: Metric[]) => {
+    const attempts = records.flatMap((record) => Object.values(record.attempts ?? {}));
+    const usage = attempts.filter((attempt) => attempt.usage !== undefined);
+    const costs = attempts.filter((attempt) => attempt.cost !== undefined);
+    const outcomes = new Map<string, number>();
+    const currencies = new Map<string, number[]>();
+    for (const attempt of attempts) {
+      outcomes.set(attempt.outcome, (outcomes.get(attempt.outcome) ?? 0) + 1);
+      if (attempt.cost !== undefined)
+        currencies.set(attempt.cost.currency, [
+          ...(currencies.get(attempt.cost.currency) ?? []),
+          attempt.cost.amount,
+        ]);
+    }
+    const coverage = (measured: number) =>
+      `${measured} measured, ${attempts.length - measured} unavailable`;
+    return {
+      reworkedChanges: new Set(
+        records
+          .filter((record) =>
+            Object.values(record.attempts ?? {}).some((attempt) => attempt.kind === "rework"),
+          )
+          .map((record) => `${record.stream}\0${record.change}`),
+      ).size,
+      initial: attempts.filter((attempt) => attempt.kind === "initial").length,
+      rework: attempts.filter((attempt) => attempt.kind === "rework").length,
+      incomplete: attempts.filter((attempt) => attempt.incomplete).length,
+      outcomes:
+        outcomes.size === 0
+          ? "none"
+          : [...outcomes.entries()]
+              .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+              .map(([outcome, count]) => `${outcome}: ${count}`)
+              .join(", "),
+      toolErrors: attempts.reduce((total, attempt) => total + attempt.errorCount, 0),
+      usageCoverage: coverage(usage.length),
+      input:
+        usage.length === 0
+          ? "unavailable"
+          : usage.reduce((total, attempt) => total + attempt.usage!.input, 0),
+      output:
+        usage.length === 0
+          ? "unavailable"
+          : usage.reduce((total, attempt) => total + attempt.usage!.output, 0),
+      cacheRead:
+        usage.length === 0
+          ? "unavailable"
+          : usage.reduce((total, attempt) => total + attempt.usage!.cacheRead, 0),
+      cacheWrite:
+        usage.length === 0
+          ? "unavailable"
+          : usage.reduce((total, attempt) => total + attempt.usage!.cacheWrite, 0),
+      costCoverage: coverage(costs.length),
+      costs:
+        currencies.size === 0
+          ? "unavailable"
+          : [...currencies.entries()]
+              .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+              .map(([currency, amounts]) => `${currency} ${formatCost(amounts)}`)
+              .join(", "),
+    };
+  };
+  const attemptRow = (name: string, records: Metric[]) => {
+    const value = attemptSummary(records);
+    return `${name}\t${value.reworkedChanges}\t${value.initial}\t${value.rework}\t${value.incomplete}\t${value.outcomes}\t${value.toolErrors}\t${value.usageCoverage}\t${value.input}\t${value.output}\t${value.cacheRead}\t${value.cacheWrite}\t${value.costCoverage}\t${value.costs}`;
+  };
   return [
     "Stream\tLanded\tNot landed\tElapsed coverage\tDispatch-to-land wall clock total\tAverage",
     ...rows.map(({ stream, records }) => row(stream, records)),
-    row(
-      "Project total",
-      rows.flatMap(({ records }) => records),
-    ),
+    row("Project total", allRecords),
+    "",
+    "Stream\tChanges with rework\tInitial attempts\tRework attempts\tIncomplete collection\tTerminal outcomes\tTool errors\tUsage coverage\tInput tokens\tOutput tokens\tCache-read tokens\tCache-write tokens\tCost coverage\tCost totals",
+    ...rows.map(({ stream, records }) => attemptRow(stream, records)),
+    attemptRow("Project total", allRecords),
   ];
 }