Read narrated workflow results without repeating completed work

.agents/implementor.md

@@ -127,6 +127,13 @@ behavior, ownership and evidence already fit the accepted plan.
 
 ## Working discipline
 
+When a command outlives its tool call, retain the tool's task handle and read
+its completion result. In one owning shell, retain the child's PID and use
+`wait` for that child. Never infer completion by searching process command
+text with `pgrep -f`; the waiting shell can match itself. Preserve the first
+output and exit status, and reuse that receipt instead of launching duplicate
+waiters or repeating the command.
+
 - Preserve unrelated user changes and use a separate worktree when the current
   tree is not the intended branch.
 - Follow the repository Code Rules and Effection lifecycle contract.

.agents/planner.md

@@ -51,6 +51,13 @@ can act without guessing or rereading.
 The Planner writes code during API design and repair assignments. Review
 assignments remain read-only. Return publication work to the Sidekick.
 
+When a command outlives its tool call, retain the tool's task handle and read
+its completion result. In one owning shell, retain the child's PID and use
+`wait` for that child. Never infer completion by searching process command
+text with `pgrep -f`; the waiting shell can match itself. Preserve the first
+output and exit status, and reuse that receipt instead of launching duplicate
+waiters or repeating the command.
+
 ## Decision completeness
 
 A plan is decision-complete when the Implementor does not need to choose:

examples/adversarial-implementation/README.md

@@ -113,6 +113,20 @@ review remain responsible for that judgment.
 
 ## Challenge, repair and review
 
+Captured replies pass through the workflow's existing `<Phase.Extract>` and
+`<SafeParse>` for schema validation.
+One narrated or fenced JSON result is accepted without another agent call.
+Multiple candidates, incomplete JSON and unclosed fences hold with the original
+reply and diagnostics. Schema matching never chooses between candidates.
+
+When the only invalid fields are an oversized summary or handoff, foundation
+response correction can shorten those fields in the same Planner session, at
+most three times. Every other field is frozen, including the API, source,
+assessment and evidence. Each correction saves its request, raw reply and
+disposition, and checks that source remains at the same clean commit. The
+productive assignment is not repeated. An ambiguous or substantively invalid
+reply has no established result to repair and holds without another prompt.
+
 The Implementor keeps passing work in a focused commit and saves a failed API
 witness outside the source checkout. It returns `needs_discovery` with
 `apiConflict: { expected, observed, reproducer, artifact }`, failed command

examples/adversarial-implementation/components/Adversarial/Foundation.md

@@ -23,10 +23,9 @@ mkdir -- {quoted}
 <Adversarial.PlannerRole assignment={assignment} guide={props.guide} as="raw" />
 </Dir>
 <Dir path={assignment.attempt}><File path="raw.txt">{raw}</File></Dir>
-<Phase.Extract text={raw} as="extracted" />
-<If condition={!extracted.ok}><Fail message="The Planner reply is not a result. Preserve raw.txt and reconcile without repeating completed work." /></If>
-<Adversarial.Schema as="schemas" />
-<Parse schema={schemas.foundation} as="result">{extracted.json}</Parse>
+<Adversarial.Response assignment={assignment} raw={raw} as="accepted" />
+<Let as="result" value={accepted.result} />
+<Dir path={assignment.attempt}><File path="response-acceptance.json"><Json value={{round:accepted.round,raw:accepted.rawPath}} /></File></Dir>
 <Dir path={assignment.attempt}><File path="result.json"><Json value={result} /></File></Dir>
 <Let as="validated" value={null} />
 <If condition={result.outcome === "complete"}>

examples/adversarial-implementation/components/Adversarial/PlannerRole.md

@@ -5,13 +5,21 @@ props:
   properties:
     assignment: {type: object}
     guide: {type: string}
