halfcycle 0.4.8 → 0.4.9

package/bin/bin.bundle.mjs

@@ -14781,32 +14781,68 @@ var HALFCYCLE_COMMAND = "npx halfcycle@latest";
 
 // ../core/dist/shown-plans.js
 var SHOWN_PLANS_FILENAME = "shown-plans.json";
-var SHOWN_PLANS_FORMAT = 1;
-var RECORD_KEYS = ["entries", "format"];
+var SHOWN_RECORD_FORMAT = 2;
+var SHOWN_RECORD_FORMAT_1 = 1;
+var FORMAT_1_KEYS = ["entries", "format"];
+var RECORD_KEYS = ["entries", "format", "reviews"];
+var WRITTEN_KEYS = ["entries", "reviews"];
 var ENTRY_KEYS = ["number", "phase", "shownAt", "version"];
-function parseShownPlans(text) {
+var REVIEW_KEYS = ["number", "parts", "phase", "reviewVersion", "round", "shownAt"];
+var REVIEW_PART_KEYS = ["awaitingAnswer", "built", "decidable", "name", "part", "sentBack"];
+function nothingShown() {
+  return { entries: [], reviews: [] };
+}
+function parseShownRecord(text) {
   try {
     if (typeof text !== "string")
-      return [];
+      return nothingShown();
     const parsed = JSON.parse(text);
-    if (!isPlainObject2(parsed) || !hasExactKeys(parsed, RECORD_KEYS))
-      return [];
-    if (parsed["format"] !== SHOWN_PLANS_FORMAT)
-      return [];
-    const rawEntries = parsed["entries"];
-    if (!Array.isArray(rawEntries))
-      return [];
-    const entries = [];
-    for (const raw of rawEntries) {
-      const entry = readEntry(raw);
-      if (entry === null)
-        return [];
-      entries.push(entry);
-    }
-    return hasDuplicates(entries) ? [] : entries;
+    if (!isPlainObject2(parsed))
+      return nothingShown();
+    let rawReviews;
+    if (parsed["format"] === SHOWN_RECORD_FORMAT && hasExactKeys(parsed, RECORD_KEYS)) {
+      rawReviews = parsed["reviews"];
+    } else if (parsed["format"] === SHOWN_RECORD_FORMAT_1 && hasExactKeys(parsed, FORMAT_1_KEYS)) {
+      rawReviews = [];
+    } else {
+      return nothingShown();
+    }
+    const record2 = readRecord(parsed["entries"], rawReviews);
+    return record2 ?? nothingShown();
   } catch {
-    return [];
+    return nothingShown();
+  }
+}
+function serialiseShownRecord(record2) {
+  if (!isPlainObject2(record2) || !hasExactKeys(record2, WRITTEN_KEYS))
+    throw new Error(UNRECORDABLE);
+  const copied = readRecord(record2["entries"], record2["reviews"]);
+  if (copied === null)
+    throw new Error(UNRECORDABLE);
+  return `${JSON.stringify({ format: SHOWN_RECORD_FORMAT, entries: copied.entries, reviews: copied.reviews }, null, 2)}
+`;
+}
+var UNRECORDABLE = "the list just shown could not be recorded on this machine.";
+function readRecord(rawEntries, rawReviews) {
+  if (!Array.isArray(rawEntries) || !Array.isArray(rawReviews))
+    return null;
+  const entries = [];
+  for (const raw of rawEntries) {
+    const entry = readEntry(raw);
+    if (entry === null)
+      return null;
+    entries.push(entry);
+  }
+  const reviews = [];
+  for (const raw of rawReviews) {
+    const review = readReview(raw);
+    if (review === null)
+      return null;
+    reviews.push(review);
   }
+  if (hasDuplicates(entries) || hasDuplicates(reviews))
+    return null;
+  return { entries, reviews };
 }
 function readEntry(raw) {
   if (!isPlainObject2(raw) || !hasExactKeys(raw, ENTRY_KEYS))
@@ -14815,7 +14851,7 @@ function readEntry(raw) {
   const number4 = raw["number"];
   const version2 = raw["version"];
   const shownAt = raw["shownAt"];
-  if (typeof phase !== "string" || phase === "")
+  if (!isNonEmptyString(phase))
     return null;
   if (!isPositiveInteger(number4) || !isPositiveInteger(version2))
     return null;
@@ -14823,6 +14859,53 @@ function readEntry(raw) {
     return null;
   return { phase, number: number4, version: version2, shownAt };
 }
+function readReview(raw) {
+  if (!isPlainObject2(raw) || !hasExactKeys(raw, REVIEW_KEYS))
+    return null;
+  const phase = raw["phase"];
+  const number4 = raw["number"];
+  const round = raw["round"];
+  const reviewVersion = raw["reviewVersion"];
+  const shownAt = raw["shownAt"];
+  const rawParts = raw["parts"];
+  if (!isNonEmptyString(phase))
+    return null;
+  if (number4 !== null && !isPositiveInteger(number4))
+    return null;
+  if (!isPositiveInteger(round) || !isWholeNumber(reviewVersion))
+    return null;
+  if (!isIsoInstant(shownAt))
+    return null;
+  if (!Array.isArray(rawParts))
+    return null;
+  const parts = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rawPart of rawParts) {
+    const part = readReviewPart(rawPart);
+    if (part === null || seen.has(part.part))
+      return null;
+    seen.add(part.part);
+    parts.push(part);
+  }
+  return { phase, number: number4, round, reviewVersion, shownAt, parts };
+}
+function readReviewPart(raw) {
+  if (!isPlainObject2(raw) || !hasExactKeys(raw, REVIEW_PART_KEYS))
+    return null;
+  const part = raw["part"];
+  const name = raw["name"];
+  const built = raw["built"];
+  const decidable = raw["decidable"];
+  const awaitingAnswer = raw["awaitingAnswer"];
+  const sentBack = raw["sentBack"];
+  if (!isNonEmptyString(part) || !isNonEmptyString(name))
+    return null;
+  if (typeof built !== "boolean" || typeof decidable !== "boolean")
+    return null;
+  if (typeof awaitingAnswer !== "boolean" || typeof sentBack !== "boolean")
+    return null;
+  return { part, name, built, decidable, awaitingAnswer, sentBack };
+}
 function isPlainObject2(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     return false;
@@ -14833,19 +14916,26 @@ function hasExactKeys(value, keys) {
   const own = Object.keys(value).sort();
   return own.length === keys.length && own.every((key, i) => key === keys[i]);
 }
+function isNonEmptyString(value) {
+  return typeof value === "string" && value !== "";
+}
 function isPositiveInteger(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 1;
 }
+function isWholeNumber(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
 function isIsoInstant(value) {
   if (typeof value !== "string")
     return false;
   const ms = Date.parse(value);
   return Number.isFinite(ms) && new Date(ms).toISOString() === value;
 }
-function hasDuplicates(entries) {
-  const phases = new Set(entries.map((entry) => entry.phase));
-  const numbers = new Set(entries.map((entry) => entry.number));
-  return phases.size !== entries.length || numbers.size !== entries.length;
+function hasDuplicates(items) {
+  const phases = new Set(items.map((item) => item.phase));
+  const numbered = items.filter((item) => item.number !== null);
+  const numbers = new Set(numbered.map((item) => item.number));
+  return phases.size !== items.length || numbers.size !== numbered.length;
 }
 
 // ../core/dist/phase-reference.js
@@ -14861,10 +14951,54 @@ function resolvePhaseReference(typed, phases) {
   const byNumber = phases.filter((entry) => Number.isInteger(entry.number) && String(entry.number) === typed);
   return byNumber.length === 1 ? byNumber[0] : null;
 }
+function typedPhaseReference(phase, number4) {
+  return phase.includes(":") && number4 !== null ? String(number4) : phase;
+}
 
 // ../core/dist/release-version.js
 var RELEASE_VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
 
+// ../core/dist/github-address.js
+var GITHUB_REPOSITORY_ADDRESS = /^https:\/\/github\.com\/[A-Za-z0-9][A-Za-z0-9-]{0,38}\/(?!\.{1,2}$)[A-Za-z0-9._-]{1,100}$/;
+var HOST = "[Gg][Ii][Tt][Hh][Uu][Bb]\\.[Cc][Oo][Mm]";
+var OWNER = "[A-Za-z0-9][A-Za-z0-9-]{0,38}";
+var RAW_REPOSITORY = "[A-Za-z0-9._-]{1,104}";
+var TAIL = `(${OWNER})/(${RAW_REPOSITORY})/?$`;
+var URL_USERINFO = "(?:[^\\s/?#@]+@)?";
+var SSH_USER = "(?:[^\\s/?#@:]+@)?";
+var REMOTE_FORMS = [
+  new RegExp(`^https?://${URL_USERINFO}${HOST}/${TAIL}`),
+  new RegExp(`^ssh://${SSH_USER}${HOST}/${TAIL}`),
+  new RegExp(`^git://${HOST}/${TAIL}`),
+  new RegExp(`^${SSH_USER}${HOST}:${TAIL}`)
+];
+var REPOSITORY_NAME = /^(?!\.{1,2}$)[A-Za-z0-9._-]{1,100}$/;
+function githubRepositoryAddress(remote) {
+  for (const form of REMOTE_FORMS) {
+    const match = form.exec(remote);
+    if (match === null)
+      continue;
+    const owner = match[1];
+    const raw = match[2];
+    if (owner === void 0 || raw === void 0)
+      return null;
+    const repository = raw.endsWith(".git") ? raw.slice(0, -4) : raw;
+    if (!REPOSITORY_NAME.test(repository))
+      return null;
+    const address = `https://github.com/${owner}/${repository}`;
+    if (!GITHUB_REPOSITORY_ADDRESS.test(address))
+      return null;
+    if (looksLikeSecret(address))
+      return null;
+    return address;
+  }
+  return null;
+}
+
+// ../core/dist/sign-in.js
+var SIGN_IN_COMMAND = '"npx halfcycle"';
+var HOOK_REMEDY = `Run ${SIGN_IN_COMMAND} in the project folder to sign in.`;
+
 // dist/control-origin.js
 var DEFAULT_CONTROL_ORIGIN = "https://control.halfcycle.ai";
 function resolveControlOrigin(env) {
@@ -15150,6 +15284,11 @@ function hasLoneSurrogate(text) {
 }
 var LONE_SURROGATE_MESSAGE = "must be valid text: it holds half of a character pair with no other half";
 
+// ../events/dist/human-agent.js
+var HUMAN_AGENT = "Human";
+var AGENT_NAME_MAX = 32;
+var agentNameSchema = external_exports.string().min(1).max(AGENT_NAME_MAX);
+
 // ../events/dist/state.js
 var utcIso8601 = external_exports.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/, "must be a UTC ISO-8601 timestamp ending in Z");
 var STATE_RECORD_FORMAT = "halfcycle-state-record/v1";
@@ -15273,6 +15412,7 @@ var coverageSchema = external_exports.object({
     });
   }
 });
+var projectTierSchema = external_exports.number().int().min(0).max(3);
 var artefactRecordSchema = stateRecordEnvelopeSchema.extend({
   recordKind: external_exports.literal("artefact"),
   artefactRef: artefactRefSchema,
@@ -15285,7 +15425,13 @@ var stepRunRecordSchema = stateRecordEnvelopeSchema.extend({
   recordKind: external_exports.literal("step-run"),
   runOutcome: runOutcomeSchema,
   failureReason: external_exports.string().optional(),
-  outcomeReason: external_exports.string().max(2e3).optional()
+  outcomeReason: external_exports.string().max(2e3).optional(),
+  // Who did this step, as the session reported it. Absent when not reported.
+  agent: agentNameSchema.optional(),
+  // When the session began this step. Absent when not reported.
+  startedAt: utcIso8601.optional(),
+  // The project's tier, when this step settled it. Absent on every other step.
+  projectTier: projectTierSchema.optional()
 }).strict().superRefine((rec, ctx) => {
   if (rec.runOutcome === "attempted-failed" && rec.failureReason === void 0) {
     ctx.addIssue({
@@ -15312,7 +15458,12 @@ var gateRecordSchema = stateRecordEnvelopeSchema.extend({
   verdict: gateVerdictSchema,
   actor: external_exports.string(),
   outcomeReason: external_exports.string().max(2e3).optional(),
-  coverage: coverageSchema.optional()
+  coverage: coverageSchema.optional(),
+  // Who did the step this checkpoint is on, as reported. Absent when not reported.
+  agent: agentNameSchema.optional(),
+  // When that step, or the review this checkpoint closes, began. Absent when not
+  // reported.
+  startedAt: utcIso8601.optional()
 }).strict().superRefine((rec, ctx) => {
   const issue2 = outcomeReasonIssue(rec.verdict, rec.outcomeReason);
   if (issue2) {
@@ -15326,7 +15477,9 @@ var interventionRecordSchema = stateRecordEnvelopeSchema.extend({
   severity: severitySchema,
   disposition: dispositionSchema,
   summary: external_exports.string().max(2e3),
-  coverage: coverageSchema.optional()
+  coverage: coverageSchema.optional(),
+  // Who caught it, as the session reported. Absent when not reported.
+  agent: agentNameSchema.optional()
 }).strict();
 var stateRecordSchema = external_exports.discriminatedUnion("recordKind", [
   artefactRecordSchema,
@@ -15420,6 +15573,11 @@ var FINDINGS_SHOWN_MAX = 50;
 var PHASE_CLOSE_REASON_MAX = 1900;
 var closeCommitSchema = external_exports.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/, "must be a full commit hash: 40 or 64 lowercase hex characters");
 var walkVerdictSchema = external_exports.enum(["clean", "defects"]);
+var acceptanceOutcomeSchema = external_exports.object({
+  verdict: walkVerdictSchema,
+  findings: external_exports.number().int().nonnegative(),
+  findingsDetail: external_exports.array(external_exports.object({ summary: external_exports.string().refine((v) => !hasLoneSurrogate(v), { message: LONE_SURROGATE_MESSAGE }) }).strict())
+}).strict();
 var closeDecisionSchema = external_exports.enum(["done-when-met", "override"]);
 function plainText(max) {
   const base = max === void 0 ? external_exports.string() : external_exports.string().max(max);
@@ -15543,12 +15701,7 @@ var attestedCloseSchema = external_exports.object({
 var attestedSchema = external_exports.object({
   closes: external_exports.array(attestedCloseSchema)
 }).strict();
-var buildRecordV2Schema = external_exports.object({
-  format: external_exports.literal(BUILD_RECORD_V2_FORMAT),
-  phase: phaseNameSchema,
-  observed: observedSchema,
-  attested: attestedSchema
-}).strict().superRefine((record2, ctx) => {
+function checkRecordHalves(record2, ctx) {
   const observedBySequence = new Map(record2.observed.closes.map((c) => [c.sequence, c]));
   const attestedSequences = record2.attested.closes.map((c) => c.sequence);
   const sameSet = attestedSequences.length === observedBySequence.size && new Set(attestedSequences).size === attestedSequences.length && attestedSequences.every((s) => observedBySequence.has(s));
@@ -15576,139 +15729,13 @@ var buildRecordV2Schema = external_exports.object({
       });
     }
   });
-});
-
-// ../events/dist/human-agent.js
-var HUMAN_AGENT = "Human";
-
-// ../events/dist/build-snapshot.js
-var buildTaskStateSchema = external_exports.enum([
-  "pending",
-  "in-flight",
-  "completed",
-  "failed",
-  "blocked"
-]);
-var BUILD_TASK_TITLE_MAX = 240;
-var BUILD_SNAPSHOT_TASK_LIMIT = 500;
-var buildTaskSchema = external_exports.object({
-  // The task's own id, as the coordinator's graph names it.
-  id: external_exports.string().min(1).max(64),
-  // What the task is, in the coordinator's words. A description of the work,
-  // bounded and scanned — never an excerpt of anybody's code.
-  title: external_exports.string().min(1).max(BUILD_TASK_TITLE_MAX),
-  // What the task is doing right now.
-  state: buildTaskStateSchema,
-  // Who holds it — a bare callsign, or the value naming a person when the work is
-  // a person's. Absent when nothing has been dispatched to it yet.
-  agent: external_exports.string().min(1).max(32).optional(),
-  // The kind of work the holder does. Present exactly when an agent holds it.
-  discipline: external_exports.string().min(1).max(64).optional(),
-  // How much thinking the holder brings. Present exactly when an agent holds it,
-  // and there is no field naming the supplier behind it.
-  tier: external_exports.string().min(1).max(32).optional(),
-  // The tasks this one cannot start before. Always present; empty means it waits
-  // on nothing, which is different from not having been computed.
-  dependsOn: external_exports.array(external_exports.string().min(1).max(64)).max(BUILD_SNAPSHOT_TASK_LIMIT),
-  // The one task this task checks, when it is a check on other work. Absent on a
-  // task that is doing the work rather than checking it.
-  reviews: external_exports.string().min(1).max(64).optional(),
-  // Which wave of the phase this task belongs to — the wave that writes the
-  // specifications, or the wave that builds them. Absent when the graph does not
-  // record it, which is different from the task belonging to neither.
-  layer: methodLayerSchema.optional(),
-  // When it was picked up, and when it settled. A reader computes how long it
-  // took; neither this row nor this payload carries a duration.
-  startedAt: utcIso8601.optional(),
-  settledAt: utcIso8601.optional()
-}).strict().superRefine((task, ctx) => {
-  if (task.reviews !== void 0 && task.reviews === task.id) {
-    ctx.addIssue({
-      code: external_exports.ZodIssueCode.custom,
-      path: ["reviews"],
-      message: `'${task.id}' reviews itself \u2014 a review names the OTHER task it checks.`
-    });
-  }
-  if (task.layer !== void 0 && !isPhaseScopedLayer(task.layer)) {
-    ctx.addIssue({
-      code: external_exports.ZodIssueCode.custom,
-      path: ["layer"],
-      message: `'${task.layer}' is not a wave a phase runs \u2014 expected one of ${PHASE_SCOPED_LAYERS.join(", ")}.`
-    });
-  }
-  const profiled = task.agent !== void 0 && task.agent !== HUMAN_AGENT;
-  for (const field of ["discipline", "tier"]) {
-    if (profiled && task[field] === void 0) {
-      ctx.addIssue({
-        code: external_exports.ZodIssueCode.custom,
-        path: [field],
-        message: `'${field}' is required on a task an agent holds.`
-      });
-    }
-    if (!profiled && task[field] !== void 0) {
-      ctx.addIssue({
-        code: external_exports.ZodIssueCode.custom,
-        path: [field],
-        message: task.agent === void 0 ? `'${field}' must be absent on a task nobody holds.` : `'${field}' must be absent on work a person holds.`
-      });
-    }
-  }
-});
-var buildPhaseSchema = external_exports.string().min(1).max(128);
-var BUILD_PHASE_TITLE_MAX = 160;
-var buildPhaseTitleSchema = external_exports.string().min(1).max(BUILD_PHASE_TITLE_MAX);
-var buildTaskListSchema = external_exports.array(buildTaskSchema).max(BUILD_SNAPSHOT_TASK_LIMIT).superRefine((tasks, ctx) => {
-  const seen = /* @__PURE__ */ new Set();
-  for (const [index, task] of tasks.entries()) {
-    if (seen.has(task.id)) {
-      ctx.addIssue({
-        code: external_exports.ZodIssueCode.custom,
-        path: [index, "id"],
-        message: `duplicate task id '${task.id}' \u2014 one graph names each task once.`
-      });
-    }
-    seen.add(task.id);
-  }
-});
-var buildSnapshotSchema = external_exports.object({
-  // Which phase this graph belongs to.
-  phase: buildPhaseSchema,
-  // That phase's name in words, when the project gives it one.
-  phaseTitle: buildPhaseTitleSchema.optional(),
-  // Every task on it. Never a partial graph and never a change since last time.
-  tasks: buildTaskListSchema,
-  // When this graph was last reported.
-  reportedAt: utcIso8601,
-  // When work on this phase was first reported with no approval of its scope in force.
-  builtWithoutApproval: utcIso8601.optional()
-}).strict();
-var buildPhaseEntrySchema = external_exports.object({
-  // Which phase has a stored graph.
-  phase: buildPhaseSchema,
-  // That phase's name in words, when the project gave it one.
-  phaseTitle: buildPhaseTitleSchema.optional(),
-  // When that phase's graph was last reported.
-  reportedAt: utcIso8601,
-  // Present when work on this phase was reported with no approval of its scope in force.
-  builtWithoutApproval: external_exports.literal(true).optional()
-}).strict();
-var buildSnapshotReportSchema = external_exports.object({
-  // Which phase this graph belongs to.
-  phase: buildPhaseSchema,
-  // That phase's name in words, when the project gives it one.
-  phaseTitle: buildPhaseTitleSchema.optional(),
-  // The whole graph, every time. Reporting a change instead of the graph is the
-  // one thing this route does not accept.
-  tasks: buildTaskListSchema
-}).strict();
-var buildSnapshotReportResultSchema = external_exports.object({
-  // What happened. One outcome today; a refusal travels as the shared wire error.
-  outcome: external_exports.literal("recorded"),
-  // Which phase the graph was recorded against.
-  phase: buildPhaseSchema,
-  // When it was recorded.
-  reportedAt: utcIso8601
-}).strict();
+}
+var buildRecordV2Schema = external_exports.object({
+  format: external_exports.literal(BUILD_RECORD_V2_FORMAT),
+  phase: phaseNameSchema,
+  observed: observedSchema,
+  attested: attestedSchema
+}).strict().superRefine(checkRecordHalves);
 
 // ../events/dist/system-description.js
 var SYSTEM_DESCRIPTION_FORMAT = 1;
@@ -15782,6 +15809,72 @@ var systemDescriptionProblemSchema = external_exports.object({
   path: external_exports.string(),
   message: external_exports.string()
 }).strict();
+function segmentMatches(pattern, segment) {
+  const literals = pattern.split("*");
+  if (literals.length === 1)
+    return pattern === segment;
+  const first = literals[0];
+  const last = literals[literals.length - 1];
+  if (!segment.startsWith(first))
+    return false;
+  let position = first.length;
+  for (const literal2 of literals.slice(1, -1)) {
+    const found = segment.indexOf(literal2, position + 1);
+    if (found === -1)
+      return false;
+    position = found + literal2.length;
+  }
+  return segment.length - last.length >= position + 1 && segment.endsWith(last);
+}
+function patternOwns(pattern, path) {
+  const want = pattern.split("/");
+  const have = path.split("/");
+  const width = have.length + 1;
+  const seen = new Uint8Array((want.length + 1) * width);
+  const from = (i, j) => {
+    if (i === want.length)
+      return true;
+    const cell = i * width + j;
+    if (seen[cell] !== 0)
+      return seen[cell] === 2;
+    const segment = want[i];
+    const result = segment === "**" ? from(i + 1, j) || j < have.length && from(i, j + 1) : j < have.length && segmentMatches(segment, have[j]) && from(i + 1, j + 1);
+    seen[cell] = result ? 2 : 1;
+    return result;
+  };
+  return from(0, 0);
+}
+function specificity(pattern) {
+  const segments = pattern.split("/");
+  const firstWildcard = segments.findIndex((segment) => segment.includes("*"));
+  return {
+    leadingLiterals: firstWildcard === -1 ? segments.length : firstWildcard,
+    wildcards: segments.filter((segment) => segment.includes("*")).length,
+    literalCharacters: pattern.replace(/[*/]/g, "").length
+  };
+}
+function outranks(a, b) {
+  if (a.rank.leadingLiterals !== b.rank.leadingLiterals)
+    return b.rank.leadingLiterals - a.rank.leadingLiterals;
+  if (a.rank.wildcards !== b.rank.wildcards)
+    return a.rank.wildcards - b.rank.wildcards;
+  if (a.rank.literalCharacters !== b.rank.literalCharacters)
+    return b.rank.literalCharacters - a.rank.literalCharacters;
+  return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+function ownerOf(path, description) {
+  let best = null;
+  for (const part of description.parts) {
+    for (const pattern of part.owns) {
+      if (!patternOwns(pattern, path))
+        continue;
+      const candidate = { id: part.id, rank: specificity(pattern) };
+      if (best === null || outranks(candidate, best) < 0)
+        best = candidate;
+    }
+  }
+  return best === null ? null : best.id;
+}
 var systemReportRecordedSchema = external_exports.object({
   outcome: external_exports.literal("recorded"),
   version: external_exports.number().int().min(1),
@@ -15811,9 +15904,14 @@ var systemDrawPhaseRequestSchema = external_exports.object({
   phase: phaseIdentitySchema,
   planVersion: external_exports.number().int().min(1)
 }).strict();
+var systemDrawClosedPhaseRequestSchema = external_exports.object({
+  picture: external_exports.literal("closed-phase"),
+  phase: phaseIdentitySchema
+}).strict();
 var systemDrawRequestSchema = external_exports.discriminatedUnion("picture", [
   systemDrawArchitectureRequestSchema,
-  systemDrawPhaseRequestSchema
+  systemDrawPhaseRequestSchema,
+  systemDrawClosedPhaseRequestSchema
 ]);
 function utf8ByteLength2(text) {
   let bytes = 0;
@@ -15852,6 +15950,174 @@ var systemDrawRefusedSchema = external_exports.object({
 var systemDrawUnavailableSchema = external_exports.object({
   outcome: external_exports.literal("unavailable")
 }).strict();
+var systemDrawNotClosedSchema = external_exports.object({
+  outcome: external_exports.literal("not-closed")
+}).strict();
+
+// ../events/dist/build-snapshot.js
+var buildTaskStateSchema = external_exports.enum([
+  "pending",
+  "in-flight",
+  "completed",
+  "failed",
+  "blocked"
+]);
+var BUILD_TASK_TITLE_MAX = 240;
+var BUILD_SNAPSHOT_TASK_LIMIT = 500;
+var BUILD_TASK_WHY_OUTSIDE_PLAN_MAX = 160;
+var BUILD_TASK_BUDGET_MAX_MINUTES = 10080;
+var BUILD_TASK_NOTE_MAX = 240;
+var BUILD_TASK_CLEAR_COMMAND_MAX = 240;
+var buildTaskKindSchema = external_exports.enum(["build", "review", "spec", "walk"]);
+var buildTaskIdSchema = external_exports.string().min(1).max(64);
+var buildTaskSchema = external_exports.object({
+  // The task's own id, as the coordinator's graph names it.
+  id: buildTaskIdSchema,
+  // What the task is, in the coordinator's words. A description of the work,
+  // bounded and scanned — never an excerpt of anybody's code.
+  title: external_exports.string().min(1).max(BUILD_TASK_TITLE_MAX),
+  // What the task is doing right now.
+  state: buildTaskStateSchema,
+  // Who holds it — a bare callsign, or the value naming a person when the work is
+  // a person's. Absent when nothing has been dispatched to it yet.
+  agent: agentNameSchema.optional(),
+  // The kind of work the holder does. Present exactly when an agent holds it.
+  discipline: external_exports.string().min(1).max(64).optional(),
+  // How much thinking the holder brings. Present exactly when an agent holds it,
+  // and there is no field naming the supplier behind it.
+  tier: external_exports.string().min(1).max(32).optional(),
+  // The tasks this one cannot start before. Always present; empty means it waits
+  // on nothing, which is different from not having been computed.
+  dependsOn: external_exports.array(buildTaskIdSchema).max(BUILD_SNAPSHOT_TASK_LIMIT),
+  // The one task this task checks, when it is a check on other work. Absent on a
+  // task that is doing the work rather than checking it.
+  reviews: buildTaskIdSchema.optional(),
+  // Which wave of the phase this task belongs to — the wave that writes the
+  // specifications, or the wave that builds them. Absent when the graph does not
+  // record it, which is different from the task belonging to neither.
+  layer: methodLayerSchema.optional(),
+  // When it was picked up, and when it settled. A reader computes how long it
+  // took; neither this row nor this payload carries a duration.
+  startedAt: utcIso8601.optional(),
+  settledAt: utcIso8601.optional(),
+  // The parts of this project's system the task builds, by their ids. Absent when
+  // it builds none; never an empty list.
+  builds: external_exports.array(systemPartIdSchema).min(1).max(SYSTEM_PARTS_MAX).optional(),
+  // In one line, why the task built a part the phase's plan does not include, in
+  // the words of whoever holds it. Absent when it gave no reason.
+  whyOutsidePlan: descriptionText(BUILD_TASK_WHY_OUTSIDE_PLAN_MAX).optional(),
+  // How long the task is expected to take, in whole minutes, from one minute to one
+  // week. A plan, not a measurement; absent when no budget was set.
+  budgetMinutes: external_exports.number().int().min(1).max(BUILD_TASK_BUDGET_MAX_MINUTES).optional(),
+  // What kind of work the task is: building, checking other work, writing what to
+  // build, or a person trying the product. Absent when the graph does not say.
+  kind: buildTaskKindSchema.optional(),
+  // One line from whoever holds the task about where it stands. Absent when there
+  // is nothing to say.
+  note: descriptionText(BUILD_TASK_NOTE_MAX).optional(),
+  // On a task held for a person, the one thing they do or run to clear it, in one
+  // line. Absent when the task names none.
+  clearCommand: descriptionText(BUILD_TASK_CLEAR_COMMAND_MAX).optional(),
+  // On a task held for a person, the crew member ready to take it on once it is
+  // cleared, by callsign. Absent when nobody is standing by.
+  standingBy: agentNameSchema.optional()
+}).strict().superRefine((task, ctx) => {
+  if (task.reviews !== void 0 && task.reviews === task.id) {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["reviews"],
+      message: `'${task.id}' reviews itself \u2014 a review names the OTHER task it checks.`
+    });
+  }
+  if (task.layer !== void 0 && !isPhaseScopedLayer(task.layer)) {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["layer"],
+      message: `'${task.layer}' is not a wave a phase runs \u2014 expected one of ${PHASE_SCOPED_LAYERS.join(", ")}.`
+    });
+  }
+  const profiled = task.agent !== void 0 && task.agent !== HUMAN_AGENT;
+  for (const field of ["discipline", "tier"]) {
+    if (profiled && task[field] === void 0) {
+      ctx.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: [field],
+        message: `'${field}' is required on a task an agent holds.`
+      });
+    }
+    if (!profiled && task[field] !== void 0) {
+      ctx.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: [field],
+        message: task.agent === void 0 ? `'${field}' must be absent on a task nobody holds.` : `'${field}' must be absent on work a person holds.`
+      });
+    }
+  }
+});
+var buildPhaseSchema = external_exports.string().min(1).max(128);
+var BUILD_PHASE_TITLE_MAX = 160;
+var buildPhaseTitleSchema = external_exports.string().min(1).max(BUILD_PHASE_TITLE_MAX);
+var buildTaskListSchema = external_exports.array(buildTaskSchema).max(BUILD_SNAPSHOT_TASK_LIMIT).superRefine((tasks, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, task] of tasks.entries()) {
+    if (seen.has(task.id)) {
+      ctx.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: [index, "id"],
+        message: `duplicate task id '${task.id}' \u2014 one graph names each task once.`
+      });
+    }
+    seen.add(task.id);
+  }
+});
+var buildTaskMarkSchema = external_exports.object({
+  // The task that was marked.
+  task: buildTaskIdSchema,
+  // When it was first marked.
+  at: utcIso8601
+}).strict();
+var buildSnapshotSchema = external_exports.object({
+  // Which phase this graph belongs to.
+  phase: buildPhaseSchema,
+  // That phase's name in words, when the project gives it one.
+  phaseTitle: buildPhaseTitleSchema.optional(),
+  // Every task on it. Never a partial graph and never a change since last time.
+  tasks: buildTaskListSchema,
+  // When this graph was last reported.
+  reportedAt: utcIso8601,
+  // When work on this phase was first reported with no approval of its scope in force.
+  builtWithoutApproval: utcIso8601.optional(),
+  // Each task that started on a part still waiting for approval, and when it was
+  // first seen doing so. Absent when there is none.
+  tasksBuiltWithoutApproval: external_exports.array(buildTaskMarkSchema).min(1).max(BUILD_SNAPSHOT_TASK_LIMIT).optional()
+}).strict();
+var buildPhaseEntrySchema = external_exports.object({
+  // Which phase has a stored graph.
+  phase: buildPhaseSchema,
+  // That phase's name in words, when the project gave it one.
+  phaseTitle: buildPhaseTitleSchema.optional(),
+  // When that phase's graph was last reported.
+  reportedAt: utcIso8601,
+  // Present when work on this phase was reported with no approval of its scope in force.
+  builtWithoutApproval: external_exports.literal(true).optional()
+}).strict();
+var buildSnapshotReportSchema = external_exports.object({
+  // Which phase this graph belongs to.
+  phase: buildPhaseSchema,
+  // That phase's name in words, when the project gives it one.
+  phaseTitle: buildPhaseTitleSchema.optional(),
+  // The whole graph, every time. Reporting a change instead of the graph is the
+  // one thing this route does not accept.
+  tasks: buildTaskListSchema
+}).strict();
+var buildSnapshotReportResultSchema = external_exports.object({
+  // What happened. One outcome today; a refusal travels as the shared wire error.
+  outcome: external_exports.literal("recorded"),
+  // Which phase the graph was recorded against.
+  phase: buildPhaseSchema,
+  // When it was recorded.
+  reportedAt: utcIso8601
+}).strict();
 
 // ../events/dist/phase-plan.js
 var PHASE_PLAN_FORMAT = 1;
@@ -15904,6 +16170,13 @@ var scopeDecisionPartSchema = external_exports.object({
   note: scopeNoteWireSchema.optional()
 }).strict();
 var planVersionSchema = external_exports.number().int().min(1);
+var carriedPhaseSchema = external_exports.object({
+  phase: scopePhaseSchema,
+  number: external_exports.number().int().min(1)
+}).strict();
+var carriedFromEntrySchema = carriedPhaseSchema.extend({
+  part: systemPartIdSchema
+}).strict();
 var phasePlanRequestSchema = external_exports.object({
   descriptionVersion: external_exports.number().int().min(1),
   plan: external_exports.unknown()
@@ -15915,7 +16188,8 @@ var phasePlanRecordedSchema = external_exports.object({
   state: plannedScopeStateSchema,
   changedParts: external_exports.array(systemPartIdSchema).max(PHASE_PLAN_CHANGES_MAX),
   typedApprovalOffered: external_exports.boolean(),
-  reportedAt: utcIso8601
+  reportedAt: utcIso8601,
+  carriedFrom: external_exports.array(carriedFromEntrySchema).min(1).max(PHASE_PLAN_CHANGES_MAX).optional()
 }).strict();
 var phasePlanRefusedSchema = external_exports.object({
   outcome: external_exports.literal("refused"),
@@ -15924,10 +16198,23 @@ var phasePlanRefusedSchema = external_exports.object({
 var phasePlanUnavailableSchema = external_exports.object({
   outcome: external_exports.literal("unavailable")
 }).strict();
+var REMOVAL_OWED_ACTS = ["dropped", "removed"];
+var removalOwedPartSchema = external_exports.object({
+  part: systemPartIdSchema,
+  name: systemPartSchema.shape.name,
+  phase: scopePhaseSchema,
+  number: external_exports.number().int().min(1),
+  act: external_exports.enum(REMOVAL_OWED_ACTS)
+}).strict();
+var phasePlanRemovalOwedSchema = external_exports.object({
+  outcome: external_exports.literal("removal-owed"),
+  parts: external_exports.array(removalOwedPartSchema).min(1).max(SYSTEM_PARTS_MAX)
+}).strict();
 var phasePlanResultSchema = external_exports.discriminatedUnion("outcome", [
   phasePlanRecordedSchema,
   phasePlanRefusedSchema,
-  phasePlanUnavailableSchema
+  phasePlanUnavailableSchema,
+  phasePlanRemovalOwedSchema
 ]);
 var scopeApproveRequestSchema = external_exports.object({
   act: external_exports.literal("approve"),
@@ -15989,7 +16276,8 @@ var scopeReadPartSchema = external_exports.object({
   change: phasePlanChangeSchema,
   summary: phasePlanSummarySchema,
   status: scopePartStatusSchema,
-  changed: external_exports.boolean()
+  changed: external_exports.boolean(),
+  carriedFrom: carriedPhaseSchema.optional()
 }).strict();
 var scopeReadDecisionSchema = external_exports.object({
   act: scopeActSchema,
@@ -16016,9 +16304,580 @@ var scopeReadPlannedSchema = external_exports.object({
 }).strict();
 var scopeReadSchema = external_exports.union([scopeReadNotPlannedSchema, scopeReadPlannedSchema]);
 
+// ../events/dist/code-link.js
+var codeLinkAddressSchema = external_exports.string().regex(GITHUB_REPOSITORY_ADDRESS, { message: "must be a GitHub repository address: https://github.com/<owner>/<repo>" }).refine((v) => !looksLikeSecret(v), { message: "looks like a password or key, so it is not sent" });
+var codeLinkFactsSchema = external_exports.object({
+  repositoryAddress: codeLinkAddressSchema.nullable(),
+  headOnGitHub: external_exports.boolean()
+}).strict().refine((v) => !(v.headOnGitHub && v.repositoryAddress === null), {
+  message: "cannot be true when the code is not on GitHub",
+  path: ["headOnGitHub"]
+});
+var PART_CODE_LINK_SCOPES = ["part", "phase"];
+var PART_CODE_LINK_RANGE_REASONS = ["not-github", "not-pushed"];
+var PART_CODE_LINK_URL_PREFIX = "https://github.com/";
+var partCodeLinkGithubSchema = external_exports.object({
+  kind: external_exports.literal("github"),
+  scope: external_exports.enum(PART_CODE_LINK_SCOPES),
+  url: external_exports.string().startsWith(PART_CODE_LINK_URL_PREFIX, { message: "must start with https://github.com/" })
+}).strict();
+var partCodeLinkRangeSchema = external_exports.object({
+  kind: external_exports.literal("range"),
+  why: external_exports.enum(PART_CODE_LINK_RANGE_REASONS),
+  from: closeCommitSchema,
+  to: closeCommitSchema
+}).strict();
+var partCodeLinkNoneSchema = external_exports.object({
+  kind: external_exports.literal("none")
+}).strict();
+var partCodeLinkSchema = external_exports.discriminatedUnion("kind", [
+  partCodeLinkGithubSchema,
+  partCodeLinkRangeSchema,
+  partCodeLinkNoneSchema
+]);
+
+// ../events/dist/observed-changes.js
+var OBSERVED_PATHS_LISTED_MAX = 50;
+var OBSERVED_PATH_MAX = 300;
+var OBSERVED_COUNT_MAX = 1e6;
+var METHOD_FILE_PATTERNS = [
+  "CLAUDE.md",
+  "AGENTS.md",
+  ".claude/context",
+  ".claude/commands",
+  ".claude/hooks",
+  ".claude/settings.json",
+  ".mcp.json",
+  ".halfcycle",
+  ".workbench",
+  "docs/product-spec.md",
+  "docs/architecture-overview.md",
+  "docs/invariants.md",
+  "docs/project-log.md",
+  "docs/code-map.md",
+  "docs/system.json",
+  "docs/diagrams",
+  "docs/features",
+  "docs/phases",
+  "docs/build-records",
+  "docs/decisions",
+  "docs/components"
+];
+var TEST_FILE_PATTERNS = [
+  "**/*.test.*",
+  "**/*.spec.*",
+  "**/*_test.*",
+  "**/*_spec.*",
+  "**/test_*.*",
+  "**/*Test.java",
+  "**/*Tests.java",
+  "**/*Test.kt",
+  "**/*Tests.cs",
+  "**/*Test.php"
+];
+function isMethodFile(path) {
+  return METHOD_FILE_PATTERNS.some((pattern) => patternOwns(pattern, path));
+}
+function isTestFile(path) {
+  return TEST_FILE_PATTERNS.some((pattern) => patternOwns(pattern, path));
+}
+var observedCountSchema = external_exports.number({ error: `must be a whole number from 0 to ${OBSERVED_COUNT_MAX}` }).int({ error: `must be a whole number from 0 to ${OBSERVED_COUNT_MAX}` }).min(0, { error: `must be a whole number from 0 to ${OBSERVED_COUNT_MAX}` }).max(OBSERVED_COUNT_MAX, { error: `must be a whole number from 0 to ${OBSERVED_COUNT_MAX}` });
+var observedDescriptionVersionSchema = external_exports.number().int().min(1);
+var observedPathSchema = external_exports.string().min(1, { message: "must not be empty" }).max(OBSERVED_PATH_MAX, { message: `must be at most ${OBSERVED_PATH_MAX} characters` });
+var observedPathListSchema = external_exports.array(observedPathSchema).max(OBSERVED_PATHS_LISTED_MAX, { message: `can list at most ${OBSERVED_PATHS_LISTED_MAX} paths` }).refine((paths) => new Set(paths).size === paths.length, { message: "must name each path once" });
+var observedMethodFilesSchema = external_exports.object({
+  added: observedCountSchema,
+  changed: observedCountSchema,
+  removed: observedCountSchema
+}).strict();
+var observedFilesSchema = external_exports.object({
+  added: observedCountSchema,
+  changed: observedCountSchema,
+  removed: observedCountSchema,
+  testFilesAdded: observedCountSchema
+}).strict().refine((v) => v.testFilesAdded <= v.added, {
+  message: "cannot be more than the files added",
+  path: ["testFilesAdded"]
+});
+function filesChanged(files) {
+  return files.added + files.changed + files.removed;
+}
+function pathsFitTheCount(files, paths) {
+  return files === null ? paths.length === 0 : paths.length <= filesChanged(files);
+}
+function checkPartsUnique(parts, ctx, at) {
+  const seen = /* @__PURE__ */ new Set();
+  parts.forEach((entry, i) => {
+    if (seen.has(entry.part)) {
+      ctx.addIssue({ code: "custom", path: [...at, i, "part"], message: `names the part "${entry.part}" twice` });
+    }
+    seen.add(entry.part);
+  });
+}
+var observedBasisCountSchema = external_exports.object({
+  outcome: external_exports.literal("count"),
+  phase: phaseNameSchema,
+  startCommit: closeCommitSchema,
+  descriptionVersion: observedDescriptionVersionSchema,
+  description: systemDescriptionSchema
+}).strict();
+var observedBasisCannotCountSchema = external_exports.object({
+  outcome: external_exports.literal("cannot-count"),
+  phase: phaseNameSchema,
+  reason: external_exports.literal("no-start-commit")
+}).strict();
+var observedBasisNothingToCountSchema = external_exports.object({
+  outcome: external_exports.literal("nothing-to-count"),
+  reason: external_exports.enum(["no-open-phase", "no-description"])
+}).strict();
+var observedBasisSchema = external_exports.discriminatedUnion("outcome", [
+  observedBasisCountSchema,
+  observedBasisCannotCountSchema,
+  observedBasisNothingToCountSchema
+]);
+var observedReportPartSchema = external_exports.object({
+  part: systemPartIdSchema,
+  added: observedCountSchema,
+  changed: observedCountSchema,
+  removed: observedCountSchema,
+  testFilesAdded: observedCountSchema
+}).strict().refine((v) => v.testFilesAdded <= v.added, {
+  message: "cannot be more than the files added",
+  path: ["testFilesAdded"]
+}).refine((v) => filesChanged(v) >= 1, {
+  message: "a part is listed only when at least one file changed under it",
+  path: ["added"]
+});
+var observedReportOutsideSchema = external_exports.object({
+  added: observedCountSchema,
+  changed: observedCountSchema,
+  removed: observedCountSchema,
+  testFilesAdded: observedCountSchema,
+  paths: observedPathListSchema
+}).strict().refine((v) => v.testFilesAdded <= v.added, {
+  message: "cannot be more than the files added",
+  path: ["testFilesAdded"]
+}).refine((v) => pathsFitTheCount(v, v.paths), {
+  message: "lists more paths than files changed",
+  path: ["paths"]
+});
+var observedChangesReportSchema = external_exports.object({
+  phase: phaseNameSchema,
+  startCommit: closeCommitSchema,
+  headCommit: closeCommitSchema,
+  headCommittedAt: utcIso8601,
+  commits: observedCountSchema,
+  descriptionVersion: observedDescriptionVersionSchema,
+  parts: external_exports.array(observedReportPartSchema).max(SYSTEM_PARTS_MAX, { message: `can list at most ${SYSTEM_PARTS_MAX} parts` }),
+  methodFiles: observedMethodFilesSchema,
+  outsideEveryPart: observedReportOutsideSchema,
+  codeLink: codeLinkFactsSchema
+}).strict().superRefine((v, ctx) => checkPartsUnique(v.parts, ctx, ["parts"]));
+var observedSaidSchema = external_exports.object({
+  title: buildTaskSchema.shape.title,
+  agent: buildTaskSchema.shape.agent,
+  whyOutsidePlan: buildTaskSchema.shape.whyOutsidePlan
+}).strict();
+var observedNotInPlanSchema = external_exports.object({
+  part: systemPartIdSchema,
+  name: systemPartSchema.shape.name,
+  said: external_exports.array(observedSaidSchema).max(BUILD_SNAPSHOT_TASK_LIMIT)
+}).strict();
+var observedChangesRecordedSchema = external_exports.object({
+  outcome: external_exports.literal("recorded"),
+  notInPlan: external_exports.array(observedNotInPlanSchema).max(SYSTEM_PARTS_MAX).superRefine((parts, ctx) => checkPartsUnique(parts, ctx, [])),
+  outside: external_exports.object({
+    files: observedCountSchema,
+    example: observedPathSchema.nullable()
+  }).strict().refine((v) => v.example === null || v.files >= 1, {
+    message: "names an example when no file changed",
+    path: ["example"]
+  })
+}).strict();
+var observedChangesKeptSchema = external_exports.object({
+  outcome: external_exports.literal("kept")
+}).strict();
+var observedChangesReportResultSchema = external_exports.discriminatedUnion("outcome", [
+  observedChangesRecordedSchema,
+  observedChangesKeptSchema
+]);
+var OBSERVE_NOT_SENT_REASONS = [
+  "not-configured",
+  "nothing-to-count",
+  "cannot-count",
+  "start-not-here",
+  "start-not-on-branch",
+  "basis-moved",
+  "refused",
+  "unreachable"
+];
+var observeRunRecordedSchema = external_exports.object({ outcome: external_exports.literal("recorded") }).strict();
+var observeRunKeptSchema = external_exports.object({ outcome: external_exports.literal("kept") }).strict();
+var observeRunNotSentSchema = external_exports.object({
+  outcome: external_exports.literal("not-sent"),
+  reason: external_exports.enum(OBSERVE_NOT_SENT_REASONS)
+}).strict();
+var observeRunResultSchema = external_exports.discriminatedUnion("outcome", [
+  observeRunRecordedSchema,
+  observeRunKeptSchema,
+  observeRunNotSentSchema
+]);
+var observedChecksFiredSchema = external_exports.array(external_exports.string().min(1)).refine((names) => names.every((name, i) => i === 0 || names[i - 1] < name), {
+  message: "must be sorted, each name once"
+});
+var observedCountingSchema = external_exports.discriminatedUnion("state", [
+  external_exports.object({
+    state: external_exports.literal("counted"),
+    startCommit: closeCommitSchema,
+    startRecordedAt: utcIso8601,
+    headCommit: closeCommitSchema,
+    headCommittedAt: utcIso8601,
+    commits: observedCountSchema,
+    countedAt: utcIso8601
+  }).strict(),
+  external_exports.object({
+    state: external_exports.literal("not-counted-yet"),
+    startCommit: closeCommitSchema,
+    startRecordedAt: utcIso8601
+  }).strict(),
+  external_exports.object({
+    state: external_exports.literal("cannot-count")
+  }).strict()
+]);
+var observedPartSchema = external_exports.object({
+  part: systemPartIdSchema,
+  files: observedFilesSchema.nullable(),
+  checksFired: observedChecksFiredSchema
+}).strict().refine((v) => v.files !== null && filesChanged(v.files) >= 1 || v.checksFired.length >= 1, {
+  message: "a part is listed only when files changed under it or a check fired on one",
+  path: ["files"]
+});
+var observedOutsideSchema = external_exports.object({
+  files: observedFilesSchema.nullable(),
+  paths: observedPathListSchema,
+  checksFired: observedChecksFiredSchema
+}).strict().refine((v) => pathsFitTheCount(v.files, v.paths), {
+  message: "lists more paths than files changed",
+  path: ["paths"]
+});
+var observedChangesSchema = external_exports.object({
+  phase: phaseNameSchema,
+  counting: observedCountingSchema,
+  descriptionVersion: observedDescriptionVersionSchema.nullable(),
+  parts: external_exports.array(observedPartSchema).max(SYSTEM_PARTS_MAX),
+  methodFiles: observedMethodFilesSchema.nullable(),
+  outsideEveryPart: observedOutsideSchema,
+  codeLink: codeLinkFactsSchema.nullable()
+}).strict().superRefine((v, ctx) => {
+  checkPartsUnique(v.parts, ctx, ["parts"]);
+  const counted = v.counting.state === "counted";
+  const rule = counted ? "must be present when the phase is counted" : "must be null until the phase is counted";
+  if (v.methodFiles !== null !== counted)
+    ctx.addIssue({ code: "custom", path: ["methodFiles"], message: rule });
+  if (v.outsideEveryPart.files !== null !== counted) {
+    ctx.addIssue({ code: "custom", path: ["outsideEveryPart", "files"], message: rule });
+  }
+  if (v.codeLink !== null !== counted)
+    ctx.addIssue({ code: "custom", path: ["codeLink"], message: rule });
+  v.parts.forEach((entry, i) => {
+    if (entry.files !== null !== counted)
+      ctx.addIssue({ code: "custom", path: ["parts", i, "files"], message: rule });
+  });
+  if (counted && v.descriptionVersion === null) {
+    ctx.addIssue({ code: "custom", path: ["descriptionVersion"], message: "must name the version the counts used" });
+  }
+});
+var partOutsideThePlanSchema = external_exports.object({
+  part: systemPartIdSchema,
+  name: systemPartSchema.shape.name,
+  seen: observedFilesSchema.nullable(),
+  tasks: external_exports.array(observedSaidSchema.extend({ id: buildTaskSchema.shape.id }).strict()).max(BUILD_SNAPSHOT_TASK_LIMIT)
+}).strict();
+var NO_TASK_SAID_LINE = "No task said it changed this part.";
+function agentSaid(task) {
+  const { title, agent, whyOutsidePlan } = task;
+  if (whyOutsidePlan === void 0)
+    return `"${title}" said it built this part, and gave no reason.`;
+  if (agent === HUMAN_AGENT)
+    return `The person on "${title}" said: "${whyOutsidePlan}"`;
+  if (agent === void 0)
+    return `The agent on "${title}" said: "${whyOutsidePlan}"`;
+  return `${agent} said, on "${title}": "${whyOutsidePlan}"`;
+}
+
+// ../events/dist/phase-review.js
+var BUILT_PART_ACTS = Object.freeze(["accept", "question", "send-back"]);
+var NOT_BUILT_PART_ACTS = Object.freeze(["carry", "drop"]);
+var REVIEW_ACTS = Object.freeze([...BUILT_PART_ACTS, ...NOT_BUILT_PART_ACTS]);
+var reviewActSchema = external_exports.enum(REVIEW_ACTS);
+function reviewActsFor(built) {
+  return built ? BUILT_PART_ACTS : NOT_BUILT_PART_ACTS;
+}
+var REVIEW_NOTE_MAX = SCOPE_NOTE_MAX;
+var reviewNoteWireSchema = external_exports.string().max(REVIEW_NOTE_MAX);
+var reviewNoteSchema = external_exports.string().min(1).max(REVIEW_NOTE_MAX);
+var REVIEW_ANSWER_MAX = 1e3;
+var reviewAgentAnswerSchema = external_exports.string().min(1).max(REVIEW_ANSWER_MAX);
+var REVIEW_PARTS_MAX = PHASE_PLAN_CHANGES_MAX * 2;
+var REVIEW_PART_CHANGES = Object.freeze([...PHASE_PLAN_CHANGE_KINDS, "not-in-plan"]);
+var reviewPartChangeSchema = external_exports.enum(REVIEW_PART_CHANGES);
+var REVIEW_DECISIONS = Object.freeze(["accepted", "carried", "dropped"]);
+var reviewDecisionSchema = external_exports.enum(REVIEW_DECISIONS);
+function actOf(decision) {
+  if (decision === "accepted")
+    return "accept";
+  if (decision === "carried")
+    return "carry";
+  return "drop";
+}
+var reviewCarriedToSchema = carriedPhaseSchema.nullable();
+var reviewStepNameSchema = stepNameSchema.refine((v) => !stepIdSchema.safeParse(v.trim()).success, {
+  message: "must be the step's plain name"
+});
+var reviewStepSchema = external_exports.object({
+  name: reviewStepNameSchema.nullable(),
+  state: unfinishedStepSchema.shape.state,
+  judged: external_exports.boolean()
+}).strict();
+var UNNAMED_STEP = "a step of this phase";
+function stepCalled(step) {
+  return step.name === null ? UNNAMED_STEP : `"${step.name}"`;
+}
+function sentenceStart(text) {
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+function unfinishedStepLabel(step) {
+  const state = step.state === "parked" ? "parked" : "attempted, and did not finish";
+  return `${stepCalled(step)} (${state})`;
+}
+function unfinishedStepLine(step) {
+  if (step.judged) {
+    return `${sentenceStart(stepCalled(step))} is judged by Halfcycle and has not passed in this phase: run that review again in your coding session until it passes.`;
+  }
+  return `Finish ${stepCalled(step)} in your coding session, or record it as declined.`;
+}
+var openReviewRequestSchema = external_exports.object({
+  actor: closeActorSchema,
+  acceptanceOutcome: acceptanceOutcomeSchema,
+  statements: closeStatementsSchema
+}).strict();
+var REVIEW_OPEN_TASKS_SHOWN_MAX = 10;
+var reviewOpenedSchema = external_exports.object({
+  outcome: external_exports.literal("opened"),
+  round: external_exports.number().int().min(1),
+  parts: external_exports.number().int().min(0).max(REVIEW_PARTS_MAX),
+  notBuilt: external_exports.number().int().min(0).max(REVIEW_PARTS_MAX),
+  counted: external_exports.boolean(),
+  typedReviewOffered: external_exports.boolean()
+}).strict().refine((v) => v.notBuilt <= v.parts, { message: "cannot exceed the parts in the round", path: ["notBuilt"] });
+var reviewTasksOpenSchema = external_exports.object({
+  outcome: external_exports.literal("tasks-open"),
+  open: external_exports.array(buildTaskSchema.shape.title).min(1).max(REVIEW_OPEN_TASKS_SHOWN_MAX),
+  more: external_exports.number().int().min(0).max(BUILD_SNAPSHOT_TASK_LIMIT)
+}).strict();
+var reviewOutstandingSchema = external_exports.object({
+  outcome: external_exports.literal("outstanding"),
+  steps: external_exports.array(reviewStepSchema).min(1)
+}).strict();
+var reviewCleanOverFindingsSchema = external_exports.object({
+  outcome: external_exports.literal("clean-over-findings"),
+  findings: external_exports.number().int().min(1)
+}).strict();
+var reviewRefusedSchema = external_exports.object({
+  outcome: external_exports.literal("refused"),
+  problems: external_exports.array(systemDescriptionProblemSchema).min(1)
+}).strict();
+function bareReviewOutcome(outcome) {
+  return external_exports.object({ outcome: external_exports.literal(outcome) }).strict();
+}
+var openReviewResultSchema = external_exports.discriminatedUnion("outcome", [
+  reviewOpenedSchema,
+  reviewTasksOpenSchema,
+  bareReviewOutcome("no-build"),
+  bareReviewOutcome("review-open"),
+  reviewOutstandingSchema,
+  reviewCleanOverFindingsSchema,
+  reviewRefusedSchema,
+  bareReviewOutcome("unavailable")
+]);
+var reviewPhaseNotOpenSchema = external_exports.object({
+  statusCode: external_exports.literal(409),
+  error: external_exports.literal("PhaseNotOpen"),
+  message: external_exports.string().min(1),
+  openPhase: external_exports.string().nullable()
+}).strict();
+var openReviewAnswerSchema = external_exports.union([openReviewResultSchema, reviewPhaseNotOpenSchema]);
+var reviewDecisionEntrySchema = external_exports.object({
+  part: systemPartIdSchema,
+  act: reviewActSchema,
+  note: reviewNoteWireSchema.optional()
+}).strict();
+var reviewDecisionRequestSchema = external_exports.object({
+  reviewVersion: external_exports.number().int().min(0),
+  decisions: external_exports.array(reviewDecisionEntrySchema).max(REVIEW_PARTS_MAX)
+}).strict();
+var reviewDecidedSchema = external_exports.object({
+  part: systemPartIdSchema,
+  name: systemPartSchema.shape.name,
+  act: reviewActSchema,
+  carriedTo: reviewCarriedToSchema.optional()
+}).strict().refine((v) => v.carriedTo !== void 0 === (v.act === "carry"), {
+  message: "is present exactly on a carry",
+  path: ["carriedTo"]
+});
+var reviewRecordedSchema = external_exports.object({
+  outcome: external_exports.literal("recorded"),
+  decided: external_exports.array(reviewDecidedSchema).max(REVIEW_PARTS_MAX),
+  waiting: external_exports.number().int().min(0).max(REVIEW_PARTS_MAX),
+  closed: external_exports.boolean(),
+  reviewVersion: external_exports.number().int().min(1)
+}).strict().superRefine((v, ctx) => {
+  if (v.closed && v.waiting !== 0) {
+    ctx.addIssue({ code: "custom", path: ["waiting"], message: "must be 0 once the phase is closed" });
+  }
+  if (v.decided.length === 0 && !v.closed) {
+    ctx.addIssue({ code: "custom", path: ["decided"], message: "may be empty only when the phase closed" });
+  }
+});
+var REVIEW_NOT_DECIDABLE_WHY = Object.freeze(["settled", "question-waiting", "sent-back"]);
+var reviewNotDecidablePartSchema = external_exports.object({
+  part: systemPartIdSchema,
+  name: systemPartSchema.shape.name,
+  why: external_exports.enum(REVIEW_NOT_DECIDABLE_WHY)
+}).strict();
+var reviewNotDecidableSchema = external_exports.object({
+  outcome: external_exports.literal("not-decidable"),
+  parts: external_exports.array(reviewNotDecidablePartSchema).min(1).max(REVIEW_PARTS_MAX)
+}).strict();
+var reviewCloseRefusedSchema = external_exports.object({
+  outcome: external_exports.literal("close-refused"),
+  steps: external_exports.array(reviewStepSchema)
+}).strict();
+var reviewWalkChangedSchema = external_exports.object({
+  outcome: external_exports.literal("walk-changed"),
+  findings: external_exports.number().int().min(1)
+}).strict();
+var reviewDecisionResultSchema = external_exports.discriminatedUnion("outcome", [
+  reviewRecordedSchema,
+  bareReviewOutcome("review-changed"),
+  bareReviewOutcome("no-review"),
+  reviewNotDecidableSchema,
+  reviewCloseRefusedSchema,
+  reviewWalkChangedSchema,
+  bareReviewOutcome("not-owner"),
+  bareReviewOutcome("no-owner"),
+  reviewRefusedSchema,
+  bareReviewOutcome("unavailable")
+]);
+var reviewSentBackSchema = external_exports.object({
+  round: external_exports.number().int().min(1),
+  note: reviewNoteSchema
+}).strict();
+var reviewQuestionSchema = external_exports.object({
+  question: reviewNoteSchema,
+  agentAnswer: reviewAgentAnswerSchema.optional()
+}).strict();
+var reviewTaskSchema = external_exports.object({
+  title: buildTaskSchema.shape.title,
+  state: buildTaskStateSchema
+}).strict();
+var reviewViewPartSchema = external_exports.object({
+  part: systemPartIdSchema,
+  name: systemPartSchema.shape.name,
+  change: reviewPartChangeSchema,
+  built: external_exports.boolean(),
+  builtWithoutApproval: external_exports.boolean(),
+  decidable: external_exports.boolean(),
+  waiting: external_exports.boolean(),
+  decision: reviewDecisionSchema.optional(),
+  reason: reviewNoteSchema.optional(),
+  carriedTo: reviewCarriedToSchema.optional(),
+  sentBack: external_exports.array(reviewSentBackSchema),
+  questions: external_exports.array(reviewQuestionSchema),
+  tasks: external_exports.array(reviewTaskSchema).max(BUILD_SNAPSHOT_TASK_LIMIT),
+  said: external_exports.array(observedSaidSchema).max(BUILD_SNAPSHOT_TASK_LIMIT),
+  codeLink: partCodeLinkSchema
+}).strict().superRefine((v, ctx) => {
+  if (v.waiting !== (v.decision === void 0)) {
+    ctx.addIssue({ code: "custom", path: ["waiting"], message: "must be true exactly when the part has no decision" });
+  }
+  if (v.decidable && !v.waiting) {
+    ctx.addIssue({ code: "custom", path: ["decidable"], message: "cannot be true for a settled part" });
+  }
+  if (v.decision !== void 0 && !reviewActsFor(v.built).includes(actOf(v.decision))) {
+    ctx.addIssue({ code: "custom", path: ["decision"], message: "is not an act this part takes" });
+  }
+  const carriedOrDropped = v.decision === "carried" || v.decision === "dropped";
+  if (v.reason !== void 0 !== carriedOrDropped) {
+    ctx.addIssue({ code: "custom", path: ["reason"], message: "is present exactly on a carry or a drop" });
+  }
+  if (v.carriedTo !== void 0 !== (v.decision === "carried")) {
+    ctx.addIssue({ code: "custom", path: ["carriedTo"], message: "is present exactly on a carry" });
+  }
+  if (v.change === "not-in-plan" && !v.built) {
+    ctx.addIssue({ code: "custom", path: ["built"], message: "is always true for a part outside the plan" });
+  }
+});
+var reviewPhaseNumberSchema = external_exports.number().int().min(1).nullable();
+var phaseReviewNoneSchema = external_exports.object({
+  state: external_exports.literal("none"),
+  phase: scopePhaseSchema,
+  number: reviewPhaseNumberSchema,
+  closedWithoutReview: external_exports.boolean()
+}).strict();
+var reviewWalkSchema = external_exports.object({
+  verdict: walkVerdictSchema,
+  findings: external_exports.number().int().min(0)
+}).strict();
+function reviewedViewSchema(state) {
+  return external_exports.object({
+    state: external_exports.literal(state),
+    phase: scopePhaseSchema,
+    number: reviewPhaseNumberSchema,
+    cycle: external_exports.number().int().min(0),
+    round: external_exports.number().int().min(1),
+    reviewVersion: external_exports.number().int().min(1),
+    typedReviewOffered: external_exports.boolean(),
+    counted: external_exports.boolean(),
+    walk: reviewWalkSchema,
+    parts: external_exports.array(reviewViewPartSchema).max(REVIEW_PARTS_MAX),
+    observed: observedChangesSchema.nullable(),
+    description: systemDescriptionSchema
+  }).strict().superRefine((v, ctx) => {
+    const seen = /* @__PURE__ */ new Set();
+    v.parts.forEach((p, i) => {
+      if (seen.has(p.part))
+        ctx.addIssue({ code: "custom", path: ["parts", i, "part"], message: "is listed twice" });
+      seen.add(p.part);
+    });
+    const counted = v.observed !== null && v.observed.counting.state === "counted";
+    if (v.counted !== counted) {
+      ctx.addIssue({ code: "custom", path: ["counted"], message: "must be true exactly when the counts are counted" });
+    }
+    if (v.observed !== null && v.observed.phase !== v.phase) {
+      ctx.addIssue({ code: "custom", path: ["observed", "phase"], message: "must be the phase under review" });
+    }
+    if (v.state === "closed") {
+      v.parts.forEach((p, i) => {
+        if (p.decision === void 0) {
+          ctx.addIssue({ code: "custom", path: ["parts", i, "decision"], message: "every part of a closed review is decided" });
+        }
+      });
+    }
+  });
+}
+var phaseReviewOpenSchema = reviewedViewSchema("open");
+var phaseReviewClosedSchema = reviewedViewSchema("closed");
+var phaseReviewViewSchema = external_exports.discriminatedUnion("state", [
+  phaseReviewNoneSchema,
+  phaseReviewOpenSchema,
+  phaseReviewClosedSchema
+]);
+
 // ../events/dist/client-version.js
 var CLIENT_VERSION_HEADER = "x-halfcycle-client";
 var TYPED_APPROVAL_OFF_SENTENCE = "Approving by typing is switched off for now.";
+var TYPED_REVIEW_OFF_SENTENCE = "Reviewing by typing is switched off for now.";
 var CLIENT_UPDATE_SENTENCE = `To approve by typing in a session, Halfcycle needs updating: run \`${HALFCYCLE_COMMAND}\` in this project's folder, then reopen your session and ask again.`;
 
 // ../events/dist/scope-notices.js
@@ -16068,7 +16927,7 @@ function sentBackNotice(entry) {
   return [
     `Before anything else: the project's owner sent the scope of phase ${entry.number}, "${entry.phase}", back with these notes.`,
     ...entry.notes.map((n) => n.part === void 0 ? `- ${n.note}` : `- "${n.part}": ${n.note}`),
-    `Change the plan to answer every note, then send it again with \`${HALFCYCLE_COMMAND} plan ${quoteForShell(entry.phase)}\`.`
+    `Change the plan to answer every note, then send it again: say "plan the next phase" to start. It then waits for the owner's approval again.`
   ].join("\n");
 }
 function waitingNotice(entry, offerTyping) {
@@ -16086,6 +16945,42 @@ function scopeNoticeText(scope, options) {
   };
 }
 
+// ../events/dist/review-notices.js
+var reviewNoticeQuestionSchema = external_exports.object({
+  phase: scopePhaseSchema,
+  number: reviewPhaseNumberSchema,
+  part: systemPartIdSchema,
+  partName: systemPartSchema.shape.name,
+  question: reviewNoteSchema
+}).strict();
+var reviewNoticeSentBackSchema = external_exports.object({
+  phase: scopePhaseSchema,
+  number: reviewPhaseNumberSchema,
+  part: systemPartIdSchema,
+  partName: systemPartSchema.shape.name,
+  note: reviewNoteSchema
+}).strict();
+var reviewNoticesSchema = external_exports.object({
+  questions: external_exports.array(reviewNoticeQuestionSchema).max(REVIEW_PARTS_MAX),
+  sentBack: external_exports.array(reviewNoticeSentBackSchema).max(REVIEW_PARTS_MAX)
+}).strict().refine((v) => v.questions.length > 0 || v.sentBack.length > 0, {
+  message: "carried only when a question waits or a part was sent back"
+});
+function phaseCalled(phase, number4) {
+  return number4 === null ? `phase "${phase}"` : `phase ${number4}, "${phase}"`;
+}
+function questionNotice(entry) {
+  const answer = `${HALFCYCLE_COMMAND} review ${quoteForShell(entry.phase)} --answer ${quoteForShell(entry.part)} "<your answer>"`;
+  return `Before anything else: the project's owner asked about "${entry.partName}" in the review of ${phaseCalled(entry.phase, entry.number)}: ${entry.question} Answer it with ${answer}.`;
+}
+function sentBackNotice2(entry) {
+  const where = entry.number === null ? `in phase "${entry.phase}"` : `in phase ${entry.number}, "${entry.phase}",`;
+  return `Before anything else: the project's owner sent "${entry.partName}" ${where} back to building: ${entry.note} Add or reopen the tasks that build it. When they are finished, run the close step again.`;
+}
+function reviewNoticeText(review) {
+  return [...review.questions.map(questionNotice), ...review.sentBack.map(sentBackNotice2)];
+}
+
 // ../events/dist/device-auth.js
 var utcIso86012 = external_exports.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/, "must be a UTC ISO-8601 timestamp ending in Z");
 var DEVICE_AUTH_STATUS = {
@@ -16273,6 +17168,56 @@ var chatScopeResultSchema = external_exports.discriminatedUnion("outcome", [
   bareOutcome("unavailable")
 ]);
 
+// ../events/dist/review-chat.js
+var chatReviewAcceptRequestSchema = external_exports.object({
+  act: external_exports.literal("accept"),
+  reference: phaseIdentitySchema,
+  reviewVersion: external_exports.number().int().min(0),
+  parts: external_exports.array(systemPartIdSchema).max(REVIEW_PARTS_MAX)
+}).strict();
+function notedRequest(act) {
+  return external_exports.object({
+    act: external_exports.literal(act),
+    reference: phaseIdentitySchema,
+    reviewVersion: external_exports.number().int().min(0),
+    part: systemPartIdSchema,
+    note: reviewNoteWireSchema
+  }).strict();
+}
+var chatReviewQuestionRequestSchema = notedRequest("question");
+var chatReviewSendBackRequestSchema = notedRequest("send-back");
+var chatReviewCarryRequestSchema = notedRequest("carry");
+var chatReviewDropRequestSchema = notedRequest("drop");
+var chatReviewRequestSchema = external_exports.discriminatedUnion("act", [
+  chatReviewAcceptRequestSchema,
+  chatReviewQuestionRequestSchema,
+  chatReviewSendBackRequestSchema,
+  chatReviewCarryRequestSchema,
+  chatReviewDropRequestSchema
+]);
+function bareOutcome2(outcome) {
+  return external_exports.object({ outcome: external_exports.literal(outcome) }).strict();
+}
+var chatReviewResultSchema = external_exports.discriminatedUnion("outcome", [
+  ...reviewDecisionResultSchema.options,
+  bareOutcome2("show-first"),
+  bareOutcome2("not-offered")
+]);
+var reviewAnswerRequestSchema = external_exports.object({
+  part: systemPartIdSchema,
+  answer: statementText(REVIEW_ANSWER_MAX)
+}).strict();
+var reviewAnswerRecordedSchema = external_exports.object({
+  outcome: external_exports.literal("recorded"),
+  name: systemPartSchema.shape.name
+}).strict();
+var reviewAnswerResultSchema = external_exports.discriminatedUnion("outcome", [
+  reviewAnswerRecordedSchema,
+  bareOutcome2("no-question"),
+  reviewRefusedSchema,
+  bareOutcome2("unavailable")
+]);
+
 // dist/hook-protocol.js
 import { writeSync } from "node:fs";
 function emitBlock(reason) {
@@ -16332,8 +17277,6 @@ function emitNeverConfigured(exitCode, reason, engagementId) {
   writeSync(2, neverConfiguredReport(reason, void 0, engagementId));
   process.exitCode = exitCode;
 }
-var SIGN_IN_COMMAND = '"npx halfcycle"';
-var HOOK_REMEDY = `Run ${SIGN_IN_COMMAND} in the project folder to sign in.`;
 function namesTheSignInCommand(text) {
   return text.includes(SIGN_IN_COMMAND);
 }
@@ -16660,13 +17603,16 @@ import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { relative } from "node:path";
 var COLOR_AWARE_SUBCOMMANDS = /* @__PURE__ */ new Set(["diff", "show", "log"]);
-function git(args2, cwd, timeoutMs) {
+function spawnGit(args2, cwd, timeoutMs) {
   const argv = COLOR_AWARE_SUBCOMMANDS.has(args2[0] ?? "") ? [args2[0], "--no-color", ...args2.slice(1)] : args2;
-  const result = spawnSync("git", argv, {
+  return spawnSync("git", argv, {
     cwd,
     encoding: "utf-8",
     ...timeoutMs === void 0 ? {} : { timeout: timeoutMs }
   });
+}
+function git(args2, cwd, timeoutMs) {
+  const result = spawnGit(args2, cwd, timeoutMs);
   if (result.error) {
     const missing = result.error.code === "ENOENT" && existsSync(cwd);
     return { ok: false, message: `git error: ${result.error.message}`, ...missing ? { gitMissing: true } : {} };
@@ -16828,6 +17774,124 @@ function getWiringStatus(pathspecs, cwd) {
     ...pathspecs
   ], cwd, WIRING_STATUS_TIMEOUT_MS);
 }
+var OBSERVE_GIT_TIMEOUT_MS = 5e3;
+function isFullCommit(value) {
+  return closeCommitSchema.safeParse(value).success;
+}
+function notACommit(name) {
+  return { ok: false, message: `${name} is not a full commit id` };
+}
+function headCommit(repoRoot) {
+  const result = git(["rev-parse", "--verify", "HEAD^{commit}"], repoRoot, OBSERVE_GIT_TIMEOUT_MS);
+  if (!result.ok)
+    return result;
+  const commit = result.value.trim();
+  return isFullCommit(commit) ? { ok: true, value: commit } : notACommit("HEAD");
+}
+function headCommittedAt(head, repoRoot) {
+  if (!isFullCommit(head))
+    return notACommit("head");
+  const result = git(["log", "-1", "--format=%cI", head], repoRoot, OBSERVE_GIT_TIMEOUT_MS);
+  if (!result.ok)
+    return result;
+  const when = new Date(result.value.trim());
+  if (Number.isNaN(when.getTime()))
+    return { ok: false, message: "git gave no readable commit time" };
+  const iso = when.toISOString();
+  return utcIso8601.safeParse(iso).success ? { ok: true, value: iso } : { ok: false, message: "git gave no readable commit time" };
+}
+function isAncestor(start, head, repoRoot) {
+  if (!isFullCommit(start))
+    return notACommit("start");
+  if (!isFullCommit(head))
+    return notACommit("head");
+  const result = spawnGit(["merge-base", "--is-ancestor", start, head], repoRoot, OBSERVE_GIT_TIMEOUT_MS);
+  if (result.error)
+    return { ok: false, message: `git error: ${result.error.message}` };
+  if (result.status === 0)
+    return { ok: true, value: true };
+  if (result.status === 1)
+    return { ok: true, value: false };
+  const stderr = result.stderr?.trim() ?? "";
+  return { ok: false, message: `git merge-base failed: ${stderr || "non-zero exit"}` };
+}
+function commitCount(start, head, repoRoot) {
+  if (!isFullCommit(start))
+    return notACommit("start");
+  if (!isFullCommit(head))
+    return notACommit("head");
+  const result = git(["rev-list", "--count", `${start}..${head}`], repoRoot, OBSERVE_GIT_TIMEOUT_MS);
+  if (!result.ok)
+    return result;
+  const text = result.value.trim();
+  if (!/^\d+$/.test(text))
+    return { ok: false, message: "git gave no readable commit count" };
+  return { ok: true, value: Number(text) };
+}
+function rangeNameStatus(start, head, repoRoot) {
+  if (!isFullCommit(start))
+    return notACommit("start");
+  if (!isFullCommit(head))
+    return notACommit("head");
+  const result = git(["diff", "--name-status", "--no-renames", "-z", start, head], repoRoot, OBSERVE_GIT_TIMEOUT_MS);
+  if (!result.ok)
+    return result;
+  return parseNameStatusZ(result.value);
+}
+function parseNameStatusZ(output) {
+  if (output === "")
+    return { ok: true, value: [] };
+  if (!output.endsWith("\0"))
+    return { ok: false, message: "git gave an unreadable list of changed files" };
+  const fields = output.slice(0, -1).split("\0");
+  if (fields.length % 2 !== 0)
+    return { ok: false, message: "git gave an unreadable list of changed files" };
+  const entries = [];
+  for (let i = 0; i < fields.length; i += 2) {
+    const status = fields[i];
+    const path = fields[i + 1];
+    if (!/^[A-Z][0-9]*$/.test(status) || status.startsWith("R") || status.startsWith("C") || path === "") {
+      return { ok: false, message: "git gave an unreadable list of changed files" };
+    }
+    entries.push({ status: status.charAt(0), path });
+  }
+  return { ok: true, value: entries };
+}
+function readCodeLinkFacts(repoRoot, head) {
+  const nothing = { repositoryAddress: null, headOnGitHub: false };
+  if (!isFullCommit(head))
+    return nothing;
+  try {
+    const remote = currentRemote(repoRoot);
+    const url2 = git(["remote", "get-url", "--", remote], repoRoot, OBSERVE_GIT_TIMEOUT_MS);
+    if (!url2.ok)
+      return nothing;
+    const repositoryAddress = githubRepositoryAddress(url2.value.trim());
+    if (repositoryAddress === null)
+      return nothing;
+    const refs = git(["for-each-ref", "--contains", head, "--format=%(refname)", `refs/remotes/${remote}/`], repoRoot, OBSERVE_GIT_TIMEOUT_MS);
+    if (!refs.ok)
+      return nothing;
+    const facts = { repositoryAddress, headOnGitHub: refs.value.trim() !== "" };
+    return codeLinkFactsSchema.safeParse(facts).success ? facts : nothing;
+  } catch {
+    return nothing;
+  }
+}
+function currentRemote(repoRoot) {
+  const symbolic = git(["symbolic-ref", "--quiet", "HEAD"], repoRoot, OBSERVE_GIT_TIMEOUT_MS);
+  if (!symbolic.ok)
+    return "origin";
+  const ref = symbolic.value.trim();
+  if (!ref.startsWith("refs/heads/"))
+    return "origin";
+  const branch = ref.slice("refs/heads/".length);
+  const configured = git(["config", "--get", `branch.${branch}.remote`], repoRoot, OBSERVE_GIT_TIMEOUT_MS);
+  if (!configured.ok)
+    return "origin";
+  const remote = configured.value.trim();
+  return remote === "" || remote === "." ? "origin" : remote;
+}
 
 // dist/screen/secret-shape.js
 function screenExcerpts(excerpts) {
@@ -18495,7 +19559,10 @@ var SESSION_NOTICE_SUFFIX = {
   "no-repository": ".norepo",
   "credential-rejected": ".credential",
   "credential-renewed-for-this-run": ".renewed",
-  "credential-missing": ".nocredential"
+  "credential-missing": ".nocredential",
+  "observe-no-start-here": ".observe-nostart",
+  "observe-not-on-branch": ".observe-nobranch",
+  "observe-no-start-recorded": ".observe-norecord"
 };
 function firstNoticeThisSession(notice, folder, sessionId) {
   if (!sessionId)
@@ -18590,6 +19657,14 @@ function orphanSweep(repoRoot, refKnown, keepSessionId, now = Date.now()) {
     }
   }
 }
+function observeThrottlePath(folder) {
+  return join6(markerDir(), `${MARKER_PREFIX}${repoHash(folder)}.observe-throttle`);
+}
+function observeNoticesPath(folder, sessionId) {
+  if (!sessionId)
+    return null;
+  return join6(markerDir(), `${MARKER_PREFIX}${repoHash(folder)}-${sessionId}.observe-said`);
+}
 
 // dist/seat-configuration.js
 import { existsSync as existsSync5, readFileSync as readFileSync8, realpathSync as realpathSync2 } from "node:fs";
@@ -18923,9 +19998,11 @@ function collectDiff(repoRoot, base) {
     getDiff: (relPath) => getWorkingTreeFileDiff(relPath, repoRoot)
   };
 }
-async function runSessionDiff(input, kind, readSeat = readSeatConfiguration) {
+async function runSessionDiff(input, kind, readSeat = readSeatConfiguration, afterPass) {
   const reply = hookReply(STOP_HOOK_EVENT[kind]);
   await evaluateSession(input, kind, reply, readSeat);
+  if (afterPass)
+    await afterPass(reply);
   reply.flush();
 }
 async function evaluateSession(input, kind, reply, readSeat) {
@@ -19106,17 +20183,328 @@ async function runSubagentStop() {
   await runSessionDiff(input, "subagent-stop");
 }
 
+// dist/observed.js
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "node:fs";
+function emptyTally() {
+  return { added: 0, changed: 0, removed: 0, testFilesAdded: 0 };
+}
+function kindOf(status) {
+  if (status === "A")
+    return "added";
+  if (status === "D")
+    return "removed";
+  return "changed";
+}
+function countObservedChanges(entries, description) {
+  const methodFiles = { added: 0, changed: 0, removed: 0 };
+  const byPart = /* @__PURE__ */ new Map();
+  const outside = emptyTally();
+  const paths = [];
+  const listed = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const kind = kindOf(entry.status);
+    if (isMethodFile(entry.path)) {
+      methodFiles[kind] += 1;
+      continue;
+    }
+    const owner = ownerOf(entry.path, description);
+    let tally;
+    if (owner === null) {
+      tally = outside;
+      if (entry.path.length >= 1 && entry.path.length <= OBSERVED_PATH_MAX && paths.length < OBSERVED_PATHS_LISTED_MAX && !listed.has(entry.path)) {
+        paths.push(entry.path);
+        listed.add(entry.path);
+      }
+    } else {
+      tally = byPart.get(owner) ?? emptyTally();
+      byPart.set(owner, tally);
+    }
+    tally[kind] += 1;
+    if (kind === "added" && isTestFile(entry.path))
+      tally.testFilesAdded += 1;
+  }
+  const parts = description.parts.filter((part) => byPart.has(part.id)).map((part) => ({ part: part.id, ...byPart.get(part.id) }));
+  return { parts, methodFiles, outsideEveryPart: { ...outside, paths } };
+}
+var OBSERVE_MIN_INTERVAL_MS = 6e4;
+var OBSERVE_RECHECK_MS = 6e5;
+var OBSERVE_REQUEST_DEADLINE_MS = 1500;
+async function requestJson(fetchFn, url2, init) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), OBSERVE_REQUEST_DEADLINE_MS);
+  try {
+    const response = await fetchFn(url2, { ...init, signal: controller.signal });
+    let body = null;
+    try {
+      body = await response.json();
+    } catch {
+      body = null;
+    }
+    if (controller.signal.aborted)
+      return { kind: "unreachable" };
+    return { kind: "answer", status: response.status, body };
+  } catch {
+    return { kind: "unreachable" };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function refusalReason(status) {
+  return status >= 500 ? "unreachable" : "refused";
+}
+async function attemptObservation(opts) {
+  const { repoRoot, head, config: config2, controlOrigin, fetchFn } = opts;
+  const base = `${controlOrigin}/engagements/${encodeURIComponent(config2.guardEngagementId)}/observed`;
+  const authorization = `Bearer ${config2.guardServiceToken}`;
+  const basisAnswer = await requestJson(fetchFn, `${base}/basis`, {
+    method: "GET",
+    headers: { Authorization: authorization }
+  });
+  if (basisAnswer.kind === "unreachable")
+    return { outcome: "not-sent", reason: "unreachable" };
+  if (basisAnswer.status < 200 || basisAnswer.status >= 300) {
+    return { outcome: "not-sent", reason: refusalReason(basisAnswer.status) };
+  }
+  const parsedBasis = observedBasisSchema.safeParse(basisAnswer.body);
+  if (!parsedBasis.success)
+    return { outcome: "not-sent", reason: "refused" };
+  const basis = parsedBasis.data;
+  if (basis.outcome === "nothing-to-count")
+    return { outcome: "not-sent", reason: "nothing-to-count" };
+  if (basis.outcome === "cannot-count")
+    return { outcome: "not-sent", reason: "cannot-count", phase: basis.phase };
+  if (repoRoot === null || !refExists(basis.startCommit, repoRoot)) {
+    return { outcome: "not-sent", reason: "start-not-here" };
+  }
+  if (head === null)
+    return { outcome: "not-sent", reason: "start-not-on-branch" };
+  const ancestor = isAncestor(basis.startCommit, head, repoRoot);
+  if (!ancestor.ok)
+    return { outcome: "not-sent", reason: "unreachable" };
+  if (!ancestor.value)
+    return { outcome: "not-sent", reason: "start-not-on-branch" };
+  const commits = commitCount(basis.startCommit, head, repoRoot);
+  const committedAt = headCommittedAt(head, repoRoot);
+  const entries = rangeNameStatus(basis.startCommit, head, repoRoot);
+  if (!commits.ok || !committedAt.ok || !entries.ok)
+    return { outcome: "not-sent", reason: "unreachable" };
+  const report = {
+    phase: basis.phase,
+    startCommit: basis.startCommit,
+    headCommit: head,
+    headCommittedAt: committedAt.value,
+    commits: commits.value,
+    descriptionVersion: basis.descriptionVersion,
+    ...countObservedChanges(entries.value, basis.description),
+    codeLink: readCodeLinkFacts(repoRoot, head)
+  };
+  if (!observedChangesReportSchema.safeParse(report).success)
+    return { outcome: "not-sent", reason: "refused" };
+  const sent = await requestJson(fetchFn, base, {
+    method: "POST",
+    headers: { Authorization: authorization, "Content-Type": "application/json" },
+    body: JSON.stringify(report)
+  });
+  if (sent.kind === "unreachable")
+    return { outcome: "not-sent", reason: "unreachable" };
+  if (sent.status === 409)
+    return { outcome: "not-sent", reason: "basis-moved" };
+  if (sent.status < 200 || sent.status >= 300)
+    return { outcome: "not-sent", reason: refusalReason(sent.status) };
+  const answer = observedChangesReportResultSchema.safeParse(sent.body);
+  if (!answer.success)
+    return { outcome: "not-sent", reason: "refused" };
+  return answer.data.outcome === "kept" ? { outcome: "kept" } : { outcome: "recorded", answer: answer.data };
+}
+function readThrottle(folder) {
+  try {
+    const parsed = JSON.parse(readFileSync9(observeThrottlePath(folder), "utf-8"));
+    if (typeof parsed !== "object" || parsed === null)
+      return null;
+    const { attemptedAt, accepted } = parsed;
+    if (typeof attemptedAt !== "number")
+      return null;
+    const sent = accepted;
+    const usable = sent !== null && sent !== void 0 && typeof sent.head === "string" && typeof sent.at === "number";
+    return { attemptedAt, accepted: usable ? { head: sent.head, at: sent.at } : null };
+  } catch {
+    return null;
+  }
+}
+function writeThrottle(folder, state) {
+  try {
+    writeFileSync4(observeThrottlePath(folder), JSON.stringify(state), "utf-8");
+  } catch {
+  }
+}
+function throttleAllows(state, head, now) {
+  if (state === null)
+    return true;
+  if (now - state.attemptedAt < OBSERVE_MIN_INTERVAL_MS)
+    return false;
+  if (state.accepted === null)
+    return true;
+  if (head === null || head !== state.accepted.head)
+    return true;
+  return now - state.accepted.at >= OBSERVE_RECHECK_MS;
+}
+function locate(cwd) {
+  const root = getRepoRoot(cwd);
+  const repoRoot = root.ok ? root.value : null;
+  const read = repoRoot === null ? null : headCommit(repoRoot);
+  return { repoRoot, folder: repoRoot ?? cwd, head: read !== null && read.ok ? read.value : null };
+}
+function recordAttempt(folder, prior, head, at, attempt2) {
+  const accepted = (attempt2.outcome === "recorded" || attempt2.outcome === "kept") && head !== null ? { head, at } : prior?.accepted ?? null;
+  writeThrottle(folder, { attemptedAt: at, accepted });
+}
+async function runObserve(deps = {}) {
+  let result;
+  try {
+    const configured = readConfig();
+    if (!configured.config) {
+      result = { outcome: "not-sent", reason: "not-configured" };
+    } else {
+      const now = deps.now ?? Date.now;
+      const where = locate(deps.cwd ?? process.cwd());
+      const prior = readThrottle(where.folder);
+      const attempt2 = await attemptObservation({
+        repoRoot: where.repoRoot,
+        head: where.head,
+        config: configured.config,
+        controlOrigin: readControlOrigin().origin,
+        fetchFn: deps.fetchFn ?? globalThis.fetch
+      });
+      recordAttempt(where.folder, prior, where.head, now(), attempt2);
+      result = attempt2.outcome === "not-sent" ? { outcome: "not-sent", reason: attempt2.reason } : { outcome: attempt2.outcome };
+    }
+  } catch {
+    result = { outcome: "not-sent", reason: "unreachable" };
+  }
+  return observeRunResultSchema.parse(result);
+}
+async function observeChanges(sessionId, reply, deps = {}) {
+  try {
+    const code = process.exitCode;
+    if (code !== void 0 && code !== null && Number(code) !== 0)
+      return;
+    const configured = readConfig();
+    if (!configured.config)
+      return;
+    const now = (deps.now ?? Date.now)();
+    const where = locate(deps.cwd ?? process.cwd());
+    const prior = readThrottle(where.folder);
+    if (!throttleAllows(prior, where.head, now))
+      return;
+    writeThrottle(where.folder, { attemptedAt: now, accepted: prior?.accepted ?? null });
+    const attempt2 = await attemptObservation({
+      repoRoot: where.repoRoot,
+      head: where.head,
+      config: configured.config,
+      controlOrigin: readControlOrigin().origin,
+      fetchFn: deps.fetchFn ?? globalThis.fetch
+    });
+    recordAttempt(where.folder, prior, where.head, now, attempt2);
+    for (const line2 of noticesFor(attempt2, where.folder, sessionId))
+      reply.notice(line2);
+  } catch {
+  }
+}
+var R1_START_NOT_HERE = "Halfcycle cannot count what this phase has changed on this computer yet, because the commit the phase started from is not here. Get the project's latest history, and it counts again at the end of the next reply.";
+var R2_START_NOT_ON_BRANCH = "Halfcycle cannot count what this phase has changed on this branch, because the branch does not contain the commit the phase started from. Switch to the branch the phase is built on, and it counts again at the end of the next reply.";
+function r3NoStartRecorded(phase) {
+  return `Halfcycle cannot count what phase ${phase} changes, because no starting commit was recorded when it opened. To count from where the project is now, run: ${HALFCYCLE_COMMAND} open-phase ${quoteForShell(phase)} --actor "you" --evidence "<what shows this phase is ready to start>"`;
+}
+function r4OutsideThePlan(parts) {
+  const first = parts.length === 1 ? "Halfcycle saw changes to a part this phase's plan does not include:" : "Halfcycle saw changes to parts this phase's plan does not include:";
+  const lines = parts.map((entry) => {
+    const said = entry.said.length === 0 ? NO_TASK_SAID_LINE : entry.said.map((task) => agentSaid(task)).join("; ");
+    return `"${entry.name}": ${said}`;
+  });
+  return [first, ...lines, "The project's owner sees them again at the review."].join("\n");
+}
+function r5OutsideEveryPart(files, example) {
+  if (files === 1) {
+    return `Halfcycle saw 1 changed file that no part of the system owns: ${example}. If it belongs to a part, add it to that part in the description of the system.`;
+  }
+  return `Halfcycle saw ${files} changed files that no part of the system owns, such as ${example}. If they belong to a part, add them to that part in the description of the system.`;
+}
+function readSaid(path) {
+  const empty = { parts: {}, outsideFiles: 0 };
+  if (path === null)
+    return empty;
+  try {
+    const parsed = JSON.parse(readFileSync9(path, "utf-8"));
+    const parts = {};
+    if (typeof parsed.parts === "object" && parsed.parts !== null) {
+      for (const [part, reasons] of Object.entries(parsed.parts)) {
+        if (Array.isArray(reasons))
+          parts[part] = reasons.filter((r) => typeof r === "string");
+      }
+    }
+    return { parts, outsideFiles: typeof parsed.outsideFiles === "number" ? parsed.outsideFiles : 0 };
+  } catch {
+    return empty;
+  }
+}
+function writeSaid(path, state) {
+  if (path === null)
+    return;
+  try {
+    writeFileSync4(path, JSON.stringify(state), "utf-8");
+  } catch {
+  }
+}
+function reasonsOf(entry) {
+  return entry.said.filter((task) => task.whyOutsidePlan !== void 0).map((task) => `${task.title}\0${task.whyOutsidePlan}`);
+}
+function noticesFor(attempt2, folder, sessionId) {
+  if (attempt2.outcome === "not-sent") {
+    if (attempt2.reason === "start-not-here") {
+      return firstNoticeThisSession("observe-no-start-here", folder, sessionId) ? [R1_START_NOT_HERE] : [];
+    }
+    if (attempt2.reason === "start-not-on-branch") {
+      return firstNoticeThisSession("observe-not-on-branch", folder, sessionId) ? [R2_START_NOT_ON_BRANCH] : [];
+    }
+    if (attempt2.reason === "cannot-count" && attempt2.phase !== void 0) {
+      return firstNoticeThisSession("observe-no-start-recorded", folder, sessionId) ? [r3NoStartRecorded(attempt2.phase)] : [];
+    }
+    return [];
+  }
+  if (attempt2.outcome === "kept")
+    return [];
+  const { notInPlan, outside } = attempt2.answer;
+  const path = observeNoticesPath(folder, sessionId);
+  const prior = readSaid(path);
+  const notices = [];
+  const parts = {};
+  let grew = false;
+  for (const entry of notInPlan) {
+    const reasons = reasonsOf(entry);
+    parts[entry.part] = reasons;
+    const before = prior.parts[entry.part];
+    if (before === void 0 || reasons.some((reason) => !before.includes(reason)))
+      grew = true;
+  }
+  if (grew)
+    notices.push(r4OutsideThePlan(notInPlan));
+  let outsideFiles = outside.files;
+  if (outside.files > prior.outsideFiles) {
+    if (outside.example !== null)
+      notices.push(r5OutsideEveryPart(outside.files, outside.example));
+    else
+      outsideFiles = prior.outsideFiles;
+  }
+  writeSaid(path, { parts, outsideFiles });
+  return notices;
+}
+
 // dist/hooks/stop.js
-async function runStop() {
+async function runStop(observeDeps = {}) {
   const input = await readHookStdin();
-  await runSessionDiff(input, "stop");
+  await runSessionDiff(input, "stop", readSeatConfiguration, (reply) => observeChanges(input.session_id, reply, observeDeps));
 }
 
-// dist/hooks/user-prompt-submit.js
-import { readFileSync as readFileSync9 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { join as join8 } from "node:path";
-
 // dist/hooks/scope-phrase.js
 var APPROVE_PREFIX = /^approve /i;
 var SEND_BACK_PREFIX = /^send back /i;
@@ -19150,6 +20538,128 @@ function matchScopePhraseShape(shape, shown) {
   return { kind: "show-first", act: "send-back" };
 }
 
+// dist/hooks/review-phrase.js
+var VERBS = [
+  [/^accept /i, "accept"],
+  [/^question /i, "question"],
+  [/^send back /i, "send-back"],
+  [/^carry /i, "carry"],
+  [/^drop /i, "drop"]
+];
+function reviewPhraseShape(prompt) {
+  if (typeof prompt !== "string")
+    return null;
+  const line2 = prompt.trim();
+  if (LINE_BREAK.test(line2))
+    return null;
+  for (const [prefix, act] of VERBS) {
+    const verb = prefix.exec(line2);
+    if (verb === null)
+      continue;
+    const rest = line2.slice(verb[0].length);
+    if (act === "accept") {
+      if (!rest.includes("/"))
+        return isValidPhaseIdentity(rest) ? { kind: "phase", reference: rest } : null;
+      return partShape(act, rest, null);
+    }
+    const colon = rest.indexOf(":");
+    if (colon === -1)
+      return act === "send-back" ? partShape(act, rest, null) : null;
+    return partShape(act, rest.slice(0, colon), rest.slice(colon + 1).trim());
+  }
+  return null;
+}
+function partShape(act, head, words) {
+  const slash = head.indexOf("/");
+  if (slash === -1)
+    return null;
+  const reference = head.slice(0, slash);
+  const part = head.slice(slash + 1);
+  if (!isValidPhaseIdentity(reference) || !SYSTEM_PART_ID_PATTERN.test(part))
+    return null;
+  return { kind: "part", act, reference, part, words };
+}
+function matchReviewPhraseShape(shape, reviews) {
+  const entry = resolvePhaseReference(shape.reference, reviews);
+  if (shape.kind === "phase") {
+    if (entry === null)
+      return { kind: "nothing" };
+    return {
+      kind: "accept",
+      entry,
+      reference: shape.reference,
+      parts: entry.parts.filter((p) => p.built && p.decidable)
+    };
+  }
+  if (entry === null)
+    return { kind: "show-first", act: shape.act };
+  const part = entry.parts.find((p) => p.part === shape.part);
+  if (part === void 0)
+    return { kind: "not-listed", act: shape.act, entry, part: shape.part };
+  return { kind: "decide", act: shape.act, entry, reference: shape.reference, part, words: shape.words };
+}
+
+// dist/hooks/shown-record.js
+import { chmodSync as chmodSync2, readFileSync as readFileSync10, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir4, platform as platform2 } from "node:os";
+import { join as join8 } from "node:path";
+function recordDir(engagementId, home) {
+  if (!isEngagementId(engagementId))
+    return null;
+  return join8(home ?? homedir4(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId);
+}
+function readShownRecord(engagementId, home) {
+  const dir = recordDir(engagementId, home);
+  if (dir === null)
+    return { entries: [], reviews: [] };
+  try {
+    return parseShownRecord(readFileSync10(join8(dir, SHOWN_PLANS_FILENAME), "utf-8"));
+  } catch {
+    return { entries: [], reviews: [] };
+  }
+}
+function movedPart(part, act) {
+  if (act === void 0)
+    return part;
+  return {
+    ...part,
+    decidable: false,
+    awaitingAnswer: part.awaitingAnswer || act === "question",
+    sentBack: part.sentBack || act === "send-back"
+  };
+}
+function moveListedReviewForward(engagementId, home, listed, reviewVersion, decided) {
+  let temp = null;
+  try {
+    const dir = recordDir(engagementId, home);
+    if (dir === null)
+      return false;
+    const path = join8(dir, SHOWN_PLANS_FILENAME);
+    const current = parseShownRecord(readFileSync10(path, "utf-8"));
+    const at = current.reviews.findIndex((r) => r.phase === listed.phase && r.shownAt === listed.shownAt && r.reviewVersion === listed.reviewVersion);
+    if (at === -1)
+      return false;
+    const acts = new Map(decided.map((d) => [d.part, d.act]));
+    const reviews = current.reviews.map((review, i) => i === at ? { ...review, reviewVersion, parts: review.parts.map((p) => movedPart(p, acts.get(p.part))) } : review);
+    const body = serialiseShownRecord({ entries: current.entries, reviews });
+    temp = join8(dir, `.${SHOWN_PLANS_FILENAME}.${process.pid}.tmp`);
+    writeFileSync5(temp, body, { mode: 384 });
+    if (platform2() !== "win32")
+      chmodSync2(temp, 384);
+    renameSync3(temp, path);
+    return true;
+  } catch {
+    if (temp !== null) {
+      try {
+        unlinkSync4(temp);
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+}
+
 // dist/hooks/user-prompt-submit-lines.js
 var TELL_THE_PERSON = "Tell the person.";
 function line(text) {
@@ -19225,14 +20735,210 @@ function lineForAnswer(act, phase, answer) {
     }
   }
 }
+var NOTHING_RECORDED = "Nothing was recorded";
+var LIST_AGAIN = 'Say "review what was built" to list it again';
+function reviewNotAttendedLine() {
+  return line(`${NOTHING_RECORDED}: reviewing by typing counts only when a person types it into an open session.`);
+}
+function reviewNotSignedInLine() {
+  return line(`${NOTHING_RECORDED}: this project is not signed in on this computer. ${HOOK_REMEDY}`);
+}
+function reviewCannotReachLine() {
+  return line(`${NOTHING_RECORDED}: Halfcycle could not be reached just now. Type the line again in a minute.`);
+}
+function reviewSwitchedOffLine() {
+  return line(`${NOTHING_RECORDED}. ${TYPED_REVIEW_OFF_SENTENCE}`);
+}
+function reviewNotOwnerLine() {
+  return line(`${NOTHING_RECORDED}: only the project's owner can review this phase.`);
+}
+function reviewNoOwnerLine() {
+  return line(`${NOTHING_RECORDED}: this project has no owner, so nobody can review its phases.`);
+}
+function reviewWrongActLine(name, built) {
+  return line(built ? `${NOTHING_RECORDED}: "${name}" was built, so it can be accepted, questioned or sent back.` : `${NOTHING_RECORDED}: "${name}" was not built, so it can only be carried or dropped.`);
+}
+function wordsActNoun(act) {
+  switch (act) {
+    case "question":
+      return "a question";
+    case "send-back":
+      return "a send-back";
+    case "carry":
+      return "a carry";
+    case "drop":
+      return "a drop";
+    default: {
+      const unreachable = act;
+      return unreachable;
+    }
+  }
+}
+function reviewNoWordsLine(act) {
+  return line(`${NOTHING_RECORDED}: ${wordsActNoun(act)} needs words after the colon.`);
+}
+function reviewWordsTooLongLine() {
+  return line(`${NOTHING_RECORDED}: the words after the colon are too long. Shorten them and type the line again.`);
+}
+function reviewWordsLookSecretLine() {
+  return line(`${NOTHING_RECORDED}: the words look like they hold a password or key, so they never left this computer. Type the line again without it.`);
+}
+function reviewShowFirstLine() {
+  return line(`${NOTHING_RECORDED}: that review has not been listed here. Say "review what was built" to list it, then type the line again.`);
+}
+function reviewPartNotListedLine(part, phase) {
+  return line(`${NOTHING_RECORDED}: "${part}" is not a part of the review of ${phase} as it was listed here.`);
+}
+function reviewNothingToAcceptLine(phase) {
+  return line(`${NOTHING_RECORDED}: no built part of ${phase} waits for your decision.`);
+}
+function reviewListedTooLongAgoLine(phase) {
+  return line(`${NOTHING_RECORDED}: ${phase} was listed an hour or more ago. ${LIST_AGAIN}, then type the line again within the hour.`);
+}
+function reviewChangedLine(phase) {
+  return line(`${NOTHING_RECORDED}: the review of ${phase} changed after it was listed here. ${LIST_AGAIN}, then type the line again.`);
+}
+function reviewAlreadyDecidedLine(name) {
+  return line(`${NOTHING_RECORDED}: "${name}" is already decided in this review.`);
+}
+function reviewAwaitingAnswerLine(name) {
+  return line(`${NOTHING_RECORDED}: "${name}" is waiting for the agent's answer to your question. Once it is in, say "review what was built" to list it again and decide the part.`);
+}
+function reviewSentBackLine(name) {
+  return line(`${NOTHING_RECORDED}: "${name}" was sent back to building in this round, so it waits for the next round.`);
+}
+function reviewWalkChangedLine(phase, number4) {
+  const typed = typedPhaseReference(phase, number4);
+  return line(`${NOTHING_RECORDED}: phase ${phase} cannot close, because its walk was recorded as clean and a defect is now recorded against it. Send the part with the defect back with send back ${typed}/<part>: <what is wrong>; when its tasks are finished, the close step opens the review again with the walk's defects.`);
+}
+function reviewNoReviewLine(phase) {
+  return line(`${NOTHING_RECORDED}: phase ${phase} has no review open.`);
+}
+function reviewCloseRefusedLine(phase, steps) {
+  if (steps.length === 0) {
+    return line(`${NOTHING_RECORDED}: phase ${phase} could not close just now. Type the line again in a minute.`);
+  }
+  const labels = steps.map(unfinishedStepLabel).join(", ");
+  const head = steps.length === 1 ? `${NOTHING_RECORDED}: phase ${phase} cannot close while 1 of its steps is unfinished: ${labels}.` : `${NOTHING_RECORDED}: phase ${phase} cannot close while ${steps.length} of its steps are unfinished: ${labels}.`;
+  return line([head, ...steps.map(unfinishedStepLine), "Then type the line again."].join(" "));
+}
+function reviewRefusedLine(act) {
+  return act === "accept" ? line(`${NOTHING_RECORDED}: Halfcycle did not accept the request. Update Halfcycle by running \`${HALFCYCLE_COMMAND}\` in this project's folder, then type the line again.`) : line(`${NOTHING_RECORDED}: the words were not accepted. Reword them in plain words and type the line again.`);
+}
+function stillWaitingOf(phase, waiting) {
+  if (waiting === 0)
+    return `No part of ${phase} waits for your decision now.`;
+  if (waiting === 1)
+    return `1 part of ${phase} still waits for your decision.`;
+  return `${waiting} parts of ${phase} still wait for your decision.`;
+}
+function stillWaiting(waiting) {
+  if (waiting === 0)
+    return "No part waits for your decision now.";
+  if (waiting === 1)
+    return "1 part still waits for your decision.";
+  return `${waiting} parts still wait for your decision.`;
+}
+function decidedWords(decided) {
+  switch (decided.act) {
+    case "accept":
+      return "accepted";
+    case "question":
+      return "questioned";
+    case "send-back":
+      return "sent back to building";
+    case "carry":
+      return decided.carriedTo === void 0 || decided.carriedTo === null ? "carried to the next phase planned" : `carried to phase ${decided.carriedTo.number}, "${decided.carriedTo.phase}"`;
+    case "drop":
+      return "dropped";
+    default: {
+      const unreachable = decided.act;
+      return unreachable;
+    }
+  }
+}
+function reviewRecordedLine(decided, phase, waiting) {
+  return line(`Recorded in your session: "${decided.name}" ${decidedWords(decided)}. ${stillWaitingOf(phase, waiting)}`);
+}
+function reviewBulkRecordedLine(accepted, phase, waiting) {
+  const first = accepted === 1 ? `Recorded in your session: 1 part of ${phase} accepted.` : `Recorded in your session: ${accepted} parts of ${phase} accepted.`;
+  return line(`${first} ${stillWaiting(waiting)}`);
+}
+function reviewClosedLine(phase) {
+  return line(`Recorded in your session. That was the last decision: phase ${phase} is closed, and its Build Record is ready.`);
+}
+function reviewNoPartsClosedLine(phase) {
+  return line(`Recorded in your session. Phase ${phase} had no parts to review, so it is closed, and its Build Record is ready.`);
+}
+function notDecidableLine(answer) {
+  const first = answer.parts[0];
+  switch (first.why) {
+    case "question-waiting":
+      return reviewAwaitingAnswerLine(first.name);
+    case "sent-back":
+      return reviewSentBackLine(first.name);
+    case "settled":
+      return reviewAlreadyDecidedLine(first.name);
+    default: {
+      const unreachable = first.why;
+      return unreachable;
+    }
+  }
+}
+function reviewLineForAnswer(context, answer) {
+  const { phase } = context;
+  switch (answer.outcome) {
+    case "recorded": {
+      if (answer.closed) {
+        return answer.decided.length === 0 ? reviewNoPartsClosedLine(phase) : reviewClosedLine(phase);
+      }
+      if (context.bulk)
+        return reviewBulkRecordedLine(answer.decided.length, phase, answer.waiting);
+      return reviewRecordedLine(answer.decided[0], phase, answer.waiting);
+    }
+    case "review-changed":
+      return reviewChangedLine(phase);
+    case "no-review":
+      return reviewNoReviewLine(phase);
+    case "not-decidable":
+      return notDecidableLine(answer);
+    case "close-refused":
+      return reviewCloseRefusedLine(phase, answer.steps);
+    case "walk-changed":
+      return reviewWalkChangedLine(phase, context.number);
+    case "not-owner":
+      return reviewNotOwnerLine();
+    case "no-owner":
+      return reviewNoOwnerLine();
+    case "refused":
+      return reviewRefusedLine(context.act);
+    case "unavailable":
+      return reviewCannotReachLine();
+    case "show-first":
+      return reviewShowFirstLine();
+    case "not-offered":
+      return reviewSwitchedOffLine();
+    default: {
+      const unreachable = answer;
+      return unreachable;
+    }
+  }
+}
 
 // dist/hooks/user-prompt-submit.js
 var CHAT_REQUEST_TIMEOUT_MS = 6e3;
 var SHOWN_ENTRY_MAX_AGE_MS = 60 * 60 * 1e3;
 async function runUserPromptSubmit(opts) {
   let act = null;
+  const review = { recognised: false };
   try {
     const prompt = promptOf(opts.input);
+    const reviewShape = reviewPhraseShape(prompt);
+    if (reviewShape !== null) {
+      const out = await decideReview(reviewShape, opts, review);
+      return out === "" ? "" : `${out}
+`;
+    }
     const shape = scopePhraseShape(prompt);
     if (shape === null)
       return "";
@@ -19240,10 +20946,114 @@ async function runUserPromptSubmit(opts) {
     return `${await decide(shape, opts)}
 `;
   } catch {
+    if (review.recognised)
+      return `${reviewCannotReachLine()}
+`;
     return act === null ? "" : `${cannotReachLine(act)}
 `;
   }
 }
+async function decideReview(shape, opts, progress) {
+  const env = opts.env ?? process.env;
+  if (shape.kind === "phase") {
+    const read2 = readConfig(env);
+    if (read2.config === null)
+      return "";
+    const match2 = matchReviewPhraseShape(shape, readShownRecord(read2.config.guardEngagementId, opts.home).reviews);
+    if (match2.kind === "nothing")
+      return "";
+    progress.recognised = true;
+    if (!readSessionAttended(env))
+      return reviewNotAttendedLine();
+    return checkAndSendReview(match2, read2.config.guardEngagementId, read2.config.guardServiceToken, env, opts);
+  }
+  progress.recognised = true;
+  if (!readSessionAttended(env))
+    return reviewNotAttendedLine();
+  const read = readConfig(env);
+  if (read.config === null) {
+    return readNeverConfiguredReason(env) === "not-this-account" ? reviewNotOwnerLine() : reviewNotSignedInLine();
+  }
+  const match = matchReviewPhraseShape(shape, readShownRecord(read.config.guardEngagementId, opts.home).reviews);
+  return checkAndSendReview(match, read.config.guardEngagementId, read.config.guardServiceToken, env, opts);
+}
+async function checkAndSendReview(match, engagementId, credential, env, opts) {
+  if (match.kind === "nothing" || match.kind === "show-first")
+    return reviewShowFirstLine();
+  if (match.kind === "not-listed")
+    return reviewPartNotListedLine(match.part, match.entry.phase);
+  const { entry } = match;
+  if (!listedRecently(entry.shownAt, (opts.now ?? Date.now)()))
+    return reviewListedTooLongAgoLine(entry.phase);
+  let candidate;
+  if (match.kind === "accept") {
+    if (entry.parts.length > 0 && match.parts.length === 0)
+      return reviewNothingToAcceptLine(entry.phase);
+    candidate = {
+      act: "accept",
+      reference: match.reference,
+      reviewVersion: entry.reviewVersion,
+      parts: match.parts.map((p) => p.part)
+    };
+  } else {
+    const { act, part } = match;
+    if (!reviewActsFor(part.built).includes(act))
+      return reviewWrongActLine(part.name, part.built);
+    let words = "";
+    if (act !== "accept") {
+      words = match.words ?? "";
+      if (words === "")
+        return reviewNoWordsLine(act);
+      if (!reviewNoteWireSchema.safeParse(words).success)
+        return reviewWordsTooLongLine();
+      if (looksLikeSecret(words))
+        return reviewWordsLookSecretLine();
+    }
+    if (part.awaitingAnswer)
+      return reviewAwaitingAnswerLine(part.name);
+    if (part.sentBack)
+      return reviewSentBackLine(part.name);
+    if (!part.decidable)
+      return reviewAlreadyDecidedLine(part.name);
+    candidate = act === "accept" ? { act, reference: match.reference, reviewVersion: entry.reviewVersion, parts: [part.part] } : { act, reference: match.reference, reviewVersion: entry.reviewVersion, part: part.part, note: words };
+  }
+  const request = chatReviewRequestSchema.safeParse(candidate);
+  if (!request.success)
+    return reviewShowFirstLine();
+  return postReview(match.kind === "accept", entry, request.data, engagementId, credential, env, opts);
+}
+async function postReview(bulk, entry, request, engagementId, credential, env, opts) {
+  const fetchFn = opts.fetchFn ?? globalThis.fetch;
+  const url2 = `${readControlOrigin(env).origin}/engagements/${encodeURIComponent(engagementId)}/phases/${encodeURIComponent(entry.phase)}/review/chat`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), CHAT_REQUEST_TIMEOUT_MS);
+  try {
+    const response = await fetchFn(url2, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${credential}`, "Content-Type": "application/json" },
+      body: JSON.stringify(request),
+      signal: controller.signal
+    });
+    if (response.status === 401)
+      return reviewNotSignedInLine();
+    if (response.status === 429 || response.status >= 500)
+      return reviewCannotReachLine();
+    const parsed = chatReviewResultSchema.safeParse(await response.json());
+    if (!parsed.success)
+      return reviewCannotReachLine();
+    const answer = parsed.data;
+    if (answer.outcome === "recorded") {
+      if (response.status !== 200)
+        return reviewCannotReachLine();
+      moveListedReviewForward(engagementId, opts.home, entry, answer.reviewVersion, answer.decided);
+    }
+    return reviewLineForAnswer({ act: request.act, bulk, phase: entry.phase, number: entry.number }, answer);
+  } catch {
+    return reviewCannotReachLine();
+  } finally {
+    clearTimeout(timer);
+  }
+}
 async function decide(shape, opts) {
   const { act } = shape;
   const env = opts.env ?? process.env;
@@ -19254,12 +21064,12 @@ async function decide(shape, opts) {
     return readNeverConfiguredReason(env) === "not-this-account" ? notOwnerLine(act) : notSignedInLine(act);
   }
   const { guardServiceToken, guardEngagementId } = read.config;
-  const shown = readShownPlans(guardEngagementId, opts.home);
+  const shown = readShownRecord(guardEngagementId, opts.home).entries;
   const match = matchScopePhraseShape(shape, shown);
   if (match.kind === "show-first")
     return showFirstLine(act);
   const { entry } = match;
-  if (!shownRecently(entry, (opts.now ?? Date.now)()))
+  if (!listedRecently(entry.shownAt, (opts.now ?? Date.now)()))
     return tooOldLine(act, entry.phase);
   let candidate;
   if (match.kind === "send-back") {
@@ -19288,19 +21098,8 @@ function promptOf(input) {
     return void 0;
   }
 }
-function readShownPlans(engagementId, home) {
-  if (!isEngagementId(engagementId))
-    return [];
-  let text;
-  try {
-    text = readFileSync9(join8(home ?? homedir4(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, SHOWN_PLANS_FILENAME), "utf-8");
-  } catch {
-    return [];
-  }
-  return parseShownPlans(text);
-}
-function shownRecently(entry, now) {
-  const age = now - Date.parse(entry.shownAt);
+function listedRecently(shownAt, now) {
+  const age = now - Date.parse(shownAt);
   return Number.isFinite(age) && age >= 0 && age < SHOWN_ENTRY_MAX_AGE_MS;
 }
 async function post(act, entry, request, engagementId, credential, env, fetchFn = globalThis.fetch) {
@@ -19332,7 +21131,7 @@ async function post(act, entry, request, engagementId, credential, env, fetchFn
 }
 
 // dist/resolve-engagement.js
-import { existsSync as existsSync6, readFileSync as readFileSync10, realpathSync as realpathSync3 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync11, realpathSync as realpathSync3 } from "node:fs";
 import { join as join9, sep as sep2 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 function defaultRegistryPath() {
@@ -19342,7 +21141,7 @@ function readRegistry(registryPath = defaultRegistryPath()) {
   if (!existsSync6(registryPath))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync10(registryPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync11(registryPath, "utf-8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
       return {};
     const out = {};
@@ -19390,11 +21189,11 @@ function runResolveEngagement(cwd, registryPath) {
 }
 
 // dist/refresh-credential.js
-import { readFileSync as readFileSync12 } from "node:fs";
+import { readFileSync as readFileSync13 } from "node:fs";
 import { resolve as resolve4 } from "node:path";
 
 // dist/mcp-headers.js
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 import { dirname as dirname4, resolve as resolve3 } from "node:path";
 function defaultWriteErr(text) {
@@ -19414,7 +21213,7 @@ function projectRootFromBinary(binaryPath) {
 function readPinnedVersion(root) {
   let raw;
   try {
-    raw = readFileSync11(resolve3(root, BUNDLE_PIN_REL), "utf-8");
+    raw = readFileSync12(resolve3(root, BUNDLE_PIN_REL), "utf-8");
   } catch {
     return void 0;
   }
@@ -19640,7 +21439,7 @@ var INITIALIZE_BODY = JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initializ
 function registeredMcpUrl(projectRoot) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync12(resolve4(projectRoot, MCP_REGISTRATION_REL), "utf-8"));
+    parsed = JSON.parse(readFileSync13(resolve4(projectRoot, MCP_REGISTRATION_REL), "utf-8"));
   } catch {
     return void 0;
   }
@@ -19747,7 +21546,7 @@ function positionRequestBody(engagementId) {
     params: { name: "halfcycle_position", arguments: { engagementId } }
   });
 }
-async function fetchScopeNotices(url2, bearer, engagementId, fetchFn, deadlineMs) {
+async function fetchPositionNotices(url2, bearer, engagementId, fetchFn, deadlineMs) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), deadlineMs);
   try {
@@ -19794,9 +21593,11 @@ async function fetchScopeNotices(url2, bearer, engagementId, fetchFn, deadlineMs
     } catch {
       return void 0;
     }
-    const scope = typeof body === "object" && body !== null ? body["scope"] : void 0;
-    const parsed = scopeNoticesSchema.safeParse(scope);
-    return parsed.success ? parsed.data : void 0;
+    if (typeof body !== "object" || body === null)
+      return void 0;
+    const scopeParsed = scopeNoticesSchema.safeParse(body["scope"]);
+    const reviewParsed = reviewNoticesSchema.safeParse(body["review"]);
+    return { scope: scopeParsed.success ? scopeParsed.data : void 0, review: reviewParsed.success ? reviewParsed.data : void 0 };
   } finally {
     clearTimeout(timer);
   }
@@ -19833,9 +21634,11 @@ async function runRefreshCredential(opts) {
             const remainingForMargin = SESSION_START_HOOK_TIMEOUT_MS - SESSION_START_MARGIN_MS - (Date.now() - startedAt);
             const positionDeadline = Math.min(opts.scopeNoticeDeadlineMs ?? SCOPE_NOTICE_DEADLINE_MS, remainingForMargin);
             if (positionDeadline > 0) {
-              const scope = await fetchScopeNotices(connection.url, connection.bearer, engagementId, opts.fetchFn ?? globalThis.fetch, positionDeadline);
-              if (scope !== void 0)
-                parts.push(...scopeNoticeLines(scope));
+              const notices = await fetchPositionNotices(connection.url, connection.bearer, engagementId, opts.fetchFn ?? globalThis.fetch, positionDeadline);
+              if (notices?.scope !== void 0)
+                parts.push(...scopeNoticeLines(notices.scope));
+              if (notices?.review !== void 0)
+                parts.push(...reviewNoticeText(notices.review));
             }
           }
         } else if (connection.sentence === CANNOT_REACH_SENTENCE || connection.sentence === SERVICE_PROBLEM_SENTENCE) {
@@ -19869,7 +21672,7 @@ async function runRefreshCredential(opts) {
 import { fileURLToPath } from "node:url";
 
 // dist/capture.js
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, existsSync as existsSync7 } from "node:fs";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync6, mkdirSync as mkdirSync3, existsSync as existsSync7 } from "node:fs";
 import { dirname as dirname5 } from "node:path";
 function runCapture(provider, endpoint, opts = {}) {
   const repoRoot = opts.repoRoot ?? process.cwd();
@@ -19906,7 +21709,7 @@ function runCapture(provider, endpoint, opts = {}) {
   const manifestFile = manifestPath(repoRoot);
   try {
     mkdirSync3(dirname5(fixture), { recursive: true });
-    writeFileSync4(fixture, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+    writeFileSync6(fixture, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { ok: false, kind: "write-failed", message: `could not write fixture: ${msg}` };
@@ -19937,7 +21740,7 @@ function readInputFile(fromFile) {
   if (!fromFile)
     return void 0;
   try {
-    return readFileSync13(fromFile, "utf-8");
+    return readFileSync14(fromFile, "utf-8");
   } catch {
     return void 0;
   }
@@ -19961,6 +21764,17 @@ async function main() {
     process.stdout.write(reply, () => process.exit(0));
     return;
   }
+  if (cmd === "observe") {
+    let line2;
+    try {
+      line2 = JSON.stringify(await runObserve());
+    } catch {
+      line2 = JSON.stringify({ outcome: "not-sent", reason: "unreachable" });
+    }
+    process.stdout.write(`${line2}
+`, () => process.exit(0));
+    return;
+  }
   if (cmd === "mcp-headers") {
     const line2 = await mcpHeaders({ binaryPath: fileURLToPath(import.meta.url) });
     process.stdout.write(line2, () => process.exit(0));
@@ -20043,6 +21857,7 @@ Commit the fixture; the next guard evaluation of this endpoint will pass.
          halfcycle-runner hook user-prompt-submit
          halfcycle-runner refresh-credential
          halfcycle-runner mcp-headers
+         halfcycle-runner observe
          halfcycle-runner resolve-engagement <cwd>
          halfcycle-runner capture <provider> <endpoint> [--from <file>]
 `);