halfcycle 0.5.1 → 0.5.3

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "halfcycle",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "Halfcycle Method bundle — resolution-stub slash commands, remote method-delivery registration, and governance-hook wiring for a Halfcycle engagement repo. It ships NO worker role files: a project's roles are authored from that project's own recorded decisions at orchestration kickoff (FX-2, W3-F-27).",
   "commands": [
     {

package/bin/bin.bundle.mjs

@@ -14665,6 +14665,9 @@ var USER_PROMPT_REMINDER_REL = ".claude/hooks/user-prompt-reminder.sh";
 var USER_PROMPT_SCOPE_REL = ".claude/hooks/user-prompt-scope.sh";
 var USER_PROMPT_FINDINGS_REL = ".claude/hooks/user-prompt-findings.sh";
 var SESSION_END_MARKER_REL = ".claude/hooks/session-end-marker.sh";
+var CONTEXT_BUDGET_CHECK_REL = ".claude/hooks/context-budget-check.sh";
+var CONTEXT_DRIFT_CHECK_REL = ".claude/hooks/context-drift-check.sh";
+var CONTEXT_DRIFT_MATCHER = "Edit|Write";
 var WRITE_CAPABLE_TOOLS = ["Edit", "MultiEdit", "NotebookEdit", "Write"];
 var PRE_TOOL_USE_MATCHER = "^(Bash|Read|Grep|Write|Edit|MultiEdit|NotebookEdit|Agent|PowerShell)$";
 function hookCommand(script, verb) {
@@ -14741,6 +14744,20 @@ var HALFCYCLE_HOOK_WIRING = [
     timeout: 5,
     command: hookCommand(SESSION_END_MARKER_REL),
     script: SESSION_END_MARKER_REL
+  },
+  {
+    event: "SessionStart",
+    matcher: null,
+    timeout: 10,
+    command: hookCommand(CONTEXT_BUDGET_CHECK_REL),
+    script: CONTEXT_BUDGET_CHECK_REL
+  },
+  {
+    event: "PostToolUse",
+    matcher: CONTEXT_DRIFT_MATCHER,
+    timeout: 5,
+    command: hookCommand(CONTEXT_DRIFT_CHECK_REL),
+    script: CONTEXT_DRIFT_CHECK_REL
   }
 ];
 var RETIRED_HOOK_COMMANDS = [
@@ -14750,7 +14767,9 @@ var RETIRED_HOOK_COMMANDS = [
   "bash ./.claude/hooks/guard-runner.sh hook post-tool-use",
   "bash ./.claude/hooks/guard-runner.sh hook stop",
   "bash ./.claude/hooks/guard-runner.sh hook subagent-stop",
-  "bash ./.claude/hooks/session-end-marker.sh"
+  "bash ./.claude/hooks/session-end-marker.sh",
+  "bash ./.claude/hooks/context-budget-check.sh",
+  "bash ./.claude/hooks/context-drift-check.sh"
 ];
 var HALFCYCLE_HOOK_COMMANDS = /* @__PURE__ */ new Set([
   ...HALFCYCLE_HOOK_WIRING.map((entry) => entry.command),
@@ -15154,7 +15173,9 @@ var CODEX_HOOK_WIRING = [
   codexHookRow("PostToolUse", CODEX_WRITE_CAPABLE_TOOLS.join("|"), 60, GUARD_RUNNER_REL, "hook post-tool-use --agent codex"),
   codexHookRow("Stop", null, 60, GUARD_RUNNER_REL, "hook stop --agent codex"),
   codexHookRow("SubagentStop", null, 60, GUARD_RUNNER_REL, "hook subagent-stop --agent codex"),
-  codexHookRow("SessionEnd", null, 3, SESSION_END_MARKER_REL)
+  codexHookRow("SessionEnd", null, 3, SESSION_END_MARKER_REL),
+  codexHookRow("SessionStart", null, 10, CONTEXT_BUDGET_CHECK_REL),
+  codexHookRow("PostToolUse", CODEX_WRITE_CAPABLE_TOOLS.join("|"), 5, CONTEXT_DRIFT_CHECK_REL)
 ];
 var RETIRED_CODEX_HOOK_COMMANDS = [];
 function codexHookCommandSet(retired) {
@@ -18082,6 +18103,30 @@ var phaseReviewViewSchema = external_exports.discriminatedUnion("state", [
   phaseReviewOpenSchema,
   phaseReviewClosedSchema
 ]);
+function reviewPartAwaitingAnswer(part) {
+  return part.questions.some((q) => q.agentAnswer === void 0);
+}
+function reviewPartSentBackIn(part, round) {
+  return part.sentBack.some((s) => s.round === round);
+}
+function shownReviewEntryOf(view, shownAt) {
+  const parts = view.parts.map((p) => ({
+    part: p.part,
+    name: p.name,
+    built: p.built,
+    decidable: p.decidable,
+    awaitingAnswer: reviewPartAwaitingAnswer(p),
+    sentBack: reviewPartSentBackIn(p, view.round)
+  }));
+  return {
+    phase: view.phase,
+    number: view.number,
+    round: view.round,
+    reviewVersion: view.reviewVersion,
+    shownAt,
+    parts
+  };
+}
 
 // ../events/dist/client-version.js
 var CLIENT_VERSION_HEADER = "x-halfcycle-client";
@@ -18542,6 +18587,42 @@ var ownerWaitDeclarationSchema = external_exports.object({
 var ownerWaitDeclarationsSchema = external_exports.object({ declarations: external_exports.array(ownerWaitDeclarationSchema) }).strict();
 var OWNER_WAIT_TOO_MANY = `This project already has ${String(OWNER_WAIT_ADDITIONS_MAX)} things added to what waits for the owner. Ask the owner to take one off on their settings page in the console first; it cannot be done by typing in chat.`;
 
+// ../events/dist/owner-wait-answer.js
+var OWNER_WAIT_SHORT_ID_LENGTH = 8;
+var ownerWaitShortIdSchema = external_exports.string().regex(/^[0-9a-f]{8}$/);
+function ownerWaitShortIdOf(declarationId) {
+  return declarationId.slice(0, OWNER_WAIT_SHORT_ID_LENGTH).toLowerCase();
+}
+var OWNER_WAIT_ANSWER_ACTS = ["approve", "decline"];
+var ownerWaitAnswerActSchema = external_exports.enum(OWNER_WAIT_ANSWER_ACTS);
+function ownerWaitApproveLineOf(declarationId) {
+  return `approve wait ${ownerWaitShortIdOf(declarationId)}`;
+}
+function ownerWaitDeclineLineOf(declarationId) {
+  return `decline wait ${ownerWaitShortIdOf(declarationId)}: <why>`;
+}
+var ownerWaitChatRequestSchema = external_exports.discriminatedUnion("act", [
+  external_exports.object({ act: external_exports.literal("approve"), wait: ownerWaitShortIdSchema }).strict(),
+  external_exports.object({ act: external_exports.literal("decline"), wait: ownerWaitShortIdSchema, note: scopeNoteWireSchema }).strict()
+]);
+function bareOutcome3(outcome) {
+  return external_exports.object({ outcome: external_exports.literal(outcome) }).strict();
+}
+var ownerWaitChatResultSchema = external_exports.discriminatedUnion("outcome", [
+  external_exports.object({
+    outcome: external_exports.literal("recorded"),
+    act: ownerWaitAnswerActSchema,
+    question: external_exports.string().min(1)
+  }).strict(),
+  external_exports.object({ outcome: external_exports.literal("refused"), problems: external_exports.array(systemDescriptionProblemSchema).min(1) }).strict(),
+  bareOutcome3("not-owner"),
+  bareOutcome3("no-owner"),
+  bareOutcome3("not-found"),
+  bareOutcome3("ambiguous"),
+  bareOutcome3("not-offered"),
+  bareOutcome3("unavailable")
+]);
+
 // ../events/dist/pacing.js
 var CLAUDE_PLANS = Object.freeze([
   Object.freeze({ id: "pro", words: "Pro", startingAgents: 2 }),
@@ -18744,6 +18825,8 @@ var autonomyActivityRowSchema = external_exports.object({
   // whether the agent says it can be undone
   how: statementText(STATEMENT_MAX).optional(),
   // how to undo it, when it can be
+  wait: ownerWaitShortIdSchema.optional(),
+  // the short id the owner types to answer a waiting decision
   at: utcIso8601
   // when it happened
 }).strict().superRefine((row, ctx) => {
@@ -18770,6 +18853,9 @@ var autonomyActivityRowSchema = external_exports.object({
       });
     }
   }
+  if (row.kind !== "waiting" && row.wait !== void 0) {
+    ctx.addIssue({ code: "custom", message: "only a waiting decision is answered by typing", path: ["wait"] });
+  }
   if (row.kind === "waiting" && (row.undoable !== void 0 || row.how !== void 0)) {
     ctx.addIssue({ code: "custom", message: "a waiting decision has not been made yet", path: ["undoable"] });
   }
@@ -29234,7 +29320,8 @@ function refusalFor(facts, description) {
 function heldStep(steps, description, why) {
   return {
     person: PERSON_HOLD_LINE,
-    agent: `${HELD_STEP_OPENER}${steps}. ${reasonSentence(description)} ${PRECAUTION_OPENER}${why}. ${HOLD_AGENT_INSTRUCTION}`
+    agent: `${HELD_STEP_OPENER}${steps}. ${reasonSentence(description)} ${PRECAUTION_OPENER}${why}. ${HOLD_AGENT_INSTRUCTION}`,
+    step: steps
   };
 }
 var STEP_VERBS = {
@@ -29651,6 +29738,7 @@ import { createHash as createHash5 } from "node:crypto";
 import { appendFileSync as appendFileSync4, readFileSync as readFileSync20, renameSync as renameSync10, unlinkSync as unlinkSync9, writeFileSync as writeFileSync12 } from "node:fs";
 var ALLOW_ONCE_MS = 5 * 60 * 1e3;
 var HELD_STEP_MAX_AGE_MS = 60 * 60 * 1e3;
+var STEP_MAX_LENGTH = 1e3;
 function isAllowReply(prompt) {
   return typeof prompt === "string" && prompt.trim().toLowerCase() === ALLOW_REPLY;
 }
@@ -29676,11 +29764,11 @@ function canonical(value) {
   }
   return JSON.stringify(value) ?? "null";
 }
-function recordHeld(sessionId, key, deps = {}) {
+function recordHeld(sessionId, key, deps = {}, step = null) {
   const paths = allowOncePaths(sessionId, deps.dir);
   if (paths === null)
     return;
-  const record2 = { version: 1, session: sessionId, key, at: nowOf(deps) };
+  const record2 = { version: 1, session: sessionId, key, at: nowOf(deps), ...isStep(step) ? { step } : {} };
   try {
     appendFileSync4(paths.held, `${JSON.stringify(record2)}
 `, { mode: 384 });
@@ -29688,23 +29776,26 @@ function recordHeld(sessionId, key, deps = {}) {
     return;
   }
 }
-function armAllow(sessionId, deps = {}) {
+function armAllowStep(sessionId, deps = {}) {
   try {
     const paths = allowOncePaths(sessionId, deps.dir);
     if (paths === null)
-      return "nothing-held";
+      return { outcome: "nothing-held", step: null };
     const now = nowOf(deps);
-    const keys = claimHeldKeys(paths.held, sessionId, now);
+    const held = claimHeld(paths.held, sessionId, now);
+    const keys = [...new Set(held.map((r) => r.key))];
     if (keys.length === 0)
-      return "nothing-held";
+      return { outcome: "nothing-held", step: null };
     if (keys.length > 1)
-      return "several-held";
-    return writeRecord(paths.allow, { version: 1, session: sessionId, key: keys[0], at: now }) ? "armed" : "not-saved";
+      return { outcome: "several-held", step: null };
+    const step = held[held.length - 1].step ?? null;
+    const saved = writeRecord(paths.allow, { version: 1, session: sessionId, key: keys[0], at: now });
+    return saved ? { outcome: "armed", step } : { outcome: "not-saved", step: null };
   } catch {
-    return "not-saved";
+    return { outcome: "not-saved", step: null };
   }
 }
-function claimHeldKeys(path, session, now) {
+function claimHeld(path, session, now) {
   const claimed = `${path}.${process.pid}.${now}.claim`;
   try {
     renameSync10(path, claimed);
@@ -29718,13 +29809,16 @@ function claimHeldKeys(path, session, now) {
     text = "";
   }
   removeQuietly(claimed);
-  const keys = /* @__PURE__ */ new Set();
+  const records = [];
   for (const line2 of text.split("\n")) {
     const r = parseRecord(line2, session);
     if (r !== null && within(r.at, now, HELD_STEP_MAX_AGE_MS))
-      keys.add(r.key);
+      records.push(r);
   }
-  return [...keys];
+  return records;
+}
+function isStep(v) {
+  return typeof v === "string" && v !== "" && v.length <= STEP_MAX_LENGTH;
 }
 function spendAllow(sessionId, key, deps = {}) {
   try {
@@ -29776,7 +29870,8 @@ function parseRecord(text, session) {
     return null;
   if (typeof r["at"] !== "number")
     return null;
-  return { version: 1, session, key: r["key"], at: r["at"] };
+  const step = r["step"];
+  return { version: 1, session, key: r["key"], at: r["at"], ...isStep(step) ? { step } : {} };
 }
 function writeRecord(path, record2) {
   const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
@@ -30696,7 +30791,7 @@ function runPreToolUse(deps) {
         const allowOnce = { ...deps.liveness?.dir === void 0 ? {} : { dir: deps.liveness.dir }, now: () => at.getTime() };
         if (spendAllow(input["session_id"], key, allowOnce))
           return "";
-        recordHeld(input["session_id"], key, allowOnce);
+        recordHeld(input["session_id"], key, allowOnce, answer.refusal.step);
       }
     }
     return `${preToolUseReplyText("refuse", answer.refusal.person, answer.refusal.agent)}
@@ -31257,6 +31352,14 @@ function partShape(act, head, words) {
     return null;
   return { kind: "part", act, reference, part, words };
 }
+function bulkAcceptTargetOf(reference, record2) {
+  const phases = /* @__PURE__ */ new Map();
+  for (const shown2 of [...record2.reviews, ...record2.entries]) {
+    if (!phases.has(shown2.phase))
+      phases.set(shown2.phase, { phase: shown2.phase, number: shown2.number });
+  }
+  return resolvePhaseReference(reference, [...phases.values()]);
+}
 function matchReviewPhraseShape(shape, reviews) {
   const resolved = resolvePhaseReference(shape.reference, reviews);
   const act = shape.kind === "phase" ? "accept" : shape.kind === "reject" ? "reject" : shape.act;
@@ -31347,6 +31450,28 @@ function moveListedReviewForward(engagementId, home, listed, reviewVersion, deci
   }
 }
 
+// dist/hooks/wait-phrase.js
+var APPROVE = /^approve wait ([0-9a-f]{8})$/i;
+var DECLINE = /^decline wait ([0-9a-f]{8})(?:\s*:(.*))?$/is;
+function waitPhraseShape(prompt) {
+  if (typeof prompt !== "string")
+    return null;
+  const line2 = prompt.trim();
+  if (LINE_BREAK.test(line2))
+    return null;
+  const approve = APPROVE.exec(line2);
+  if (approve !== null)
+    return shapeOf("approve", approve[1], null);
+  const decline = DECLINE.exec(line2);
+  if (decline !== null)
+    return shapeOf("decline", decline[1], decline[2] === void 0 ? null : decline[2].trim());
+  return null;
+}
+function shapeOf(act, typed, words) {
+  const wait = typed.toLowerCase();
+  return ownerWaitShortIdSchema.safeParse(wait).success ? { act, wait, words } : null;
+}
+
 // dist/hooks/user-prompt-submit-lines.js
 var TELL_THE_PERSON = "Tell the person.";
 function line(text) {
@@ -31684,14 +31809,15 @@ function autonomyLineForAnswer(answer) {
 }
 var NOTHING_ALLOWED = "Nothing was allowed";
 var ALLOW_MINUTES = Math.round(ALLOW_ONCE_MS / 6e4);
-function allowArmedLine() {
-  return line(`The person allowed the paused step once. Run it again now, exactly as before; it will go ahead once if it runs within ${ALLOW_MINUTES} minutes, and any other risky step is still paused.`);
+function allowArmedLine(step = null) {
+  const named = step === null ? "The person allowed the paused step once." : `The person allowed this paused step once: ${step}.`;
+  return line(`${named} Run it again now, exactly as before; it will go ahead once if it runs within ${ALLOW_MINUTES} minutes, and any other risky step is still paused.`);
 }
 function allowNothingHeldLine() {
   return line(`${NOTHING_ALLOWED}: no step is paused in this session.`);
 }
 function allowSeveralHeldLine() {
-  return line(`${NOTHING_ALLOWED}: more than one step is paused in this session. Ask the agent to try the one you mean again, then type ${ALLOW_REPLY}.`);
+  return `${NOTHING_ALLOWED}: more than one step was paused, so Halfcycle could not tell which one you meant. Nothing ran. When your agent tries the step again, type ${ALLOW_REPLY} once more. ${SHOW_AS_WRITTEN}`;
 }
 function allowNotAttendedLine() {
   return line(`${NOTHING_ALLOWED}: a paused step can be allowed by typing only when a person types it into an open session.`);
@@ -31700,14 +31826,81 @@ function allowNotSavedLine() {
   return line(`${NOTHING_ALLOWED}: Halfcycle could not save the answer on this computer. Type ${ALLOW_REPLY} again.`);
 }
 var CODEX_TYPING_NEVER_COUNTS = "in Codex, Halfcycle cannot tell a line a person typed from one a program sent, so a typed decision never counts there";
+var SHOW_AS_WRITTEN = "Show the person this line as written.";
+function codexLine(text) {
+  return `${text} ${SHOW_AS_WRITTEN}`;
+}
 function codexScopeLine(act) {
-  return act === "approve" ? line(`${nothingDone(act)}: ${CODEX_TYPING_NEVER_COUNTS}. To approve, choose Accept in the console.`) : line(`${nothingDone(act)}: ${CODEX_TYPING_NEVER_COUNTS}. The console offers only Accept, so work cannot be sent back from Codex.`);
+  return act === "approve" ? codexLine(`${nothingDone(act)}: ${CODEX_TYPING_NEVER_COUNTS}. To approve, choose Accept in the console.`) : codexLine(`${nothingDone(act)}: ${CODEX_TYPING_NEVER_COUNTS}. The console offers only Accept, so work cannot be sent back from Codex.`);
 }
 function codexReviewLine(act) {
-  return act === "accept" ? line(`${NOTHING_RECORDED}: ${CODEX_TYPING_NEVER_COUNTS}. To accept, choose Accept in the console.`) : line(`${NOTHING_RECORDED}: ${CODEX_TYPING_NEVER_COUNTS}. The console offers only Accept, so this cannot be done from Codex.`);
+  return act === "accept" ? codexLine(`${NOTHING_RECORDED}: ${CODEX_TYPING_NEVER_COUNTS}. To accept, choose Accept in the console.`) : codexLine(`${NOTHING_RECORDED}: ${CODEX_TYPING_NEVER_COUNTS}. The console offers only Accept, so this cannot be done from Codex.`);
 }
 function codexAutonomyLine() {
-  return line(`${AUTONOMY_NOTHING_CHANGED}: ${CODEX_TYPING_NEVER_COUNTS}. Turn it on or off with "${AUTONOMY_A1_TITLE}" in the console's settings.`);
+  return codexLine(`${AUTONOMY_NOTHING_CHANGED}: ${CODEX_TYPING_NEVER_COUNTS}. Turn it on or off with "${AUTONOMY_A1_TITLE}" in the console's settings.`);
+}
+function waitTypedLine(context) {
+  return context.act === "approve" ? ownerWaitApproveLineOf(context.wait) : ownerWaitDeclineLineOf(context.wait);
+}
+function waitRecordedLine(act, question) {
+  return act === "approve" ? line(`Recorded in your session: you approved "${question}". The agent can go ahead with it.`) : line(`Recorded in your session: you declined "${question}", with your words. The agent must not go ahead with it.`);
+}
+function waitNotAttendedLine() {
+  return line(`${NOTHING_RECORDED}: an answer counts only when a person types it into an open session.`);
+}
+function waitNotSignedInLine() {
+  return line(`${NOTHING_RECORDED}: this project is not signed in on this computer. ${HOOK_REMEDY}`);
+}
+function waitNotOwnerLine() {
+  return line(`${NOTHING_RECORDED}: only the project's owner can answer a decision that waits for them.`);
+}
+function waitNoOwnerLine() {
+  return line(`${NOTHING_RECORDED}: this project has no owner, so nobody can answer its decisions.`);
+}
+function waitNotFoundLine(context) {
+  return line(`${NOTHING_RECORDED}: no decision waiting for you has the id ${context.wait}. Type the line the agent gave you with its question, such as ${waitTypedLine(context)}.`);
+}
+function waitAmbiguousLine(context) {
+  return line(`${NOTHING_RECORDED}: more than one decision waiting for you starts with ${context.wait}. Ask the agent to put the question to you again.`);
+}
+function waitNoWordsLine(context) {
+  return line(`${NOTHING_RECORDED}: a decline needs your reason after the colon, as in ${ownerWaitDeclineLineOf(context.wait)}.`);
+}
+function waitRefusedLine() {
+  return line(`${NOTHING_RECORDED}: Halfcycle did not accept the words. Reword them in plain words and type the line again.`);
+}
+function waitSwitchedOffLine() {
+  return line(`${NOTHING_RECORDED}. ${TYPED_APPROVAL_OFF_SENTENCE}`);
+}
+function waitCannotReachLine() {
+  return line(`${NOTHING_RECORDED}: Halfcycle could not be reached just now. Type the line again in a minute.`);
+}
+function codexWaitLine(context) {
+  return codexLine(`${NOTHING_RECORDED}: ${CODEX_TYPING_NEVER_COUNTS}. To answer, type ${waitTypedLine(context)} in a Claude Code session on this project.`);
+}
+function waitLineForAnswer(context, answer) {
+  switch (answer.outcome) {
+    case "recorded":
+      return waitRecordedLine(answer.act, answer.question);
+    case "refused":
+      return waitRefusedLine();
+    case "not-owner":
+      return waitNotOwnerLine();
+    case "no-owner":
+      return waitNoOwnerLine();
+    case "not-found":
+      return waitNotFoundLine(context);
+    case "ambiguous":
+      return waitAmbiguousLine(context);
+    case "not-offered":
+      return waitSwitchedOffLine();
+    case "unavailable":
+      return waitCannotReachLine();
+    default: {
+      const unreachable = answer;
+      return unreachable;
+    }
+  }
 }
 
 // dist/hooks/user-prompt-submit.js
@@ -31733,6 +31926,7 @@ function agentOf(opts) {
 async function decideLine(opts) {
   let act = null;
   let autonomyAct = null;
+  let waitRecognised = false;
   const review = { recognised: false };
   try {
     const prompt = promptOf(opts.input);
@@ -31743,6 +31937,12 @@ async function decideLine(opts) {
     if (autonomyShape !== null) {
       autonomyAct = autonomyShape;
       return `${await decideAutonomy(autonomyShape, opts)}
+`;
+    }
+    const waitShape = waitPhraseShape(prompt);
+    if (waitShape !== null) {
+      waitRecognised = true;
+      return `${await decideWait(waitShape, opts)}
 `;
     }
     const reviewShape = reviewPhraseShape(prompt);
@@ -31760,6 +31960,9 @@ async function decideLine(opts) {
   } catch {
     if (autonomyAct !== null)
       return `${autonomyCannotReachLine()}
+`;
+    if (waitRecognised)
+      return `${waitCannotReachLine()}
 `;
     if (review.recognised)
       return `${reviewCannotReachLine()}
@@ -31772,13 +31975,13 @@ function decideAllow(opts) {
   const env = opts.env ?? process.env;
   if ((opts.agent ?? "claude-code") === "claude-code" && !readSessionAttended(env))
     return allowNotAttendedLine();
-  const outcome = armAllow(sessionIdOf(opts.input), {
+  const { outcome, step } = armAllowStep(sessionIdOf(opts.input), {
     ...opts.tempDir === void 0 ? {} : { dir: opts.tempDir },
     ...opts.now === void 0 ? {} : { now: opts.now }
   });
   switch (outcome) {
     case "armed":
-      return allowArmedLine();
+      return allowArmedLine(step);
     case "nothing-held":
       return allowNothingHeldLine();
     case "several-held":
@@ -31805,6 +32008,57 @@ async function decideAutonomy(act, opts) {
   const { guardServiceToken, guardEngagementId } = read.config;
   return postAutonomy(act, guardEngagementId, guardServiceToken, env, opts.fetchFn);
 }
+async function decideWait(shape, opts) {
+  const env = opts.env ?? process.env;
+  const context = { act: shape.act, wait: shape.wait };
+  const typed = whoTyped(opts);
+  if (typed === "cannot-tell")
+    return codexWaitLine(context);
+  if (typed === "not-attended")
+    return waitNotAttendedLine();
+  const read = readConfig(env);
+  if (read.config === null) {
+    return readNeverConfiguredReason(env) === "not-this-account" ? waitNotOwnerLine() : waitNotSignedInLine();
+  }
+  let candidate = { act: "approve", wait: shape.wait };
+  if (shape.act === "decline") {
+    const words = shape.words ?? "";
+    if (words === "")
+      return waitNoWordsLine(context);
+    if (!scopeNoteWireSchema.safeParse(words).success)
+      return reviewWordsTooLongLine();
+    if (looksLikeSecret(words))
+      return reviewWordsLookSecretLine();
+    candidate = { act: "decline", wait: shape.wait, note: words };
+  }
+  const request = ownerWaitChatRequestSchema.parse(candidate);
+  const { guardServiceToken, guardEngagementId } = read.config;
+  const url2 = `${readControlOrigin(env).origin}/engagements/${encodeURIComponent(guardEngagementId)}/owner-waits/chat`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), CHAT_REQUEST_TIMEOUT_MS);
+  try {
+    const response = await (opts.fetchFn ?? globalThis.fetch)(url2, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${guardServiceToken}`, "Content-Type": "application/json" },
+      body: JSON.stringify(request),
+      signal: controller.signal
+    });
+    if (response.status === 401)
+      return waitNotSignedInLine();
+    if (response.status === 429 || response.status >= 500)
+      return waitCannotReachLine();
+    const parsed = ownerWaitChatResultSchema.safeParse(await response.json());
+    if (!parsed.success)
+      return waitCannotReachLine();
+    if (parsed.data.outcome === "recorded" && response.status !== 200)
+      return waitCannotReachLine();
+    return waitLineForAnswer(context, parsed.data);
+  } catch {
+    return waitCannotReachLine();
+  } finally {
+    clearTimeout(timer);
+  }
+}
 async function postAutonomy(act, engagementId, credential, env, fetchFn = globalThis.fetch) {
   const url2 = `${readControlOrigin(env).origin}/engagements/${encodeURIComponent(engagementId)}/autonomy/chat`;
   const controller = new AbortController();
@@ -31838,8 +32092,12 @@ async function decideReview(shape, opts, progress) {
     const read2 = readConfig(env);
     if (read2.config === null)
       return "";
-    const match2 = matchReviewPhraseShape(shape, readShownRecord(read2.config.guardEngagementId, opts.home).reviews);
-    if (match2.kind === "nothing")
+    const { guardEngagementId: engagementId, guardServiceToken: credential } = read2.config;
+    const record2 = readShownRecord(engagementId, opts.home);
+    const listed = matchReviewPhraseShape(shape, record2.reviews);
+    const fresh = listed.kind === "accept" && listedRecently(listed.entry.shownAt, (opts.now ?? Date.now)());
+    const target = listed.kind === "ambiguous" || fresh ? null : bulkAcceptTargetOf(shape.reference, record2);
+    if (target?.kind === "none")
       return "";
     progress.recognised = true;
     const typed2 = whoTyped(opts);
@@ -31847,7 +32105,11 @@ async function decideReview(shape, opts, progress) {
       return codexReviewLine("accept");
     if (typed2 === "not-attended")
       return reviewNotAttendedLine();
-    return checkAndSendReview(match2, read2.config.guardEngagementId, read2.config.guardServiceToken, env, opts);
+    if (target === null)
+      return checkAndSendReview(listed, engagementId, credential, env, opts);
+    if (target.kind === "ambiguous")
+      return reviewAmbiguousLine(target.entries.map((e) => e.phase));
+    return readThenAccept(shape, target.entry.phase, engagementId, credential, env, opts);
   }
   progress.recognised = true;
   const typed = whoTyped(opts);
@@ -31862,6 +32124,38 @@ async function decideReview(shape, opts, progress) {
   const match = matchReviewPhraseShape(shape, readShownRecord(read.config.guardEngagementId, opts.home).reviews);
   return checkAndSendReview(match, read.config.guardEngagementId, read.config.guardServiceToken, env, opts);
 }
+var REVIEW_READ_TIMEOUT_MS = 3e3;
+async function readThenAccept(shape, phase, engagementId, credential, env, opts) {
+  const fetchFn = opts.fetchFn ?? globalThis.fetch;
+  const url2 = `${readControlOrigin(env).origin}/engagements/${encodeURIComponent(engagementId)}/phases/${encodeURIComponent(phase)}/review`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REVIEW_READ_TIMEOUT_MS);
+  let raw;
+  try {
+    const response = await fetchFn(url2, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${credential}` },
+      signal: controller.signal
+    });
+    if (response.status === 401)
+      return reviewNotSignedInLine();
+    if (response.status !== 200)
+      return reviewCannotReachLine();
+    raw = await response.json();
+  } catch {
+    return reviewCannotReachLine();
+  } finally {
+    clearTimeout(timer);
+  }
+  const parsed = phaseReviewViewSchema.safeParse(raw);
+  if (!parsed.success)
+    return reviewCannotReachLine();
+  const view = parsed.data;
+  if (view.state !== "open")
+    return reviewNoReviewLine(phase);
+  const entry = shownReviewEntryOf(view, new Date((opts.now ?? Date.now)()).toISOString());
+  return checkAndSendReview(matchReviewPhraseShape(shape, [entry]), engagementId, credential, env, opts);
+}
 async function checkAndSendReview(match, engagementId, credential, env, opts) {
   if (match.kind === "nothing" || match.kind === "show-first")
     return reviewShowFirstLine();
@@ -32415,6 +32709,10 @@ function isCheckedSessionStart(input, profile) {
   return CHECKED_SOURCES.has(source);
 }
 var CONNECTED_SENTENCE = `Halfcycle's sign-in works and its service answered. If its tools are missing, turn on ${MCP_SERVER_KEY} in /mcp; if it is not listed, run "claude mcp reset-project-choices" here and restart Claude Code.`;
+var CODEX_CONNECTED_SENTENCE = "Halfcycle's sign-in works and its service answered. If its tools are missing, start a new Codex session to reconnect them.";
+function connectedSentenceFor(profile) {
+  return profile.id === "codex" ? CODEX_CONNECTED_SENTENCE : CONNECTED_SENTENCE;
+}
 var INITIALIZE_BODY = JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initialize", params: {} });
 var SESSION_START_PROBE_ATTEMPTS = 2;
 function registeredMcpUrl(projectRoot) {
@@ -32501,6 +32799,7 @@ async function probeDelivery(url2, bearer, fetchFn, deadlineMs, maxAttempts) {
   }
 }
 async function checkConnection(renewedToken, opts) {
+  const profile = opts.profile ?? AGENT_PROFILES["claude-code"];
   const url2 = registeredMcpUrl(projectRootFromBinary(opts.binaryPath));
   if (url2 === void 0)
     return void 0;
@@ -32514,10 +32813,10 @@ async function checkConnection(renewedToken, opts) {
     environmentTokenFirst: false
   });
   if (CREDENTIAL_PLACEHOLDERS.includes(bearer)) {
-    return { sentence: PLACEHOLDER_SENTENCES[bearer], url: url2, bearer };
+    return { sentence: PLACEHOLDER_SENTENCES[bearer], url: url2, bearer, connected: false };
   }
   const outcome = await probeDelivery(url2, bearer, opts.fetchFn ?? globalThis.fetch, opts.checkDeadlineMs ?? CONNECTION_CHECK_DEADLINE_MS, opts.maxAttempts ?? SESSION_START_PROBE_ATTEMPTS);
-  return { sentence: outcome ?? CONNECTED_SENTENCE, url: url2, bearer };
+  return { sentence: outcome ?? connectedSentenceFor(profile), url: url2, bearer, connected: outcome === void 0 };
 }
 function positionRequestBody(engagementId) {
   return JSON.stringify({
@@ -32607,10 +32906,10 @@ async function runRefreshCredential(opts) {
     renewalOpen = false;
     const parts = [];
     if (isCheckedSessionStart(input, profile)) {
-      const connection = await checkConnection(renewedToken, { ...opts, writeErr });
+      const connection = await checkConnection(renewedToken, { ...opts, profile, writeErr });
       if (connection !== void 0) {
         parts.push(connection.sentence);
-        if (connection.sentence === CONNECTED_SENTENCE) {
+        if (connection.connected) {
           const engagementId = readConfig().config?.guardEngagementId;
           if (engagementId !== void 0) {
             const remainingForMargin = SESSION_START_HOOK_TIMEOUT_MS - SESSION_START_MARGIN_MS - (Date.now() - startedAt);