+    correction: {type: [object, 'null'], default: null}
   required: [assignment, guide]
   additionalProperties: false
 ---
 
 <Adversarial.Schema as="schemas" />
 <Phase.Profile role="planner" design={true} assessment={props.assignment.assessment} as="profile" />
 <Output><Agent name="claude"><Session name={props.assignment.session} model={profile.model} effort={profile.effort}><Prompt throwOnError={true}>
+<If condition={props.correction !== null}>
+You remain the original Planner. This is response-only correction {props.correction.ordinal} of three. Shorten only the rejected summary or handoff to its stated bound. Every other result value is frozen by the supplied schema, including the API, outcome, source revision, artifacts, assessment and command evidence.
+
+Perform no implementation, command execution, test, signing, publication or other productive work. Do not repeat the earlier assignment. Return only the corrected JSON result. If the existing facts cannot satisfy the schema, preserve that uncertainty; do not invent evidence.
+
+<Json value={props.correction} />
+<Else>
 <If condition={props.assignment.initialize}>
 You are the adversarial Planner. This assignment authorizes API implementation and representative consumer validation in the assigned checkout.
 
@@ -34,4 +42,6 @@ Prepared assignment:
 
 Return exactly one JSON object satisfying this contract. Evidence names actual command receipts and revisions; schema validation does not establish that tests passed.
 <Json value={schemas.foundation} />
+</Else>
+</If>
 </Prompt></Session></Agent></Output>

examples/adversarial-implementation/components/Adversarial/Response.md

