halfcycle 0.4.13 → 0.4.14

package/dist/index.js

@@ -2,7 +2,8 @@
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 import { existsSync as existsSync3, lstatSync, mkdirSync as mkdirSync4, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname3, join as join5, posix, relative } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join5, posix, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../core/dist/guard-record.js
@@ -267,13 +268,69 @@ var REMOTE_FORMS = [
 var SIGN_IN_COMMAND = '"npx halfcycle"';
 var HOOK_REMEDY = `Run ${SIGN_IN_COMMAND} in the project folder to sign in.`;
 
-// ../events/dist/result.js
+// ../core/dist/task-plan.js
 import { z as z2 } from "zod";
-var firedGuardSchema = z2.object({
-  guardId: z2.string(),
-  patternRef: z2.string(),
+var TASK_PLAN_TASKS_MAX = 500;
+var TASK_PLAN_ID_MAX = 64;
+var TASK_PLAN_KINDS = ["build", "review", "spec", "walk", "check"];
+var CONTROL_CHARACTER = /[\u0000-\u001f\u007f-\u009f]/;
+var planText = z2.string().refine((text) => !CONTROL_CHARACTER.test(text), { message: "holds a control character" });
+var taskIdSchema = z2.string().min(1).max(TASK_PLAN_ID_MAX).refine((text) => !CONTROL_CHARACTER.test(text), { message: "holds a control character" });
+var taskPlanTaskSchema = z2.object({
+  id: taskIdSchema,
+  kind: z2.enum(TASK_PLAN_KINDS),
+  dependsOn: z2.array(taskIdSchema).max(TASK_PLAN_TASKS_MAX),
+  reviews: taskIdSchema.optional(),
+  heldBy: z2.literal("person").optional(),
+  touches: z2.object({
+    files: z2.array(planText).optional(),
+    interfaces: z2.array(planText).optional()
+  }).strict().optional(),
+  wholeProject: z2.literal(true).optional(),
+  ships: z2.enum(["deploy", "release"]).optional()
+}).strict().superRefine((task, ctx) => {
+  if (task.reviews !== void 0 && task.kind !== "review") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["reviews"],
+      message: "only a review task names the task it reviews"
+    });
+  }
+  if (task.wholeProject !== void 0 && task.kind !== "check") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["wholeProject"],
+      message: "only a check task is a whole-project check"
+    });
+  }
+  if ((task.kind === "review" || task.kind === "check" || task.kind === "walk") && ((task.touches?.files?.length ?? 0) > 0 || (task.touches?.interfaces?.length ?? 0) > 0)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["touches"],
+      message: "a review, check or walk task touches nothing"
+    });
+  }
+});
+var taskPlanSchema = z2.object({
+  phase: z2.string().min(1).refine((text) => !CONTROL_CHARACTER.test(text), { message: "holds a control character" }),
+  tasks: z2.array(taskPlanTaskSchema).max(TASK_PLAN_TASKS_MAX)
+}).strict();
+var taskListRowSchema = z2.object({
+  id: planText,
+  dependsOn: z2.array(planText)
+}).loose();
+var taskListFileSchema = z2.union([
+  z2.object({ phase: planText, tasks: z2.array(taskListRowSchema) }).loose(),
+  z2.array(z2.unknown())
+]);
+
+// ../events/dist/result.js
+import { z as z3 } from "zod";
+var firedGuardSchema = z3.object({
+  guardId: z3.string(),
+  patternRef: z3.string(),
   severity: severitySchema,
-  explanation: z2.string(),
+  explanation: z3.string(),
   /**
    * The repo-relative path of the file this firing was decided on. The matcher
    * has the file live at the moment it decides to fire; this is the field that
@@ -297,62 +354,62 @@ var firedGuardSchema = z2.object({
    * safe-parse it and decide what to do with a refusal, rather than assume the
    * two shapes agree.
    */
-  path: z2.string().optional()
+  path: z3.string().optional()
 }).strict();
