halfcycle 0.4.8 → 0.4.9

package/dist/index.js

@@ -238,6 +238,25 @@ var HALFCYCLE_COMMAND = "npx halfcycle@latest";
 // ../core/dist/release-version.js
 var RELEASE_VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
 
+// ../core/dist/github-address.js
+var GITHUB_REPOSITORY_ADDRESS = /^https:\/\/github\.com\/[A-Za-z0-9][A-Za-z0-9-]{0,38}\/(?!\.{1,2}$)[A-Za-z0-9._-]{1,100}$/;
+var HOST = "[Gg][Ii][Tt][Hh][Uu][Bb]\\.[Cc][Oo][Mm]";
+var OWNER = "[A-Za-z0-9][A-Za-z0-9-]{0,38}";
+var RAW_REPOSITORY = "[A-Za-z0-9._-]{1,104}";
+var TAIL = `(${OWNER})/(${RAW_REPOSITORY})/?$`;
+var URL_USERINFO = "(?:[^\\s/?#@]+@)?";
+var SSH_USER = "(?:[^\\s/?#@:]+@)?";
+var REMOTE_FORMS = [
+  new RegExp(`^https?://${URL_USERINFO}${HOST}/${TAIL}`),
+  new RegExp(`^ssh://${SSH_USER}${HOST}/${TAIL}`),
+  new RegExp(`^git://${HOST}/${TAIL}`),
+  new RegExp(`^${SSH_USER}${HOST}:${TAIL}`)
+];
+
+// ../core/dist/sign-in.js
+var SIGN_IN_COMMAND = '"npx halfcycle"';
+var HOOK_REMEDY = `Run ${SIGN_IN_COMMAND} in the project folder to sign in.`;
+
 // ../events/dist/result.js
 import { z as z2 } from "zod";
 var firedGuardSchema = z2.object({
@@ -305,17 +324,29 @@ function hasLoneSurrogate(text) {
 var LONE_SURROGATE_MESSAGE = "must be valid text: it holds half of a character pair with no other half";
 
 // ../events/dist/state.js
+import { z as z4 } from "zod";
+
+// ../events/dist/human-agent.js
 import { z as z3 } from "zod";
-var utcIso8601 = z3.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 HUMAN_AGENT = "Human";
+var AGENT_NAME_MAX = 32;
+var agentNameSchema = z3.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 STATE_RECORD_FORMAT = "halfcycle-state-record/v1";
-var stepIdSchema = z3.string().regex(/^(l[0-5](-l[0-5])?|xl)\.[a-z0-9-]+$/);
-var methodVersionSchema = z3.string().regex(RELEASE_VERSION_PATTERN);
+var stepIdSchema = z4.string().regex(/^(l[0-5](-l[0-5])?|xl)\.[a-z0-9-]+$/);
+var methodVersionSchema = z4.string().regex(RELEASE_VERSION_PATTERN);
 var anchorPathRegex = /^(?!\/)(?!.*#)(?!method\/)(?!(.*\/)?docs\/method\/).+$/;
-var recordKindSchema = z3.enum(["artefact", "step-run", "gate", "intervention"]);
-var methodLayerSchema = z3.enum(["l0", "l1", "l2", "l3", "l3-l4", "l4", "l5", "xl"]);
-var evidenceKindSchema = z3.enum(["anchor", "diff", "repro", "question-answer", "no-op"]);
-var declarableEvidenceKindSchema = z3.enum(["anchor", "diff", "repro", "question-answer"]);
-var dispositionSchema = z3.enum([
+var recordKindSchema = z4.enum(["artefact", "step-run", "gate", "intervention"]);
+var methodLayerSchema = z4.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([
   "prevented",
   "corrected-in-spec",
   "corrected-in-scope",
@@ -325,20 +356,20 @@ var dispositionSchema = z3.enum([
   "surfaced",
   "filed-forward"
 ]);
-var mechanismSchema = z3.enum(["guard", "verdict", "served-step", "method-step"]);
-var artefactStateSchema = z3.enum(["created", "updated"]);
+var mechanismSchema = z4.enum(["guard", "verdict", "served-step", "method-step"]);
+var artefactStateSchema = z4.enum(["created", "updated"]);
 var QUALIFIED_OUTCOMES = ["declined", "parked"];
-var qualifiedOutcomeSchema = z3.enum(QUALIFIED_OUTCOMES);
+var qualifiedOutcomeSchema = z4.enum(QUALIFIED_OUTCOMES);
 function isQualifiedOutcome(outcome) {
   return QUALIFIED_OUTCOMES.includes(outcome);
 }
-var runOutcomeSchema = z3.enum([
+var runOutcomeSchema = z4.enum([
   "completed",
   "attempted-failed",
   ...QUALIFIED_OUTCOMES
 ]);
-var gateKindSchema = z3.enum(["approval", "mechanical"]);
-var gateVerdictSchema = z3.enum(["pass", "fail", ...QUALIFIED_OUTCOMES]);
+var gateKindSchema = z4.enum(["approval", "mechanical"]);
+var gateVerdictSchema = z4.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}'` };
@@ -350,47 +381,47 @@ function outcomeReasonIssue(outcome, reason) {
   }
   return null;
 }
-var anchorEvidenceSchema = z3.object({
-  kind: z3.literal("anchor"),
-  path: z3.string().regex(anchorPathRegex),
+var anchorEvidenceSchema = z4.object({
+  kind: z4.literal("anchor"),
+  path: z4.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: z3.number().optional()
+  line: z4.number().optional()
 }).strict();
-var diffEvidenceSchema = z3.object({
-  kind: z3.literal("diff"),
-  ref: z3.string()
+var diffEvidenceSchema = z4.object({
+  kind: z4.literal("diff"),
+  ref: z4.string()
 }).strict();
-var reproEvidenceSchema = z3.object({
-  kind: z3.literal("repro"),
-  steps: z3.string().max(2e3)
+var reproEvidenceSchema = z4.object({
+  kind: z4.literal("repro"),
+  steps: z4.string().max(2e3)
 }).strict();
-var questionAnswerEvidenceSchema = z3.object({
-  kind: z3.literal("question-answer"),
-  question: z3.string().max(2e3),
-  before: z3.string().max(2e3),
-  after: z3.string().max(2e3)
+var questionAnswerEvidenceSchema = z4.object({
+  kind: z4.literal("question-answer"),
+  question: z4.string().max(2e3),
+  before: z4.string().max(2e3),
+  after: z4.string().max(2e3)
 }).strict();
-var noOpEvidenceSchema = z3.object({
-  kind: z3.literal("no-op"),
-  inspected: z3.string().max(2e3),
-  unchangedBecause: z3.string().max(2e3)
+var noOpEvidenceSchema = z4.object({
+  kind: z4.literal("no-op"),
+  inspected: z4.string().max(2e3),
+  unchangedBecause: z4.string().max(2e3)
 }).strict();
-var evidenceSchema = z3.discriminatedUnion("kind", [
+var evidenceSchema = z4.discriminatedUnion("kind", [
   anchorEvidenceSchema,
   diffEvidenceSchema,
   reproEvidenceSchema,
   questionAnswerEvidenceSchema,
   noOpEvidenceSchema
 ]);
-var stateRecordEnvelopeSchema = z3.object({
-  format: z3.literal(STATE_RECORD_FORMAT),
+var stateRecordEnvelopeSchema = z4.object({
+  format: z4.literal(STATE_RECORD_FORMAT),
   recordKind: recordKindSchema,
-  recordId: z3.string().uuid(),
+  recordId: z4.string().uuid(),
   methodVersion: methodVersionSchema,
-  engagementId: z3.string(),
+  engagementId: z4.string(),
   stepId: stepIdSchema,
   // Immutable: names when the thing happened, never when a later disposition
   // moved.
@@ -406,80 +437,94 @@ var stateRecordEnvelopeSchema = z3.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: z3.string().optional()
+  phase: z4.string().optional()
 });
-var artefactRefSchema = z3.object({
-  name: z3.string(),
-  parent: z3.string()
+var artefactRefSchema = z4.object({
+  name: z4.string(),
+  parent: z4.string()
 }).strict();
-var coverageSchema = z3.object({
-  asked: z3.number().int().nonnegative(),
-  answered: z3.number().int().nonnegative()
+var coverageSchema = z4.object({
+  asked: z4.number().int().nonnegative(),
+  answered: z4.number().int().nonnegative()
 }).strict().superRefine((coverage, ctx) => {
   if (coverage.answered > coverage.asked) {
     ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.ZodIssueCode.custom,
       path: ["answered"],
       message: "answered cannot be more than asked"
     });
   }
 });
+var projectTierSchema = z4.number().int().min(0).max(3);
 var artefactRecordSchema = stateRecordEnvelopeSchema.extend({
-  recordKind: z3.literal("artefact"),
+  recordKind: z4.literal("artefact"),
   artefactRef: artefactRefSchema,
   // Some layer wrote it, by construction — an empty array is not a legitimate
   // state, so the schema says so.
-  writtenByLayers: z3.array(methodLayerSchema).min(1),
+  writtenByLayers: z4.array(methodLayerSchema).min(1),
   state: artefactStateSchema
 }).strict();
 var stepRunRecordSchema = stateRecordEnvelopeSchema.extend({
-  recordKind: z3.literal("step-run"),
+  recordKind: z4.literal("step-run"),
   runOutcome: runOutcomeSchema,
-  failureReason: z3.string().optional(),
-  outcomeReason: z3.string().max(2e3).optional()
+  failureReason: z4.string().optional(),
+  outcomeReason: z4.string().max(2e3).optional(),
+  // Who did this step, as the session reported it. Absent when not reported.
+  agent: agentNameSchema.optional(),
+  // When the session began this step. Absent when not reported.
+  startedAt: utcIso8601.optional(),
+  // The project's tier, when this step settled it. Absent on every other step.
+  projectTier: projectTierSchema.optional()
 }).strict().superRefine((rec, ctx) => {
   if (rec.runOutcome === "attempted-failed" && rec.failureReason === void 0) {
     ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.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: z3.ZodIssueCode.custom,
+      code: z4.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: z3.ZodIssueCode.custom, path: ["outcomeReason"], ...issue });
+    ctx.addIssue({ code: z4.ZodIssueCode.custom, path: ["outcomeReason"], ...issue });
   }
 });
 var gateRecordSchema = stateRecordEnvelopeSchema.extend({
-  recordKind: z3.literal("gate"),
+  recordKind: z4.literal("gate"),
   gateKind: gateKindSchema,
   verdict: gateVerdictSchema,
-  actor: z3.string(),
-  outcomeReason: z3.string().max(2e3).optional(),
-  coverage: coverageSchema.optional()
+  actor: z4.string(),
+  outcomeReason: z4.string().max(2e3).optional(),
+  coverage: coverageSchema.optional(),
+  // Who did the step this checkpoint is on, as reported. Absent when not reported.
+  agent: agentNameSchema.optional(),
+  // When that step, or the review this checkpoint closes, began. Absent when not
+  // reported.
+  startedAt: utcIso8601.optional()
 }).strict().superRefine((rec, ctx) => {
   const issue = outcomeReasonIssue(rec.verdict, rec.outcomeReason);
   if (issue) {
-    ctx.addIssue({ code: z3.ZodIssueCode.custom, path: ["outcomeReason"], ...issue });
+    ctx.addIssue({ code: z4.ZodIssueCode.custom, path: ["outcomeReason"], ...issue });
   }
 });
 var interventionRecordSchema = stateRecordEnvelopeSchema.extend({
-  recordKind: z3.literal("intervention"),
+  recordKind: z4.literal("intervention"),
   layer: methodLayerSchema,
   mechanism: mechanismSchema,
   severity: severitySchema,
   disposition: dispositionSchema,
-  summary: z3.string().max(2e3),
-  coverage: coverageSchema.optional()
+  summary: z4.string().max(2e3),
+  coverage: coverageSchema.optional(),
+  // Who caught it, as the session reported. Absent when not reported.
+  agent: agentNameSchema.optional()
 }).strict();
-var stateRecordSchema = z3.discriminatedUnion("recordKind", [
+var stateRecordSchema = z4.discriminatedUnion("recordKind", [
   artefactRecordSchema,
   stepRunRecordSchema,
   gateRecordSchema,
@@ -487,7 +532,7 @@ var stateRecordSchema = z3.discriminatedUnion("recordKind", [
 ]);
 
 // ../events/dist/build-record.js
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // ../events/dist/control-characters.js
 var CONTROL_CHARACTER_CLASS = "\\p{Cc}";
@@ -577,11 +622,16 @@ var ACTOR_MAX = 200;
 var FINDING_MAX = 500;
 var FINDINGS_SHOWN_MAX = 50;
 var PHASE_CLOSE_REASON_MAX = 1900;
-var closeCommitSchema = z4.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/, "must be a full commit hash: 40 or 64 lowercase hex characters");
-var walkVerdictSchema = z4.enum(["clean", "defects"]);
-var closeDecisionSchema = z4.enum(["done-when-met", "override"]);
+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({
+  verdict: walkVerdictSchema,
+  findings: z5.number().int().nonnegative(),
+  findingsDetail: z5.array(z5.object({ summary: z5.string().refine((v) => !hasLoneSurrogate(v), { message: LONE_SURROGATE_MESSAGE }) }).strict())
+}).strict();
+var closeDecisionSchema = z5.enum(["done-when-met", "override"]);
 function plainText(max) {
-  const base = max === void 0 ? z4.string() : z4.string().max(max);
+  const base = max === void 0 ? z5.string() : z5.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 });
@@ -593,81 +643,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 = z4.string().refine((v) => isValidPhaseIdentity(v), {
+var phaseNameSchema = z5.string().refine((v) => isValidPhaseIdentity(v), {
   message: PHASE_NAME_RULE
 });
-var phaseIdentitySchema = z4.union([z4.string(), z4.number()], { error: "must be a phase name or a whole number" }).refine((v) => isValidPhaseIdentity(v), { message: PHASE_NAME_RULE });
-var closeStatementsSchema = z4.object({
+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({
   thesis: statementText(STATEMENT_MAX).nullable(),
   outcome: statementText(STATEMENT_MAX).nullable(),
-  deviations: z4.array(statementText(DEVIATION_MAX)).max(DEVIATIONS_MAX),
+  deviations: z5.array(statementText(DEVIATION_MAX)).max(DEVIATIONS_MAX),
   closeCommit: closeCommitSchema.nullable()
 }).strict();
-var closedBySchema = z4.discriminatedUnion("kind", [
-  z4.object({ kind: z4.literal("account"), email: plainText().nullable() }).strict(),
-  z4.object({ kind: z4.literal("no-account") }).strict(),
-  z4.object({ kind: z4.literal("account-removed") }).strict(),
-  z4.object({ kind: z4.literal("not-recorded") }).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 STEP_NAME_MAX = 200;
 var stepNameSchema = plainText(STEP_NAME_MAX).refine((v) => v.trim().length > 0, {
   message: "must not be blank"
 });
-var unfinishedStepSchema = z4.object({
+var unfinishedStepSchema = z5.object({
   stepId: plainText(),
-  state: z4.enum(["parked", "failed"]),
+  state: z5.enum(["parked", "failed"]),
   name: stepNameSchema.optional()
 }).strict();
-var crossedSchema = z4.discriminatedUnion("kind", [
-  z4.object({ kind: z4.literal("none") }).strict(),
-  z4.object({ kind: z4.literal("unfinished-steps"), steps: z4.array(unfinishedStepSchema).min(1) }).strict(),
-  z4.object({ kind: z4.literal("clean-over-findings"), findings: z4.number().int().min(1) }).strict(),
-  z4.object({ kind: z4.literal("not-recorded") }).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 seatCoverageSchema = z4.object({
-  enrolled: z4.number().int().nonnegative(),
-  conformant: z4.number().int().nonnegative()
+var seatCoverageSchema = z5.object({
+  enrolled: z5.number().int().nonnegative(),
+  conformant: z5.number().int().nonnegative()
 }).strict().refine((c) => c.conformant <= c.enrolled, {
   message: "conformant cannot exceed enrolled",
   path: ["conformant"]
 });
-var observedCloseSchema = z4.object({
-  sequence: z4.number().int().min(1),
+var observedCloseSchema = z5.object({
+  sequence: z5.number().int().min(1),
   closedAt: utcIso8601,
   closedBy: closedBySchema,
   crossed: crossedSchema,
   seatCoverage: seatCoverageSchema.nullable()
 }).strict();
-var couldNotRunCheckSchema = z4.object({
+var couldNotRunCheckSchema = z5.object({
   check: plainText(),
   description: plainText().nullable(),
   reason: plainText()
 }).strict();
-var firedCheckSchema = z4.object({
+var firedCheckSchema = z5.object({
   check: plainText(),
   description: plainText().nullable(),
   severity: severitySchema,
   explanation: plainText().nullable(),
-  occurrences: z4.number().int().min(1)
+  occurrences: z5.number().int().min(1)
 }).strict();
-var phaseChecksSchema = z4.discriminatedUnion("state", [
-  z4.object({ state: z4.literal("not-observed") }).strict(),
-  z4.object({
-    state: z4.literal("nothing-fired"),
-    runs: z4.number().int().min(1),
-    couldNotRun: z4.array(couldNotRunCheckSchema)
+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)
   }).strict(),
-  z4.object({
-    state: z4.literal("fired"),
-    runs: z4.number().int().min(1),
-    couldNotRun: z4.array(couldNotRunCheckSchema),
-    fired: z4.array(firedCheckSchema).min(1)
+  z5.object({
+    state: z5.literal("fired"),
+    runs: z5.number().int().min(1),
+    couldNotRun: z5.array(couldNotRunCheckSchema),
+    fired: z5.array(firedCheckSchema).min(1)
   }).strict()
 ]);
-var observedSchema = z4.object({
+var observedSchema = z5.object({
   engagementId: plainText(),
   methodVersion: methodVersionSchema,
-  closes: z4.array(observedCloseSchema).min(1),
+  closes: z5.array(observedCloseSchema).min(1),
   checks: phaseChecksSchema
 }).strict().superRefine((o, ctx) => {
   o.closes.forEach((close, i) => {
@@ -680,18 +730,18 @@ var observedSchema = z4.object({
     }
   });
 });
-var attestedWalkSchema = z4.object({
+var attestedWalkSchema = z5.object({
   verdict: walkVerdictSchema,
-  findings: z4.array(plainText(FINDING_MAX)).max(FINDINGS_SHOWN_MAX),
-  findingsNotShown: z4.number().int().nonnegative()
+  findings: z5.array(plainText(FINDING_MAX)).max(FINDINGS_SHOWN_MAX),
+  findingsNotShown: z5.number().int().nonnegative()
 }).strict();
-var attestedStatementsSchema = z4.object({
+var attestedStatementsSchema = z5.object({
   thesis: plainText(STATEMENT_MAX).nullable(),
   outcome: plainText(STATEMENT_MAX).nullable(),
-  deviations: z4.array(plainText(DEVIATION_MAX)).max(DEVIATIONS_MAX)
+  deviations: z5.array(plainText(DEVIATION_MAX)).max(DEVIATIONS_MAX)
 }).strict();
-var attestedCloseSchema = z4.object({
-  sequence: z4.number().int().min(1),
+var attestedCloseSchema = z5.object({
+  sequence: z5.number().int().min(1),
   decision: closeDecisionSchema,
   actor: plainText(ACTOR_MAX).nullable(),
   reason: plainText(PHASE_CLOSE_REASON_MAX).nullable(),
@@ -699,15 +749,10 @@ var attestedCloseSchema = z4.object({
   closeCommit: closeCommitSchema.nullable(),
   statements: attestedStatementsSchema
 }).strict();
-var attestedSchema = z4.object({
-  closes: z4.array(attestedCloseSchema)
+var attestedSchema = z5.object({
+  closes: z5.array(attestedCloseSchema)
 }).strict();
-var buildRecordV2Schema = z4.object({
-  format: z4.literal(BUILD_RECORD_V2_FORMAT),
-  phase: phaseNameSchema,
-  observed: observedSchema,
-  attested: attestedSchema
-}).strict().superRefine((record2, ctx) => {
+function checkRecordHalves(record2, ctx) {
   const observedBySequence = new Map(record2.observed.closes.map((c) => [c.sequence, c]));
   const attestedSequences = record2.attested.closes.map((c) => c.sequence);
   const sameSet = attestedSequences.length === observedBySequence.size && new Set(attestedSequences).size === attestedSequences.length && attestedSequences.every((s) => observedBySequence.has(s));
@@ -735,18 +780,24 @@ var buildRecordV2Schema = z4.object({
       });
     }
   });
-});
+}
+var buildRecordV2Schema = z5.object({
+  format: z5.literal(BUILD_RECORD_V2_FORMAT),
+  phase: phaseNameSchema,
+  observed: observedSchema,
+  attested: attestedSchema
+}).strict().superRefine(checkRecordHalves);
 
 // ../events/dist/crew.js
-import { z as z5 } from "zod";
-var crewGroupSchema = z5.enum(["builder", "reviewer", "always-on"]);
-var crewTierSchema = z5.enum(["deep", "standard", "fast"]);
+import { z as z6 } from "zod";
+var crewGroupSchema = z6.enum(["builder", "reviewer", "always-on"]);
+var crewTierSchema = z6.enum(["deep", "standard", "fast"]);
 var CREW_DISCIPLINE_MAX = 64;
-var crewFaceHeadSchema = z5.enum(["sq", "sqr", "rnd", "dome", "hex"]);
-var crewFaceAntennaSchema = z5.enum(["none", "stalk", "twin", "dish"]);
-var crewFaceEyesSchema = z5.enum(["dots", "bars", "visor", "cyclops"]);
-var crewFaceMouthSchema = z5.enum(["line", "grid", "dots", "wave"]);
-var crewFaceSchema = z5.object({
+var crewFaceHeadSchema = z6.enum(["sq", "sqr", "rnd", "dome", "hex"]);
+var crewFaceAntennaSchema = z6.enum(["none", "stalk", "twin", "dish"]);
+var crewFaceEyesSchema = z6.enum(["dots", "bars", "visor", "cyclops"]);
+var crewFaceMouthSchema = z6.enum(["line", "grid", "dots", "wave"]);
+var crewFaceSchema = z6.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,
@@ -757,17 +808,17 @@ var crewFaceSchema = z5.object({
   // The mouth.
   mouth: crewFaceMouthSchema,
   // Whether this member is drawn with ears.
-  ears: z5.boolean()
+  ears: z6.boolean()
 }).strict();
-var crewMemberSchema = z5.object({
+var crewMemberSchema = z6.object({
   // The agent's name. The same twenty-one on every project, so a name is a
   // vocabulary a returning client already knows.
-  callsign: z5.string().min(1).max(32),
+  callsign: z6.string().min(1).max(32),
   // Which of the three headings this member reads under.
   group: crewGroupSchema,
   // The kind of work this member takes. A task names a discipline, and only
   // agents holding it can be dispatched to it.
-  discipline: z5.string().min(1).max(CREW_DISCIPLINE_MAX),
+  discipline: z6.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,
@@ -930,10 +981,1199 @@ var CREW_ROSTER = [
 ];
 var CREW_ROSTER_SIZE = CREW_ROSTER.length;
 var CREW_CALLSIGNS = CREW_ROSTER.map((member) => member.callsign);
+var crewRoleSchema = z6.enum([
+  "business-analyst",
+  "architect",
+  "spec-writer",
+  "builder",
+  "context-docs",
+  "spec-reviewer",
+  "code-test-reviewer",
+  "delivery-lead",
+  "quality-lead"
+]);
+var crewLayerSchema = methodLayerSchema.extract(["l0", "l1", "l2", "l3", "l4", "l5"]);
+var crewRoleLayersSchema = z6.object({
+  leads: z6.array(crewLayerSchema),
+  helps: z6.array(crewLayerSchema)
+}).strict();
+
+// ../events/dist/build-snapshot.js
+import { z as z8 } from "zod";
+
+// ../events/dist/system-description.js
+import { z as z7 } from "zod";
+var SYSTEM_DESCRIPTION_FORMAT = 1;
+var SYSTEM_PARTS_MAX = 60;
+var SYSTEM_CONNECTIONS_MAX = 400;
+var SYSTEM_SLOT_MAX = 11;
+var SYSTEM_OWNS_MAX = 20;
+var SYSTEM_OWNED_PATTERN_MAX = 200;
+var SYSTEM_PART_NAME_MAX = 60;
+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 = z7.enum(SYSTEM_LANES, {
+  error: `must be one of ${SYSTEM_LANES.join(", ")}`
+});
+var SYSTEM_CONNECTION_KINDS = ["call", "event", "write", "external"];
+var systemConnectionKindSchema = z7.enum(SYSTEM_CONNECTION_KINDS, {
+  error: `must be one of ${SYSTEM_CONNECTION_KINDS.join(", ")}`
+});
+var LINE_SEPARATOR = /[\u2028\u2029]/;
+function descriptionText(max) {
+  return statementText(max).refine((v) => v.trim().length > 0, { message: "must not be empty or only spaces" }).refine((v) => !LINE_SEPARATOR.test(v), {
+    message: "must be one line: it holds a line or paragraph separator"
+  });
+}
+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) {
+  return pattern.split("/").some((segment) => segment.length === 0);
+}
+function hasDotSegment(pattern) {
+  return pattern.split("/").some((segment) => segment === "." || segment === "..");
+}
+function hasPartialDoubleStar(pattern) {
+  return pattern.split("/").some((segment) => segment.includes("**") && segment !== "**");
+}
+var SEGMENT_CHARACTERS = /^[A-Za-z0-9._\-*]*$/;
+function hasForeignCharacter(pattern) {
+  return pattern.split("/").some((segment) => !SEGMENT_CHARACTERS.test(segment));
+}
+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 = z7.object({
+  id: systemPartIdSchema,
+  name: descriptionText(SYSTEM_PART_NAME_MAX),
+  description: descriptionText(SYSTEM_PART_DESCRIPTION_MAX),
+  lane: systemLaneSchema,
+  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 = z7.object({
+  from: systemPartIdSchema,
+  to: systemPartIdSchema,
+  kind: systemConnectionKindSchema,
+  label: descriptionText(SYSTEM_CONNECTION_LABEL_MAX)
+}).strict();
+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 = z7.object({
+  path: z7.string(),
+  message: z7.string()
+}).strict();
+var systemReportRecordedSchema = z7.object({
+  outcome: z7.literal("recorded"),
+  version: z7.number().int().min(1),
+  reportedAt: utcIso8601
+}).strict();
+var systemReportRefusedSchema = z7.object({
+  outcome: z7.literal("refused"),
+  problems: z7.array(systemDescriptionProblemSchema).min(1)
+}).strict();
+var systemReportUnavailableSchema = z7.object({
+  outcome: z7.literal("unavailable")
+}).strict();
+var systemReportResultSchema = z7.discriminatedUnion("outcome", [
+  systemReportRecordedSchema,
+  systemReportRefusedSchema,
+  systemReportUnavailableSchema
+]);
+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 = z7.object({
+  picture: z7.literal("architecture"),
+  version: z7.number().int().min(1)
+}).strict();
+var systemDrawPhaseRequestSchema = z7.object({
+  picture: z7.literal("phase"),
+  phase: phaseIdentitySchema,
+  planVersion: z7.number().int().min(1)
+}).strict();
+var systemDrawClosedPhaseRequestSchema = z7.object({
+  picture: z7.literal("closed-phase"),
+  phase: phaseIdentitySchema
+}).strict();
+var systemDrawRequestSchema = z7.discriminatedUnion("picture", [
+  systemDrawArchitectureRequestSchema,
+  systemDrawPhaseRequestSchema,
+  systemDrawClosedPhaseRequestSchema
+]);
+function utf8ByteLength2(text) {
+  let bytes = 0;
+  for (let i = 0; i < text.length; i++) {
+    const unit = text.charCodeAt(i);
+    if (unit < 128)
+      bytes += 1;
+    else if (unit < 2048)
+      bytes += 2;
+    else if (unit >= 55296 && unit <= 56319 && i + 1 < text.length) {
+      const next = text.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        i++;
+      } else {
+        bytes += 3;
+      }
+    } else
+      bytes += 3;
+  }
+  return bytes;
+}
+var BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
+function base64DecodedLength(text) {
+  const padding = text.endsWith("==") ? 2 : text.endsWith("=") ? 1 : 0;
+  return text.length / 4 * 3 - padding;
+}
+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 = z7.object({
+  outcome: z7.literal("refused"),
+  reason: z7.string().min(1)
+}).strict();
+var systemDrawUnavailableSchema = z7.object({
+  outcome: z7.literal("unavailable")
+}).strict();
+var systemDrawNotClosedSchema = z7.object({
+  outcome: z7.literal("not-closed")
+}).strict();
+
+// ../events/dist/build-snapshot.js
+var buildTaskStateSchema = z8.enum([
+  "pending",
+  "in-flight",
+  "completed",
+  "failed",
+  "blocked"
+]);
+var BUILD_TASK_TITLE_MAX = 240;
+var BUILD_SNAPSHOT_TASK_LIMIT = 500;
+var BUILD_TASK_WHY_OUTSIDE_PLAN_MAX = 160;
+var BUILD_TASK_BUDGET_MAX_MINUTES = 10080;
+var BUILD_TASK_NOTE_MAX = 240;
+var BUILD_TASK_CLEAR_COMMAND_MAX = 240;
+var buildTaskKindSchema = z8.enum(["build", "review", "spec", "walk"]);
+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: 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: 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: 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: 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(),
+  // Which wave of the phase this task belongs to — the wave that writes the
+  // specifications, or the wave that builds them. Absent when the graph does not
+  // record it, which is different from the task belonging to neither.
+  layer: methodLayerSchema.optional(),
+  // When it was picked up, and when it settled. A reader computes how long it
+  // took; neither this row nor this payload carries a duration.
+  startedAt: utcIso8601.optional(),
+  settledAt: utcIso8601.optional(),
+  // The parts of this project's system the task builds, by their ids. Absent when
+  // it builds none; never an empty list.
+  builds: 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: 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, or a person trying the product. Absent when the graph does not say.
+  kind: buildTaskKindSchema.optional(),
+  // One line from whoever holds the task about where it stands. Absent when there
+  // is nothing to say.
+  note: descriptionText(BUILD_TASK_NOTE_MAX).optional(),
+  // On a task held for a person, the one thing they do or run to clear it, in one
+  // line. Absent when the task names none.
+  clearCommand: descriptionText(BUILD_TASK_CLEAR_COMMAND_MAX).optional(),
+  // On a task held for a person, the crew member ready to take it on once it is
+  // cleared, by callsign. Absent when nobody is standing by.
+  standingBy: agentNameSchema.optional()
+}).strict().superRefine((task, ctx) => {
+  if (task.reviews !== void 0 && task.reviews === task.id) {
+    ctx.addIssue({
+      code: 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: z8.ZodIssueCode.custom,
+      path: ["layer"],
+      message: `'${task.layer}' is not a wave a phase runs \u2014 expected one of ${PHASE_SCOPED_LAYERS.join(", ")}.`
+    });
+  }
+  const profiled = task.agent !== void 0 && task.agent !== HUMAN_AGENT;
+  for (const field of ["discipline", "tier"]) {
+    if (profiled && task[field] === void 0) {
+      ctx.addIssue({
+        code: z8.ZodIssueCode.custom,
+        path: [field],
+        message: `'${field}' is required on a task an agent holds.`
+      });
+    }
+    if (!profiled && task[field] !== void 0) {
+      ctx.addIssue({
+        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 = z8.string().min(1).max(128);
+var BUILD_PHASE_TITLE_MAX = 160;
+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: z8.ZodIssueCode.custom,
+        path: [index, "id"],
+        message: `duplicate task id '${task.id}' \u2014 one graph names each task once.`
+      });
+    }
+    seen.add(task.id);
+  }
+});
+var buildTaskMarkSchema = z8.object({
+  // The task that was marked.
+  task: buildTaskIdSchema,
+  // When it was first marked.
+  at: utcIso8601
+}).strict();
+var buildSnapshotSchema = z8.object({
+  // Which phase this graph belongs to.
+  phase: buildPhaseSchema,
+  // That phase's name in words, when the project gives it one.
+  phaseTitle: buildPhaseTitleSchema.optional(),
+  // Every task on it. Never a partial graph and never a change since last time.
+  tasks: buildTaskListSchema,
+  // When this graph was last reported.
+  reportedAt: utcIso8601,
+  // When work on this phase was first reported with no approval of its scope in force.
+  builtWithoutApproval: utcIso8601.optional(),
+  // Each task that started on a part still waiting for approval, and when it was
+  // first seen doing so. Absent when there is none.
+  tasksBuiltWithoutApproval: z8.array(buildTaskMarkSchema).min(1).max(BUILD_SNAPSHOT_TASK_LIMIT).optional()
+}).strict();
+var buildPhaseEntrySchema = z8.object({
+  // Which phase has a stored graph.
+  phase: buildPhaseSchema,
+  // That phase's name in words, when the project gave it one.
+  phaseTitle: buildPhaseTitleSchema.optional(),
+  // When that phase's graph was last reported.
+  reportedAt: utcIso8601,
+  // Present when work on this phase was reported with no approval of its scope in force.
+  builtWithoutApproval: z8.literal(true).optional()
+}).strict();
+var buildSnapshotReportSchema = z8.object({
+  // Which phase this graph belongs to.
+  phase: buildPhaseSchema,
+  // That phase's name in words, when the project gives it one.
+  phaseTitle: buildPhaseTitleSchema.optional(),
+  // The whole graph, every time. Reporting a change instead of the graph is the
+  // one thing this route does not accept.
+  tasks: buildTaskListSchema
+}).strict();
+var buildSnapshotReportResultSchema = z8.object({
+  // What happened. One outcome today; a refusal travels as the shared wire error.
+  outcome: z8.literal("recorded"),
+  // Which phase the graph was recorded against.
+  phase: buildPhaseSchema,
+  // When it was recorded.
+  reportedAt: utcIso8601
+}).strict();
+
+// ../events/dist/phase-plan.js
+import { z as z9 } from "zod";
+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 = z9.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 = z9.object({
+  part: systemPartIdSchema,
+  change: phasePlanChangeSchema,
+  summary: phasePlanSummarySchema
+}).strict();
+var phasePlanSchema = z9.object({
+  format: z9.literal(PHASE_PLAN_FORMAT, { error: `must be ${PHASE_PLAN_FORMAT}` }),
+  phase: phasePlanPhaseSchema,
+  changes: z9.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"
+});
+var SCOPE_STATE_NAMES = [
+  "not-planned",
+  "waiting",
+  "sent-back",
+  "approved",
+  "partly-stale",
+  "withdrawn"
+];
+var scopeStateNameSchema = z9.enum(SCOPE_STATE_NAMES);
+var plannedScopeStateSchema = scopeStateNameSchema.exclude(["not-planned"]);
+var SCOPE_PART_STATUSES = ["approved", "waiting"];
+var scopePartStatusSchema = z9.enum(SCOPE_PART_STATUSES);
+var SCOPE_ACTS = ["approve", "send-back", "withdraw"];
+var scopeActSchema = z9.enum(SCOPE_ACTS);
+var SCOPE_GIVEN_IN = ["console", "chat"];
+var scopeGivenInSchema = z9.enum(SCOPE_GIVEN_IN);
+var scopeNoteSchema = descriptionText(SCOPE_NOTE_MAX);
+var scopeNoteWireSchema = z9.string().max(SCOPE_NOTE_MAX);
+var SCOPE_PART_VERDICTS = ["ok", "change"];
+var scopePartVerdictSchema = z9.enum(SCOPE_PART_VERDICTS);
+var scopeDecisionPartSchema = z9.object({
+  part: systemPartIdSchema,
+  verdict: scopePartVerdictSchema,
+  note: scopeNoteWireSchema.optional()
+}).strict();
+var planVersionSchema = z9.number().int().min(1);
+var carriedPhaseSchema = z9.object({
+  phase: scopePhaseSchema,
+  number: z9.number().int().min(1)
+}).strict();
+var carriedFromEntrySchema = carriedPhaseSchema.extend({
+  part: systemPartIdSchema
+}).strict();
+var phasePlanRequestSchema = z9.object({
+  descriptionVersion: z9.number().int().min(1),
+  plan: z9.unknown()
+}).strict();
+var phasePlanRecordedSchema = z9.object({
+  outcome: z9.literal("recorded"),
+  version: planVersionSchema,
+  phaseNumber: z9.number().int().min(1),
+  state: plannedScopeStateSchema,
+  changedParts: z9.array(systemPartIdSchema).max(PHASE_PLAN_CHANGES_MAX),
+  typedApprovalOffered: z9.boolean(),
+  reportedAt: utcIso8601,
+  carriedFrom: z9.array(carriedFromEntrySchema).min(1).max(PHASE_PLAN_CHANGES_MAX).optional()
+}).strict();
+var phasePlanRefusedSchema = z9.object({
+  outcome: z9.literal("refused"),
+  problems: z9.array(systemDescriptionProblemSchema).min(1)
+}).strict();
+var phasePlanUnavailableSchema = z9.object({
+  outcome: z9.literal("unavailable")
+}).strict();
+var REMOVAL_OWED_ACTS = ["dropped", "removed"];
+var removalOwedPartSchema = z9.object({
+  part: systemPartIdSchema,
+  name: systemPartSchema.shape.name,
+  phase: scopePhaseSchema,
+  number: z9.number().int().min(1),
+  act: z9.enum(REMOVAL_OWED_ACTS)
+}).strict();
+var phasePlanRemovalOwedSchema = z9.object({
+  outcome: z9.literal("removal-owed"),
+  parts: z9.array(removalOwedPartSchema).min(1).max(SYSTEM_PARTS_MAX)
+}).strict();
+var phasePlanResultSchema = z9.discriminatedUnion("outcome", [
+  phasePlanRecordedSchema,
+  phasePlanRefusedSchema,
+  phasePlanUnavailableSchema,
+  phasePlanRemovalOwedSchema
+]);
+var scopeApproveRequestSchema = z9.object({
+  act: z9.literal("approve"),
+  planVersion: planVersionSchema,
+  parts: z9.array(scopeDecisionPartSchema).max(PHASE_PLAN_CHANGES_MAX)
+}).strict();
+var scopeSendBackRequestSchema = z9.object({
+  act: z9.literal("send-back"),
+  planVersion: planVersionSchema,
+  parts: z9.array(scopeDecisionPartSchema).max(PHASE_PLAN_CHANGES_MAX),
+  note: scopeNoteWireSchema.optional()
+}).strict();
+var scopeWithdrawRequestSchema = z9.object({
+  act: z9.literal("withdraw"),
+  planVersion: planVersionSchema
+}).strict();
+var scopeDecisionRequestSchema = z9.discriminatedUnion("act", [
+  scopeApproveRequestSchema,
+  scopeSendBackRequestSchema,
+  scopeWithdrawRequestSchema
+]);
+var scopeDecisionRecordedSchema = z9.object({
+  outcome: z9.literal("recorded"),
+  act: scopeActSchema,
+  phase: scopePhaseSchema,
+  planVersion: planVersionSchema,
+  state: plannedScopeStateSchema,
+  decidedAt: utcIso8601
+}).strict();
+var scopeDecisionAlreadyApprovedSchema = z9.object({
+  outcome: z9.literal("already-approved"),
+  replanNeeded: z9.boolean(),
+  reason: z9.string().min(1)
+}).strict();
+var scopeDecisionRefusedSchema = z9.object({
+  outcome: z9.literal("refused"),
+  problems: z9.array(systemDescriptionProblemSchema).min(1)
+}).strict();
+var scopeDecisionUnavailableSchema = z9.object({
+  outcome: z9.literal("unavailable")
+}).strict();
+function reasonOutcome(outcome) {
+  return z9.object({ outcome: z9.literal(outcome), reason: z9.string().min(1) }).strict();
+}
+var scopeDecisionResultSchema = z9.discriminatedUnion("outcome", [
+  scopeDecisionRecordedSchema,
+  scopeDecisionAlreadyApprovedSchema,
+  scopeDecisionRefusedSchema,
+  scopeDecisionUnavailableSchema,
+  reasonOutcome("not-owner"),
+  reasonOutcome("no-owner"),
+  reasonOutcome("plan-changed"),
+  reasonOutcome("nothing-to-withdraw"),
+  reasonOutcome("build-started")
+]);
+var scopeReadPartSchema = z9.object({
+  part: systemPartIdSchema,
+  name: systemPartSchema.shape.name,
+  change: phasePlanChangeSchema,
+  summary: phasePlanSummarySchema,
+  status: scopePartStatusSchema,
+  changed: z9.boolean(),
+  carriedFrom: carriedPhaseSchema.optional()
+}).strict();
+var scopeReadDecisionSchema = z9.object({
+  act: scopeActSchema,
+  planVersion: planVersionSchema,
+  givenIn: scopeGivenInSchema,
+  at: utcIso8601,
+  parts: z9.array(scopeDecisionPartSchema).max(PHASE_PLAN_CHANGES_MAX),
+  note: scopeNoteWireSchema.optional()
+}).strict();
+var scopeReadNotPlannedSchema = z9.object({
+  phase: scopePhaseSchema,
+  state: z9.literal("not-planned"),
+  canDecide: z9.boolean()
+}).strict();
+var scopeReadPlannedSchema = z9.object({
+  phase: scopePhaseSchema,
+  state: plannedScopeStateSchema,
+  phaseNumber: z9.number().int().min(1),
+  planVersion: planVersionSchema,
+  parts: z9.array(scopeReadPartSchema).min(1).max(PHASE_PLAN_CHANGES_MAX),
+  decisions: z9.array(scopeReadDecisionSchema),
+  canDecide: z9.boolean(),
+  replanLine: z9.string().min(1).optional()
+}).strict();
+var scopeReadSchema = z9.union([scopeReadNotPlannedSchema, scopeReadPlannedSchema]);
+
+// ../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
+}).strict();
+var observedFilesSchema = z12.object({
+  added: observedCountSchema,
+  changed: observedCountSchema,
+  removed: observedCountSchema,
+  testFilesAdded: observedCountSchema
+}).strict().refine((v) => v.testFilesAdded <= v.added, {
+  message: "cannot be more than the files added",
+  path: ["testFilesAdded"]
+});
+function filesChanged(files) {
+  return files.added + files.changed + files.removed;
+}
+function pathsFitTheCount(files, paths) {
+  return files === null ? paths.length === 0 : paths.length <= filesChanged(files);
+}
+function checkPartsUnique(parts, ctx, at) {
+  const seen = /* @__PURE__ */ new Set();
+  parts.forEach((entry, i) => {
+    if (seen.has(entry.part)) {
+      ctx.addIssue({ code: "custom", path: [...at, i, "part"], message: `names the part "${entry.part}" twice` });
+    }
+    seen.add(entry.part);
+  });
+}
+var observedBasisCountSchema = z12.object({
+  outcome: z12.literal("count"),
+  phase: phaseNameSchema,
+  startCommit: closeCommitSchema,
+  descriptionVersion: observedDescriptionVersionSchema,
+  description: systemDescriptionSchema
+}).strict();
+var observedBasisCannotCountSchema = z12.object({
+  outcome: z12.literal("cannot-count"),
+  phase: phaseNameSchema,
+  reason: z12.literal("no-start-commit")
+}).strict();
+var observedBasisNothingToCountSchema = z12.object({
+  outcome: z12.literal("nothing-to-count"),
+  reason: z12.enum(["no-open-phase", "no-description"])
+}).strict();
+var observedBasisSchema = z12.discriminatedUnion("outcome", [
+  observedBasisCountSchema,
+  observedBasisCannotCountSchema,
+  observedBasisNothingToCountSchema
+]);
+var observedReportPartSchema = z12.object({
+  part: systemPartIdSchema,
+  added: observedCountSchema,
+  changed: observedCountSchema,
+  removed: observedCountSchema,
+  testFilesAdded: observedCountSchema
+}).strict().refine((v) => v.testFilesAdded <= v.added, {
+  message: "cannot be more than the files added",
+  path: ["testFilesAdded"]
+}).refine((v) => filesChanged(v) >= 1, {
+  message: "a part is listed only when at least one file changed under it",
+  path: ["added"]
+});
+var observedReportOutsideSchema = z12.object({
+  added: observedCountSchema,
+  changed: observedCountSchema,
+  removed: observedCountSchema,
+  testFilesAdded: observedCountSchema,
+  paths: observedPathListSchema
+}).strict().refine((v) => v.testFilesAdded <= v.added, {
+  message: "cannot be more than the files added",
+  path: ["testFilesAdded"]
+}).refine((v) => pathsFitTheCount(v, v.paths), {
+  message: "lists more paths than files changed",
+  path: ["paths"]
+});
+var observedChangesReportSchema = z12.object({
+  phase: phaseNameSchema,
+  startCommit: closeCommitSchema,
+  headCommit: closeCommitSchema,
+  headCommittedAt: utcIso8601,
+  commits: observedCountSchema,
+  descriptionVersion: observedDescriptionVersionSchema,
+  parts: z12.array(observedReportPartSchema).max(SYSTEM_PARTS_MAX, { message: `can list at most ${SYSTEM_PARTS_MAX} parts` }),
+  methodFiles: observedMethodFilesSchema,
+  outsideEveryPart: observedReportOutsideSchema,
+  codeLink: codeLinkFactsSchema
+}).strict().superRefine((v, ctx) => checkPartsUnique(v.parts, ctx, ["parts"]));
+var observedSaidSchema = z12.object({
+  title: buildTaskSchema.shape.title,
+  agent: buildTaskSchema.shape.agent,
+  whyOutsidePlan: buildTaskSchema.shape.whyOutsidePlan
+}).strict();
+var observedNotInPlanSchema = z12.object({
+  part: systemPartIdSchema,
+  name: systemPartSchema.shape.name,
+  said: z12.array(observedSaidSchema).max(BUILD_SNAPSHOT_TASK_LIMIT)
+}).strict();
+var observedChangesRecordedSchema = z12.object({
+  outcome: z12.literal("recorded"),
+  notInPlan: z12.array(observedNotInPlanSchema).max(SYSTEM_PARTS_MAX).superRefine((parts, ctx) => checkPartsUnique(parts, ctx, [])),
+  outside: z12.object({
+    files: observedCountSchema,
+    example: observedPathSchema.nullable()
+  }).strict().refine((v) => v.example === null || v.files >= 1, {
+    message: "names an example when no file changed",
+    path: ["example"]
+  })
+}).strict();
+var observedChangesKeptSchema = z12.object({
+  outcome: z12.literal("kept")
+}).strict();
+var observedChangesReportResultSchema = z12.discriminatedUnion("outcome", [
+  observedChangesRecordedSchema,
+  observedChangesKeptSchema
+]);
+var OBSERVE_NOT_SENT_REASONS = [
+  "not-configured",
+  "nothing-to-count",
+  "cannot-count",
+  "start-not-here",
+  "start-not-on-branch",
+  "basis-moved",
+  "refused",
+  "unreachable"
+];
+var observeRunRecordedSchema = 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/phase-review.js
+import { z as z13 } 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);
+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 REVIEW_ANSWER_MAX = 1e3;
+var reviewAgentAnswerSchema = z13.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 REVIEW_DECISIONS = Object.freeze(["accepted", "carried", "dropped"]);
+var reviewDecisionSchema = z13.enum(REVIEW_DECISIONS);
+function actOf(decision) {
+  if (decision === "accepted")
+    return "accept";
+  if (decision === "carried")
+    return "carry";
+  return "drop";
+}
+var reviewCarriedToSchema = carriedPhaseSchema.nullable();
+var reviewStepNameSchema = stepNameSchema.refine((v) => !stepIdSchema.safeParse(v.trim()).success, {
+  message: "must be the step's plain name"
+});
+var reviewStepSchema = z13.object({
+  name: reviewStepNameSchema.nullable(),
+  state: unfinishedStepSchema.shape.state,
+  judged: z13.boolean()
+}).strict();
+function codeLinkLine(link) {
+  switch (link.kind) {
+    case "github":
+      return link.scope === "part" ? `The code: ${link.url}` : `The code: ${link.url} GitHub cannot show only this part's code, so this opens every change in this phase.`;
+    case "range":
+      return link.why === "not-github" ? `The code is on your machine, not on GitHub. This phase's changes are ${shortCommit(link.from)}..${shortCommit(link.to)}.` : `This phase's newest changes are not on GitHub yet. They are ${shortCommit(link.from)}..${shortCommit(link.to)} on your machine.`;
+    case "none":
+      return void 0;
+    default:
+      return assertNever(link);
+  }
+}
+function assertNever(value) {
+  throw new Error(`unexpected value: ${JSON.stringify(value)}`);
+}
+var openReviewRequestSchema = z13.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()
+}).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)
+}).strict();
+var reviewOutstandingSchema = z13.object({
+  outcome: z13.literal("outstanding"),
+  steps: z13.array(reviewStepSchema).min(1)
+}).strict();
+var reviewCleanOverFindingsSchema = z13.object({
+  outcome: z13.literal("clean-over-findings"),
+  findings: z13.number().int().min(1)
+}).strict();
+var reviewRefusedSchema = z13.object({
+  outcome: z13.literal("refused"),
+  problems: z13.array(systemDescriptionProblemSchema).min(1)
+}).strict();
+function bareReviewOutcome(outcome) {
+  return z13.object({ outcome: z13.literal(outcome) }).strict();
+}
+var openReviewResultSchema = z13.discriminatedUnion("outcome", [
+  reviewOpenedSchema,
+  reviewTasksOpenSchema,
+  bareReviewOutcome("no-build"),
+  bareReviewOutcome("review-open"),
+  reviewOutstandingSchema,
+  reviewCleanOverFindingsSchema,
+  reviewRefusedSchema,
+  bareReviewOutcome("unavailable")
+]);
+var reviewPhaseNotOpenSchema = z13.object({
+  statusCode: z13.literal(409),
+  error: z13.literal("PhaseNotOpen"),
+  message: z13.string().min(1),
+  openPhase: z13.string().nullable()
+}).strict();
+var openReviewAnswerSchema = z13.union([openReviewResultSchema, reviewPhaseNotOpenSchema]);
+var reviewDecisionEntrySchema = z13.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)
+}).strict();
+var reviewDecidedSchema = z13.object({
+  part: systemPartIdSchema,
+  name: systemPartSchema.shape.name,
+  act: reviewActSchema,
+  carriedTo: reviewCarriedToSchema.optional()
+}).strict().refine((v) => v.carriedTo !== void 0 === (v.act === "carry"), {
+  message: "is present exactly on a carry",
+  path: ["carriedTo"]
+});
+var reviewRecordedSchema = 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)
+}).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({
+  part: systemPartIdSchema,
+  name: systemPartSchema.shape.name,
+  why: z13.enum(REVIEW_NOT_DECIDABLE_WHY)
+}).strict();
+var reviewNotDecidableSchema = z13.object({
+  outcome: z13.literal("not-decidable"),
+  parts: z13.array(reviewNotDecidablePartSchema).min(1).max(REVIEW_PARTS_MAX)
+}).strict();
+var reviewCloseRefusedSchema = z13.object({
+  outcome: z13.literal("close-refused"),
+  steps: z13.array(reviewStepSchema)
+}).strict();
+var reviewWalkChangedSchema = z13.object({
+  outcome: z13.literal("walk-changed"),
+  findings: z13.number().int().min(1)
+}).strict();
+var reviewDecisionResultSchema = z13.discriminatedUnion("outcome", [
+  reviewRecordedSchema,
+  bareReviewOutcome("review-changed"),
+  bareReviewOutcome("no-review"),
+  reviewNotDecidableSchema,
+  reviewCloseRefusedSchema,
+  reviewWalkChangedSchema,
+  bareReviewOutcome("not-owner"),
+  bareReviewOutcome("no-owner"),
+  reviewRefusedSchema,
+  bareReviewOutcome("unavailable")
+]);
+var reviewSentBackSchema = z13.object({
+  round: z13.number().int().min(1),
+  note: reviewNoteSchema
+}).strict();
+var reviewQuestionSchema = z13.object({
+  question: reviewNoteSchema,
+  agentAnswer: reviewAgentAnswerSchema.optional()
+}).strict();
+var reviewTaskSchema = z13.object({
+  title: buildTaskSchema.shape.title,
+  state: buildTaskStateSchema
+}).strict();
+var reviewViewPartSchema = z13.object({
+  part: systemPartIdSchema,
+  name: systemPartSchema.shape.name,
+  change: reviewPartChangeSchema,
+  built: z13.boolean(),
+  builtWithoutApproval: z13.boolean(),
+  decidable: z13.boolean(),
+  waiting: z13.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),
+  codeLink: partCodeLinkSchema
+}).strict().superRefine((v, ctx) => {
+  if (v.waiting !== (v.decision === void 0)) {
+    ctx.addIssue({ code: "custom", path: ["waiting"], message: "must be true exactly when the part has no decision" });
+  }
+  if (v.decidable && !v.waiting) {
+    ctx.addIssue({ code: "custom", path: ["decidable"], message: "cannot be true for a settled part" });
+  }
+  if (v.decision !== void 0 && !reviewActsFor(v.built).includes(actOf(v.decision))) {
+    ctx.addIssue({ code: "custom", path: ["decision"], message: "is not an act this part takes" });
+  }
+  const carriedOrDropped = v.decision === "carried" || v.decision === "dropped";
+  if (v.reason !== void 0 !== carriedOrDropped) {
+    ctx.addIssue({ code: "custom", path: ["reason"], message: "is present exactly on a carry or a drop" });
+  }
+  if (v.carriedTo !== void 0 !== (v.decision === "carried")) {
+    ctx.addIssue({ code: "custom", path: ["carriedTo"], message: "is present exactly on a carry" });
+  }
+  if (v.change === "not-in-plan" && !v.built) {
+    ctx.addIssue({ code: "custom", path: ["built"], message: "is always true for a part outside the plan" });
+  }
+});
+var reviewPhaseNumberSchema = z13.number().int().min(1).nullable();
+var phaseReviewNoneSchema = z13.object({
+  state: z13.literal("none"),
+  phase: scopePhaseSchema,
+  number: reviewPhaseNumberSchema,
+  closedWithoutReview: z13.boolean()
+}).strict();
+var reviewWalkSchema = z13.object({
+  verdict: walkVerdictSchema,
+  findings: z13.number().int().min(0)
+}).strict();
+function reviewedViewSchema(state) {
+  return z13.object({
+    state: z13.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(),
+    walk: reviewWalkSchema,
+    parts: z13.array(reviewViewPartSchema).max(REVIEW_PARTS_MAX),
+    observed: observedChangesSchema.nullable(),
+    description: systemDescriptionSchema
+  }).strict().superRefine((v, ctx) => {
+    const seen = /* @__PURE__ */ new Set();
+    v.parts.forEach((p, i) => {
+      if (seen.has(p.part))
+        ctx.addIssue({ code: "custom", path: ["parts", i, "part"], message: "is listed twice" });
+      seen.add(p.part);
+    });
+    const counted2 = v.observed !== null && v.observed.counting.state === "counted";
+    if (v.counted !== counted2) {
+      ctx.addIssue({ code: "custom", path: ["counted"], message: "must be true exactly when the counts are counted" });
+    }
+    if (v.observed !== null && v.observed.phase !== v.phase) {
+      ctx.addIssue({ code: "custom", path: ["observed", "phase"], message: "must be the phase under review" });
+    }
+    if (v.state === "closed") {
+      v.parts.forEach((p, i) => {
+        if (p.decision === void 0) {
+          ctx.addIssue({ code: "custom", path: ["parts", i, "decision"], message: "every part of a closed review is decided" });
+        }
+      });
+    }
+  });
+}
+var phaseReviewOpenSchema = reviewedViewSchema("open");
+var phaseReviewClosedSchema = reviewedViewSchema("closed");
+var phaseReviewViewSchema = z13.discriminatedUnion("state", [
+  phaseReviewNoneSchema,
+  phaseReviewOpenSchema,
+  phaseReviewClosedSchema
+]);
+
+// ../events/dist/build-record-v3.js
+var BUILD_RECORD_V3_FORMAT = "halfcycle-build-record/v3";
+var recordReviewRoundSchema = z14.object({
+  round: z14.number().int().min(1),
+  openedAt: utcIso8601,
+  verdict: walkVerdictSchema,
+  findings: z14.number().int().min(0)
+}).strict();
+var recordReviewApprovalSchema = z14.discriminatedUnion("kind", [
+  z14.object({
+    kind: z14.literal("approved"),
+    planVersion: planVersionSchema,
+    givenIn: scopeGivenInSchema,
+    approvedAt: utcIso8601
+  }).strict(),
+  z14.object({ kind: z14.literal("none") }).strict()
+]);
+var recordReviewGateSchema = z14.object({
+  gate: boardGateNameSchema,
+  state: boardStepStateSchema
+}).strict();
+var recordReviewQuestionSchema = z14.object({
+  question: reviewNoteSchema,
+  agentAnswer: reviewAgentAnswerSchema
+}).strict();
+var recordReviewPartSchema = z14.object({
+  part: systemPartIdSchema,
+  name: systemPartSchema.shape.name,
+  change: reviewPartChangeSchema,
+  built: z14.boolean(),
+  builtWithoutApproval: z14.boolean(),
+  decision: reviewDecisionSchema,
+  reason: reviewNoteSchema.optional(),
+  carriedTo: reviewCarriedToSchema.optional(),
+  sentBack: z14.array(reviewSentBackSchema),
+  questions: z14.array(recordReviewQuestionSchema),
+  codeLink: partCodeLinkSchema
+}).strict().superRefine((v, ctx) => {
+  const carriedOrDropped = v.decision === "carried" || v.decision === "dropped";
+  if (v.reason !== void 0 !== carriedOrDropped) {
+    ctx.addIssue({ code: "custom", path: ["reason"], message: "is present exactly on a carry or a drop" });
+  }
+  if (v.carriedTo !== void 0 !== (v.decision === "carried")) {
+    ctx.addIssue({ code: "custom", path: ["carriedTo"], message: "is present exactly on a carry" });
+  }
+});
+var SPINE_ORDER = boardGateNameSchema.options;
+var recordReviewGatesSchema = z14.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),
+  approval: recordReviewApprovalSchema,
+  planVersion: planVersionSchema.nullable(),
+  descriptionVersion: observedDescriptionVersionSchema,
+  gates: recordReviewGatesSchema,
+  observed: observedChangesSchema.nullable(),
+  parts: z14.array(recordReviewPartSchema).max(REVIEW_PARTS_MAX)
+}).strict().superRefine((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" });
+    }
+  });
+  const seen = /* @__PURE__ */ new Set();
+  v.parts.forEach((p, i) => {
+    if (seen.has(p.part))
+      ctx.addIssue({ code: "custom", path: ["parts", i, "part"], message: "is listed twice" });
+    seen.add(p.part);
+    if (v.observed === null && p.codeLink.kind !== "none") {
+      ctx.addIssue({ code: "custom", path: ["parts", i, "codeLink"], message: "must be none when nothing was observed" });
+    }
+  });
+});
+var buildRecordV3Schema = z14.object({
+  ...buildRecordV2Schema.shape,
+  format: z14.literal(BUILD_RECORD_V3_FORMAT),
+  review: recordReviewSchema
+}).strict().superRefine((record2, ctx) => {
+  checkRecordHalves(record2, ctx);
+  const closes = record2.observed.closes;
+  const newest = closes[closes.length - 1].sequence;
+  if (record2.review.sequence !== newest) {
+    ctx.addIssue({ code: "custom", path: ["review", "sequence"], message: "must be the newest close" });
+  }
+  const at = record2.attested.closes.findIndex((c) => c.sequence === record2.review.sequence);
+  const close = at === -1 ? void 0 : record2.attested.closes[at];
+  if (close !== void 0 && close.decision !== "done-when-met") {
+    ctx.addIssue({ code: "custom", path: ["attested", "closes", at, "decision"], message: "a close made by a review is done-when-met" });
+  }
+  const last = record2.review.rounds[record2.review.rounds.length - 1];
+  if (close !== void 0 && last !== void 0) {
+    const attested = close.walk === null ? null : close.walk.findings.length + close.walk.findingsNotShown;
+    if (attested !== last.findings) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["review", "rounds", record2.review.rounds.length - 1, "findings"],
+        message: "must equal the findings of the closing walk"
+      });
+    }
+  }
+  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 z6 } from "zod";
-var utcIso86012 = z6.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 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");
 var DEVICE_AUTH_STATUS = {
   /** The poll: minted, nobody has acted yet. Keep polling. 200. */
   PENDING: "pending",
@@ -974,25 +2214,25 @@ var DEVICE_POLL_REFUSALS = [
   DEVICE_AUTH_STATUS.EXPIRED,
   DEVICE_AUTH_STATUS.UNKNOWN
 ];
-var deviceAuthStartResponseSchema = z6.object({
-  deviceCode: z6.string().min(1),
-  userCode: z6.string().min(1),
-  verificationUrl: z6.string().min(1),
+var deviceAuthStartResponseSchema = z15.object({
+  deviceCode: z15.string().min(1),
+  userCode: z15.string().min(1),
+  verificationUrl: z15.string().min(1),
   expiresAt: utcIso86012,
-  pollIntervalMs: z6.number().int().positive()
+  pollIntervalMs: z15.number().int().positive()
 }).strict();
-var devicePollPendingSchema = z6.object({
-  status: z6.literal(DEVICE_AUTH_STATUS.PENDING),
-  pollIntervalMs: z6.number().int().positive()
+var devicePollPendingSchema = z15.object({
+  status: z15.literal(DEVICE_AUTH_STATUS.PENDING),
+  pollIntervalMs: z15.number().int().positive()
 }).strict();
-var devicePollApprovedSchema = z6.object({
-  status: z6.literal(DEVICE_AUTH_STATUS.APPROVED),
-  accountId: z6.string().min(1),
-  credential: z6.string().min(1),
+var devicePollApprovedSchema = z15.object({
+  status: z15.literal(DEVICE_AUTH_STATUS.APPROVED),
+  accountId: z15.string().min(1),
+  credential: z15.string().min(1),
   expiresAt: utcIso86012
 }).strict();
-var deviceAuthRefusalSchema = z6.object({
-  status: z6.enum([
+var deviceAuthRefusalSchema = z15.object({
+  status: z15.enum([
     DEVICE_AUTH_STATUS.DECLINED,
     DEVICE_AUTH_STATUS.EXPIRED,
     DEVICE_AUTH_STATUS.UNKNOWN,
@@ -1003,25 +2243,25 @@ var deviceAuthRefusalSchema = z6.object({
     DEVICE_AUTH_STATUS.ALREADY_DECIDED,
     DEVICE_AUTH_STATUS.TERMS_REQUIRED
   ]),
-  message: z6.string().min(1)
+  message: z15.string().min(1)
 }).strict();
-var devicePollResponseSchema = z6.union([
+var devicePollResponseSchema = z15.union([
   devicePollPendingSchema,
   devicePollApprovedSchema,
   deviceAuthRefusalSchema
 ]);
-var deviceConfirmRequestSchema = z6.object({
-  userCode: z6.string().min(1),
-  decision: z6.enum(["approve", "decline"]),
-  externalAuthId: z6.string().min(1).optional(),
-  email: z6.string().optional(),
-  acceptTerms: z6.boolean().optional()
+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()
 }).strict();
-var deviceConfirmRecordedSchema = z6.object({
-  status: z6.literal(DEVICE_AUTH_STATUS.RECORDED),
-  accountId: z6.string().min(1).optional()
+var deviceConfirmRecordedSchema = z15.object({
+  status: z15.literal(DEVICE_AUTH_STATUS.RECORDED),
+  accountId: z15.string().min(1).optional()
 }).strict();
-var deviceConfirmResponseSchema = z6.union([
+var deviceConfirmResponseSchema = z15.union([
   deviceConfirmRecordedSchema,
   deviceAuthRefusalSchema
 ]);
@@ -1033,20 +2273,20 @@ function projectPageUrl(engagementId) {
 }
 
 // ../events/dist/credential-wire.js
-import { z as z7 } from "zod";
-var engagementCredentialResponseSchema = z7.object({
-  engagementId: z7.string(),
-  sessionToken: z7.string(),
-  mcpUrl: z7.string(),
-  guardUrl: z7.string(),
-  controlTelemetryUrl: z7.string(),
-  methodVersion: z7.string().optional(),
-  consoleUrl: z7.string().optional()
+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()
 }).strict();
-var ciTokenExchangeResponseSchema = z7.object({
-  token: z7.string(),
+var ciTokenExchangeResponseSchema = z16.object({
+  token: z16.string(),
   expiresAt: utcIso8601,
-  engagementId: z7.string()
+  engagementId: z16.string()
 }).strict();
 var NO_CREDENTIAL_PLACEHOLDER = "halfcycle:no-credential";
 var NOT_THIS_ACCOUNT_PLACEHOLDER = "halfcycle:not-this-account";
@@ -1063,37 +2303,37 @@ var PLACEHOLDER_SENTENCES = Object.freeze({
 });
 
 // ../events/dist/phase-record.js
-import { z as z8 } from "zod";
-var phaseRecordRefusalReasonSchema = z8.enum([
+import { z as z17 } from "zod";
+var phaseRecordRefusalReasonSchema = z17.enum([
   "still-open",
   "reopened",
   "never-opened",
   "never-closed",
   "closed-before-records"
 ]);
-var phaseRecordRecordSchema = z8.object({
-  outcome: z8.literal("record"),
+var phaseRecordRecordSchema = z17.object({
+  outcome: z17.literal("record"),
   phase: phaseNameSchema,
-  record: buildRecordV2Schema
+  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 = z8.object({
-  outcome: z8.literal("withheld"),
+var phaseRecordWithheldSchema = z17.object({
+  outcome: z17.literal("withheld"),
   phase: phaseNameSchema,
-  sequence: z8.number().int().min(1),
+  sequence: z17.number().int().min(1),
   closedAt: utcIso8601,
-  message: z8.string()
+  message: z17.string()
 }).strict();
 var phaseRecordRefusedSchema = wireErrorSchema.extend({
-  outcome: z8.literal("refused"),
+  outcome: z17.literal("refused"),
   phase: phaseNameSchema,
-  statusCode: z8.literal(409),
-  error: z8.literal("PhaseRecordRefused"),
+  statusCode: z17.literal(409),
+  error: z17.literal("PhaseRecordRefused"),
   reason: phaseRecordRefusalReasonSchema
 }).strict();
-var phaseRecordResponseSchema = z8.discriminatedUnion("outcome", [
+var phaseRecordResponseSchema = z17.discriminatedUnion("outcome", [
   phaseRecordRecordSchema,
   phaseRecordWithheldSchema,
   phaseRecordRefusedSchema
@@ -1147,6 +2387,7 @@ var ENGAGEMENT_ENV_KEYS = [
   ...GUARD_ENV_KEYS,
   "CONTROL_TELEMETRY_URL"
 ];
+var PHASE_STAMP_ENV_KEY = "HALFCYCLE_PHASE";
 function reconcileEnvText2(existing, values, keys = ENGAGEMENT_ENV_KEYS) {
   return reconcileEnvText(existing, values, keys);
 }
@@ -1247,7 +2488,7 @@ halfcycle_env_file() {
 
 // dist/identity.js
 import { execFileSync } from "node:child_process";
-import { existsSync, linkSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync, linkSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname2, isAbsolute, join as join3 } from "node:path";
 import { randomUUID } from "node:crypto";
 var PROJECT_IDENTITY_NOTE = 'projectId is NOT the engagement id \u2014 it identifies this repository/worktree to Halfcycle, not an engagement. The engagement id lives in .halfcycle/bundle.json, in its "engagementId" field.';
@@ -1296,6 +2537,41 @@ function readRootCommit(targetRepoRoot) {
 function readRemote(targetRepoRoot) {
   return git(targetRepoRoot, ["remote", "get-url", "origin"]);
 }
+function stripUrlUserinfoTextually(trimmed) {
+  const schemeEnd = trimmed.indexOf("://") + 3;
+  const pathStart = (() => {
+    const match = /[/?#]/.exec(trimmed.slice(schemeEnd));
+    return match ? schemeEnd + match.index : trimmed.length;
+  })();
+  const authority = trimmed.slice(schemeEnd, pathStart);
+  const at = authority.lastIndexOf("@");
+  if (at === -1)
+    return trimmed;
+  return trimmed.slice(0, schemeEnd) + authority.slice(at + 1) + trimmed.slice(pathStart);
+}
+function redactRemoteCredential(remote) {
+  if (remote === null)
+    return null;
+  const trimmed = remote.trim();
+  if (trimmed.includes("://")) {
+    try {
+      const url = new URL(trimmed);
+      if (url.username === "" && url.password === "")
+        return trimmed;
+      url.username = "";
+      url.password = "";
+      return url.toString();
+    } catch {
+      return stripUrlUserinfoTextually(trimmed);
+    }
+  }
+  const at = trimmed.lastIndexOf("@");
+  if (at === -1)
+    return trimmed;
+  const userinfo = trimmed.slice(0, at);
+  const rest = trimmed.slice(at + 1);
+  return userinfo.includes(":") && rest.includes(":") ? rest : trimmed;
+}
 function readIgnoredPaths(targetRepoRoot, paths) {
   if (paths.length === 0)
     return null;
@@ -1331,11 +2607,12 @@ function readIgnoredPaths(targetRepoRoot, paths) {
 function mintOrReadIdentity(targetRepoRoot) {
   const path = join3(targetRepoRoot, ".halfcycle", "project.json");
   if (existsSync(path)) {
+    repairRemoteCredential(targetRepoRoot);
     const onDisk = JSON.parse(readFileSync2(path, "utf-8"));
     const identity = {
       projectId: onDisk.projectId ?? "",
       rootCommit: onDisk.rootCommit ?? null,
-      remote: onDisk.remote ?? null,
+      remote: redactRemoteCredential(onDisk.remote ?? null),
       note: PROJECT_IDENTITY_NOTE
     };
     return { identity, minted: false };
@@ -1346,10 +2623,40 @@ function mintIdentity(targetRepoRoot) {
   return {
     projectId: randomUUID(),
     rootCommit: readRootCommit(targetRepoRoot),
-    remote: readRemote(targetRepoRoot),
+    remote: redactRemoteCredential(readRemote(targetRepoRoot)),
     note: PROJECT_IDENTITY_NOTE
   };
 }
+function repairRemoteCredential(targetRepoRoot) {
+  const path = join3(targetRepoRoot, ".halfcycle", "project.json");
+  let onDisk;
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf-8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+      return;
+    onDisk = parsed;
+  } catch {
+    return;
+  }
+  const storedRemote = onDisk.remote ?? null;
+  const remote = redactRemoteCredential(storedRemote);
+  if (remote === storedRemote)
+    return;
+  const identity = {
+    projectId: onDisk.projectId ?? "",
+    rootCommit: onDisk.rootCommit ?? null,
+    remote,
+    note: PROJECT_IDENTITY_NOTE
+  };
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync2(temporary, serializeProjectIdentity(identity), { encoding: "utf-8", flag: "wx" });
+    renameSync(temporary, path);
+  } catch {
+  } finally {
+    rmSync(temporary, { force: true });
+  }
+}
 function serializeProjectIdentity(identity) {
   return JSON.stringify(identity, null, 2) + "\n";
 }
@@ -2399,18 +3706,21 @@ exit 0
 var GENERATED_USER_PROMPT_SCOPE_HEADER = "# Typed scope approval \u2014 generated by";
 function generateUserPromptScopeHook() {
   return `#!/usr/bin/env bash
-${GENERATED_USER_PROMPT_SCOPE_HEADER} the Halfcycle installer.
+${GENERATED_USER_PROMPT_SCOPE_HEADER} the Halfcycle installer, now also for the close review.
 #
-# Lets the owner of this project approve a phase's scope, or send it back, by
-# typing "approve <phase>" or "send back <phase>: <note>" as the whole prompt in
-# their own Claude Code session.
+# Lets the owner of this project approve a phase's scope, or send it back, and
+# decide one part of a phase's close review, by typing one line as the whole
+# prompt in their own Claude Code session: "approve <phase>", "send back
+# <phase>: <note>", "accept <phase>/<part>", "question <phase>/<part>: <words>",
+# "carry <phase>/<part>: <words>" or "drop <phase>/<part>: <words>".
 #
 # AN ORDINARY PROMPT STARTS NOTHING. This script reads the hook input once and
 # looks only at the start of the prompt's value. Unless the prompt begins, after
-# any whitespace (typed, or escaped in the input), with "approve " or
-# "send back " in any case, it exits 0 with no output, and Node never starts.
-# A quote inside any other field arrives escaped, so no other field (the folder
-# the session is in, for one) can read as the start of the prompt.
+# any whitespace (typed, or escaped in the input), with "approve ", "send back ",
+# "accept ", "question ", "carry " or "drop ", in any case, it exits 0 with no
+# output, and Node never starts. A quote inside any other field arrives escaped,
+# so no other field (the folder the session is in, for one) can read as the
+# start of the prompt.
 #
 # Otherwise it finds the project root from its own location, never from the
 # folder the session has moved to, and hands the same input to the guard
@@ -2431,7 +3741,7 @@ IFS= read -r -d '' HC_INPUT || true
 # \\u escape, or as the UTF-8 bytes of a Unicode space. Compared byte for byte.
 HC_LEAD='[[:space:]]|\\\\[nrtf]|\\\\u(000[9a-d]|0020|00a0|1680|200[0-9a]|202[89f]|205f|3000|feff)'
 HC_LEAD="$HC_LEAD|"$'\\xc2\\xa0|\\xe1\\x9a\\x80|\\xe2\\x80[\\x80-\\x8a\\xa8\\xa9\\xaf]|\\xe2\\x81\\x9f|\\xe3\\x80\\x80|\\xef\\xbb\\xbf'
-if ! printf '%s' "$HC_INPUT" | LC_ALL=C grep -Eiq "\\"prompt\\"[[:space:]]*:[[:space:]]*\\"($HC_LEAD)*(approve|send back) "; then
+if ! printf '%s' "$HC_INPUT" | LC_ALL=C grep -Eiq "\\"prompt\\"[[:space:]]*:[[:space:]]*\\"($HC_LEAD)*(approve|send back|accept|question|carry|drop) "; then
   exit 0
 fi
 
@@ -2711,8 +4021,10 @@ function checkDrift(targetRepoRoot) {
   return { drifted: installed !== current, installed, current, methodVersion: pin?.methodVersion ?? null };
 }
 function writeProjectIdentity(targetRepo) {
-  if (existsSync3(join5(targetRepo, PROJECT_IDENTITY_REL)))
+  if (existsSync3(join5(targetRepo, PROJECT_IDENTITY_REL))) {
+    repairRemoteCredential(targetRepo);
     return "skipped";
+  }
   createProjectIdentityFile(targetRepo);
   return "written";
 }
@@ -3682,6 +4994,32 @@ function printRecordText(text) {
   });
   return out;
 }
+var MARKUP = /[\\`*_~$<>&[\]{}#|]/;
+function printStrictText(text) {
+  if (text === "")
+    return "(blank)";
+  let out = "";
+  for (const ch of text) {
+    if (HIDDEN.test(ch))
+      out += `U+${ch.codePointAt(0).toString(16).toUpperCase().padStart(4, "0")}`;
+    else if (MARKUP.test(ch))
+      out += `\\${ch}`;
+    else
+      out += ch;
+  }
+  return out;
+}
+function printItemStartText(text) {
+  const out = printStrictText(text);
+  if (out.startsWith(" "))
+    return `&#32;${out.slice(1)}`;
+  if (out.startsWith("-") || out.startsWith("+"))
+    return `\\${out}`;
+  const ordered = /^(\d{1,9})([.)])/.exec(out);
+  if (ordered !== null)
+    return `${ordered[1]}\\${out.slice(ordered[1].length)}`;
+  return out;
+}
 function makePrinter() {
   let hidden = false;
   return {
@@ -3690,6 +5028,16 @@ function makePrinter() {
         hidden = true;
       return printRecordText(value);
     },
+    strict(value) {
+      if (!hidden && HIDDEN.test(value))
+        hidden = true;
+      return printStrictText(value);
+    },
+    itemStart(value) {
+      if (!hidden && HIDDEN.test(value))
+        hidden = true;
+      return printItemStartText(value);
+    },
     sawHidden() {
       return hidden;
     }
@@ -3905,6 +5253,52 @@ function renderClose(heading, observed, attested, checks, p) {
     renderStated(attested, p)
   ];
 }
+var REVIEW_LABEL = "**Recorded by Halfcycle from the owner's review.** Each part the review held, and how the project's owner decided it. A line marked as the agent's is the agent's own answer, not Halfcycle's.";
+var REVIEW_NO_PARTS = "The review had no parts, so it closed on one accept that names no part.";
+function approvalLine(approval) {
+  if (approval.kind === "none")
+    return "Built without an approved scope.";
+  const where = approval.givenIn === "console" ? "in the console" : "in their own session";
+  return `Scope approved by the project's owner, plan version ${String(approval.planVersion)}, ${where}.`;
+}
+function decisionText(part, p) {
+  switch (part.decision) {
+    case "accepted":
+      return "Accepted";
+    case "carried":
+      return part.carriedTo === null || part.carriedTo === void 0 ? `Carried to the next phase planned: ${p.text(part.reason ?? "")}` : `Carried to phase ${String(part.carriedTo.number)}: ${p.text(part.reason ?? "")}`;
+    case "dropped":
+      return `Dropped: ${p.text(part.reason ?? "")}`;
+  }
+}
+function reviewPartLines(part, p) {
+  const lines = [`- ${p.itemStart(part.name)} \u2014 ${decisionText(part, p)}`];
+  const code = codeLinkLine(part.codeLink);
+  if (code !== void 0)
+    lines.push(`  - ${p.text(code)}`);
+  for (const sent of part.sentBack)
+    lines.push(`  - Sent back in round ${String(sent.round)}: ${p.text(sent.note)}`);
+  for (const q of part.questions) {
+    lines.push(`  - Question: ${p.text(q.question)}`);
+    lines.push(`  - The agent answered: ${p.text(q.agentAnswer)}`);
+  }
+  return lines;
+}
+function removalsLine(record2, p) {
+  const removals = removalsOf(record2);
+  if (removals.length === 0)
+    return null;
+  return `Take these parts out of docs/system.json: ${removals.map((r) => `"${p.strict(r.name)}" (${r.act})`).join(", ")}.`;
+}
+function renderReview(record2, p) {
+  const review = record2.review;
+  const blocks = ["## The owner's review", REVIEW_LABEL, approvalLine(review.approval)];
+  blocks.push(review.parts.length === 0 ? REVIEW_NO_PARTS : review.parts.flatMap((part) => reviewPartLines(part, p)).join("\n"));
+  const removals = removalsLine(record2, p);
+  if (removals !== null)
+    blocks.push(removals);
+  return blocks;
+}
 function renderBuildRecordV2Markdown(record2) {
   const p = makePrinter();
   const attestedBySequence = /* @__PURE__ */ new Map();
@@ -3930,6 +5324,8 @@ function renderBuildRecordV2Markdown(record2) {
     ...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)
   ];
+  if (record2.format === "halfcycle-build-record/v3")
+    body.push(...renderReview(record2, p));
   if (total > 1) {
     body.push("## Earlier closes");
     for (const close of closes.slice(0, -1)) {
@@ -3944,7 +5340,7 @@ function renderBuildRecordV2Markdown(record2) {
 }
 
 // dist/build-record/write.js
-import { closeSync, existsSync as existsSync6, mkdirSync as mkdirSync6, openSync, readFileSync as readFileSync7, renameSync, rmSync as rmSync3, writeSync } from "node:fs";
+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) {
@@ -3970,7 +5366,7 @@ function createExclusiveOnDisk(path, data) {
   closeSync(fd);
 }
 function renameOnDisk(from, to) {
-  renameSync(from, to);
+  renameSync2(from, to);
 }
 var NODE_RECORD_PAIR_IO = {
   createExclusive: createExclusiveOnDisk,
@@ -3996,7 +5392,7 @@ function isOwnEarlierRecord(existingText, served) {
   } catch {
     return false;
   }
-  const existing = buildRecordV2Schema.safeParse(parsedJson);
+  const existing = buildRecordSchema.safeParse(parsedJson);
   if (!existing.success)
     return false;
   const old = existing.data;
@@ -4079,6 +5475,23 @@ function replaceOne(io, tmp, finalPath, text) {
 // dist/build-record/obtain.js
 import { relative as relative3 } from "node:path";
 
+// dist/open-phase.js
+function writePhaseStamp(engagementId, phase, home) {
+  if (!isEngagementId(engagementId)) {
+    return { path: "(none \u2014 no valid project id)", reason: new InvalidEngagementIdError(engagementId).message };
+  }
+  const path = engagementEnvPath(engagementId, home);
+  if (phase !== null && !isValidPhaseIdentity(phase)) {
+    return { path, reason: new InvalidPhaseIdentityError(phase).message };
+  }
+  try {
+    writeEngagementEnv(engagementId, { [PHASE_STAMP_ENV_KEY]: phase }, home, [PHASE_STAMP_ENV_KEY]);
+    return null;
+  } catch (err) {
+    return { path, reason: err instanceof Error ? err.message : String(err) };
+  }
+}
+
 // dist/missing-route.js
 var MESSAGE = {
   GET: /^Route GET .* not found\.$/s,
@@ -4105,7 +5518,13 @@ var REFUSAL_REASONS = phaseRecordRefusalReasonSchema.options;
 function buildRecordUrl(credential, phase) {
   return `${credential.serviceUrl}/engagements/${encodeURIComponent(credential.engagementId)}/phases/${encodeURIComponent(phase)}/build-record`;
 }
-async function obtainBuildRecord(credential, repoRoot, phase, io = NODE_RECORD_PAIR_IO) {
+function clearStampFor(engagementId, phase, home) {
+  const stamped = readEngagementEnv(engagementId, home)?.[PHASE_STAMP_ENV_KEY];
+  if (stamped !== phase)
+    return null;
+  return writePhaseStamp(engagementId, null, home);
+}
+async function obtainBuildRecord(credential, repoRoot, phase, io = NODE_RECORD_PAIR_IO, home) {
   const url = buildRecordUrl(credential, phase);
   let res;
   let text;
@@ -4158,7 +5577,8 @@ async function obtainBuildRecord(credential, repoRoot, phase, io = NODE_RECORD_P
       kind: "written",
       jsonPath: relative3(repoRoot, result.jsonPath),
       mdPath: relative3(repoRoot, result.mdPath),
-      headline: latestCloseHeadline(answer.record)
+      headline: latestCloseHeadline(answer.record),
+      stampFailure: clearStampFor(credential.engagementId, phase, home)
     };
   }
   if (isMissingRoute("GET", res.status, raw)) {