@@ -0,0 +1,69 @@
+---
+description: 'Validate a saved foundation reply and bound response-only corrections in its original session. Use <Adversarial.Response assignment={assignment} raw={raw} as="accepted" />.'
+props:
+  type: object
+  properties:
+    assignment: {type: object}
+    raw: {type: string}
+  required: [assignment, raw]
+  additionalProperties: false
+returns: {type: object}
+---
+
+<Adversarial.Schema as="schemas" />
+<Let as="raw" value={props.raw} />
+<Let as="rawPath" value={props.assignment.attempt + "/raw.txt"} />
+<Let as="round" value={0} />
+<Phase.Extract text={raw} as="extracted" />
+<If condition={!extracted.ok}>
+<Dir path={props.assignment.attempt}><File path="response-rejection-0000.json"><Json value={extracted} /></File></Dir>
+<Fail message="No unambiguous substantive foundation result is established. Preserve raw.txt and response-rejection-0000.json; no productive prompt is repeated." />
+</If>
+<SafeParse schema={schemas.foundation} as="checked">{extracted.json}</SafeParse>
+<If condition={!checked.ok}>
+<Dir path={props.assignment.attempt}><File path="response-rejection-0000.json"><Json value={checked} /></File></Dir>
+<Let as="relaxed" value={{...schemas.foundation,properties:{...schemas.foundation.properties,summary:{type:"string",minLength:1},handoff:{type:"string",minLength:1}}}} />
+<SafeParse schema={relaxed} as="established">{extracted.json}</SafeParse>
+<If condition={!established.ok}><Fail message="No unambiguous substantive foundation result is established. Preserve raw.txt and response-rejection-0000.json; no productive prompt is repeated." /></If>
+<Let as="frozen" value={{...schemas.foundation,properties:Object.fromEntries(Object.entries(schemas.foundation.properties).map(([key,schema]) => [key,(key === "summary" || key === "handoff") && established.value[key].length > schema.maxLength ? schema : {const:established.value[key]}]))}} />
+<Loop max={3}>
+<If condition={checked.ok}><Break /></If>
+<Let as="round" value={round + 1} />
+<Let as="directory" value={props.assignment.attempt + "/response-corrections/" + round} />
+<Dir path={props.assignment.attempt + "/response-corrections"}><Let as="parentPrepared" value={true} /></Dir>
+<Let as="quoted" value={"'" + directory.replaceAll("'","'\"'\"'") + "'"} />
+```bash exec as="reserved"
+mkdir -- {quoted}
+```
+<If condition={reserved.exitCode !== 0}><Fail message="Preserve the occupied response correction; do not repeat its prompt." /></If>
+<Let as="packet" value={{ordinal:round,remaining:3-round,raw:rawPath,rejection:checked.errors,established:established.value,resultSchema:frozen}} />
+<If condition={JSON.stringify(packet).length > 64000}><Fail message="The response correction packet exceeds its input bound; preserve it without dispatch." /></If>
+<Dir path={directory}><File path="request.json"><Json value={packet} /></File></Dir>
+<Ticket.Checkout repository={props.assignment.repository} as="before" />
+<If condition={!before.clean || before.head !== established.value.revision}><Fail message="Reconcile source before response-only correction." /></If>
+<Dir path={props.assignment.repository}>
+```bash exec as="statusBefore"
+git status --porcelain=v1 --untracked-files=all
+```
+</Dir>
+<If condition={statusBefore.exitCode !== 0 || statusBefore.stdout !== ""}><Fail message="Reconcile tracked and untracked source before response-only correction." /></If>
+<Dir path={directory}><File path="source-before.json"><Json value={statusBefore} /></File></Dir>
+<Dir path={props.assignment.repository}><Adversarial.PlannerRole assignment={{...props.assignment,initialize:false}} guide="" correction={packet} as="raw" /></Dir>
+<Let as="rawPath" value={directory + "/raw.txt"} />
+<Dir path={directory}><File path="raw.txt">{raw}</File></Dir>
+<Ticket.Checkout repository={props.assignment.repository} as="after" />
+<Dir path={props.assignment.repository}>
+```bash exec as="statusAfter"
+git status --porcelain=v1 --untracked-files=all
+```
+</Dir>
+<Dir path={directory}><File path="source-after.json"><Json value={statusAfter} /></File></Dir>
+<If condition={!after.clean || after.head !== before.head || statusAfter.exitCode !== 0 || statusAfter.stdout !== statusBefore.stdout}><Fail message="Response-only correction changed source. Preserve its effects and hold." /></If>
+<Phase.Extract text={raw} as="extracted" />
+<Let as="checked" value={{ok:false,input:raw,errors:extracted.ok ? [] : [extracted.rejection]}} />
+<If condition={extracted.ok}><SafeParse schema={frozen} as="checked">{extracted.json}</SafeParse></If>
+<Dir path={directory}><File path="disposition.json"><Json value={{round,accepted:checked.ok,raw:rawPath,errors:checked.ok ? [] : checked.errors}} /></File></Dir>
+</Loop>
+<If condition={!checked.ok}><Fail message="Three response-only corrections are exhausted. Preserve their receipts; no productive prompt is repeated." /></If>
+</If>
+<Return value={{result:checked.value,round,rawPath}} />

examples/adversarial-implementation/components/Phase/Extract.ts