-var notRunCheckSchema = z2.object({
+var notRunCheckSchema = z3.object({
   /** Which check did not run, by the same reference a fired check carries. */
-  patternRef: z2.string(),
+  patternRef: z3.string(),
   /**
    * Why it could not run, in plain words — what this client did not send, or
    * that the check's kind is not implemented yet. Never the check's own rule.
    */
-  reason: z2.string()
+  reason: z3.string()
 }).strict();
-var resultEnvelopeSchema = z2.object({
-  guardsFired: z2.array(firedGuardSchema),
+var resultEnvelopeSchema = z3.object({
+  guardsFired: z3.array(firedGuardSchema),
   severity: severitySchema.nullable(),
-  blocking: z2.boolean(),
-  explanation: z2.string(),
+  blocking: z3.boolean(),
+  explanation: z3.string(),
   /**
    * The checks that could not run on this edit, each named with the reason.
    * Absent when every check ran — so an evaluation where nothing was skipped
    * looks exactly as it always has, and an absent list is never an empty one.
    */
-  notRun: z2.array(notRunCheckSchema).optional()
+  notRun: z3.array(notRunCheckSchema).optional()
 }).strict();
-var wireErrorSchema = z2.object({
-  statusCode: z2.number(),
-  error: z2.string(),
-  message: z2.string()
+var wireErrorSchema = z3.object({
+  statusCode: z3.number(),
+  error: z3.string(),
+  message: z3.string()
 }).strict();
 
 // ../events/dist/build-record.js
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // ../events/dist/state.js
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // ../events/dist/human-agent.js
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var HUMAN_AGENT = "Human";
 var AGENT_NAME_MAX = 32;
-var agentNameSchema = z3.string().min(1).max(AGENT_NAME_MAX);
+var agentNameSchema = z4.string().min(1).max(AGENT_NAME_MAX);
 
 // ../events/dist/state.js
-var utcIso8601 = z4.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 utcIso8601 = z5.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";
-var stepIdSchema = z4.string().regex(/^(l[0-5](-l[0-5])?|xl)\.[a-z0-9-]+$/);
-var methodVersionSchema = z4.string().regex(RELEASE_VERSION_PATTERN);
+var stepIdSchema = z5.string().regex(/^(l[0-5](-l[0-5])?|xl)\.[a-z0-9-]+$/);
+var methodVersionSchema = z5.string().regex(RELEASE_VERSION_PATTERN);
 var anchorPathRegex = /^(?!\/)(?!.*#)(?!method\/)(?!(.*\/)?docs\/method\/).+$/;
-var recordKindSchema = z4.enum(["artefact", "step-run", "gate", "intervention"]);
-var methodLayerSchema = z4.enum(["l0", "l1", "l2", "l3", "l3-l4", "l4", "l5", "xl"]);
+var recordKindSchema = z5.enum(["artefact", "step-run", "gate", "intervention"]);
+var methodLayerSchema = z5.enum(["l0", "l1", "l2", "l3", "l3-l4", "l4", "l5", "xl"]);
 var PHASE_SCOPED_LAYERS = ["l4", "l5"];
 function isPhaseScopedLayer(layer) {
   return PHASE_SCOPED_LAYERS.includes(layer);
 }
-var evidenceKindSchema = z4.enum(["anchor", "diff", "repro", "question-answer", "no-op"]);
-var declarableEvidenceKindSchema = z4.enum(["anchor", "diff", "repro", "question-answer"]);
-var dispositionSchema = z4.enum([
+var evidenceKindSchema = z5.enum(["anchor", "diff", "repro", "question-answer", "no-op"]);
+var declarableEvidenceKindSchema = z5.enum(["anchor", "diff", "repro", "question-answer"]);
+var dispositionSchema = z5.enum([
   "prevented",
   "corrected-in-spec",
   "corrected-in-scope",
@@ -362,20 +419,20 @@ var dispositionSchema = z4.enum([
   "surfaced",
   "filed-forward"
 ]);
-var mechanismSchema = z4.enum(["guard", "verdict", "served-step", "method-step"]);
-var artefactStateSchema = z4.enum(["created", "updated"]);
+var mechanismSchema = z5.enum(["guard", "verdict", "served-step", "method-step"]);
+var artefactStateSchema = z5.enum(["created", "updated"]);
 var QUALIFIED_OUTCOMES = ["declined", "parked"];
-var qualifiedOutcomeSchema = z4.enum(QUALIFIED_OUTCOMES);
+var qualifiedOutcomeSchema = z5.enum(QUALIFIED_OUTCOMES);
 function isQualifiedOutcome(outcome) {
   return QUALIFIED_OUTCOMES.includes(outcome);
 }
-var runOutcomeSchema = z4.enum([
+var runOutcomeSchema = z5.enum([
   "completed",
   "attempted-failed",
   ...QUALIFIED_OUTCOMES
 ]);
-var gateKindSchema = z4.enum(["approval", "mechanical"]);
-var gateVerdictSchema = z4.enum(["pass", "fail", ...QUALIFIED_OUTCOMES]);
+var gateKindSchema = z5.enum(["approval", "mechanical"]);
+var gateVerdictSchema = z5.enum(["pass", "fail", ...QUALIFIED_OUTCOMES]);
 function outcomeReasonIssue(outcome, reason) {
   if (isQualifiedOutcome(outcome) && reason === void 0) {
     return { message: `outcomeReason is required when the outcome is '${outcome}'` };
@@ -387,47 +444,47 @@ function outcomeReasonIssue(outcome, reason) {
   }
   return null;
 }
-var anchorEvidenceSchema = z4.object({
-  kind: z4.literal("anchor"),
-  path: z4.string().regex(anchorPathRegex),
+var anchorEvidenceSchema = z5.object({
+  kind: z5.literal("anchor"),
+  path: z5.string().regex(anchorPathRegex),
   // Optional 1-based line number within the file at `path`. Present when the
   // writer knows the exact line; omitted — never `0`, never `null` — when it
   // does not, because a line number is not always obtainable. Absence is a
   // valid, permanent state here, not a gap meant to be filled in later.
-  line: z4.number().optional()
+  line: z5.number().optional()
 }).strict();
-var diffEvidenceSchema = z4.object({
-  kind: z4.literal("diff"),
-  ref: z4.string()
+var diffEvidenceSchema = z5.object({
+  kind: z5.literal("diff"),
+  ref: z5.string()
 }).strict();
-var reproEvidenceSchema = z4.object({
-  kind: z4.literal("repro"),
-  steps: z4.string().max(2e3)
+var reproEvidenceSchema = z5.object({
+  kind: z5.literal("repro"),
+  steps: z5.string().max(2e3)
 }).strict();
-var questionAnswerEvidenceSchema = z4.object({
-  kind: z4.literal("question-answer"),
-  question: z4.string().max(2e3),
-  before: z4.string().max(2e3),
-  after: z4.string().max(2e3)
+var questionAnswerEvidenceSchema = z5.object({
+  kind: z5.literal("question-answer"),
+  question: z5.string().max(2e3),
+  before: z5.string().max(2e3),
+  after: z5.string().max(2e3)
 }).strict();
-var noOpEvidenceSchema = z4.object({
-  kind: z4.literal("no-op"),
-  inspected: z4.string().max(2e3),
-  unchangedBecause: z4.string().max(2e3)
+var noOpEvidenceSchema = z5.object({
+  kind: z5.literal("no-op"),
+  inspected: z5.string().max(2e3),
+  unchangedBecause: z5.string().max(2e3)
 }).strict();
-var evidenceSchema = z4.discriminatedUnion("kind", [
+var evidenceSchema = z5.discriminatedUnion("kind", [
   anchorEvidenceSchema,
   diffEvidenceSchema,
   reproEvidenceSchema,
   questionAnswerEvidenceSchema,
   noOpEvidenceSchema
 ]);
-var stateRecordEnvelopeSchema = z4.object({
-  format: z4.literal(STATE_RECORD_FORMAT),
+var stateRecordEnvelopeSchema = z5.object({
+  format: z5.literal(STATE_RECORD_FORMAT),
   recordKind: recordKindSchema,
-  recordId: z4.string().uuid(),
+  recordId: z5.string().uuid(),
   methodVersion: methodVersionSchema,
-  engagementId: z4.string(),
+  engagementId: z5.string(),
   stepId: stepIdSchema,
   // Immutable: names when the thing happened, never when a later disposition
   // moved.
@@ -443,38 +500,38 @@ var stateRecordEnvelopeSchema = z4.object({
   // for the whole project rather than per phase. Absence is meaningful on its
   // own — it is never replaced with a placeholder value, and it is read as
   // "satisfies any phase", not as "unknown".
-  phase: z4.string().optional()
+  phase: z5.string().optional()
 });
-var artefactRefSchema = z4.object({
-  name: z4.string(),
-  parent: z4.string()
+var artefactRefSchema = z5.object({
+  name: z5.string(),
+  parent: z5.string()
 }).strict();
-var coverageSchema = z4.object({
-  asked: z4.number().int().nonnegative(),
-  answered: z4.number().int().nonnegative()
+var coverageSchema = z5.object({
+  asked: z5.number().int().nonnegative(),
+  answered: z5.number().int().nonnegative()
 }).strict().superRefine((coverage, ctx) => {
   if (coverage.answered > coverage.asked) {
     ctx.addIssue({
-      code: z4.ZodIssueCode.custom,
+      code: z5.ZodIssueCode.custom,
       path: ["answered"],
       message: "answered cannot be more than asked"
     });
   }
 });
-var projectTierSchema = z4.number().int().min(0).max(3);
+var projectTierSchema = z5.number().int().min(0).max(3);
 var artefactRecordSchema = stateRecordEnvelopeSchema.extend({
-  recordKind: z4.literal("artefact"),
+  recordKind: z5.literal("artefact"),
   artefactRef: artefactRefSchema,
   // Some layer wrote it, by construction — an empty array is not a legitimate
   // state, so the schema says so.
-  writtenByLayers: z4.array(methodLayerSchema).min(1),
+  writtenByLayers: z5.array(methodLayerSchema).min(1),
   state: artefactStateSchema
 }).strict();
 var stepRunRecordSchema = stateRecordEnvelopeSchema.extend({
-  recordKind: z4.literal("step-run"),
+  recordKind: z5.literal("step-run"),
   runOutcome: runOutcomeSchema,
-  failureReason: z4.string().optional(),
-  outcomeReason: z4.string().max(2e3).optional(),
+  failureReason: z5.string().optional(),
+  outcomeReason: z5.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.
@@ -484,29 +541,29 @@ var stepRunRecordSchema = stateRecordEnvelopeSchema.extend({
 }).strict().superRefine((rec, ctx) => {
   if (rec.runOutcome === "attempted-failed" && rec.failureReason === void 0) {
     ctx.addIssue({
-      code: z4.ZodIssueCode.custom,
+      code: z5.ZodIssueCode.custom,
       path: ["failureReason"],
       message: "failureReason is required when runOutcome is 'attempted-failed'"
     });
   }
   if (rec.runOutcome !== "attempted-failed" && rec.failureReason !== void 0) {
     ctx.addIssue({
-      code: z4.ZodIssueCode.custom,
+      code: z5.ZodIssueCode.custom,
       path: ["failureReason"],
       message: "failureReason is only present when runOutcome is 'attempted-failed'"
     });
   }
   const issue = outcomeReasonIssue(rec.runOutcome, rec.outcomeReason);
   if (issue) {
-    ctx.addIssue({ code: z4.ZodIssueCode.custom, path: ["outcomeReason"], ...issue });
+    ctx.addIssue({ code: z5.ZodIssueCode.custom, path: ["outcomeReason"], ...issue });
   }
 });
 var gateRecordSchema = stateRecordEnvelopeSchema.extend({
-  recordKind: z4.literal("gate"),
+  recordKind: z5.literal("gate"),
   gateKind: gateKindSchema,
   verdict: gateVerdictSchema,
-  actor: z4.string(),
-  outcomeReason: z4.string().max(2e3).optional(),
+  actor: z5.string(),
+  outcomeReason: z5.string().max(2e3).optional(),
   coverage: coverageSchema.optional(),
   // Who did the step this checkpoint is on, as reported. Absent when not reported.
   agent: agentNameSchema.optional(),
@@ -516,21 +573,21 @@ var gateRecordSchema = stateRecordEnvelopeSchema.extend({
 }).strict().superRefine((rec, ctx) => {
   const issue = outcomeReasonIssue(rec.verdict, rec.outcomeReason);
   if (issue) {
-    ctx.addIssue({ code: z4.ZodIssueCode.custom, path: ["outcomeReason"], ...issue });
+    ctx.addIssue({ code: z5.ZodIssueCode.custom, path: ["outcomeReason"], ...issue });
   }
 });
 var interventionRecordSchema = stateRecordEnvelopeSchema.extend({
-  recordKind: z4.literal("intervention"),
+  recordKind: z5.literal("intervention"),
   layer: methodLayerSchema,
   mechanism: mechanismSchema,
   severity: severitySchema,
   disposition: dispositionSchema,
-  summary: z4.string().max(2e3),
+  summary: z5.string().max(2e3),
   coverage: coverageSchema.optional(),
   // Who caught it, as the session reported. Absent when not reported.
   agent: agentNameSchema.optional()
 }).strict();
-var stateRecordSchema = z4.discriminatedUnion("recordKind", [
+var stateRecordSchema = z5.discriminatedUnion("recordKind", [
   artefactRecordSchema,
   stepRunRecordSchema,
   gateRecordSchema,
@@ -539,9 +596,9 @@ var stateRecordSchema = z4.discriminatedUnion("recordKind", [
 
 // ../events/dist/control-characters.js
 var CONTROL_CHARACTER_CLASS = "\\p{Cc}";
-var CONTROL_CHARACTER = new RegExp(CONTROL_CHARACTER_CLASS, "u");
+var CONTROL_CHARACTER2 = new RegExp(CONTROL_CHARACTER_CLASS, "u");
 function hasControlCharacter(text) {
-  return CONTROL_CHARACTER.test(text);
+  return CONTROL_CHARACTER2.test(text);
 }
 
 // ../events/dist/phase-identity.js
@@ -632,16 +689,16 @@ var ACTOR_MAX = 200;
 var FINDING_MAX = 500;
 var FINDINGS_SHOWN_MAX = 50;
 var PHASE_CLOSE_REASON_MAX = 1900;
-var closeCommitSchema = z5.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/, "must be a full commit hash: 40 or 64 lowercase hex characters");
-var walkVerdictSchema = z5.enum(["clean", "defects"]);
-var acceptanceOutcomeSchema = z5.object({
+var closeCommitSchema = z6.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/, "must be a full commit hash: 40 or 64 lowercase hex characters");
+var walkVerdictSchema = z6.enum(["clean", "defects"]);
+var acceptanceOutcomeSchema = z6.object({
   verdict: walkVerdictSchema,
-  findings: z5.number().int().nonnegative(),
-  findingsDetail: z5.array(z5.object({ summary: z5.string().refine((v) => !hasLoneSurrogate(v), { message: LONE_SURROGATE_MESSAGE }) }).strict())
+  findings: z6.number().int().nonnegative(),
+  findingsDetail: z6.array(z6.object({ summary: z6.string().refine((v) => !hasLoneSurrogate(v), { message: LONE_SURROGATE_MESSAGE }) }).strict())
 }).strict();
-var closeDecisionSchema = z5.enum(["done-when-met", "override"]);
+var closeDecisionSchema = z6.enum(["done-when-met", "override"]);
 function plainText(max) {
-  const base = max === void 0 ? z5.string() : z5.string().max(max);
+  const base = max === void 0 ? z6.string() : z6.string().max(max);
   return base.refine((v) => !hasControlCharacter(v), {
     message: "must be one line with no control characters (no line breaks, tabs or NUL)"
   }).refine((v) => !hasLoneSurrogate(v), { message: LONE_SURROGATE_MESSAGE });
@@ -653,81 +710,81 @@ function statementText(max) {
 }
 var closeActorSchema = plainText(ACTOR_MAX);
 var PHASE_NAME_RULE = `must be a phase name: not empty, no slash or backslash, not starting with a dot, no control characters, at most ${PHASE_NAME_MAX_BYTES} bytes`;
-var phaseNameSchema = z5.string().refine((v) => isValidPhaseIdentity(v), {
+var phaseNameSchema = z6.string().refine((v) => isValidPhaseIdentity(v), {
   message: PHASE_NAME_RULE
 });
-var phaseIdentitySchema = z5.union([z5.string(), z5.number()], { error: "must be a phase name or a whole number" }).refine((v) => isValidPhaseIdentity(v), { message: PHASE_NAME_RULE });
-var closeStatementsSchema = z5.object({
+var phaseIdentitySchema = z6.union([z6.string(), z6.number()], { error: "must be a phase name or a whole number" }).refine((v) => isValidPhaseIdentity(v), { message: PHASE_NAME_RULE });
+var closeStatementsSchema = z6.object({
   thesis: statementText(STATEMENT_MAX).nullable(),
   outcome: statementText(STATEMENT_MAX).nullable(),
-  deviations: z5.array(statementText(DEVIATION_MAX)).max(DEVIATIONS_MAX),
+  deviations: z6.array(statementText(DEVIATION_MAX)).max(DEVIATIONS_MAX),
   closeCommit: closeCommitSchema.nullable()
 }).strict();
-var closedBySchema = z5.discriminatedUnion("kind", [
-  z5.object({ kind: z5.literal("account"), email: plainText().nullable() }).strict(),
-  z5.object({ kind: z5.literal("no-account") }).strict(),
-  z5.object({ kind: z5.literal("account-removed") }).strict(),
-  z5.object({ kind: z5.literal("not-recorded") }).strict()
+var closedBySchema = z6.discriminatedUnion("kind", [
+  z6.object({ kind: z6.literal("account"), email: plainText().nullable() }).strict(),
+  z6.object({ kind: z6.literal("no-account") }).strict(),
+  z6.object({ kind: z6.literal("account-removed") }).strict(),
+  z6.object({ kind: z6.literal("not-recorded") }).strict()
 ]);
 var STEP_NAME_MAX = 200;
 var stepNameSchema = plainText(STEP_NAME_MAX).refine((v) => v.trim().length > 0, {
   message: "must not be blank"
 });
-var unfinishedStepSchema = z5.object({
+var unfinishedStepSchema = z6.object({
   stepId: plainText(),
-  state: z5.enum(["parked", "failed"]),
+  state: z6.enum(["parked", "failed"]),
   name: stepNameSchema.optional()
 }).strict();
-var crossedSchema = z5.discriminatedUnion("kind", [
-  z5.object({ kind: z5.literal("none") }).strict(),
-  z5.object({ kind: z5.literal("unfinished-steps"), steps: z5.array(unfinishedStepSchema).min(1) }).strict(),
-  z5.object({ kind: z5.literal("clean-over-findings"), findings: z5.number().int().min(1) }).strict(),
-  z5.object({ kind: z5.literal("not-recorded") }).strict()
+var crossedSchema = z6.discriminatedUnion("kind", [
+  z6.object({ kind: z6.literal("none") }).strict(),
+  z6.object({ kind: z6.literal("unfinished-steps"), steps: z6.array(unfinishedStepSchema).min(1) }).strict(),
+  z6.object({ kind: z6.literal("clean-over-findings"), findings: z6.number().int().min(1) }).strict(),
+  z6.object({ kind: z6.literal("not-recorded") }).strict()
 ]);
-var seatCoverageSchema = z5.object({
-  enrolled: z5.number().int().nonnegative(),
-  conformant: z5.number().int().nonnegative()
+var seatCoverageSchema = z6.object({
+  enrolled: z6.number().int().nonnegative(),
+  conformant: z6.number().int().nonnegative()
 }).strict().refine((c) => c.conformant <= c.enrolled, {
   message: "conformant cannot exceed enrolled",
   path: ["conformant"]
 });
-var observedCloseSchema = z5.object({
-  sequence: z5.number().int().min(1),
+var observedCloseSchema = z6.object({
+  sequence: z6.number().int().min(1),
   closedAt: utcIso8601,
   closedBy: closedBySchema,
   crossed: crossedSchema,
   seatCoverage: seatCoverageSchema.nullable()
 }).strict();
-var couldNotRunCheckSchema = z5.object({
+var couldNotRunCheckSchema = z6.object({
   check: plainText(),
   description: plainText().nullable(),
   reason: plainText()
 }).strict();
-var firedCheckSchema = z5.object({
+var firedCheckSchema = z6.object({
   check: plainText(),
   description: plainText().nullable(),
   severity: severitySchema,
   explanation: plainText().nullable(),
-  occurrences: z5.number().int().min(1)
+  occurrences: z6.number().int().min(1)
 }).strict();
-var phaseChecksSchema = z5.discriminatedUnion("state", [
-  z5.object({ state: z5.literal("not-observed") }).strict(),
-  z5.object({
-    state: z5.literal("nothing-fired"),
-    runs: z5.number().int().min(1),
-    couldNotRun: z5.array(couldNotRunCheckSchema)
+var phaseChecksSchema = z6.discriminatedUnion("state", [
+  z6.object({ state: z6.literal("not-observed") }).strict(),
+  z6.object({
+    state: z6.literal("nothing-fired"),
+    runs: z6.number().int().min(1),
+    couldNotRun: z6.array(couldNotRunCheckSchema)
   }).strict(),
-  z5.object({
-    state: z5.literal("fired"),
-    runs: z5.number().int().min(1),
-    couldNotRun: z5.array(couldNotRunCheckSchema),
-    fired: z5.array(firedCheckSchema).min(1)
+  z6.object({
+    state: z6.literal("fired"),
+    runs: z6.number().int().min(1),
+    couldNotRun: z6.array(couldNotRunCheckSchema),
+    fired: z6.array(firedCheckSchema).min(1)
   }).strict()
 ]);
-var observedSchema = z5.object({
+var observedSchema = z6.object({
   engagementId: plainText(),
   methodVersion: methodVersionSchema,
-  closes: z5.array(observedCloseSchema).min(1),
+  closes: z6.array(observedCloseSchema).min(1),
   checks: phaseChecksSchema
 }).strict().superRefine((o, ctx) => {
   o.closes.forEach((close, i) => {
@@ -740,18 +797,18 @@ var observedSchema = z5.object({
     }
   });
 });
-var attestedWalkSchema = z5.object({
+var attestedWalkSchema = z6.object({
   verdict: walkVerdictSchema,
-  findings: z5.array(plainText(FINDING_MAX)).max(FINDINGS_SHOWN_MAX),
-  findingsNotShown: z5.number().int().nonnegative()
+  findings: z6.array(plainText(FINDING_MAX)).max(FINDINGS_SHOWN_MAX),
+  findingsNotShown: z6.number().int().nonnegative()
 }).strict();
-var attestedStatementsSchema = z5.object({
+var attestedStatementsSchema = z6.object({
   thesis: plainText(STATEMENT_MAX).nullable(),
   outcome: plainText(STATEMENT_MAX).nullable(),
-  deviations: z5.array(plainText(DEVIATION_MAX)).max(DEVIATIONS_MAX)
+  deviations: z6.array(plainText(DEVIATION_MAX)).max(DEVIATIONS_MAX)
 }).strict();
-var attestedCloseSchema = z5.object({
-  sequence: z5.number().int().min(1),
+var attestedCloseSchema = z6.object({
+  sequence: z6.number().int().min(1),
   decision: closeDecisionSchema,
   actor: plainText(ACTOR_MAX).nullable(),
   reason: plainText(PHASE_CLOSE_REASON_MAX).nullable(),
@@ -759,8 +816,8 @@ var attestedCloseSchema = z5.object({
   closeCommit: closeCommitSchema.nullable(),
   statements: attestedStatementsSchema
 }).strict();
-var attestedSchema = z5.object({
-  closes: z5.array(attestedCloseSchema)
+var attestedSchema = z6.object({
+  closes: z6.array(attestedCloseSchema)
 }).strict();
 function checkRecordHalves(record2, ctx) {
   const observedBySequence = new Map(record2.observed.closes.map((c) => [c.sequence, c]));
@@ -791,18 +848,18 @@ function checkRecordHalves(record2, ctx) {
     }
   });
 }
-var buildRecordV2Schema = z5.object({
-  format: z5.literal(BUILD_RECORD_V2_FORMAT),
+var buildRecordV2Schema = z6.object({
+  format: z6.literal(BUILD_RECORD_V2_FORMAT),
   phase: phaseNameSchema,
   observed: observedSchema,
   attested: attestedSchema
 }).strict().superRefine(checkRecordHalves);
 
 // ../events/dist/build-snapshot.js
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // ../events/dist/system-description.js
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var SYSTEM_DESCRIPTION_FORMAT = 1;
 var SYSTEM_PARTS_MAX = 60;
 var SYSTEM_CONNECTIONS_MAX = 400;
@@ -814,11 +871,11 @@ var SYSTEM_PART_DESCRIPTION_MAX = 160;
 var SYSTEM_CONNECTION_LABEL_MAX = 60;
 var SYSTEM_PART_ID_PATTERN = /^[a-z][a-z0-9-]{0,39}$/;
 var SYSTEM_LANES = ["clients", "edge", "services", "data", "external"];
-var systemLaneSchema = z6.enum(SYSTEM_LANES, {
+var systemLaneSchema = z7.enum(SYSTEM_LANES, {
   error: `must be one of ${SYSTEM_LANES.join(", ")}`
 });
 var SYSTEM_CONNECTION_KINDS = ["call", "event", "write", "external"];
-var systemConnectionKindSchema = z6.enum(SYSTEM_CONNECTION_KINDS, {
+var systemConnectionKindSchema = z7.enum(SYSTEM_CONNECTION_KINDS, {
   error: `must be one of ${SYSTEM_CONNECTION_KINDS.join(", ")}`
 });
 var LINE_SEPARATOR = /[\u2028\u2029]/;
@@ -827,7 +884,7 @@ function descriptionText(max) {
     message: "must be one line: it holds a line or paragraph separator"
   });
 }
-var systemPartIdSchema = z6.string().regex(SYSTEM_PART_ID_PATTERN, {
+var systemPartIdSchema = z7.string().regex(SYSTEM_PART_ID_PATTERN, {
   message: "must be a short id: a lowercase letter, then lowercase letters, digits or hyphens, 40 characters at most"
 }).refine((v) => !looksLikeSecret(v), { message: "looks like a password or key; choose another id" });
 function hasEmptySegment(pattern) {
@@ -843,50 +900,50 @@ var SEGMENT_CHARACTERS = /^[A-Za-z0-9._\-*]*$/;
 function hasForeignCharacter(pattern) {
   return pattern.split("/").some((segment) => !SEGMENT_CHARACTERS.test(segment));
 }
-var systemOwnedPatternSchema = z6.string().max(SYSTEM_OWNED_PATTERN_MAX, { message: `must be at most ${SYSTEM_OWNED_PATTERN_MAX} characters` }).refine((v) => !hasEmptySegment(v), {
+var systemOwnedPatternSchema = z7.string().max(SYSTEM_OWNED_PATTERN_MAX, { message: `must be at most ${SYSTEM_OWNED_PATTERN_MAX} characters` }).refine((v) => !hasEmptySegment(v), {
   message: "must not start or end with a slash, or have two slashes together"
 }).refine((v) => !hasDotSegment(v), { message: 'must not have a "." or ".." folder in it' }).refine((v) => !hasPartialDoubleStar(v), { message: '"**" must stand alone between slashes' }).refine((v) => !hasForeignCharacter(v), {
   message: 'may use only letters, digits, ".", "_", "-" and "*" between slashes'
 }).refine((v) => !looksLikeSecret(v), {
   message: "this path looks like a credential; list a shorter folder above it"
 });
-var systemPartSchema = z6.object({
+var systemPartSchema = z7.object({
   id: systemPartIdSchema,
   name: descriptionText(SYSTEM_PART_NAME_MAX),
   description: descriptionText(SYSTEM_PART_DESCRIPTION_MAX),
   lane: systemLaneSchema,
-  slot: z6.number({ error: `must be a whole number from 0 to ${SYSTEM_SLOT_MAX}` }).int({ error: `must be a whole number from 0 to ${SYSTEM_SLOT_MAX}` }).min(0, { error: `must be a whole number from 0 to ${SYSTEM_SLOT_MAX}` }).max(SYSTEM_SLOT_MAX, { error: `must be a whole number from 0 to ${SYSTEM_SLOT_MAX}` }),
-  outside: z6.boolean(),
-  owns: z6.array(systemOwnedPatternSchema).max(SYSTEM_OWNS_MAX, { message: `can list at most ${SYSTEM_OWNS_MAX} paths` })
+  slot: z7.number({ error: `must be a whole number from 0 to ${SYSTEM_SLOT_MAX}` }).int({ error: `must be a whole number from 0 to ${SYSTEM_SLOT_MAX}` }).min(0, { error: `must be a whole number from 0 to ${SYSTEM_SLOT_MAX}` }).max(SYSTEM_SLOT_MAX, { error: `must be a whole number from 0 to ${SYSTEM_SLOT_MAX}` }),
+  outside: z7.boolean(),
+  owns: z7.array(systemOwnedPatternSchema).max(SYSTEM_OWNS_MAX, { message: `can list at most ${SYSTEM_OWNS_MAX} paths` })
 }).strict();
-var systemConnectionSchema = z6.object({
+var systemConnectionSchema = z7.object({
   from: systemPartIdSchema,
   to: systemPartIdSchema,
   kind: systemConnectionKindSchema,
   label: descriptionText(SYSTEM_CONNECTION_LABEL_MAX)
 }).strict();
-var systemDescriptionSchema = z6.object({
-  format: z6.literal(SYSTEM_DESCRIPTION_FORMAT, { error: `must be ${SYSTEM_DESCRIPTION_FORMAT}` }),
-  parts: z6.array(systemPartSchema).min(1, { message: "must list at least one part" }).max(SYSTEM_PARTS_MAX, { message: `can hold at most ${SYSTEM_PARTS_MAX} parts (five lanes of twelve slots)` }),
-  connections: z6.array(systemConnectionSchema).max(SYSTEM_CONNECTIONS_MAX, { message: `can hold at most ${SYSTEM_CONNECTIONS_MAX} connections` })
+var systemDescriptionSchema = z7.object({
+  format: z7.literal(SYSTEM_DESCRIPTION_FORMAT, { error: `must be ${SYSTEM_DESCRIPTION_FORMAT}` }),
+  parts: z7.array(systemPartSchema).min(1, { message: "must list at least one part" }).max(SYSTEM_PARTS_MAX, { message: `can hold at most ${SYSTEM_PARTS_MAX} parts (five lanes of twelve slots)` }),
+  connections: z7.array(systemConnectionSchema).max(SYSTEM_CONNECTIONS_MAX, { message: `can hold at most ${SYSTEM_CONNECTIONS_MAX} connections` })
 }).strict();
-var systemDescriptionProblemSchema = z6.object({
-  path: z6.string(),
-  message: z6.string()
+var systemDescriptionProblemSchema = z7.object({
+  path: z7.string(),
+  message: z7.string()
 }).strict();
-var systemReportRecordedSchema = z6.object({
-  outcome: z6.literal("recorded"),
-  version: z6.number().int().min(1),
+var systemReportRecordedSchema = z7.object({
+  outcome: z7.literal("recorded"),
+  version: z7.number().int().min(1),
   reportedAt: utcIso8601
 }).strict();
-var systemReportRefusedSchema = z6.object({
-  outcome: z6.literal("refused"),
-  problems: z6.array(systemDescriptionProblemSchema).min(1)
+var systemReportRefusedSchema = z7.object({
+  outcome: z7.literal("refused"),
+  problems: z7.array(systemDescriptionProblemSchema).min(1)
 }).strict();
-var systemReportUnavailableSchema = z6.object({
-  outcome: z6.literal("unavailable")
+var systemReportUnavailableSchema = z7.object({
+  outcome: z7.literal("unavailable")
 }).strict();
-var systemReportResultSchema = z6.discriminatedUnion("outcome", [
+var systemReportResultSchema = z7.discriminatedUnion("outcome", [
   systemReportRecordedSchema,
   systemReportRefusedSchema,
   systemReportUnavailableSchema
@@ -894,20 +951,20 @@ var systemReportResultSchema = z6.discriminatedUnion("outcome", [
 var SYSTEM_DRAW_SVG_MAX_BYTES = 2 * 1024 * 1024;
 var SYSTEM_DRAW_MERMAID_MAX_BYTES = 256 * 1024;
 var SYSTEM_DRAW_PNG_MAX_BYTES = 8 * 1024 * 1024;
-var systemDrawArchitectureRequestSchema = z6.object({
-  picture: z6.literal("architecture"),
-  version: z6.number().int().min(1)
+var systemDrawArchitectureRequestSchema = z7.object({
+  picture: z7.literal("architecture"),
+  version: z7.number().int().min(1)
 }).strict();
-var systemDrawPhaseRequestSchema = z6.object({
-  picture: z6.literal("phase"),
+var systemDrawPhaseRequestSchema = z7.object({
+  picture: z7.literal("phase"),
   phase: phaseIdentitySchema,
-  planVersion: z6.number().int().min(1)
+  planVersion: z7.number().int().min(1)
 }).strict();
-var systemDrawClosedPhaseRequestSchema = z6.object({
-  picture: z6.literal("closed-phase"),
+var systemDrawClosedPhaseRequestSchema = z7.object({
+  picture: z7.literal("closed-phase"),
   phase: phaseIdentitySchema
 }).strict();
-var systemDrawRequestSchema = z6.discriminatedUnion("picture", [
+var systemDrawRequestSchema = z7.discriminatedUnion("picture", [
   systemDrawArchitectureRequestSchema,
   systemDrawPhaseRequestSchema,
   systemDrawClosedPhaseRequestSchema
@@ -938,23 +995,23 @@ function base64DecodedLength(text) {
   const padding = text.endsWith("==") ? 2 : text.endsWith("=") ? 1 : 0;
   return text.length / 4 * 3 - padding;
 }
-var systemPictureSchema = z6.object({
-  svg: z6.string().min(1).refine((v) => utf8ByteLength2(v) <= SYSTEM_DRAW_SVG_MAX_BYTES, { message: "the picture is larger than 2 MB" }),
-  png: z6.string().min(1).refine((v) => v.length % 4 === 0 && BASE64.test(v), { message: "the image is not valid base64" }).refine((v) => base64DecodedLength(v) <= SYSTEM_DRAW_PNG_MAX_BYTES, { message: "the image is larger than 8 MB" })
+var systemPictureSchema = z7.object({
+  svg: z7.string().min(1).refine((v) => utf8ByteLength2(v) <= SYSTEM_DRAW_SVG_MAX_BYTES, { message: "the picture is larger than 2 MB" }),
+  png: z7.string().min(1).refine((v) => v.length % 4 === 0 && BASE64.test(v), { message: "the image is not valid base64" }).refine((v) => base64DecodedLength(v) <= SYSTEM_DRAW_PNG_MAX_BYTES, { message: "the image is larger than 8 MB" })
 }).strict();
-var systemDrawRefusedSchema = z6.object({
-  outcome: z6.literal("refused"),
-  reason: z6.string().min(1)
+var systemDrawRefusedSchema = z7.object({
+  outcome: z7.literal("refused"),
+  reason: z7.string().min(1)
 }).strict();
-var systemDrawUnavailableSchema = z6.object({
-  outcome: z6.literal("unavailable")
+var systemDrawUnavailableSchema = z7.object({
+  outcome: z7.literal("unavailable")
 }).strict();
-var systemDrawNotClosedSchema = z6.object({
-  outcome: z6.literal("not-closed")
+var systemDrawNotClosedSchema = z7.object({
+  outcome: z7.literal("not-closed")
 }).strict();
 
 // ../events/dist/build-snapshot.js
-var buildTaskStateSchema = z7.enum([
+var buildTaskStateSchema = z8.enum([
   "pending",
   "in-flight",
   "completed",
@@ -967,27 +1024,27 @@ 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 = z7.enum(["build", "review", "spec", "walk", "check"]);
-var buildTaskIdSchema = z7.string().min(1).max(64);
-var buildTaskSchema = z7.object({
+var buildTaskKindSchema = z8.enum(["build", "review", "spec", "walk", "check"]);
+var buildTaskIdSchema = z8.string().min(1).max(64);
+var buildTaskSchema = z8.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: z7.string().min(1).max(BUILD_TASK_TITLE_MAX),
+  title: z8.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: z7.string().min(1).max(64).optional(),
+  discipline: z8.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: z7.string().min(1).max(32).optional(),
+  tier: z8.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: z7.array(buildTaskIdSchema).max(BUILD_SNAPSHOT_TASK_LIMIT),
+  dependsOn: z8.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(),
@@ -1001,13 +1058,13 @@ var buildTaskSchema = z7.object({
   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: z7.array(systemPartIdSchema).min(1).max(SYSTEM_PARTS_MAX).optional(),
+  builds: z8.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: z7.number().int().min(1).max(BUILD_TASK_BUDGET_MAX_MINUTES).optional(),
+  budgetMinutes: z8.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, a person trying the product, or a run of the project's own checks.
   // Absent when the graph does not say.
@@ -1024,14 +1081,14 @@ var buildTaskSchema = z7.object({
 }).strict().superRefine((task, ctx) => {
   if (task.reviews !== void 0 && task.reviews === task.id) {
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z8.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: z7.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       path: ["layer"],
       message: `'${task.layer}' is not a wave a phase runs \u2014 expected one of ${PHASE_SCOPED_LAYERS.join(", ")}.`
     });
@@ -1040,29 +1097,29 @@ var buildTaskSchema = z7.object({
   for (const field of ["discipline", "tier"]) {
     if (profiled && task[field] === void 0) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         path: [field],
         message: `'${field}' is required on a task an agent holds.`
       });
     }
     if (!profiled && task[field] !== void 0) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z8.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 = z7.string().min(1).max(128);
+var buildPhaseSchema = z8.string().min(1).max(128);
 var BUILD_PHASE_TITLE_MAX = 160;
-var buildPhaseTitleSchema = z7.string().min(1).max(BUILD_PHASE_TITLE_MAX);
-var buildTaskListSchema = z7.array(buildTaskSchema).max(BUILD_SNAPSHOT_TASK_LIMIT).superRefine((tasks, ctx) => {
+var buildPhaseTitleSchema = z8.string().min(1).max(BUILD_PHASE_TITLE_MAX);
+var buildTaskListSchema = z8.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: z7.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         path: [index, "id"],
         message: `duplicate task id '${task.id}' \u2014 one graph names each task once.`
       });
@@ -1070,13 +1127,13 @@ var buildTaskListSchema = z7.array(buildTaskSchema).max(BUILD_SNAPSHOT_TASK_LIMI
     seen.add(task.id);
   }
 });
-var buildTaskMarkSchema = z7.object({
+var buildTaskMarkSchema = z8.object({
   // The task that was marked.
   task: buildTaskIdSchema,
   // When it was first marked.
   at: utcIso8601
 }).strict();
-var buildSnapshotSchema = z7.object({
+var buildSnapshotSchema = z8.object({
   // Which phase this graph belongs to.
   phase: buildPhaseSchema,
   // That phase's name in words, when the project gives it one.
@@ -1089,9 +1146,9 @@ var buildSnapshotSchema = z7.object({
   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: z7.array(buildTaskMarkSchema).min(1).max(BUILD_SNAPSHOT_TASK_LIMIT).optional()
+  tasksBuiltWithoutApproval: z8.array(buildTaskMarkSchema).min(1).max(BUILD_SNAPSHOT_TASK_LIMIT).optional()
 }).strict();
-var buildPhaseEntrySchema = z7.object({
+var buildPhaseEntrySchema = z8.object({
   // Which phase has a stored graph.
   phase: buildPhaseSchema,
   // That phase's name in words, when the project gave it one.
@@ -1099,9 +1156,9 @@ var buildPhaseEntrySchema = z7.object({
   // 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: z7.literal(true).optional()
+  builtWithoutApproval: z8.literal(true).optional()
 }).strict();
-var buildSnapshotReportSchema = z7.object({
+var buildSnapshotReportSchema = z8.object({
   // Which phase this graph belongs to.
   phase: buildPhaseSchema,
   // That phase's name in words, when the project gives it one.
@@ -1110,9 +1167,9 @@ var buildSnapshotReportSchema = z7.object({
   // one thing this route does not accept.
   tasks: buildTaskListSchema
 }).strict();
-var buildSnapshotReportResultSchema = z7.object({
+var buildSnapshotReportResultSchema = z8.object({
   // What happened. One outcome today; a refusal travels as the shared wire error.
-  outcome: z7.literal("recorded"),
+  outcome: z8.literal("recorded"),
   // Which phase the graph was recorded against.
   phase: buildPhaseSchema,
   // When it was recorded.
@@ -1120,27 +1177,55 @@ var buildSnapshotReportResultSchema = z7.object({
 }).strict();
 
 // ../events/dist/phase-plan.js
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
+
+// ../events/dist/change-path-order.js
+import { z as z9 } from "zod";
+var PATH_ORDER = Object.freeze(["small", "mini", "full"]);
+var changePathSchema = z9.enum(PATH_ORDER);
+var PHASE_PATHS = Object.freeze(["mini", "full"]);
+var phasePathSchema = z9.enum(PHASE_PATHS);
+var changeUpPathSchema = z9.enum(["mini", "full"]);
+var CHANGE_PATH_NEXT = Object.freeze({
+  small: Object.freeze({ say: "make the small change", section: "small" }),
+  mini: Object.freeze({ say: "scope the mini phase", section: "mini" }),
+  full: Object.freeze({ say: "plan the next phase", section: "full" })
+});
+var changePathNextSchema = z9.object({
+  say: z9.enum([CHANGE_PATH_NEXT.small.say, CHANGE_PATH_NEXT.mini.say, CHANGE_PATH_NEXT.full.say]),
+  section: changePathSchema
+}).strict();
+var CHANGE_SENTENCE_MAX = 4e3;
+var planMovedUpSchema = z9.object({
+  to: z9.literal("full"),
+  sentence: z9.string().min(1).max(CHANGE_SENTENCE_MAX),
+  next: changePathNextSchema
+}).strict().refine((m) => m.next.say === CHANGE_PATH_NEXT.full.say && m.next.section === CHANGE_PATH_NEXT.full.section, {
+  message: "names the full path's next phrase and section",
+  path: ["next"]
+});
+
+// ../events/dist/phase-plan.js
 var PHASE_PLAN_FORMAT = 1;
 var PHASE_PLAN_CHANGES_MAX = 60;
 var PHASE_PLAN_SUMMARY_MAX = 160;
 var SCOPE_NOTE_MAX = 500;
 var PHASE_PLAN_PHASE_MAX = buildPhaseSchema.maxLength ?? 0;
 var PHASE_PLAN_CHANGE_KINDS = ["add", "change", "remove"];
-var phasePlanChangeSchema = z8.enum(PHASE_PLAN_CHANGE_KINDS, {
+var phasePlanChangeSchema = z10.enum(PHASE_PLAN_CHANGE_KINDS, {
   error: `must be one of ${PHASE_PLAN_CHANGE_KINDS.join(", ")}`
 });
 var phasePlanPhaseSchema = phaseIdentitySchema.refine((v) => !isValidPhaseIdentity(v) || buildPhaseSchema.safeParse(String(v)).success, { message: `must be at most ${PHASE_PLAN_PHASE_MAX} characters` });
 var phasePlanSummarySchema = descriptionText(PHASE_PLAN_SUMMARY_MAX);
-var phasePlanEntrySchema = z8.object({
+var phasePlanEntrySchema = z10.object({
   part: systemPartIdSchema,
   change: phasePlanChangeSchema,
   summary: phasePlanSummarySchema
 }).strict();
-var phasePlanSchema = z8.object({
-  format: z8.literal(PHASE_PLAN_FORMAT, { error: `must be ${PHASE_PLAN_FORMAT}` }),
+var phasePlanSchema = z10.object({
+  format: z10.literal(PHASE_PLAN_FORMAT, { error: `must be ${PHASE_PLAN_FORMAT}` }),
   phase: phasePlanPhaseSchema,
-  changes: z8.array(phasePlanEntrySchema).min(1, { message: "must list at least one part" }).max(PHASE_PLAN_CHANGES_MAX, { message: `can list at most ${PHASE_PLAN_CHANGES_MAX} parts` })
+  changes: z10.array(phasePlanEntrySchema).min(1, { message: "must list at least one part" }).max(PHASE_PLAN_CHANGES_MAX, { message: `can list at most ${PHASE_PLAN_CHANGES_MAX} parts` })
 }).strict();
 var scopePhaseSchema = buildPhaseSchema.refine((v) => isValidPhaseIdentity(v), {
   message: "must be a phase name"
@@ -1152,109 +1237,110 @@ var SCOPE_STATE_NAMES = [
   "approved",
   "partly-stale"
 ];
-var scopeStateNameSchema = z8.enum(SCOPE_STATE_NAMES);
+var scopeStateNameSchema = z10.enum(SCOPE_STATE_NAMES);
 var plannedScopeStateSchema = scopeStateNameSchema.exclude(["not-planned"]);
 var SCOPE_PART_STATUSES = ["approved", "waiting"];
-var scopePartStatusSchema = z8.enum(SCOPE_PART_STATUSES);
+var scopePartStatusSchema = z10.enum(SCOPE_PART_STATUSES);
 var SCOPE_ACTS = ["approve", "send-back"];
-var scopeActSchema = z8.enum(SCOPE_ACTS);
+var scopeActSchema = z10.enum(SCOPE_ACTS);
 var SCOPE_GIVEN_IN = ["console", "chat"];
-var scopeGivenInSchema = z8.enum(SCOPE_GIVEN_IN);
+var scopeGivenInSchema = z10.enum(SCOPE_GIVEN_IN);
 var scopeNoteSchema = descriptionText(SCOPE_NOTE_MAX);
-var scopeNoteWireSchema = z8.string().max(SCOPE_NOTE_MAX);
+var scopeNoteWireSchema = z10.string().max(SCOPE_NOTE_MAX);
 var SCOPE_PART_VERDICTS = ["ok", "change"];
-var scopePartVerdictSchema = z8.enum(SCOPE_PART_VERDICTS);
-var scopeDecisionPartSchema = z8.object({
+var scopePartVerdictSchema = z10.enum(SCOPE_PART_VERDICTS);
+var scopeDecisionPartSchema = z10.object({
   part: systemPartIdSchema,
   verdict: scopePartVerdictSchema,
   note: scopeNoteWireSchema.optional()
 }).strict();
-var planVersionSchema = z8.number().int().min(1);
-var carriedPhaseSchema = z8.object({
+var planVersionSchema = z10.number().int().min(1);
+var carriedPhaseSchema = z10.object({
   phase: scopePhaseSchema,
-  number: z8.number().int().min(1)
+  number: z10.number().int().min(1)
 }).strict();
 var carriedFromEntrySchema = carriedPhaseSchema.extend({
   part: systemPartIdSchema
 }).strict();
-var phasePlanRequestSchema = z8.object({
-  descriptionVersion: z8.number().int().min(1),
-  plan: z8.unknown()
+var phasePlanRequestSchema = z10.object({
+  descriptionVersion: z10.number().int().min(1),
+  plan: z10.unknown()
 }).strict();
-var phasePlanRecordedSchema = z8.object({
-  outcome: z8.literal("recorded"),
+var phasePlanRecordedSchema = z10.object({
+  outcome: z10.literal("recorded"),
   version: planVersionSchema,
-  phaseNumber: z8.number().int().min(1),
+  phaseNumber: z10.number().int().min(1),
   state: plannedScopeStateSchema,
-  changedParts: z8.array(systemPartIdSchema).max(PHASE_PLAN_CHANGES_MAX),
-  typedApprovalOffered: z8.boolean(),
+  changedParts: z10.array(systemPartIdSchema).max(PHASE_PLAN_CHANGES_MAX),
+  typedApprovalOffered: z10.boolean(),
   reportedAt: utcIso8601,
-  carriedFrom: z8.array(carriedFromEntrySchema).min(1).max(PHASE_PLAN_CHANGES_MAX).optional()
+  carriedFrom: z10.array(carriedFromEntrySchema).min(1).max(PHASE_PLAN_CHANGES_MAX).optional(),
+  movedUp: planMovedUpSchema.optional()
 }).strict();
-var phasePlanRefusedSchema = z8.object({
-  outcome: z8.literal("refused"),
-  problems: z8.array(systemDescriptionProblemSchema).min(1)
+var phasePlanRefusedSchema = z10.object({
+  outcome: z10.literal("refused"),
+  problems: z10.array(systemDescriptionProblemSchema).min(1)
 }).strict();
-var phasePlanUnavailableSchema = z8.object({
-  outcome: z8.literal("unavailable")
+var phasePlanUnavailableSchema = z10.object({
+  outcome: z10.literal("unavailable")
 }).strict();
 var REMOVAL_OWED_ACTS = ["dropped", "removed"];
-var removalOwedPartSchema = z8.object({
+var removalOwedPartSchema = z10.object({
   part: systemPartIdSchema,
   name: systemPartSchema.shape.name,
   phase: scopePhaseSchema,
-  number: z8.number().int().min(1),
-  act: z8.enum(REMOVAL_OWED_ACTS)
+  number: z10.number().int().min(1),
+  act: z10.enum(REMOVAL_OWED_ACTS)
 }).strict();
-var phasePlanRemovalOwedSchema = z8.object({
-  outcome: z8.literal("removal-owed"),
-  parts: z8.array(removalOwedPartSchema).min(1).max(SYSTEM_PARTS_MAX)
+var phasePlanRemovalOwedSchema = z10.object({
+  outcome: z10.literal("removal-owed"),
+  parts: z10.array(removalOwedPartSchema).min(1).max(SYSTEM_PARTS_MAX)
 }).strict();
-var phasePlanResultSchema = z8.discriminatedUnion("outcome", [
+var phasePlanResultSchema = z10.discriminatedUnion("outcome", [
   phasePlanRecordedSchema,
   phasePlanRefusedSchema,
   phasePlanUnavailableSchema,
   phasePlanRemovalOwedSchema
 ]);
-var scopeApproveRequestSchema = z8.object({
-  act: z8.literal("approve"),
+var scopeApproveRequestSchema = z10.object({
+  act: z10.literal("approve"),
   planVersion: planVersionSchema,
-  parts: z8.array(scopeDecisionPartSchema).max(PHASE_PLAN_CHANGES_MAX)
+  parts: z10.array(scopeDecisionPartSchema).max(PHASE_PLAN_CHANGES_MAX)
 }).strict();
-var scopeSendBackRequestSchema = z8.object({
-  act: z8.literal("send-back"),
+var scopeSendBackRequestSchema = z10.object({
+  act: z10.literal("send-back"),
   planVersion: planVersionSchema,
-  parts: z8.array(scopeDecisionPartSchema).max(PHASE_PLAN_CHANGES_MAX),
+  parts: z10.array(scopeDecisionPartSchema).max(PHASE_PLAN_CHANGES_MAX),
   note: scopeNoteWireSchema.optional()
 }).strict();
-var scopeDecisionRequestSchema = z8.discriminatedUnion("act", [
+var scopeDecisionRequestSchema = z10.discriminatedUnion("act", [
   scopeApproveRequestSchema,
   scopeSendBackRequestSchema
 ]);
-var scopeDecisionRecordedSchema = z8.object({
-  outcome: z8.literal("recorded"),
+var scopeDecisionRecordedSchema = z10.object({
+  outcome: z10.literal("recorded"),
   act: scopeActSchema,
   phase: scopePhaseSchema,
   planVersion: planVersionSchema,
   state: plannedScopeStateSchema,
   decidedAt: utcIso8601
 }).strict();
-var scopeDecisionAlreadyApprovedSchema = z8.object({
-  outcome: z8.literal("already-approved"),
-  replanNeeded: z8.boolean(),
-  reason: z8.string().min(1)
+var scopeDecisionAlreadyApprovedSchema = z10.object({
+  outcome: z10.literal("already-approved"),
+  replanNeeded: z10.boolean(),
+  reason: z10.string().min(1)
 }).strict();
-var scopeDecisionRefusedSchema = z8.object({
-  outcome: z8.literal("refused"),
-  problems: z8.array(systemDescriptionProblemSchema).min(1)
+var scopeDecisionRefusedSchema = z10.object({
+  outcome: z10.literal("refused"),
+  problems: z10.array(systemDescriptionProblemSchema).min(1)
 }).strict();
-var scopeDecisionUnavailableSchema = z8.object({
-  outcome: z8.literal("unavailable")
+var scopeDecisionUnavailableSchema = z10.object({
+  outcome: z10.literal("unavailable")
 }).strict();
 function reasonOutcome(outcome) {
-  return z8.object({ outcome: z8.literal(outcome), reason: z8.string().min(1) }).strict();
+  return z10.object({ outcome: z10.literal(outcome), reason: z10.string().min(1) }).strict();
 }
-var scopeDecisionResultSchema = z8.discriminatedUnion("outcome", [
+var scopeDecisionResultSchema = z10.discriminatedUnion("outcome", [
   scopeDecisionRecordedSchema,
   scopeDecisionAlreadyApprovedSchema,
   scopeDecisionRefusedSchema,
@@ -1264,357 +1350,88 @@ var scopeDecisionResultSchema = z8.discriminatedUnion("outcome", [
   reasonOutcome("plan-changed"),
   reasonOutcome("build-started")
 ]);
-var scopeReadPartSchema = z8.object({
+var scopeReadPartSchema = z10.object({
   part: systemPartIdSchema,
   name: systemPartSchema.shape.name,
   change: phasePlanChangeSchema,
   summary: phasePlanSummarySchema,
   status: scopePartStatusSchema,
-  changed: z8.boolean(),
+  changed: z10.boolean(),
   carriedFrom: carriedPhaseSchema.optional()
 }).strict();
-var scopeReadDecisionSchema = z8.object({
+var scopeReadDecisionSchema = z10.object({
   act: scopeActSchema,
   planVersion: planVersionSchema,
   givenIn: scopeGivenInSchema,
   at: utcIso8601,
-  parts: z8.array(scopeDecisionPartSchema).max(PHASE_PLAN_CHANGES_MAX),
+  parts: z10.array(scopeDecisionPartSchema).max(PHASE_PLAN_CHANGES_MAX),
   note: scopeNoteWireSchema.optional()
 }).strict();
-var scopeReadNotPlannedSchema = z8.object({
+var scopeReadNotPlannedSchema = z10.object({
   phase: scopePhaseSchema,
-  state: z8.literal("not-planned"),
-  canDecide: z8.boolean()
+  state: z10.literal("not-planned"),
+  canDecide: z10.boolean()
 }).strict();
-var scopeReadPlannedSchema = z8.object({
+var scopeReadPlannedSchema = z10.object({
   phase: scopePhaseSchema,
   state: plannedScopeStateSchema,
-  phaseNumber: z8.number().int().min(1),
+  phaseNumber: z10.number().int().min(1),
   planVersion: planVersionSchema,
-  parts: z8.array(scopeReadPartSchema).min(1).max(PHASE_PLAN_CHANGES_MAX),
-  decisions: z8.array(scopeReadDecisionSchema),
-  canDecide: z8.boolean(),
-  replanLine: z8.string().min(1).optional()
+  parts: z10.array(scopeReadPartSchema).min(1).max(PHASE_PLAN_CHANGES_MAX),
+  decisions: z10.array(scopeReadDecisionSchema),
+  canDecide: z10.boolean(),
+  replanLine: z10.string().min(1).optional()
 }).strict();
-var scopeReadSchema = z8.union([scopeReadNotPlannedSchema, scopeReadPlannedSchema]);
+var scopeReadSchema = z10.union([scopeReadNotPlannedSchema, scopeReadPlannedSchema]);
 
-// ../events/dist/crew.js
-import { z as z9 } from "zod";
-var crewGroupSchema = z9.enum(["analyst-architect", "builder", "reviewer", "lead"]);
-var crewTierSchema = z9.enum(["deep", "standard", "fast"]);
-var CREW_DISCIPLINE_MAX = 64;
-var crewFaceHeadSchema = z9.enum(["sq", "sqr", "rnd", "dome", "hex", "gable"]);
-var crewFaceAntennaSchema = z9.enum(["none", "stalk", "twin", "dish"]);
-var crewFaceEyesSchema = z9.enum(["dots", "bars", "visor", "cyclops"]);
-var crewFaceMouthSchema = z9.enum(["line", "grid", "dots", "wave"]);
-var crewFaceSchema = z9.object({
-  // The outline of the head. Members who do the same kind of work share one, so a
-  // team is recognisable before any name is read.
-  head: crewFaceHeadSchema,
-  // What sits on top of the head, if anything.
-  antenna: crewFaceAntennaSchema,
-  // The eyes.
-  eyes: crewFaceEyesSchema,
-  // The mouth.
-  mouth: crewFaceMouthSchema,
-  // Whether this member is drawn with ears.
-  ears: z9.boolean()
+// ../events/dist/observed-changes.js
+import { z as z12 } from "zod";
+
+// ../events/dist/code-link.js
+import { z as z11 } from "zod";
+var codeLinkAddressSchema = z11.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 = z11.object({
+  repositoryAddress: codeLinkAddressSchema.nullable(),
+  headOnGitHub: z11.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 = z11.object({
+  kind: z11.literal("github"),
+  scope: z11.enum(PART_CODE_LINK_SCOPES),
+  url: z11.string().startsWith(PART_CODE_LINK_URL_PREFIX, { message: "must start with https://github.com/" })
 }).strict();
-var crewRoleSchema = z9.enum([
-  "business-analyst",
-  "architect",
-  "spec-writer",
-  "builder",
-  "context-docs",
-  "spec-reviewer",
-  "code-test-reviewer",
-  "delivery-lead",
-  "quality-lead"
+var partCodeLinkRangeSchema = z11.object({
+  kind: z11.literal("range"),
+  why: z11.enum(PART_CODE_LINK_RANGE_REASONS),
+  from: closeCommitSchema,
+  to: closeCommitSchema
+}).strict();
+var partCodeLinkNoneSchema = z11.object({
+  kind: z11.literal("none")
+}).strict();
+var partCodeLinkSchema = z11.discriminatedUnion("kind", [
+  partCodeLinkGithubSchema,
+  partCodeLinkRangeSchema,
+  partCodeLinkNoneSchema
 ]);
-var crewMemberSchema = z9.object({
-  // The agent's name. The same names on every project, so a name is a
-  // vocabulary a returning client already knows.
-  callsign: z9.string().min(1).max(32),
-  // Which of the four teams this member belongs to.
-  group: crewGroupSchema,
-  // The part this member plays, which decides the stages it leads and helps with.
-  role: crewRoleSchema,
-  // The kind of work this member takes. A task names a discipline, and only
-  // agents holding it can be dispatched to it.
-  discipline: z9.string().min(1).max(CREW_DISCIPLINE_MAX),
-  // How much thinking this member brings. There is no field naming the supplier
-  // behind it, on this shape or on any other.
-  tier: crewTierSchema,
-  // How this member's face is drawn. The same face on every project, so a
-  // returning client recognises a member before reading the name.
-  face: crewFaceSchema
-}).strict();
-var CREW_ROSTER = [
-  // ── analysts and architects ─────────────────────────────────────────────────
-  {
-    callsign: "SOFIA",
-    group: "analyst-architect",
-    role: "business-analyst",
-    discipline: "business analyst",
-    tier: "deep",
-    face: { head: "gable", antenna: "stalk", eyes: "dots", mouth: "wave", ears: false }
-  },
-  {
-    callsign: "BEA",
-    group: "analyst-architect",
-    role: "business-analyst",
-    discipline: "business analyst",
-    tier: "standard",
-    face: { head: "gable", antenna: "none", eyes: "visor", mouth: "line", ears: false }
-  },
-  {
-    callsign: "WREN",
-    group: "analyst-architect",
-    role: "architect",
-    discipline: "solution architect",
-    tier: "deep",
-    face: { head: "gable", antenna: "dish", eyes: "bars", mouth: "line", ears: true }
-  },
-  {
-    callsign: "PEI",
-    group: "analyst-architect",
-    role: "architect",
-    discipline: "technical architect",
-    tier: "standard",
-    face: { head: "gable", antenna: "twin", eyes: "cyclops", mouth: "dots", ears: false }
-  },
-  // ── builders: code ──────────────────────────────────────────────────────────
-  {
-    callsign: "ADA",
-    group: "builder",
-    role: "builder",
-    discipline: "implementation",
-    tier: "deep",
-    face: { head: "sq", antenna: "stalk", eyes: "dots", mouth: "line", ears: false }
-  },
-  {
-    callsign: "OTTO",
-    group: "builder",
-    role: "builder",
-    discipline: "implementation",
-    tier: "deep",
-    face: { head: "sq", antenna: "twin", eyes: "bars", mouth: "grid", ears: true }
-  },
-  {
-    callsign: "MILO",
-    group: "builder",
-    role: "builder",
-    discipline: "implementation",
-    tier: "standard",
-    face: { head: "sqr", antenna: "stalk", eyes: "dots", mouth: "dots", ears: false }
-  },
-  {
-    callsign: "NOVA",
-    group: "builder",
-    role: "builder",
-    discipline: "implementation",
-    tier: "standard",
-    face: { head: "sq", antenna: "dish", eyes: "cyclops", mouth: "line", ears: false }
-  },
-  {
-    callsign: "HUGO",
-    group: "builder",
-    role: "builder",
-    discipline: "infrastructure",
-    tier: "standard",
-    face: { head: "sq", antenna: "twin", eyes: "dots", mouth: "grid", ears: true }
-  },
-  // ── builders: specs and docs ────────────────────────────────────────────────
-  {
-    callsign: "IRIS",
-    group: "builder",
-    role: "spec-writer",
-    discipline: "feature spec",
-    tier: "deep",
-    face: { head: "dome", antenna: "stalk", eyes: "visor", mouth: "line", ears: false }
-  },
-  {
-    callsign: "JUNO",
-    group: "builder",
-    role: "spec-writer",
-    discipline: "feature spec",
-    tier: "standard",
-    face: { head: "dome", antenna: "none", eyes: "dots", mouth: "wave", ears: false }
-  },
-  {
-    callsign: "LEX",
-    group: "builder",
-    role: "context-docs",
-    discipline: "context & docs",
-    tier: "fast",
-    face: { head: "dome", antenna: "twin", eyes: "bars", mouth: "dots", ears: false }
-  },
-  // ── reviewers ───────────────────────────────────────────────────────────────
-  {
-    callsign: "VERA",
-    group: "reviewer",
-    role: "spec-reviewer",
-    discipline: "spec consistency",
-    tier: "deep",
-    face: { head: "rnd", antenna: "stalk", eyes: "visor", mouth: "line", ears: false }
-  },
-  {
-    callsign: "ODIN",
-    group: "reviewer",
-    role: "spec-reviewer",
-    discipline: "cross-spec audit",
-    tier: "deep",
-    face: { head: "rnd", antenna: "dish", eyes: "cyclops", mouth: "line", ears: false }
-  },
-  {
-    callsign: "CASS",
-    group: "reviewer",
-    role: "code-test-reviewer",
-    discipline: "code review",
-    tier: "deep",
-    face: { head: "rnd", antenna: "none", eyes: "visor", mouth: "grid", ears: true }
-  },
-  {
-    callsign: "THEO",
-    group: "reviewer",
-    role: "code-test-reviewer",
-    discipline: "code review",
-    tier: "standard",
-    face: { head: "rnd", antenna: "twin", eyes: "bars", mouth: "line", ears: false }
-  },
-  {
-    callsign: "KAI",
-    group: "reviewer",
-    role: "code-test-reviewer",
-    discipline: "code review",
-    tier: "standard",
-    face: { head: "rnd", antenna: "none", eyes: "bars", mouth: "line", ears: true }
-  },
-  {
-    callsign: "ECHO",
-    group: "reviewer",
-    role: "code-test-reviewer",
-    discipline: "test quality",
-    tier: "standard",
-    face: { head: "rnd", antenna: "stalk", eyes: "dots", mouth: "wave", ears: false }
-  },
-  {
-    callsign: "MAVIS",
-    group: "reviewer",
-    role: "code-test-reviewer",
-    discipline: "suites & coverage",
-    tier: "standard",
-    face: { head: "rnd", antenna: "none", eyes: "visor", mouth: "dots", ears: false }
-  },
-  {
-    callsign: "ZARA",
-    group: "reviewer",
-    role: "code-test-reviewer",
-    discipline: "smoke & walk aid",
-    tier: "standard",
-    face: { head: "rnd", antenna: "dish", eyes: "bars", mouth: "wave", ears: false }
-  },
-  {
-    callsign: "NORA",
-    group: "reviewer",
-    role: "code-test-reviewer",
-    discipline: "evidence & provenance",
-    tier: "fast",
-    face: { head: "rnd", antenna: "twin", eyes: "dots", mouth: "line", ears: false }
-  },
-  // ── leads ───────────────────────────────────────────────────────────────────
-  {
-    callsign: "ARGUS",
-    group: "lead",
-    role: "quality-lead",
-    discipline: "quality lead \xB7 every diff",
-    tier: "standard",
-    face: { head: "hex", antenna: "dish", eyes: "visor", mouth: "grid", ears: true }
-  },
-  {
-    callsign: "ATLAS",
-    group: "lead",
-    role: "delivery-lead",
-    discipline: "delivery lead",
-    tier: "deep",
-    face: { head: "hex", antenna: "twin", eyes: "cyclops", mouth: "line", ears: true }
-  }
-];
-var CREW_ROSTER_SIZE = CREW_ROSTER.length;
-var CREW_CALLSIGNS = CREW_ROSTER.map((member) => member.callsign);
-var crewLayerSchema = methodLayerSchema.extract(["l0", "l1", "l2", "l3", "l4", "l5"]);
-var crewRoleLayersSchema = z9.object({
-  leads: z9.array(crewLayerSchema),
-  helps: z9.array(crewLayerSchema)
-}).strict();
-
-// ../events/dist/build-record-v3.js
-import { z as z14 } from "zod";
-
-// ../events/dist/board-vocabulary.js
-import { z as z10 } from "zod";
-var boardStepStateSchema = z10.enum([
-  "not-instrumented",
-  "done",
-  "did-not-pass",
-  "could-not-complete",
-  "not-yet-available",
-  "qualified"
-]);
-var boardGateNameSchema = z10.enum([
-  "scope",
-  "architecture",
-  "specs",
-  "taskgraph",
-  "phase-close"
-]);
-
-// ../events/dist/code-link.js
-import { z as z11 } from "zod";
-var codeLinkAddressSchema = z11.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 = z11.object({
-  repositoryAddress: codeLinkAddressSchema.nullable(),
-  headOnGitHub: z11.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 = z11.object({
-  kind: z11.literal("github"),
-  scope: z11.enum(PART_CODE_LINK_SCOPES),
-  url: z11.string().startsWith(PART_CODE_LINK_URL_PREFIX, { message: "must start with https://github.com/" })
-}).strict();
-var partCodeLinkRangeSchema = z11.object({
-  kind: z11.literal("range"),
-  why: z11.enum(PART_CODE_LINK_RANGE_REASONS),
-  from: closeCommitSchema,
-  to: closeCommitSchema
-}).strict();
-var partCodeLinkNoneSchema = z11.object({
-  kind: z11.literal("none")
-}).strict();
-var partCodeLinkSchema = z11.discriminatedUnion("kind", [
-  partCodeLinkGithubSchema,
-  partCodeLinkRangeSchema,
-  partCodeLinkNoneSchema
-]);
-
-// ../events/dist/observed-changes.js
-import { z as z12 } from "zod";
-var OBSERVED_PATHS_LISTED_MAX = 50;
-var OBSERVED_PATH_MAX = 300;
-var OBSERVED_COUNT_MAX = 1e6;
-var observedCountSchema = z12.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 = z12.number().int().min(1);
-var observedPathSchema = z12.string().min(1, { message: "must not be empty" }).max(OBSERVED_PATH_MAX, { message: `must be at most ${OBSERVED_PATH_MAX} characters` });
-var observedPathListSchema = z12.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 = z12.object({
-  added: observedCountSchema,
-  changed: observedCountSchema,
-  removed: observedCountSchema
+
+// ../events/dist/observed-changes.js
+var OBSERVED_PATHS_LISTED_MAX = 50;
+var OBSERVED_PATH_MAX = 300;
+var OBSERVED_COUNT_MAX = 1e6;
+var observedCountSchema = z12.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 = z12.number().int().min(1);
+var observedPathSchema = z12.string().min(1, { message: "must not be empty" }).max(OBSERVED_PATH_MAX, { message: `must be at most ${OBSERVED_PATH_MAX} characters` });
+var observedPathListSchema = z12.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 = z12.object({
+  added: observedCountSchema,
+  changed: observedCountSchema,
+  removed: observedCountSchema
 }).strict();
 var observedFilesSchema = z12.object({
   added: observedCountSchema,
@@ -1737,111 +1554,734 @@ var OBSERVE_NOT_SENT_REASONS = [
   "refused",
   "unreachable"
 ];
-var observeRunRecordedSchema = z12.object({ outcome: z12.literal("recorded") }).strict();
-var observeRunKeptSchema = z12.object({ outcome: z12.literal("kept") }).strict();
-var observeRunNotSentSchema = z12.object({
-  outcome: z12.literal("not-sent"),
-  reason: z12.enum(OBSERVE_NOT_SENT_REASONS)
+var observeRunRecordedSchema = z12.object({ outcome: z12.literal("recorded") }).strict();
+var observeRunKeptSchema = z12.object({ outcome: z12.literal("kept") }).strict();
+var observeRunNotSentSchema = z12.object({
+  outcome: z12.literal("not-sent"),
+  reason: z12.enum(OBSERVE_NOT_SENT_REASONS)
+}).strict();
+var observeRunResultSchema = z12.discriminatedUnion("outcome", [
+  observeRunRecordedSchema,
+  observeRunKeptSchema,
+  observeRunNotSentSchema
+]);
+var observedChecksFiredSchema = z12.array(z12.string().min(1)).refine((names) => names.every((name, i) => i === 0 || names[i - 1] < name), {
+  message: "must be sorted, each name once"
+});
+var observedCountingSchema = z12.discriminatedUnion("state", [
+  z12.object({
+    state: z12.literal("counted"),
+    startCommit: closeCommitSchema,
+    startRecordedAt: utcIso8601,
+    headCommit: closeCommitSchema,
+    headCommittedAt: utcIso8601,
+    commits: observedCountSchema,
+    countedAt: utcIso8601
+  }).strict(),
+  z12.object({
+    state: z12.literal("not-counted-yet"),
+    startCommit: closeCommitSchema,
+    startRecordedAt: utcIso8601
+  }).strict(),
+  z12.object({
+    state: z12.literal("cannot-count")
+  }).strict()
+]);
+var observedPartSchema = z12.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 = z12.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 = z12.object({
+  phase: phaseNameSchema,
+  counting: observedCountingSchema,
+  descriptionVersion: observedDescriptionVersionSchema.nullable(),
+  parts: z12.array(observedPartSchema).max(SYSTEM_PARTS_MAX),
+  methodFiles: observedMethodFilesSchema.nullable(),
+  outsideEveryPart: observedOutsideSchema,
+  codeLink: codeLinkFactsSchema.nullable()
+}).strict().superRefine((v, ctx) => {
+  checkPartsUnique(v.parts, ctx, ["parts"]);
+  const counted2 = v.counting.state === "counted";
+  const rule = counted2 ? "must be present when the phase is counted" : "must be null until the phase is counted";
+  if (v.methodFiles !== null !== counted2)
+    ctx.addIssue({ code: "custom", path: ["methodFiles"], message: rule });
+  if (v.outsideEveryPart.files !== null !== counted2) {
+    ctx.addIssue({ code: "custom", path: ["outsideEveryPart", "files"], message: rule });
+  }
+  if (v.codeLink !== null !== counted2)
+    ctx.addIssue({ code: "custom", path: ["codeLink"], message: rule });
+  v.parts.forEach((entry, i) => {
+    if (entry.files !== null !== counted2)
+      ctx.addIssue({ code: "custom", path: ["parts", i, "files"], message: rule });
+  });
+  if (counted2 && v.descriptionVersion === null) {
+    ctx.addIssue({ code: "custom", path: ["descriptionVersion"], message: "must name the version the counts used" });
+  }
+});
+var partOutsideThePlanSchema = z12.object({
+  part: systemPartIdSchema,
+  name: systemPartSchema.shape.name,
+  seen: observedFilesSchema.nullable(),
+  tasks: z12.array(observedSaidSchema.extend({ id: buildTaskSchema.shape.id }).strict()).max(BUILD_SNAPSHOT_TASK_LIMIT)
+}).strict();
+function shortCommit(commit) {
+  return commit.slice(0, 7);
+}
+
+// ../events/dist/work-record.js
+import { z as z14 } from "zod";
+
+// ../events/dist/crew-tier.js
+import { z as z13 } from "zod";
+var crewTierSchema = z13.enum(["deep", "standard", "fast"]);
+
+// ../events/dist/work-record.js
+var agentWorkText = statementText(STATEMENT_MAX);
+var WORK_FINDINGS_MAX = 100;
+var WORK_ANSWERS_MAX = 100;
+var WORK_ATTEMPT_LIMIT = 4;
+var WORK_CLAIM_CHECKS_MAX = 20;
+var findingIdSchema = z14.string().regex(/^F[1-9][0-9]?\.[AQ][1-9][0-9]{0,2}$/, { message: "must be a finding id such as F1.A1" });
+var WORK_STAGES = Object.freeze(["asked", "quality"]);
+var workStageSchema = z14.enum(WORK_STAGES);
+var workVerdictSchema = z14.enum(["pass", "fail"]);
+var WORK_FINDING_KINDS = Object.freeze([
+  "asked",
+  "quality",
+  "unrecorded-call",
+  "undeclared-listed-decision"
+]);
+var workFindingKindSchema = z14.enum(WORK_FINDING_KINDS);
+var WORK_ASKED_ONLY_FINDING_KINDS = Object.freeze([
+  "unrecorded-call",
+  "undeclared-listed-decision"
+]);
+var workOutcomeSchema = z14.enum(["fixed", "declined", "deferred"]);
+var DIAGNOSIS_CAUSES = Object.freeze([
+  "spec",
+  "ordering",
+  "approach",
+  "capability",
+  "environment",
+  "review"
+]);
+var diagnosisCauseSchema = z14.enum(DIAGNOSIS_CAUSES);
+var diagnosisNextSchema = z14.enum(["different-way", "stop", "ask-person"]);
+var callUndoableSchema = z14.enum(["yes", "no"]);
+var callKindSchema = z14.enum(["default", "listed"]);
+var commitShaSchema = closeCommitSchema;
+var workChangeIdSchema = z14.string().uuid({ message: "must be the change id Halfcycle gave" });
+var workTaskSubjectSchema = z14.object({
+  kind: z14.literal("task"),
+  phase: buildPhaseSchema,
+  task: buildTaskIdSchema
+}).strict();
+var workChangeSubjectSchema = z14.object({
+  kind: z14.literal("change"),
+  change: workChangeIdSchema
+}).strict();
+var workPhaseSubjectSchema = z14.object({
+  kind: z14.literal("phase"),
+  phase: buildPhaseSchema
+}).strict();
+var workSubjectSchema = z14.discriminatedUnion("kind", [
+  workTaskSubjectSchema,
+  workChangeSubjectSchema,
+  workPhaseSubjectSchema
+]);
+var workItemSubjectSchema = z14.discriminatedUnion("kind", [workTaskSubjectSchema, workChangeSubjectSchema]);
+var workFindingInputSchema = z14.object({
+  kind: workFindingKindSchema,
+  says: agentWorkText
+}).strict();
+var workReviewRecordSchema = z14.object({
+  record: z14.literal("review"),
+  subject: workItemSubjectSchema,
+  stage: workStageSchema,
+  verdict: workVerdictSchema,
+  reviewer: agentNameSchema,
+  builder: agentNameSchema,
+  builderTier: crewTierSchema,
+  head: commitShaSchema,
+  findings: z14.array(workFindingInputSchema).max(WORK_FINDINGS_MAX, { message: `can carry at most ${WORK_FINDINGS_MAX} findings` }),
+  retryReason: agentWorkText.optional(),
+  diagnosis: z14.string().uuid({ message: "must be the diagnosis id Halfcycle gave" }).optional(),
+  followsDiagnosis: z14.boolean().optional()
+}).strict().refine((r) => r.stage === "asked" || r.findings.every((f) => !WORK_ASKED_ONLY_FINDING_KINDS.includes(f.kind)), {
+  message: "a review for quality cannot raise an unrecorded call or an undeclared listed decision",
+  path: ["findings"]
+});
+var workAnswerSchema = z14.object({
+  finding: findingIdSchema,
+  outcome: workOutcomeSchema,
+  reason: agentWorkText.optional()
+}).strict().refine((a) => a.outcome === "fixed" === (a.reason === void 0), {
+  message: "a reason is given exactly when a finding is declined or deferred",
+  path: ["reason"]
+});
+var workOutcomesRecordSchema = z14.object({
+  record: z14.literal("outcomes"),
+  subject: workItemSubjectSchema,
+  by: agentNameSchema,
+  answers: z14.array(workAnswerSchema).min(1, { message: "must answer at least one finding" }).max(WORK_ANSWERS_MAX, { message: `can carry at most ${WORK_ANSWERS_MAX} answers` })
+}).strict().refine((r) => new Set(r.answers.map((a) => a.finding)).size === r.answers.length, {
+  message: "answers each finding once",
+  path: ["answers"]
+});
+var workClaimsRecordSchema = z14.object({
+  record: z14.literal("claims"),
+  subject: workItemSubjectSchema,
+  head: commitShaSchema,
+  by: agentNameSchema,
+  checks: z14.array(z14.object({ label: agentWorkText }).strict()).min(1, { message: "must name at least one check" }).max(WORK_CLAIM_CHECKS_MAX, { message: `can name at most ${WORK_CLAIM_CHECKS_MAX} checks` })
+}).strict().refine((r) => new Set(r.checks.map((c) => c.label)).size === r.checks.length, {
+  message: "names each check once",
+  path: ["checks"]
+});
+var workDiagnosisRecordSchema = z14.object({
+  record: z14.literal("diagnosis"),
+  subject: workItemSubjectSchema,
+  afterAttempt: z14.number().int().min(2, { message: "must be attempt 2 or later" }).max(WORK_ATTEMPT_LIMIT - 1, { message: `must be attempt ${WORK_ATTEMPT_LIMIT - 1} or earlier` }),
+  by: agentNameSchema,
+  cause: diagnosisCauseSchema,
+  says: agentWorkText,
+  next: diagnosisNextSchema,
+  change: agentWorkText.optional(),
+  question: agentWorkText.optional(),
+  answer: agentWorkText.optional()
+}).strict().refine((r) => r.next === "different-way" === (r.change !== void 0), {
+  message: "says what will change exactly when the next step is to try a different way",
+  path: ["change"]
+}).refine((r) => r.next === "ask-person" === (r.question !== void 0), {
+  message: "carries a question exactly when the next step is to ask the person",
+  path: ["question"]
+});
+var workCallRecordSchema = z14.object({
+  record: z14.literal("call"),
+  subject: workSubjectSchema,
+  by: agentNameSchema,
+  question: agentWorkText,
+  chose: agentWorkText,
+  statedDefault: agentWorkText,
+  undoable: callUndoableSchema,
+  how: agentWorkText.optional()
+}).strict().refine((r) => r.undoable === "yes" === (r.how !== void 0), {
+  message: "says how to undo it exactly when it can be undone",
+  path: ["how"]
+});
+var workRecordSchema = z14.discriminatedUnion("record", [
+  workReviewRecordSchema,
+  workOutcomesRecordSchema,
+  workClaimsRecordSchema,
+  workDiagnosisRecordSchema,
+  workCallRecordSchema
+]);
+var WORK_STANDINGS = Object.freeze([
+  "not-reviewed",
+  "stopped",
+  "held",
+  "needs-diagnosis",
+  "failed",
+  "in-review",
+  "findings-open",
+  "passed"
+]);
+var workStandingSchema = z14.enum(WORK_STANDINGS);
+var workRecordResultSchema = z14.object({
+  outcome: z14.enum(["recorded", "kept"]),
+  attempt: z14.number().int().min(1).optional(),
+  findings: z14.array(findingIdSchema).max(WORK_FINDINGS_MAX).optional(),
+  diagnosis: z14.string().uuid().optional(),
+  standing: workStandingSchema,
+  says: z14.string().min(1)
+}).strict();
+var WORK_REFUSAL_STATUS = Object.freeze({
+  "phase-not-open": 409,
+  "unknown-task": 400,
+  "unknown-change": 404,
+  "change-finished": 409,
+  "out-of-order": 409,
+  "same-agent": 409,
+  "already-recorded": 409,
+  "already-answered": 409,
+  "unknown-finding": 400,
+  "findings-unanswered": 409,
+  "listed-decision-passed": 400,
+  "needs-diagnosis": 409,
+  "no-diagnosis-due": 409,
+  "not-fresh": 409,
+  "graph-unchanged": 409,
+  "no-graph": 400,
+  "wrong-diagnosis": 409,
+  "diagnosis-not-followed": 400,
+  stopped: 409,
+  held: 409,
+  "attempt-limit": 409,
+  "same-attempt": 409,
+  "call-not-recorded": 409
+});
+var WORK_REFUSALS = Object.freeze(Object.keys(WORK_REFUSAL_STATUS));
+var workRefusalSchema = z14.enum(WORK_REFUSALS);
+var workRefusalErrorSchema = wireErrorSchema.extend({ error: workRefusalSchema }).strict().refine((e) => e.statusCode === WORK_REFUSAL_STATUS[e.error], {
+  message: "carries the status its refusal is answered with",
+  path: ["statusCode"]
+});
+var testCommandIdSchema = z14.string().regex(/^[0-9a-f]{16}$/, { message: "must be 16 lower-case hex characters" });
+var workCountSchema = z14.number().int().min(0);
+var testRunReportSchema = z14.object({
+  runId: z14.string().uuid(),
+  subject: workItemSubjectSchema,
+  label: agentWorkText,
+  when: z14.enum(["before", "after"]),
+  commandId: testCommandIdSchema,
+  head: commitShaSchema,
+  changedOutsideTests: workCountSchema,
+  uncommitted: workCountSchema,
+  beforeRunId: z14.string().uuid().nullable(),
+  changedSinceBefore: workCountSchema.nullable(),
+  exitCode: z14.number().int().nullable(),
+  timedOut: z14.boolean(),
+  passed: workCountSchema.nullable(),
+  failed: workCountSchema.nullable(),
+  durationMs: workCountSchema,
+  startedAt: utcIso8601,
+  reason: agentWorkText.optional()
+}).strict().refine((r) => r.passed === null === (r.failed === null), {
+  message: "counts both passed and failed, or neither",
+  path: ["failed"]
+}).refine((r) => r.when === "after" || r.beforeRunId === null && r.changedSinceBefore === null, {
+  message: "a run before the change is measured against no earlier run",
+  path: ["beforeRunId"]
+}).refine((r) => !r.timedOut || r.exitCode === null, {
+  message: "a run that timed out has no exit code",
+  path: ["exitCode"]
+});
+var testRunResultSchema = z14.object({ outcome: z14.literal("recorded") }).strict();
+var TEST_PROOF_REASONS = Object.freeze([
+  "no-run-before",
+  "before-after-change",
+  "not-counted",
+  "passed-before",
+  "no-run-after",
+  "command-changed",
+  "not-after-before",
+  "nothing-changed",
+  "failed-after",
+  "after-not-at-claimed-head"
+]);
+var testProofReasonSchema = z14.enum(TEST_PROOF_REASONS);
+var testProofStateSchema = z14.enum(["proven", "not-proven", "unchecked"]);
+var testRunCountsSchema = z14.object({
+  passed: workCountSchema.nullable(),
+  failed: workCountSchema.nullable(),
+  durationMs: workCountSchema,
+  timedOut: z14.boolean()
+}).strict();
+var workTestSchema = z14.object({
+  label: agentWorkText,
+  state: testProofStateSchema,
+  why: testProofReasonSchema.optional(),
+  claimedBy: agentNameSchema,
+  before: testRunCountsSchema.optional(),
+  after: testRunCountsSchema.optional()
+}).strict().refine((t) => t.state === "not-proven" === (t.why !== void 0), {
+  message: "gives a reason exactly when a check is not proven",
+  path: ["why"]
+});
+var workFindingOutcomeSchema = z14.object({
+  outcome: workOutcomeSchema,
+  reason: agentWorkText.optional(),
+  by: agentNameSchema
+}).strict().refine((o) => o.outcome === "fixed" === (o.reason === void 0), {
+  message: "a reason is given exactly when a finding is declined or deferred",
+  path: ["reason"]
+});
+var workFindingSchema = z14.object({
+  id: findingIdSchema,
+  kind: workFindingKindSchema,
+  says: agentWorkText,
+  outcome: workFindingOutcomeSchema.optional()
+}).strict();
+var workStageViewSchema = z14.object({
+  reviewer: agentNameSchema,
+  verdict: workVerdictSchema,
+  findings: z14.array(workFindingSchema).max(WORK_FINDINGS_MAX)
+}).strict();
+var workAttemptSchema = z14.object({
+  attempt: z14.number().int().min(1),
+  builder: agentNameSchema,
+  builderTier: crewTierSchema,
+  head: commitShaSchema,
+  retryReason: agentWorkText.optional(),
+  diagnosis: z14.string().uuid().optional(),
+  followsDiagnosis: z14.boolean().optional(),
+  asked: workStageViewSchema.optional(),
+  quality: workStageViewSchema.optional()
+}).strict();
+var workDiagnosisSchema = z14.object({
+  id: z14.string().uuid(),
+  afterAttempt: z14.number().int().min(2).max(WORK_ATTEMPT_LIMIT - 1),
+  by: agentNameSchema,
+  cause: diagnosisCauseSchema,
+  says: agentWorkText,
+  next: diagnosisNextSchema,
+  change: agentWorkText.optional(),
+  question: agentWorkText.optional(),
+  answer: agentWorkText.optional()
+}).strict().refine((d) => d.next === "different-way" === (d.change !== void 0), {
+  message: "says what will change exactly when the next step is to try a different way",
+  path: ["change"]
+}).refine((d) => d.next === "ask-person" === (d.question !== void 0), {
+  message: "carries a question exactly when the next step is to ask the person",
+  path: ["question"]
+});
+var workCallSchema = z14.object({
+  subject: workSubjectSchema,
+  by: agentNameSchema,
+  kind: callKindSchema,
+  question: agentWorkText,
+  chose: agentWorkText,
+  statedDefault: agentWorkText,
+  undoable: callUndoableSchema,
+  how: agentWorkText.nullable(),
+  at: utcIso8601
+}).strict().superRefine((c, ctx) => checkReadCallHow(c, ctx));
+function checkReadCallHow(c, ctx) {
+  if (c.undoable === "yes" !== (c.how !== null)) {
+    ctx.addIssue({ code: "custom", path: ["how"], message: "says how to undo it exactly when it can be undone" });
+  }
+}
+var workTaskViewSchema = z14.object({
+  task: buildTaskIdSchema,
+  standing: workStandingSchema,
+  attempts: z14.array(workAttemptSchema),
+  diagnoses: z14.array(workDiagnosisSchema),
+  tests: z14.array(workTestSchema)
+}).strict();
+var WORK_CLAIM_ACTS = Object.freeze(["accept", "reject"]);
+var workClaimActSchema = z14.enum(WORK_CLAIM_ACTS);
+var workClaimAnswerSchema = z14.object({
+  act: workClaimActSchema,
+  note: z14.string().min(1).max(SCOPE_NOTE_MAX).nullable()
+}).strict().refine((a) => a.act === "reject" === (a.note !== null), {
+  message: "carries the owner's note exactly on a reject",
+  path: ["note"]
+});
+var workUncheckedClaimSchema = z14.object({
+  task: buildTaskIdSchema,
+  label: agentWorkText,
+  head: commitShaSchema,
+  claimedBy: agentNameSchema,
+  answer: workClaimAnswerSchema.nullable()
+}).strict();
+var phaseWorkSchema = z14.object({
+  phase: buildPhaseSchema,
+  tasks: z14.array(workTaskViewSchema),
+  calls: z14.array(workCallSchema),
+  uncheckedClaims: z14.array(workUncheckedClaimSchema)
+}).strict();
+
+// ../events/dist/crew.js
+import { z as z15 } from "zod";
+var crewGroupSchema = z15.enum(["analyst-architect", "builder", "reviewer", "lead"]);
+var CREW_DISCIPLINE_MAX = 64;
+var crewFaceHeadSchema = z15.enum(["sq", "sqr", "rnd", "dome", "hex", "gable"]);
+var crewFaceAntennaSchema = z15.enum(["none", "stalk", "twin", "dish"]);
+var crewFaceEyesSchema = z15.enum(["dots", "bars", "visor", "cyclops"]);
+var crewFaceMouthSchema = z15.enum(["line", "grid", "dots", "wave"]);
+var crewFaceSchema = z15.object({
+  // The outline of the head. Members who do the same kind of work share one, so a
+  // team is recognisable before any name is read.
+  head: crewFaceHeadSchema,
+  // What sits on top of the head, if anything.
+  antenna: crewFaceAntennaSchema,
+  // The eyes.
+  eyes: crewFaceEyesSchema,
+  // The mouth.
+  mouth: crewFaceMouthSchema,
+  // Whether this member is drawn with ears.
+  ears: z15.boolean()
+}).strict();
+var crewRoleSchema = z15.enum([
+  "business-analyst",
+  "architect",
+  "spec-writer",
+  "builder",
+  "context-docs",
+  "spec-reviewer",
+  "code-test-reviewer",
+  "delivery-lead",
+  "quality-lead"
+]);
+var crewMemberSchema = z15.object({
+  // The agent's name. The same names on every project, so a name is a
+  // vocabulary a returning client already knows.
+  callsign: z15.string().min(1).max(32),
+  // Which of the four teams this member belongs to.
+  group: crewGroupSchema,
+  // The part this member plays, which decides the stages it leads and helps with.
+  role: crewRoleSchema,
+  // The kind of work this member takes. A task names a discipline, and only
+  // agents holding it can be dispatched to it.
+  discipline: z15.string().min(1).max(CREW_DISCIPLINE_MAX),
+  // How much thinking this member brings. There is no field naming the supplier
+  // behind it, on this shape or on any other.
+  tier: crewTierSchema,
+  // How this member's face is drawn. The same face on every project, so a
+  // returning client recognises a member before reading the name.
+  face: crewFaceSchema
+}).strict();
+var CREW_ROSTER = [
+  // ── analysts and architects ─────────────────────────────────────────────────
+  {
+    callsign: "SOFIA",
+    group: "analyst-architect",
+    role: "business-analyst",
+    discipline: "business analyst",
+    tier: "deep",
+    face: { head: "gable", antenna: "stalk", eyes: "dots", mouth: "wave", ears: false }
+  },
+  {
+    callsign: "BEA",
+    group: "analyst-architect",
+    role: "business-analyst",
+    discipline: "business analyst",
+    tier: "standard",
+    face: { head: "gable", antenna: "none", eyes: "visor", mouth: "line", ears: false }
+  },
+  {
+    callsign: "WREN",
+    group: "analyst-architect",
+    role: "architect",
+    discipline: "solution architect",
+    tier: "deep",
+    face: { head: "gable", antenna: "dish", eyes: "bars", mouth: "line", ears: true }
+  },
+  {
+    callsign: "PEI",
+    group: "analyst-architect",
+    role: "architect",
+    discipline: "technical architect",
+    tier: "standard",
+    face: { head: "gable", antenna: "twin", eyes: "cyclops", mouth: "dots", ears: false }
+  },
+  // ── builders: code ──────────────────────────────────────────────────────────
+  {
+    callsign: "ADA",
+    group: "builder",
+    role: "builder",
+    discipline: "implementation",
+    tier: "deep",
+    face: { head: "sq", antenna: "stalk", eyes: "dots", mouth: "line", ears: false }
+  },
+  {
+    callsign: "OTTO",
+    group: "builder",
+    role: "builder",
+    discipline: "implementation",
+    tier: "deep",
+    face: { head: "sq", antenna: "twin", eyes: "bars", mouth: "grid", ears: true }
+  },
+  {
+    callsign: "MILO",
+    group: "builder",
+    role: "builder",
+    discipline: "implementation",
+    tier: "standard",
+    face: { head: "sqr", antenna: "stalk", eyes: "dots", mouth: "dots", ears: false }
+  },
+  {
+    callsign: "NOVA",
+    group: "builder",
+    role: "builder",
+    discipline: "implementation",
+    tier: "standard",
+    face: { head: "sq", antenna: "dish", eyes: "cyclops", mouth: "line", ears: false }
+  },
+  {
+    callsign: "HUGO",
+    group: "builder",
+    role: "builder",
+    discipline: "infrastructure",
+    tier: "standard",
+    face: { head: "sq", antenna: "twin", eyes: "dots", mouth: "grid", ears: true }
+  },
+  // ── builders: specs and docs ────────────────────────────────────────────────
+  {
+    callsign: "IRIS",
+    group: "builder",
+    role: "spec-writer",
+    discipline: "feature spec",
+    tier: "deep",
+    face: { head: "dome", antenna: "stalk", eyes: "visor", mouth: "line", ears: false }
+  },
+  {
+    callsign: "JUNO",
+    group: "builder",
+    role: "spec-writer",
+    discipline: "feature spec",
+    tier: "standard",
+    face: { head: "dome", antenna: "none", eyes: "dots", mouth: "wave", ears: false }
+  },
+  {
+    callsign: "LEX",
+    group: "builder",
+    role: "context-docs",
+    discipline: "context & docs",
+    tier: "fast",
+    face: { head: "dome", antenna: "twin", eyes: "bars", mouth: "dots", ears: false }
+  },
+  // ── reviewers ───────────────────────────────────────────────────────────────
+  {
+    callsign: "VERA",
+    group: "reviewer",
+    role: "spec-reviewer",
+    discipline: "spec consistency",
+    tier: "deep",
+    face: { head: "rnd", antenna: "stalk", eyes: "visor", mouth: "line", ears: false }
+  },
+  {
+    callsign: "ODIN",
+    group: "reviewer",
+    role: "spec-reviewer",
+    discipline: "cross-spec audit",
+    tier: "deep",
+    face: { head: "rnd", antenna: "dish", eyes: "cyclops", mouth: "line", ears: false }
+  },
+  {
+    callsign: "CASS",
+    group: "reviewer",
+    role: "code-test-reviewer",
+    discipline: "code review",
+    tier: "deep",
+    face: { head: "rnd", antenna: "none", eyes: "visor", mouth: "grid", ears: true }
+  },
+  {
+    callsign: "THEO",
+    group: "reviewer",
+    role: "code-test-reviewer",
+    discipline: "code review",
+    tier: "standard",
+    face: { head: "rnd", antenna: "twin", eyes: "bars", mouth: "line", ears: false }
+  },
+  {
+    callsign: "KAI",
+    group: "reviewer",
+    role: "code-test-reviewer",
+    discipline: "code review",
+    tier: "standard",
+    face: { head: "rnd", antenna: "none", eyes: "bars", mouth: "line", ears: true }
+  },
+  {
+    callsign: "ECHO",
+    group: "reviewer",
+    role: "code-test-reviewer",
+    discipline: "test quality",
+    tier: "standard",
+    face: { head: "rnd", antenna: "stalk", eyes: "dots", mouth: "wave", ears: false }
+  },
+  {
+    callsign: "MAVIS",
+    group: "reviewer",
+    role: "code-test-reviewer",
+    discipline: "suites & coverage",
+    tier: "standard",
+    face: { head: "rnd", antenna: "none", eyes: "visor", mouth: "dots", ears: false }
+  },
+  {
+    callsign: "ZARA",
+    group: "reviewer",
+    role: "code-test-reviewer",
+    discipline: "smoke & walk aid",
+    tier: "standard",
+    face: { head: "rnd", antenna: "dish", eyes: "bars", mouth: "wave", ears: false }
+  },
+  {
+    callsign: "NORA",
+    group: "reviewer",
+    role: "code-test-reviewer",
+    discipline: "evidence & provenance",
+    tier: "fast",
+    face: { head: "rnd", antenna: "twin", eyes: "dots", mouth: "line", ears: false }
+  },
+  // ── leads ───────────────────────────────────────────────────────────────────
+  {
+    callsign: "ARGUS",
+    group: "lead",
+    role: "quality-lead",
+    discipline: "quality lead \xB7 every diff",
+    tier: "standard",
+    face: { head: "hex", antenna: "dish", eyes: "visor", mouth: "grid", ears: true }
+  },
+  {
+    callsign: "ATLAS",
+    group: "lead",
+    role: "delivery-lead",
+    discipline: "delivery lead",
+    tier: "deep",
+    face: { head: "hex", antenna: "twin", eyes: "cyclops", mouth: "line", ears: true }
+  }
+];
+var CREW_ROSTER_SIZE = CREW_ROSTER.length;
+var CREW_CALLSIGNS = CREW_ROSTER.map((member) => member.callsign);
+var crewLayerSchema = methodLayerSchema.extract(["l0", "l1", "l2", "l3", "l4", "l5"]);
+var crewRoleLayersSchema = z15.object({
+  leads: z15.array(crewLayerSchema),
+  helps: z15.array(crewLayerSchema)
 }).strict();
-var observeRunResultSchema = z12.discriminatedUnion("outcome", [
-  observeRunRecordedSchema,
-  observeRunKeptSchema,
-  observeRunNotSentSchema
+
+// ../events/dist/build-record-v3.js
+import { z as z18 } from "zod";
+
+// ../events/dist/board-vocabulary.js
+import { z as z16 } from "zod";
+var boardStepStateSchema = z16.enum([
+  "not-instrumented",
+  "done",
+  "did-not-pass",
+  "could-not-complete",
+  "not-yet-available",
+  "qualified"
 ]);
-var observedChecksFiredSchema = z12.array(z12.string().min(1)).refine((names) => names.every((name, i) => i === 0 || names[i - 1] < name), {
-  message: "must be sorted, each name once"
-});
-var observedCountingSchema = z12.discriminatedUnion("state", [
-  z12.object({
-    state: z12.literal("counted"),
-    startCommit: closeCommitSchema,
-    startRecordedAt: utcIso8601,
-    headCommit: closeCommitSchema,
-    headCommittedAt: utcIso8601,
-    commits: observedCountSchema,
-    countedAt: utcIso8601
-  }).strict(),
-  z12.object({
-    state: z12.literal("not-counted-yet"),
-    startCommit: closeCommitSchema,
-    startRecordedAt: utcIso8601
-  }).strict(),
-  z12.object({
-    state: z12.literal("cannot-count")
-  }).strict()
+var boardGateNameSchema = z16.enum([
+  "scope",
+  "architecture",
+  "specs",
+  "taskgraph",
+  "phase-close"
 ]);
-var observedPartSchema = z12.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 = z12.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 = z12.object({
-  phase: phaseNameSchema,
-  counting: observedCountingSchema,
-  descriptionVersion: observedDescriptionVersionSchema.nullable(),
-  parts: z12.array(observedPartSchema).max(SYSTEM_PARTS_MAX),
-  methodFiles: observedMethodFilesSchema.nullable(),
-  outsideEveryPart: observedOutsideSchema,
-  codeLink: codeLinkFactsSchema.nullable()
-}).strict().superRefine((v, ctx) => {
-  checkPartsUnique(v.parts, ctx, ["parts"]);
-  const counted2 = v.counting.state === "counted";
-  const rule = counted2 ? "must be present when the phase is counted" : "must be null until the phase is counted";
-  if (v.methodFiles !== null !== counted2)
-    ctx.addIssue({ code: "custom", path: ["methodFiles"], message: rule });
-  if (v.outsideEveryPart.files !== null !== counted2) {
-    ctx.addIssue({ code: "custom", path: ["outsideEveryPart", "files"], message: rule });
-  }
-  if (v.codeLink !== null !== counted2)
-    ctx.addIssue({ code: "custom", path: ["codeLink"], message: rule });
-  v.parts.forEach((entry, i) => {
-    if (entry.files !== null !== counted2)
-      ctx.addIssue({ code: "custom", path: ["parts", i, "files"], message: rule });
-  });
-  if (counted2 && v.descriptionVersion === null) {
-    ctx.addIssue({ code: "custom", path: ["descriptionVersion"], message: "must name the version the counts used" });
-  }
-});
-var partOutsideThePlanSchema = z12.object({
-  part: systemPartIdSchema,
-  name: systemPartSchema.shape.name,
-  seen: observedFilesSchema.nullable(),
-  tasks: z12.array(observedSaidSchema.extend({ id: buildTaskSchema.shape.id }).strict()).max(BUILD_SNAPSHOT_TASK_LIMIT)
-}).strict();
-function shortCommit(commit) {
-  return commit.slice(0, 7);
-}
 
 // ../events/dist/phase-review.js
-import { z as z13 } from "zod";
+import { z as z17 } from "zod";
 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 = z13.enum(REVIEW_ACTS);
+var reviewActSchema = z17.enum(REVIEW_ACTS);
 function reviewActsFor(built) {
   return built ? BUILT_PART_ACTS : NOT_BUILT_PART_ACTS;
 }
 var REVIEW_NOTE_MAX = SCOPE_NOTE_MAX;
-var reviewNoteWireSchema = z13.string().max(REVIEW_NOTE_MAX);
-var reviewNoteSchema = z13.string().min(1).max(REVIEW_NOTE_MAX);
+var reviewNoteWireSchema = z17.string().max(REVIEW_NOTE_MAX);
+var reviewNoteSchema = z17.string().min(1).max(REVIEW_NOTE_MAX);
 var REVIEW_ANSWER_MAX = 1e3;
-var reviewAgentAnswerSchema = z13.string().min(1).max(REVIEW_ANSWER_MAX);
+var reviewAgentAnswerSchema = z17.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 = z13.enum(REVIEW_PART_CHANGES);
+var reviewPartChangeSchema = z17.enum(REVIEW_PART_CHANGES);
 var REVIEW_DECISIONS = Object.freeze(["accepted", "carried", "dropped"]);
-var reviewDecisionSchema = z13.enum(REVIEW_DECISIONS);
+var reviewDecisionSchema = z17.enum(REVIEW_DECISIONS);
 function actOf(decision) {
   if (decision === "accepted")
     return "accept";
@@ -1853,10 +2293,10 @@ var reviewCarriedToSchema = carriedPhaseSchema.nullable();
 var reviewStepNameSchema = stepNameSchema.refine((v) => !stepIdSchema.safeParse(v.trim()).success, {
   message: "must be the step's plain name"
 });
-var reviewStepSchema = z13.object({
+var reviewStepSchema = z17.object({
   name: reviewStepNameSchema.nullable(),
   state: unfinishedStepSchema.shape.state,
-  judged: z13.boolean()
+  judged: z17.boolean()
 }).strict();
 function codeLinkLine(link) {
   switch (link.kind) {
@@ -1873,41 +2313,41 @@ function codeLinkLine(link) {
 function assertNever(value) {
   throw new Error(`unexpected value: ${JSON.stringify(value)}`);
 }
-var openReviewRequestSchema = z13.object({
+var openReviewRequestSchema = z17.object({
   actor: closeActorSchema,
   acceptanceOutcome: acceptanceOutcomeSchema,
   statements: closeStatementsSchema
 }).strict();
 var REVIEW_OPEN_TASKS_SHOWN_MAX = 10;
-var reviewOpenedSchema = z13.object({
-  outcome: z13.literal("opened"),
-  round: z13.number().int().min(1),
-  parts: z13.number().int().min(0).max(REVIEW_PARTS_MAX),
-  notBuilt: z13.number().int().min(0).max(REVIEW_PARTS_MAX),
-  counted: z13.boolean(),
-  typedReviewOffered: z13.boolean()
+var reviewOpenedSchema = z17.object({
+  outcome: z17.literal("opened"),
+  round: z17.number().int().min(1),
+  parts: z17.number().int().min(0).max(REVIEW_PARTS_MAX),
+  notBuilt: z17.number().int().min(0).max(REVIEW_PARTS_MAX),
+  counted: z17.boolean(),
+  typedReviewOffered: z17.boolean()
 }).strict().refine((v) => v.notBuilt <= v.parts, { message: "cannot exceed the parts in the round", path: ["notBuilt"] });
-var reviewTasksOpenSchema = z13.object({
-  outcome: z13.literal("tasks-open"),
-  open: z13.array(buildTaskSchema.shape.title).min(1).max(REVIEW_OPEN_TASKS_SHOWN_MAX),
-  more: z13.number().int().min(0).max(BUILD_SNAPSHOT_TASK_LIMIT)
+var reviewTasksOpenSchema = z17.object({
+  outcome: z17.literal("tasks-open"),
+  open: z17.array(buildTaskSchema.shape.title).min(1).max(REVIEW_OPEN_TASKS_SHOWN_MAX),
+  more: z17.number().int().min(0).max(BUILD_SNAPSHOT_TASK_LIMIT)
 }).strict();
-var reviewOutstandingSchema = z13.object({
-  outcome: z13.literal("outstanding"),
-  steps: z13.array(reviewStepSchema).min(1)
+var reviewOutstandingSchema = z17.object({
+  outcome: z17.literal("outstanding"),
+  steps: z17.array(reviewStepSchema).min(1)
 }).strict();
-var reviewCleanOverFindingsSchema = z13.object({
-  outcome: z13.literal("clean-over-findings"),
-  findings: z13.number().int().min(1)
+var reviewCleanOverFindingsSchema = z17.object({
+  outcome: z17.literal("clean-over-findings"),
+  findings: z17.number().int().min(1)
 }).strict();
-var reviewRefusedSchema = z13.object({
-  outcome: z13.literal("refused"),
-  problems: z13.array(systemDescriptionProblemSchema).min(1)
+var reviewRefusedSchema = z17.object({
+  outcome: z17.literal("refused"),
+  problems: z17.array(systemDescriptionProblemSchema).min(1)
 }).strict();
 function bareReviewOutcome(outcome) {
-  return z13.object({ outcome: z13.literal(outcome) }).strict();
+  return z17.object({ outcome: z17.literal(outcome) }).strict();
 }
-var openReviewResultSchema = z13.discriminatedUnion("outcome", [
+var openReviewResultSchema = z17.discriminatedUnion("outcome", [
   reviewOpenedSchema,
   reviewTasksOpenSchema,
   bareReviewOutcome("no-build"),
@@ -1917,23 +2357,33 @@ var openReviewResultSchema = z13.discriminatedUnion("outcome", [
   reviewRefusedSchema,
   bareReviewOutcome("unavailable")
 ]);
-var reviewPhaseNotOpenSchema = z13.object({
-  statusCode: z13.literal(409),
-  error: z13.literal("PhaseNotOpen"),
-  message: z13.string().min(1),
-  openPhase: z13.string().nullable()
+var reviewPhaseNotOpenSchema = z17.object({
+  statusCode: z17.literal(409),
+  error: z17.literal("PhaseNotOpen"),
+  message: z17.string().min(1),
+  openPhase: z17.string().nullable()
 }).strict();
-var openReviewAnswerSchema = z13.union([openReviewResultSchema, reviewPhaseNotOpenSchema]);
-var reviewDecisionEntrySchema = z13.object({
+var openReviewAnswerSchema = z17.union([openReviewResultSchema, reviewPhaseNotOpenSchema]);
+var reviewDecisionEntrySchema = z17.object({
   part: systemPartIdSchema,
   act: reviewActSchema,
   note: reviewNoteWireSchema.optional()
 }).strict();
-var reviewDecisionRequestSchema = z13.object({
-  reviewVersion: z13.number().int().min(0),
-  decisions: z13.array(reviewDecisionEntrySchema).max(REVIEW_PARTS_MAX)
+var reviewClaimActSchema = workClaimActSchema;
+var REVIEW_CLAIMS_MAX = BUILD_SNAPSHOT_TASK_LIMIT * WORK_CLAIM_CHECKS_MAX;
+var reviewClaimAnswerSchema = z17.object({
+  task: buildTaskIdSchema,
+  label: agentWorkText,
+  head: commitShaSchema,
+  act: reviewClaimActSchema,
+  note: reviewNoteWireSchema.optional()
+}).strict();
+var reviewDecisionRequestSchema = z17.object({
+  reviewVersion: z17.number().int().min(0),
+  decisions: z17.array(reviewDecisionEntrySchema).max(REVIEW_PARTS_MAX),
+  claims: z17.array(reviewClaimAnswerSchema).max(REVIEW_CLAIMS_MAX)
 }).strict();
-var reviewDecidedSchema = z13.object({
+var reviewDecidedSchema = z17.object({
   part: systemPartIdSchema,
   name: systemPartSchema.shape.name,
   act: reviewActSchema,
@@ -1942,39 +2392,51 @@ var reviewDecidedSchema = z13.object({
   message: "is present exactly on a carry",
   path: ["carriedTo"]
 });
-var reviewRecordedSchema = z13.object({
-  outcome: z13.literal("recorded"),
-  decided: z13.array(reviewDecidedSchema).max(REVIEW_PARTS_MAX),
-  waiting: z13.number().int().min(0).max(REVIEW_PARTS_MAX),
-  closed: z13.boolean(),
-  reviewVersion: z13.number().int().min(1)
+var reviewRecordedSchema = z17.object({
+  outcome: z17.literal("recorded"),
+  decided: z17.array(reviewDecidedSchema).max(REVIEW_PARTS_MAX),
+  waiting: z17.number().int().min(0).max(REVIEW_PARTS_MAX),
+  closed: z17.boolean(),
+  reviewVersion: z17.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 = z13.object({
+var reviewNotDecidablePartSchema = z17.object({
   part: systemPartIdSchema,
   name: systemPartSchema.shape.name,
-  why: z13.enum(REVIEW_NOT_DECIDABLE_WHY)
+  why: z17.enum(REVIEW_NOT_DECIDABLE_WHY)
+}).strict();
+var REVIEW_CLAIM_NOT_DECIDABLE_WHY = Object.freeze(["not-unchecked", "answered", "claim-changed"]);
+var reviewClaimNotDecidableWhySchema = z17.enum(REVIEW_CLAIM_NOT_DECIDABLE_WHY);
+var reviewNotDecidableClaimSchema = z17.object({
+  task: buildTaskIdSchema,
+  label: agentWorkText,
+  why: reviewClaimNotDecidableWhySchema
 }).strict();
-var reviewNotDecidableSchema = z13.object({
-  outcome: z13.literal("not-decidable"),
-  parts: z13.array(reviewNotDecidablePartSchema).min(1).max(REVIEW_PARTS_MAX)
+var reviewNotDecidableSchema = z17.object({
+  outcome: z17.literal("not-decidable"),
+  parts: z17.array(reviewNotDecidablePartSchema).max(REVIEW_PARTS_MAX),
+  claims: z17.array(reviewNotDecidableClaimSchema).max(REVIEW_CLAIMS_MAX)
+}).strict().refine((v) => v.parts.length + v.claims.length > 0, {
+  message: "names at least one part or claim",
+  path: ["parts"]
+});
+var reviewPartsNotDecidableSchema = z17.object({
+  outcome: z17.literal("not-decidable"),
+  parts: z17.array(reviewNotDecidablePartSchema).min(1).max(REVIEW_PARTS_MAX)
 }).strict();
-var reviewCloseRefusedSchema = z13.object({
-  outcome: z13.literal("close-refused"),
-  steps: z13.array(reviewStepSchema)
+var reviewCloseRefusedSchema = z17.object({
+  outcome: z17.literal("close-refused"),
+  steps: z17.array(reviewStepSchema)
 }).strict();
-var reviewWalkChangedSchema = z13.object({
-  outcome: z13.literal("walk-changed"),
-  findings: z13.number().int().min(1)
+var reviewWalkChangedSchema = z17.object({
+  outcome: z17.literal("walk-changed"),
+  findings: z17.number().int().min(1)
 }).strict();
-var reviewDecisionResultSchema = z13.discriminatedUnion("outcome", [
+var reviewDecisionResultSchema = z17.discriminatedUnion("outcome", [
   reviewRecordedSchema,
   bareReviewOutcome("review-changed"),
   bareReviewOutcome("no-review"),
@@ -1986,33 +2448,33 @@ var reviewDecisionResultSchema = z13.discriminatedUnion("outcome", [
   reviewRefusedSchema,
   bareReviewOutcome("unavailable")
 ]);
-var reviewSentBackSchema = z13.object({
-  round: z13.number().int().min(1),
+var reviewSentBackSchema = z17.object({
+  round: z17.number().int().min(1),
   note: reviewNoteSchema
 }).strict();
-var reviewQuestionSchema = z13.object({
+var reviewQuestionSchema = z17.object({
   question: reviewNoteSchema,
   agentAnswer: reviewAgentAnswerSchema.optional()
 }).strict();
-var reviewTaskSchema = z13.object({
+var reviewTaskSchema = z17.object({
   title: buildTaskSchema.shape.title,
   state: buildTaskStateSchema
 }).strict();
-var reviewViewPartSchema = z13.object({
+var reviewViewPartSchema = z17.object({
   part: systemPartIdSchema,
   name: systemPartSchema.shape.name,
   change: reviewPartChangeSchema,
-  built: z13.boolean(),
-  builtWithoutApproval: z13.boolean(),
-  decidable: z13.boolean(),
-  waiting: z13.boolean(),
+  built: z17.boolean(),
+  builtWithoutApproval: z17.boolean(),
+  decidable: z17.boolean(),
+  waiting: z17.boolean(),
   decision: reviewDecisionSchema.optional(),
   reason: reviewNoteSchema.optional(),
   carriedTo: reviewCarriedToSchema.optional(),
-  sentBack: z13.array(reviewSentBackSchema),
-  questions: z13.array(reviewQuestionSchema),
-  tasks: z13.array(reviewTaskSchema).max(BUILD_SNAPSHOT_TASK_LIMIT),
-  said: z13.array(observedSaidSchema).max(BUILD_SNAPSHOT_TASK_LIMIT),
+  sentBack: z17.array(reviewSentBackSchema),
+  questions: z17.array(reviewQuestionSchema),
+  tasks: z17.array(reviewTaskSchema).max(BUILD_SNAPSHOT_TASK_LIMIT),
+  said: z17.array(observedSaidSchema).max(BUILD_SNAPSHOT_TASK_LIMIT),
   codeLink: partCodeLinkSchema
 }).strict().superRefine((v, ctx) => {
   if (v.waiting !== (v.decision === void 0)) {
@@ -2035,29 +2497,29 @@ var reviewViewPartSchema = z13.object({
     ctx.addIssue({ code: "custom", path: ["built"], message: "is always true for a part outside the plan" });
   }
 });
-var reviewPhaseNumberSchema = z13.number().int().min(1).nullable();
-var phaseReviewNoneSchema = z13.object({
-  state: z13.literal("none"),
+var reviewPhaseNumberSchema = z17.number().int().min(1).nullable();
+var phaseReviewNoneSchema = z17.object({
+  state: z17.literal("none"),
   phase: scopePhaseSchema,
   number: reviewPhaseNumberSchema,
-  closedWithoutReview: z13.boolean()
+  closedWithoutReview: z17.boolean()
 }).strict();
-var reviewWalkSchema = z13.object({
+var reviewWalkSchema = z17.object({
   verdict: walkVerdictSchema,
-  findings: z13.number().int().min(0)
+  findings: z17.number().int().min(0)
 }).strict();
 function reviewedViewSchema(state) {
-  return z13.object({
-    state: z13.literal(state),
+  return z17.object({
+    state: z17.literal(state),
     phase: scopePhaseSchema,
     number: reviewPhaseNumberSchema,
-    cycle: z13.number().int().min(0),
-    round: z13.number().int().min(1),
-    reviewVersion: z13.number().int().min(1),
-    typedReviewOffered: z13.boolean(),
-    counted: z13.boolean(),
+    cycle: z17.number().int().min(0),
+    round: z17.number().int().min(1),
+    reviewVersion: z17.number().int().min(1),
+    typedReviewOffered: z17.boolean(),
+    counted: z17.boolean(),
     walk: reviewWalkSchema,
-    parts: z13.array(reviewViewPartSchema).max(REVIEW_PARTS_MAX),
+    parts: z17.array(reviewViewPartSchema).max(REVIEW_PARTS_MAX),
     observed: observedChangesSchema.nullable(),
     description: systemDescriptionSchema
   }).strict().superRefine((v, ctx) => {
@@ -2085,7 +2547,7 @@ function reviewedViewSchema(state) {
 }
 var phaseReviewOpenSchema = reviewedViewSchema("open");
 var phaseReviewClosedSchema = reviewedViewSchema("closed");
-var phaseReviewViewSchema = z13.discriminatedUnion("state", [
+var phaseReviewViewSchema = z17.discriminatedUnion("state", [
   phaseReviewNoneSchema,
   phaseReviewOpenSchema,
   phaseReviewClosedSchema
@@ -2093,45 +2555,45 @@ var phaseReviewViewSchema = z13.discriminatedUnion("state", [
 
 // ../events/dist/build-record-v3.js
 var BUILD_RECORD_V3_FORMAT = "halfcycle-build-record/v3";
-var recordRoundStatedSchema = z14.object({
+var recordRoundStatedSchema = z18.object({
   actor: attestedCloseSchema.shape.actor,
   statements: attestedStatementsSchema
 }).strict();
-var recordReviewRoundSchema = z14.object({
-  round: z14.number().int().min(1),
+var recordReviewRoundSchema = z18.object({
+  round: z18.number().int().min(1),
   openedAt: utcIso8601,
   verdict: walkVerdictSchema,
-  findings: z14.number().int().min(0),
+  findings: z18.number().int().min(0),
   stated: recordRoundStatedSchema.optional()
 }).strict();
-var recordReviewApprovalSchema = z14.discriminatedUnion("kind", [
-  z14.object({
-    kind: z14.literal("approved"),
+var recordReviewApprovalSchema = z18.discriminatedUnion("kind", [
+  z18.object({
+    kind: z18.literal("approved"),
     planVersion: planVersionSchema,
     givenIn: scopeGivenInSchema,
     approvedAt: utcIso8601
   }).strict(),
-  z14.object({ kind: z14.literal("none") }).strict()
+  z18.object({ kind: z18.literal("none") }).strict()
 ]);
-var recordReviewGateSchema = z14.object({
+var recordReviewGateSchema = z18.object({
   gate: boardGateNameSchema,
   state: boardStepStateSchema
 }).strict();
-var recordReviewQuestionSchema = z14.object({
+var recordReviewQuestionSchema = z18.object({
   question: reviewNoteSchema,
   agentAnswer: reviewAgentAnswerSchema
 }).strict();
-var recordReviewPartSchema = z14.object({
+var recordReviewPartSchema = z18.object({
   part: systemPartIdSchema,
   name: systemPartSchema.shape.name,
   change: reviewPartChangeSchema,
-  built: z14.boolean(),
-  builtWithoutApproval: z14.boolean(),
+  built: z18.boolean(),
+  builtWithoutApproval: z18.boolean(),
   decision: reviewDecisionSchema,
   reason: reviewNoteSchema.optional(),
   carriedTo: reviewCarriedToSchema.optional(),
-  sentBack: z14.array(reviewSentBackSchema),
-  questions: z14.array(recordReviewQuestionSchema),
+  sentBack: z18.array(reviewSentBackSchema),
+  questions: z18.array(recordReviewQuestionSchema),
   codeLink: partCodeLinkSchema
 }).strict().superRefine((v, ctx) => {
   const carriedOrDropped = v.decision === "carried" || v.decision === "dropped";
@@ -2143,23 +2605,24 @@ var recordReviewPartSchema = z14.object({
   }
 });
 var SPINE_ORDER = boardGateNameSchema.options;
-var recordReviewGatesSchema = z14.array(recordReviewGateSchema).superRefine((gates, ctx) => {
+var recordReviewGatesSchema = z18.array(recordReviewGateSchema).superRefine((gates, ctx) => {
   const inOrder = gates.length === SPINE_ORDER.length && gates.every((g, i) => g.gate === SPINE_ORDER[i]);
   if (!inOrder) {
     ctx.addIssue({ code: "custom", message: `must be exactly the five checkpoints in order: ${SPINE_ORDER.join(", ")}` });
   }
 });
-var recordReviewSchema = z14.object({
-  sequence: z14.number().int().min(1),
-  cycle: z14.number().int().min(0),
-  rounds: z14.array(recordReviewRoundSchema).min(1),
+var recordReviewSchema = z18.object({
+  sequence: z18.number().int().min(1),
+  cycle: z18.number().int().min(0),
+  rounds: z18.array(recordReviewRoundSchema).min(1),
   approval: recordReviewApprovalSchema,
   planVersion: planVersionSchema.nullable(),
   descriptionVersion: observedDescriptionVersionSchema,
   gates: recordReviewGatesSchema,
   observed: observedChangesSchema.nullable(),
-  parts: z14.array(recordReviewPartSchema).max(REVIEW_PARTS_MAX)
-}).strict().superRefine((v, ctx) => {
+  parts: z18.array(recordReviewPartSchema).max(REVIEW_PARTS_MAX)
+}).strict().superRefine((v, ctx) => checkRecordReview(v, ctx));
+function checkRecordReview(v, ctx) {
   v.rounds.forEach((r, i) => {
     if (r.round !== i + 1) {
       ctx.addIssue({ code: "custom", path: ["rounds", i, "round"], message: "rounds must be numbered 1, 2, 3 \u2026 in order with no gap" });
@@ -2177,12 +2640,13 @@ var recordReviewSchema = z14.object({
       ctx.addIssue({ code: "custom", path: ["parts", i, "codeLink"], message: "must be none when nothing was observed" });
     }
   });
-});
-var buildRecordV3Schema = z14.object({
+}
+var buildRecordV3Schema = z18.object({
   ...buildRecordV2Schema.shape,
-  format: z14.literal(BUILD_RECORD_V3_FORMAT),
+  format: z18.literal(BUILD_RECORD_V3_FORMAT),
   review: recordReviewSchema
-}).strict().superRefine((record2, ctx) => {
+}).strict().superRefine((record2, ctx) => checkReviewedRecord(record2, ctx));
+function checkReviewedRecord(record2, ctx) {
   checkRecordHalves(record2, ctx);
   const closes = record2.observed.closes;
   const newest = closes[closes.length - 1].sequence;
@@ -2208,24 +2672,11 @@ var buildRecordV3Schema = z14.object({
   if (record2.review.observed !== null && record2.review.observed.phase !== record2.phase) {
     ctx.addIssue({ code: "custom", path: ["review", "observed", "phase"], message: "must be this record's phase" });
   }
-});
-var buildRecordSchema = z14.discriminatedUnion("format", [buildRecordV2Schema, buildRecordV3Schema]);
-function removalsOf(record2) {
-  if (record2.format !== BUILD_RECORD_V3_FORMAT)
-    return [];
-  const out = [];
-  for (const p of record2.review.parts) {
-    if (p.change === "add" && p.decision === "dropped")
-      out.push({ part: p.part, name: p.name, act: "dropped" });
-    else if (p.change === "remove" && p.decision === "accepted")
-      out.push({ part: p.part, name: p.name, act: "removed" });
-  }
-  return out;
 }
 
 // ../events/dist/device-auth.js
-import { z as z15 } from "zod";
-var utcIso86012 = z15.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");
+import { z as z19 } from "zod";
+var utcIso86012 = z19.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 = {
   /** The poll: minted, nobody has acted yet. Keep polling. 200. */
   PENDING: "pending",
@@ -2266,25 +2717,25 @@ var DEVICE_POLL_REFUSALS = [
   DEVICE_AUTH_STATUS.EXPIRED,
   DEVICE_AUTH_STATUS.UNKNOWN
 ];
-var deviceAuthStartResponseSchema = z15.object({
-  deviceCode: z15.string().min(1),
-  userCode: z15.string().min(1),
-  verificationUrl: z15.string().min(1),
+var deviceAuthStartResponseSchema = z19.object({
+  deviceCode: z19.string().min(1),
+  userCode: z19.string().min(1),
+  verificationUrl: z19.string().min(1),
   expiresAt: utcIso86012,
-  pollIntervalMs: z15.number().int().positive()
+  pollIntervalMs: z19.number().int().positive()
 }).strict();
-var devicePollPendingSchema = z15.object({
-  status: z15.literal(DEVICE_AUTH_STATUS.PENDING),
-  pollIntervalMs: z15.number().int().positive()
+var devicePollPendingSchema = z19.object({
+  status: z19.literal(DEVICE_AUTH_STATUS.PENDING),
+  pollIntervalMs: z19.number().int().positive()
 }).strict();
-var devicePollApprovedSchema = z15.object({
-  status: z15.literal(DEVICE_AUTH_STATUS.APPROVED),
-  accountId: z15.string().min(1),
-  credential: z15.string().min(1),
+var devicePollApprovedSchema = z19.object({
+  status: z19.literal(DEVICE_AUTH_STATUS.APPROVED),
+  accountId: z19.string().min(1),
+  credential: z19.string().min(1),
   expiresAt: utcIso86012
 }).strict();
-var deviceAuthRefusalSchema = z15.object({
-  status: z15.enum([
+var deviceAuthRefusalSchema = z19.object({
+  status: z19.enum([
     DEVICE_AUTH_STATUS.DECLINED,
     DEVICE_AUTH_STATUS.EXPIRED,
     DEVICE_AUTH_STATUS.UNKNOWN,
@@ -2295,25 +2746,25 @@ var deviceAuthRefusalSchema = z15.object({
     DEVICE_AUTH_STATUS.ALREADY_DECIDED,
     DEVICE_AUTH_STATUS.TERMS_REQUIRED
   ]),
-  message: z15.string().min(1)
+  message: z19.string().min(1)
 }).strict();
-var devicePollResponseSchema = z15.union([
+var devicePollResponseSchema = z19.union([
   devicePollPendingSchema,
   devicePollApprovedSchema,
   deviceAuthRefusalSchema
 ]);
-var deviceConfirmRequestSchema = z15.object({
-  userCode: z15.string().min(1),
-  decision: z15.enum(["approve", "decline"]),
-  externalAuthId: z15.string().min(1).optional(),
-  email: z15.string().optional(),
-  acceptTerms: z15.boolean().optional()
+var deviceConfirmRequestSchema = z19.object({
+  userCode: z19.string().min(1),
+  decision: z19.enum(["approve", "decline"]),
+  externalAuthId: z19.string().min(1).optional(),
+  email: z19.string().optional(),
+  acceptTerms: z19.boolean().optional()
 }).strict();
-var deviceConfirmRecordedSchema = z15.object({
-  status: z15.literal(DEVICE_AUTH_STATUS.RECORDED),
-  accountId: z15.string().min(1).optional()
+var deviceConfirmRecordedSchema = z19.object({
+  status: z19.literal(DEVICE_AUTH_STATUS.RECORDED),
+  accountId: z19.string().min(1).optional()
 }).strict();
-var deviceConfirmResponseSchema = z15.union([
+var deviceConfirmResponseSchema = z19.union([
   deviceConfirmRecordedSchema,
   deviceAuthRefusalSchema
 ]);
@@ -2325,20 +2776,20 @@ function projectPageUrl(engagementId) {
 }
 
 // ../events/dist/credential-wire.js
-import { z as z16 } from "zod";
-var engagementCredentialResponseSchema = z16.object({
-  engagementId: z16.string(),
-  sessionToken: z16.string(),
-  mcpUrl: z16.string(),
-  guardUrl: z16.string(),
-  controlTelemetryUrl: z16.string(),
-  methodVersion: z16.string().optional(),
-  consoleUrl: z16.string().optional()
+import { z as z20 } from "zod";
+var engagementCredentialResponseSchema = z20.object({
+  engagementId: z20.string(),
+  sessionToken: z20.string(),
+  mcpUrl: z20.string(),
+  guardUrl: z20.string(),
+  controlTelemetryUrl: z20.string(),
+  methodVersion: z20.string().optional(),
+  consoleUrl: z20.string().optional()
 }).strict();
-var ciTokenExchangeResponseSchema = z16.object({
-  token: z16.string(),
+var ciTokenExchangeResponseSchema = z20.object({
+  token: z20.string(),
   expiresAt: utcIso8601,
-  engagementId: z16.string()
+  engagementId: z20.string()
 }).strict();
 var NO_CREDENTIAL_PLACEHOLDER = "halfcycle:no-credential";
 var NOT_THIS_ACCOUNT_PLACEHOLDER = "halfcycle:not-this-account";
@@ -2355,42 +2806,118 @@ var PLACEHOLDER_SENTENCES = Object.freeze({
 });
 
 // ../events/dist/phase-record.js
-import { z as z17 } from "zod";
-var phaseRecordRefusalReasonSchema = z17.enum([
+import { z as z22 } from "zod";
+
+// ../events/dist/build-record-v4.js
+import { z as z21 } from "zod";
+var BUILD_RECORD_V4_FORMAT = "halfcycle-build-record/v4";
+var recordReviewClaimSchema = z21.object({
+  ...reviewClaimAnswerSchema.shape,
+  note: reviewNoteSchema.nullable()
+}).strict().superRefine((c, ctx) => {
+  if (c.act === "accept" !== (c.note === null)) {
+    ctx.addIssue({ code: "custom", path: ["note"], message: "carries the owner's note exactly on a reject" });
+  }
+});
+var recordCallSchema = z21.object(workCallSchema.shape).omit({ at: true }).strict().superRefine((c, ctx) => checkReadCallHow(c, ctx));
+var recordReviewV4Schema = z21.object({
+  ...recordReviewSchema.shape,
+  claims: z21.array(recordReviewClaimSchema).max(REVIEW_CLAIMS_MAX),
+  calls: z21.array(recordCallSchema)
+}).strict().superRefine((v, ctx) => checkRecordReview(v, ctx));
+var buildRecordV4Schema = z21.object({
+  ...buildRecordV3Schema.shape,
+  format: z21.literal(BUILD_RECORD_V4_FORMAT),
+  path: phasePathSchema,
+  review: recordReviewV4Schema
+}).strict().superRefine((record2, ctx) => checkReviewedRecord(record2, ctx));
+var buildRecordSchema = z21.discriminatedUnion("format", [
+  buildRecordV2Schema,
+  buildRecordV3Schema,
+  buildRecordV4Schema
+]);
+var OWNER_REVIEW_FORMATS = Object.freeze([BUILD_RECORD_V3_FORMAT, BUILD_RECORD_V4_FORMAT]);
+function hasOwnerReview(record2) {
+  return OWNER_REVIEW_FORMATS.includes(record2.format);
+}
+function keptClaimsOf(record2) {
+  return record2.format === BUILD_RECORD_V4_FORMAT ? record2.review.claims : null;
+}
+function keptCallsOf(record2) {
+  return record2.format === BUILD_RECORD_V4_FORMAT ? record2.review.calls : null;
+}
+function keptPathOf(record2) {
+  return record2.format === BUILD_RECORD_V4_FORMAT ? record2.path : null;
+}
+function removalsOf(record2) {
+  if (!hasOwnerReview(record2))
+    return [];
+  const out = [];
+  for (const p of record2.review.parts) {
+    if (p.change === "add" && p.decision === "dropped")
+      out.push({ part: p.part, name: p.name, act: "dropped" });
+    else if (p.change === "remove" && p.decision === "accepted")
+      out.push({ part: p.part, name: p.name, act: "removed" });
+  }
+  return out;
+}
+
+// ../events/dist/phase-record.js
+var phaseRecordRefusalReasonSchema = z22.enum([
   "still-open",
   "reopened",
   "never-opened",
   "never-closed",
   "closed-before-records"
 ]);
-var phaseRecordRecordSchema = z17.object({
-  outcome: z17.literal("record"),
+var phaseRecordRecordSchema = z22.object({
+  outcome: z22.literal("record"),
   phase: phaseNameSchema,
   record: buildRecordSchema
 }).strict().refine((body) => body.record.phase === body.phase, {
   message: "the record is for a different phase than the one asked for",
   path: ["record", "phase"]
 });
-var phaseRecordWithheldSchema = z17.object({
-  outcome: z17.literal("withheld"),
+var phaseRecordWithheldSchema = z22.object({
+  outcome: z22.literal("withheld"),
   phase: phaseNameSchema,
-  sequence: z17.number().int().min(1),
+  sequence: z22.number().int().min(1),
   closedAt: utcIso8601,
-  message: z17.string()
+  message: z22.string()
 }).strict();
 var phaseRecordRefusedSchema = wireErrorSchema.extend({
-  outcome: z17.literal("refused"),
+  outcome: z22.literal("refused"),
   phase: phaseNameSchema,
-  statusCode: z17.literal(409),
-  error: z17.literal("PhaseRecordRefused"),
+  statusCode: z22.literal(409),
+  error: z22.literal("PhaseRecordRefused"),
   reason: phaseRecordRefusalReasonSchema
 }).strict();
-var phaseRecordResponseSchema = z17.discriminatedUnion("outcome", [
+var phaseRecordResponseSchema = z22.discriminatedUnion("outcome", [
   phaseRecordRecordSchema,
   phaseRecordWithheldSchema,
   phaseRecordRefusedSchema
 ]);
 
+// ../events/dist/work-words.js
+var CALLS_HEADING = "Calls made without asking you";
+var CALLS_EXPLAINED = "These are the decisions the agents recorded taking on their own, each against a stated default. Halfcycle lists what they recorded; it cannot see a call an agent did not record.";
+function callMadeLine(call) {
+  return `${call.by} decided "${call.question}": chose "${call.chose}". The stated default was "${call.statedDefault}".`;
+}
+function callUndoLine(call) {
+  return call.undoable === "yes" ? `${call.by} says this can be undone: "${call.how ?? ""}"` : `${call.by} says this cannot be undone.`;
+}
+var NO_CALLS_LINE = "No agent recorded a call made without asking in this phase.";
+var UNCHECKED_CLAIMS_HEADING = "Checks nobody ran";
+function claimSaidLine(claim) {
+  return `Task ${claim.task}: an agent said "${claim.label}" passes at commit ${claim.head}, and Halfcycle never ran it.`;
+}
+function recordedClaimLine(claim) {
+  const said = claimSaidLine(claim);
+  return claim.act === "accept" ? `${said} Accepted by the project's owner.` : `${said} Rejected by the project's owner: "${claim.note ?? ""}"`;
+}
+var NO_UNCHECKED_CLAIMS_LINE = "No agent said a check passes that Halfcycle never ran.";
+
 // dist/engagement-credential.js
 import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { platform as platform2 } from "node:os";
@@ -2860,8 +3387,12 @@ function parseManifest(text) {
     "eventsCreated",
     "hooksCreated",
     "permissionsCreated",
-    "denyCreated"
+    "denyCreated",
+    "statusLineSha256"
   ], '"settings"');
+  if (s["statusLineSha256"] !== void 0 && (typeof s["statusLineSha256"] !== "string" || !HEX64.test(s["statusLineSha256"]))) {
+    throw new UnreadableManifestError('"settings.statusLineSha256" is not a hash');
+  }
   const settings = {
     created: bool(s["created"], "settings.created"),
     adopted: bool(s["adopted"], "settings.adopted"),
@@ -2871,7 +3402,8 @@ function parseManifest(text) {
     eventsCreated: stringArray(s["eventsCreated"], "settings.eventsCreated"),
     hooksCreated: bool(s["hooksCreated"], "settings.hooksCreated"),
     permissionsCreated: bool(s["permissionsCreated"], "settings.permissionsCreated"),
-    denyCreated: bool(s["denyCreated"], "settings.denyCreated")
+    denyCreated: bool(s["denyCreated"], "settings.denyCreated"),
+    ...typeof s["statusLineSha256"] === "string" ? { statusLineSha256: s["statusLineSha256"] } : {}
   };
   let mcp;
   if (raw["mcp"] !== void 0) {
@@ -2949,6 +3481,7 @@ function recordSettings(draft, observed) {
     draft.settings = observed;
     return;
   }
+  const statusLineSha256 = observed.statusLineSha256 ?? prev.statusLineSha256;
   draft.settings = {
     created: prev.created,
     adopted: prev.adopted,
@@ -2958,7 +3491,8 @@ function recordSettings(draft, observed) {
     eventsCreated: union(prev.eventsCreated, observed.eventsCreated),
     hooksCreated: prev.hooksCreated,
     permissionsCreated: prev.permissionsCreated,
-    denyCreated: prev.denyCreated
+    denyCreated: prev.denyCreated,
+    ...statusLineSha256 !== void 0 ? { statusLineSha256 } : {}
   };
 }
 function recordDenyRetired(draft, hashes) {
@@ -3052,7 +3586,7 @@ function withoutHalfcycleCommands(entry, halfcycleCommands) {
   const remaining = entry.hooks.filter((h) => !isHalfcycleCommand(h, halfcycleCommands));
   return remaining.length > 0 ? { ...entry, hooks: remaining } : null;
 }
-function mergeSettings(existing, generated, retiredOurs) {
+function mergeSettings(existing, generated, retiredOurs, statusLine) {
   const merged = { ...existing };
   if (generated.$schema !== void 0) {
     merged.$schema = generated.$schema;
@@ -3075,6 +3609,9 @@ function mergeSettings(existing, generated, retiredOurs) {
   }
   merged.hooks = mergedHooks;
   merged.permissions = mergePermissions(existing.permissions, generated.permissions, retiredOurs);
+  if (statusLine !== void 0 && !("statusLine" in existing)) {
+    merged.statusLine = { ...statusLine };
+  }
   return merged;
 }
 function mergePermissions(existing, generated, retiredOurs) {
@@ -3284,7 +3821,8 @@ function closedWriteSet() {
       GITATTRIBUTES_HEADER,
       ...lfRules([...Object.keys(OWNED_GENERATED_HEADERS), ...RETIRED_WRITE_SET_FILES])
     ]),
-    generatedSha256: sha256OfWhatThisVersionWrites(commands)
+    generatedSha256: sha256OfWhatThisVersionWrites(commands),
+    statusLineSha256: /* @__PURE__ */ new Set([canonicalSha256(HALFCYCLE_STATUS_LINE)])
   };
 }
 function sha256OfWhatThisVersionWrites(commands) {
@@ -3319,7 +3857,7 @@ function noteFile(draft, targetRepo, rel, outcome) {
   }
   recordInstalledFile(draft, rel, readFileSync4(join5(targetRepo, rel)));
 }
-function recordSettingsMerge(draft, existing, generated, preexisted) {
+function recordSettingsMerge(draft, existing, generated, preexisted, merged) {
   const generatedHooks = generated.hooks ?? {};
   const hookCommands = Object.values(generatedHooks).flatMap((entries) => entries.flatMap((entry) => entry.hooks.map((h) => h.command)));
   const ours = /* @__PURE__ */ new Set([...hookCommands, ...HALFCYCLE_HOOK_COMMANDS]);
@@ -3336,9 +3874,16 @@ function recordSettingsMerge(draft, existing, generated, preexisted) {
     eventsCreated: Object.keys(generatedHooks).filter((event) => !(existingHooks && event in existingHooks)),
     hooksCreated: existing.hooks === void 0,
     permissionsCreated: existing.permissions === void 0,
-    denyCreated: existing.permissions?.deny === void 0
+    denyCreated: existing.permissions?.deny === void 0,
+    ...ourStatusLineSha256(merged) !== void 0 ? { statusLineSha256: ourStatusLineSha256(merged) } : {}
   });
 }
+function ourStatusLineSha256(settings) {
+  if (!("statusLine" in settings))
+    return void 0;
+  const hash = canonicalSha256(settings["statusLine"]);
+  return hash === canonicalSha256(HALFCYCLE_STATUS_LINE) ? hash : void 0;
+}
 function recordMcpMerge(draft, existingText, writtenText) {
   const before = existingText === null ? void 0 : JSON.parse(existingText);
   const servers = isPlainObject(before) ? before["mcpServers"] : void 0;
@@ -3589,6 +4134,29 @@ function settingsParseRefusal(targetRepo, err) {
   return `${file} could not be read as JSON${where} \u2014 fix it and run "npx halfcycle" again.`;
 }
 var SETTINGS_SCHEMA = "https://json.schemastore.org/claude-code-settings.json";
+var HALFCYCLE_STATUS_LINE = Object.freeze({
+  type: "command",
+  command: 'bash "$CLAUDE_PROJECT_DIR"/.claude/hooks/guard-runner.sh statusline'
+});
+function statusLineSetElsewhere(targetRepo, home = homedir2(), env = process.env) {
+  const places = [join5(targetRepo, ".claude", "settings.local.json"), join5(home, ".claude", "settings.json")];
+  const configDir = env["CLAUDE_CONFIG_DIR"];
+  if (configDir !== void 0 && configDir !== "") {
+    const expanded = configDir === "~" ? home : configDir.startsWith("~/") ? join5(home, configDir.slice(2)) : configDir;
+    places.push(join5(isAbsolute2(expanded) ? expanded : resolve(expanded), "settings.json"));
+  }
+  return places.some((path) => {
+    if (!existsSync3(path))
+      return false;
+    let value;
+    try {
+      value = JSON.parse(readFileSync4(path, "utf-8"));
+    } catch {
+      return true;
+    }
+    return !isPlainObject(value) || "statusLine" in value;
+  });
+}
 function generateSettingsJson() {
   const hooks = {};
   for (const { event, matcher, timeout, command } of HALFCYCLE_HOOK_WIRING) {
@@ -4050,7 +4618,7 @@ function generateMcpRegistration(existing, mcpOrigin) {
   };
   return JSON.stringify(base, null, 2) + "\n";
 }
-var REQUIRED_GITIGNORE_ENTRIES = [".halfcycle/state.json", `${ZONE_B_DIR}/`];
+var REQUIRED_GITIGNORE_ENTRIES = [".halfcycle/state.json", `${ZONE_B_DIR}/`, ".claude/worktrees/"];
 var GITIGNORE_HEADER = "# Halfcycle \u2014 machine-local secrets/state and Zone-B (never push to client remote)";
 function adoptBlockUnderHeader(before, header, claimable) {
   const claimed = [];
@@ -4323,9 +4891,10 @@ async function install(options) {
     throw new SettingsParseRefused(settingsParseRefusal(targetRepo, err));
   }
   const retiredOurs = retiredRulesThisInstallAdded(draft.previous);
-  recordSettingsMerge(draft, existingSettings, generatedSettings, settingsPreexisted);
+  const statusLine = statusLineSetElsewhere(targetRepo, home, options.env) ? void 0 : HALFCYCLE_STATUS_LINE;
+  const mergedSettings = mergeSettings(existingSettings, generatedSettings, retiredOurs, statusLine);
+  recordSettingsMerge(draft, existingSettings, generatedSettings, settingsPreexisted, mergedSettings);
   recordDenyRetired(draft, retiredOurs.map((rule) => sha256Hex(rule)));
-  const mergedSettings = mergeSettings(existingSettings, generatedSettings, retiredOurs);
   const mergedSettingsText = inLineEndingOf(readFileOrNull(settingsPath), JSON.stringify(mergedSettings, null, 2) + "\n");
   mkdirSync4(dirname3(settingsPath), { recursive: true });
   writeFileSync4(settingsPath, mergedSettingsText, "utf-8");
@@ -5248,6 +5817,10 @@ var HEADER_CHECKS = "Halfcycle's checks are automatic rules drawn from the ways
 var HEADER_KEPT = "Halfcycle derived this record and kept a copy of it when the phase closed. It changes that copy afterwards in one way only. If an account that closed this phase is later deleted, its email is removed, and so is the name given at any close Halfcycle recorded as made by that account. The client's Halfcycle command-line tool wrote this file from the kept copy, when the phase closed or when the record was fetched again. So a later deletion reaches this file the next time the record is fetched. The same record, as data, is in the .json file of the same name beside this one. If the phase is closed again, this file is replaced by a new record that describes every close, this one included.";
 var HEADER_HIDDEN = "Some text in this record contains characters that do not print. Each is shown as U+ and its code of four or more hex digits; the .json file holds the text exactly.";
 var OBSERVED_LABEL = "**Observed by Halfcycle**";
+var PATH_LINE = Object.freeze({
+  mini: "Path: mini phase",
+  full: "Path: full phase"
+});
 var STATED_LABEL = "**Stated by the client** \u2014 Halfcycle did not check these.";
 var MISMATCHED_HALVES = "This Build Record could not be written: its two parts describe different closes.";
 function renderChecks(checks, p) {
@@ -5495,6 +6068,30 @@ function renderReview(record2, p) {
     blocks.push(removals);
   return blocks;
 }
+function renderCalls(calls, p) {
+  if (calls.length === 0)
+    return [`## ${CALLS_HEADING}`, NO_CALLS_LINE];
+  const lines = calls.flatMap((c) => {
+    const by = p.itemStart(c.by);
+    return [
+      `- ${callMadeLine({ by, question: p.text(c.question), chose: p.text(c.chose), statedDefault: p.text(c.statedDefault) })}`,
+      `  - ${callUndoLine({ by: p.text(c.by), undoable: c.undoable, how: c.how === null ? null : p.text(c.how) })}`
+    ];
+  });
+  return [`## ${CALLS_HEADING}`, CALLS_EXPLAINED, lines.join("\n")];
+}
+function renderClaims(claims, p) {
+  if (claims.length === 0)
+    return [`## ${UNCHECKED_CLAIMS_HEADING}`, NO_UNCHECKED_CLAIMS_LINE];
+  const lines = claims.map((c) => `- ${recordedClaimLine({
+    task: p.text(c.task),
+    label: p.text(c.label),
+    head: shortCommit(c.head),
+    act: c.act,
+    note: c.note === null ? null : p.text(c.note)
+  })}`);
+  return [`## ${UNCHECKED_CLAIMS_HEADING}`, lines.join("\n")];
+}
 var EARLIER_ROUNDS_LABEL = `${STATED_LABEL} What was said each time the owner's review was asked for, before the round that closed the phase. What was said for that last round is under the close above. If the account that asked for a round is later deleted, the name given for that round is removed.`;
 function renderRoundStated(round, stated, p) {
   const label = "> - Acceptance walk (the finished work tried as a user would, by someone other than its builder): ";
@@ -5539,7 +6136,8 @@ function renderBuildRecordV2Markdown(record2) {
   const closes = [...record2.observed.closes].sort((a, b) => a.sequence - b.sequence);
   const total = closes.length;
   const latest = closes[total - 1];
-  const rounds = record2.format === "halfcycle-build-record/v3" ? record2.review.rounds : [];
+  const rounds = hasOwnerReview(record2) ? record2.review.rounds : [];
+  const path = keptPathOf(record2);
   const roundsAfter = rounds.length <= 1 ? null : `after ${String(rounds.length)} rounds of the owner's review.${rounds.some((r) => r.stated !== void 0) ? ' What was said for each earlier round is under "Earlier rounds of the review".' : ""}`;
   const body = [
     `Phase: ${phase} (the name the client gave it)`,
@@ -5547,14 +6145,23 @@ function renderBuildRecordV2Markdown(record2) {
     [
       `- Method version: ${p.text(record2.observed.methodVersion)}. The Halfcycle method is updated from time to time, and each update has its own version number. This is the one the phase was run under. A project moves to a newer version only between phases.`,
       `- Project identifier: ${p.text(record2.observed.engagementId)}. Halfcycle keeps this project's records under this identifier.`,
-      `- Record format: ${p.text(record2.format)}. This names the layout this file and the .json file beside it follow, for software that reads them.`
+      `- Record format: ${p.text(record2.format)}. This names the layout this file and the .json file beside it follow, for software that reads them.`,
+      ...path === null ? [] : [`- ${PATH_LINE[path]}`]
     ].join("\n"),
     total === 1 ? roundsAfter === null ? "This phase was closed once." : `This phase was closed once, ${roundsAfter}` : `This phase was closed ${String(total)} times. The latest close is described first; each earlier close follows, as it was recorded when it was made.${roundsAfter === null ? "" : ` The latest close came ${roundsAfter}`}`,
     ...renderChecks(record2.observed.checks, p),
     ...renderClose(total === 1 ? "## The close" : `## The latest close (close ${String(latest.sequence)} of ${String(total)})`, latest, attestedBySequence.get(latest.sequence), record2.observed.checks.state, p, rounds.length > 1)
   ];
-  if (record2.format === "halfcycle-build-record/v3")
-    body.push(...renderReview(record2, p), ...renderEarlierRounds(record2, p));
+  if (hasOwnerReview(record2))
+    body.push(...renderReview(record2, p));
+  const calls = keptCallsOf(record2);
+  if (calls !== null)
+    body.push(...renderCalls(calls, p));
+  const claims = keptClaimsOf(record2);
+  if (claims !== null)
+    body.push(...renderClaims(claims, p));
+  if (hasOwnerReview(record2))
+    body.push(...renderEarlierRounds(record2, p));
   if (total > 1) {
     body.push("## Earlier closes");
     for (const close of closes.slice(0, -1)) {
@@ -5569,16 +6176,11 @@ function renderBuildRecordV2Markdown(record2) {
 }
 
 // dist/build-record/write.js
-import { closeSync, existsSync as existsSync6, mkdirSync as mkdirSync6, openSync, readFileSync as readFileSync7, renameSync as renameSync2, rmSync as rmSync3, writeSync } from "node:fs";
-import { basename, join as join8, resolve, relative as relative2, isAbsolute as isAbsolute2 } from "node:path";
-var BUILD_RECORD_DIR = join8("docs", "build-records");
-function assertInsideOutDir(outDir, candidate, identity) {
-  const rel = relative2(outDir, resolve(candidate));
-  const isPlainFilename = rel !== "" && rel !== ".." && !isAbsolute2(rel) && rel === basename(rel);
-  if (!isPlainFilename) {
-    throw new InvalidPhaseIdentityError(identity, BUILD_RECORD_DIR);
-  }
-}
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, rmSync as rmSync4 } from "node:fs";
+import { basename, join as join8, resolve as resolve2, relative as relative2, isAbsolute as isAbsolute3 } from "node:path";
+
+// dist/build-record/pair-io.js
+import { closeSync, openSync, readFileSync as readFileSync7, renameSync as renameSync2, rmSync as rmSync3, writeSync } from "node:fs";
 function createExclusiveOnDisk(path, data) {
   const bytes = typeof data === "string" ? Buffer.from(data, "utf-8") : data;
   const fd = openSync(path, "wx");
@@ -5614,6 +6216,41 @@ function readIfPresent(path) {
     return null;
   }
 }
+function createPairExclusive(io, jsonPath, jsonText, mdPath, mdText) {
+  let createdJson = false;
+  try {
+    io.createExclusive(jsonPath, jsonText);
+    createdJson = true;
+    io.createExclusive(mdPath, mdText);
+    return "created";
+  } catch (err) {
+    if (createdJson)
+      rmSync3(jsonPath, { force: true });
+    if (!isEexist(err))
+      throw err;
+    return "exists";
+  }
+}
+function replaceOne(io, tmp, finalPath, text) {
+  rmSync3(tmp, { force: true });
+  try {
+    io.createExclusive(tmp, text);
+    io.rename(tmp, finalPath);
+  } catch (err) {
+    rmSync3(tmp, { force: true });
+    throw err;
+  }
+}
+
+// dist/build-record/write.js
+var BUILD_RECORD_DIR = join8("docs", "build-records");
+function assertInsideOutDir(outDir, candidate, identity) {
+  const rel = relative2(outDir, resolve2(candidate));
+  const isPlainFilename = rel !== "" && rel !== ".." && !isAbsolute3(rel) && rel === basename(rel);
+  if (!isPlainFilename) {
+    throw new InvalidPhaseIdentityError(identity, BUILD_RECORD_DIR);
+  }
+}
 function isOwnEarlierRecord(existingText, served) {
   let parsedJson;
   try {
@@ -5642,7 +6279,7 @@ function writeRecordPair(repoRoot, phase, rawRecord, record2, io = NODE_RECORD_P
   if (!isValidPhaseIdentity(phase)) {
     throw new InvalidPhaseIdentityError(phase, BUILD_RECORD_DIR);
   }
-  const outDir = resolve(repoRoot, BUILD_RECORD_DIR);
+  const outDir = resolve2(repoRoot, BUILD_RECORD_DIR);
   const segment = renderPhaseSegment(phase);
   const jsonPath = join8(outDir, `${segment}.json`);
   const mdPath = join8(outDir, `${segment}.md`);
@@ -5654,17 +6291,8 @@ function writeRecordPair(repoRoot, phase, rawRecord, record2, io = NODE_RECORD_P
   const jsonText = serialiseServedRecord(rawRecord);
   const mdText = renderBuildRecordV2Markdown(record2);
   mkdirSync6(outDir, { recursive: true });
-  let createdJson = false;
-  try {
-    io.createExclusive(jsonPath, jsonText);
-    createdJson = true;
-    io.createExclusive(mdPath, mdText);
+  if (createPairExclusive(io, jsonPath, jsonText, mdPath, mdText) === "created") {
     return { kind: "created", jsonPath, mdPath };
-  } catch (err) {
-    if (createdJson)
-      rmSync3(jsonPath, { force: true });
-    if (!isEexist(err))
-      throw err;
   }
   const existingJson = readIfPresent(jsonPath);
   if (existingJson === null) {
@@ -5684,22 +6312,12 @@ function writeRecordPair(repoRoot, phase, rawRecord, record2, io = NODE_RECORD_P
     try {
       replaceOne(io, jsonTmp, jsonPath, existingJson);
     } catch {
-      rmSync3(jsonPath, { force: true });
+      rmSync4(jsonPath, { force: true });
     }
     throw err;
   }
   return { kind: "replaced", jsonPath, mdPath };
 }
-function replaceOne(io, tmp, finalPath, text) {
-  rmSync3(tmp, { force: true });
-  try {
-    io.createExclusive(tmp, text);
-    io.rename(tmp, finalPath);
-  } catch (err) {
-    rmSync3(tmp, { force: true });
-    throw err;
-  }
-}
 
 // dist/build-record/obtain.js
 import { relative as relative3 } from "node:path";