@@ -0,0 +1,157 @@
+import { parseJson } from "@executablemd/core";
+import type { Json } from "@executablemd/core";
+import { Err, Ok } from "effection";
+import type { Operation, Result } from "effection";
+
+export const props = {
+  type: "object",
+  properties: { text: { type: "string" } },
+  required: ["text"],
+  additionalProperties: false,
+};
+export const returns = { type: "object" };
+
+export default function* Extract(props: Record<string, Json>): Operation<Json> {
+  const input = props.text;
+  if (typeof input !== "string") {
+    throw new TypeError("Phase.Extract requires text.");
+  }
+  const parsed = readResult(input);
+  if (!parsed.ok) {
+    return {
+      ok: false,
+      rejection: {
+        kind: "response_validation",
+        code: "extraction",
+        message: parsed.error.message,
+        issues: [],
+      },
+    };
+  }
+  return { ok: true, json: JSON.stringify(parsed.value) };
+}
+
+function parseText(text: string): Result<Json> {
+  try {
+    return Ok(parseJson(JSON.parse(text)));
+  } catch (error) {
+    return Err(error);
+  }
+}
+
+function opensRecord(text: string): boolean {
+  return (
+    /^\s*\{\s*(?:"|}|$)/.test(text) ||
+    /^\s*\[\s*(?:\{|\[|"|\]|(?:-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?|true|false|null)(?=\s*(?:,|\]|$))|$)/.test(
+      text,
+    )
+  );
+}
+
+function readResult(input: string): Result<Json> {
+  const whole = parseText(input.trim());
+  if (whole.ok) {
+    return whole;
+  }
+  const candidates: Json[] = [];
+  let outside = "";
+  let fence: { marker: string; json: boolean; unlabeled: boolean; body: string } | undefined;
+  for (const line of input.split(/(?<=\n)/)) {
+    const delimiter =
+      fence === undefined
+        ? /(`{3,}|~{3,})([^\r\n]*)/.exec(line)
+        : /^ {0,3}(`{3,}|~{3,})([^\r\n]*)/.exec(line);
+    if (fence !== undefined) {
+      if (
+        delimiter &&
+        delimiter[1][0] === fence.marker[0] &&
+        delimiter[1].length >= fence.marker.length &&
+        delimiter[2].trim() === ""
+      ) {
+        if (fence.json || (fence.unlabeled && opensRecord(fence.body))) {
+          const parsed = parseText(fence.body);
+          if (!parsed.ok) {
+            return parsed;
+          }
+          candidates.push(parsed.value);
+        }
+        fence = undefined;
+      } else {
+        fence.body += line;
+      }
+    } else if (delimiter) {
+      if (delimiter[2].includes(delimiter[1])) {
+        outside += line;
+        continue;
+      }
+      const language = delimiter[2].trim().toLowerCase();
+      fence = {
+        marker: delimiter[1],
+        json: language === "json",
+        unlabeled: language === "",
+        body: "",
+      };
+      outside += line.slice(0, delimiter.index) + "\n";
+    } else {
+      outside += line;
+    }
+  }
+  if (fence !== undefined) {
+    return Err(new Error("The agent reply contains an unclosed code fence."));
+  }
+  for (let index = 0; index < outside.length; index += 1) {
+    if (
+      (outside[index] !== "{" && outside[index] !== "[") ||
+      /[A-Za-z0-9_$]/.test(outside[index - 1] ?? "")
+    ) {
+      continue;
+    }
+    if (!opensRecord(outside.slice(index))) {
+      continue;
+    }
+    const end = recordEnd(outside, index);
+    if (!end.ok) {
+      return end;
+    }
+    const parsed = parseText(outside.slice(index, end.value));
+    if (!parsed.ok) {
+      return parsed;
+    }
+    candidates.push(parsed.value);
+    index = end.value - 1;
+  }
+  if (candidates.length !== 1) {
+    return Err(new Error("The agent reply must contain exactly one unambiguous JSON result."));
+  }
+  return Ok(candidates[0]);
+}
+
+function recordEnd(text: string, start: number): Result<number> {
+  const closings: string[] = [];
+  let quoted = false;
+  let escaped = false;
+  for (let index = start; index < text.length; index += 1) {
+    const character = text[index];
+    if (quoted) {
+      if (escaped) {
+        escaped = false;
+      } else if (character === "\\") {
+        escaped = true;
+      } else if (character === '"') {
+        quoted = false;
+      }
+    } else if (character === '"') {
+      quoted = true;
+    } else if (character === "{" || character === "[") {
+      closings.push(character === "{" ? "}" : "]");
+    } else if (character === "}" || character === "]") {
+      if (character !== closings.pop()) {
+        return Err(new Error("The agent reply contains an incomplete JSON result."));
+      }
+      if (closings.length === 0) {
+        return Ok(index + 1);
+      }
+    }
+  }
+  return Err(new Error("The agent reply contains an incomplete JSON result."));
+}