halfcycle 0.3.7

package/dist/bin.js

@@ -0,0 +1,3156 @@
+#!/usr/bin/env node
+
+// dist/bin.js
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { readFileSync as readFileSync8 } from "node:fs";
+import { join as join9 } from "node:path";
+
+// dist/install.js
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname2, join as join5, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// dist/engagement-credential.js
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { platform as platform2 } from "node:os";
+import { join as join2 } from "node:path";
+
+// dist/account-credential.js
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { dirname, join } from "node:path";
+function halfcycleHome(home) {
+  return join(home ?? homedir(), ".halfcycle");
+}
+function accountStorePath(home) {
+  return join(halfcycleHome(home), "account.json");
+}
+function normaliseOrigin(serviceUrl) {
+  return serviceUrl.trim().replace(/\/+$/, "").toLowerCase();
+}
+function readStore(home) {
+  let raw;
+  try {
+    raw = readFileSync(accountStorePath(home), "utf-8");
+  } catch {
+    return { version: 1, accounts: {} };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || typeof parsed.accounts !== "object") {
+      return { version: 1, accounts: {} };
+    }
+    return { version: 1, accounts: parsed.accounts ?? {} };
+  } catch {
+    return { version: 1, accounts: {} };
+  }
+}
+function writeStore(store, home) {
+  const path = accountStorePath(home);
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  writeFileSync(path, `${JSON.stringify(store, null, 2)}
+`, { mode: 384 });
+  if (platform() !== "win32") {
+    chmodSync(path, 384);
+    try {
+      chmodSync(dirname(path), 448);
+    } catch {
+    }
+  }
+}
+function readStoredCredential(serviceUrl, home) {
+  const entry = readStore(home).accounts[normaliseOrigin(serviceUrl)];
+  if (!entry || typeof entry.credential !== "string" || entry.credential.trim() === "") {
+    return void 0;
+  }
+  return entry;
+}
+function writeStoredCredential(serviceUrl, entry, home) {
+  const store = readStore(home);
+  store.accounts[normaliseOrigin(serviceUrl)] = {
+    accountId: entry.accountId,
+    credential: entry.credential,
+    expiresAt: entry.expiresAt,
+    signedInAt: entry.signedInAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeStore(store, home);
+}
+function forgetStoredCredential(serviceUrl, home) {
+  const store = readStore(home);
+  const key = normaliseOrigin(serviceUrl);
+  if (!(key in store.accounts))
+    return false;
+  delete store.accounts[key];
+  writeStore(store, home);
+  return true;
+}
+
+// dist/engagement-credential.js
+var ENGAGEMENTS_DIR = "engagements";
+var ENV_FILENAME = "env";
+var PIN_ENGAGEMENT_ID_FIELD = "engagementId";
+function engagementStateDir(engagementId, home) {
+  return join2(halfcycleHome(home), ENGAGEMENTS_DIR, engagementId);
+}
+function engagementEnvPath(engagementId, home) {
+  return join2(engagementStateDir(engagementId, home), ENV_FILENAME);
+}
+var GUARD_ENV_KEYS = [
+  "GUARD_SERVICE_URL",
+  "GUARD_SERVICE_TOKEN",
+  "GUARD_ENGAGEMENT_ID"
+];
+var ENGAGEMENT_ENV_KEYS = [
+  "HALFCYCLE_SERVICE_URL",
+  "HALFCYCLE_MCP_URL",
+  "HALFCYCLE_TOKEN",
+  "HALFCYCLE_ENGAGEMENT_ID",
+  ...GUARD_ENV_KEYS,
+  "CONTROL_TELEMETRY_URL"
+];
+var ENV_HEADER = "# Halfcycle per-engagement credential \u2014 machine level, owner-only, never in a repository.";
+function shq(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function unquote(value) {
+  const v = value.trim();
+  if (v.length >= 2 && v.startsWith("'") && v.endsWith("'")) {
+    return v.slice(1, -1).split(`'\\''`).join(`'`);
+  }
+  if (v.length >= 2 && v.startsWith('"') && v.endsWith('"'))
+    return v.slice(1, -1);
+  return v;
+}
+function parseEnvText(raw) {
+  const out = {};
+  for (const line of raw.split("\n")) {
+    const eq = line.indexOf("=");
+    if (eq === -1)
+      continue;
+    const key = line.slice(0, eq).replace(/^\s*export\s+/, "").trim();
+    if (key === "" || key.startsWith("#"))
+      continue;
+    out[key] = unquote(line.slice(eq + 1));
+  }
+  return out;
+}
+function reconcileEnvText(existing, values, keys = ENGAGEMENT_ENV_KEYS) {
+  const desired = new Map(keys.map((k) => [k, values[k] ?? ""]));
+  const line = (k) => `${k}=${shq(desired.get(k) ?? "")}`;
+  if (existing === null) {
+    return `${ENV_HEADER}
+` + keys.map(line).join("\n") + "\n";
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const out = existing.split("\n").map((existingLine) => {
+    const eq = existingLine.indexOf("=");
+    if (eq === -1)
+      return existingLine;
+    const lhs = existingLine.slice(0, eq);
+    const exported = /^\s*export\s+/.exec(lhs);
+    const prefix = exported === null ? "" : exported[0];
+    const key = lhs.slice(prefix.length).trim();
+    if (desired.has(key)) {
+      seen.add(key);
+      return `${prefix}${line(key)}`;
+    }
+    return existingLine;
+  });
+  const missing = keys.filter((k) => !seen.has(k));
+  if (missing.length > 0) {
+    const trailingBlank = out.length > 0 && out[out.length - 1] === "";
+    const prefix = trailingBlank ? "" : existing.endsWith("\n") ? "" : "\n";
+    out.push(`${prefix}${ENV_HEADER}
+` + missing.map(line).join("\n"));
+  }
+  let result = out.join("\n");
+  if (existing.endsWith("\n") && !result.endsWith("\n"))
+    result += "\n";
+  return result;
+}
+function readEngagementEnv(engagementId, home) {
+  try {
+    return parseEnvText(readFileSync2(engagementEnvPath(engagementId, home), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeEngagementEnv(engagementId, values, home) {
+  const path = engagementEnvPath(engagementId, home);
+  const dir = engagementStateDir(engagementId, home);
+  mkdirSync2(dir, { recursive: true, mode: 448 });
+  let existing;
+  try {
+    existing = readFileSync2(path, "utf-8");
+  } catch {
+    existing = null;
+  }
+  const reconciled = reconcileEnvText(existing, values);
+  const outcome = existing === reconciled ? "skipped" : "written";
+  if (outcome === "written") {
+    writeFileSync2(path, reconciled, { mode: 384 });
+  }
+  applyOwnerOnly(path, dir);
+  return outcome;
+}
+function applyOwnerOnly(path, dir) {
+  if (platform2() === "win32")
+    return;
+  try {
+    chmodSync2(path, 384);
+  } catch {
+  }
+  try {
+    chmodSync2(dir, 448);
+  } catch {
+  }
+}
+function engagementResolutionShell() {
+  return `# --- Halfcycle credential resolution (generated; do not edit) ----------------
+# THE CREDENTIAL IS NOT IN THIS REPOSITORY. It lives at
+#   $HOME/.halfcycle/${ENGAGEMENTS_DIR}/<engagement-id>/${ENV_FILENAME}
+# written owner-only by \`npx halfcycle\`. What this repository holds is the
+# engagement id, in the committed .halfcycle/bundle.json. So: read the id out of
+# the pin, then name the file. There is no jq here and node is not dependable on a
+# desktop session's PATH, so the id is cut out with sed \u2014 after flattening the
+# file, because sed is line-oriented and the pin's line breaks are not a contract.
+#
+# Sets HALFCYCLE_ENV_FILE, HALFCYCLE_ENV_ENGAGEMENT and HALFCYCLE_ENV_PROBLEM in
+# the CALLER's shell and returns a status. Call it as \`if halfcycle_env_file \u2026\`,
+# never as \`$(halfcycle_env_file \u2026)\` \u2014 a command substitution is a subshell and
+# would discard everything it set.
+halfcycle_env_file() {
+  HALFCYCLE_ENV_FILE=""
+  HALFCYCLE_ENV_ENGAGEMENT=""
+  HALFCYCLE_ENV_PROBLEM=""
+  hc_pin="$1/.halfcycle/bundle.json"
+  if [ ! -f "$hc_pin" ]; then
+    HALFCYCLE_ENV_PROBLEM="no-pin"
+    return 1
+  fi
+  hc_id=$(tr -d '\\n' < "$hc_pin" | sed -n 's/.*"${PIN_ENGAGEMENT_ID_FIELD}"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/p')
+  if [ -z "$hc_id" ]; then
+    HALFCYCLE_ENV_PROBLEM="no-id"
+    return 1
+  fi
+  HALFCYCLE_ENV_ENGAGEMENT="$hc_id"
+  if [ -z "\${HOME:-}" ]; then
+    HALFCYCLE_ENV_PROBLEM="no-home"
+    return 1
+  fi
+  hc_env="$HOME/.halfcycle/${ENGAGEMENTS_DIR}/$hc_id/${ENV_FILENAME}"
+  if [ ! -f "$hc_env" ]; then
+    HALFCYCLE_ENV_PROBLEM="no-credential"
+    return 1
+  fi
+  HALFCYCLE_ENV_FILE="$hc_env"
+  return 0
+}
+# --- end Halfcycle credential resolution ------------------------------------`;
+}
+
+// dist/identity.js
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync as readFileSync3 } from "node:fs";
+import { 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.';
+function git(targetRepoRoot, args2) {
+  try {
+    const out = execFileSync("git", ["-C", targetRepoRoot, ...args2], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const trimmed = out.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  } catch {
+    return null;
+  }
+}
+function readRootCommit(targetRepoRoot) {
+  const roots = git(targetRepoRoot, ["rev-list", "--max-parents=0", "HEAD"]);
+  if (!roots)
+    return null;
+  const lines = roots.split("\n").filter((l) => l.length > 0);
+  return lines.length > 0 ? lines[lines.length - 1] : null;
+}
+function readRemote(targetRepoRoot) {
+  return git(targetRepoRoot, ["remote", "get-url", "origin"]);
+}
+function mintOrReadIdentity(targetRepoRoot) {
+  const path = join3(targetRepoRoot, ".halfcycle", "project.json");
+  if (existsSync(path)) {
+    const onDisk = JSON.parse(readFileSync3(path, "utf-8"));
+    const identity2 = {
+      projectId: onDisk.projectId ?? "",
+      rootCommit: onDisk.rootCommit ?? null,
+      remote: onDisk.remote ?? null,
+      note: PROJECT_IDENTITY_NOTE
+    };
+    return { identity: identity2, minted: false };
+  }
+  const identity = {
+    projectId: randomUUID(),
+    rootCommit: readRootCommit(targetRepoRoot),
+    remote: readRemote(targetRepoRoot),
+    note: PROJECT_IDENTITY_NOTE
+  };
+  return { identity, minted: true };
+}
+
+// dist/mcp-endpoint.js
+var MCP_ENDPOINT_PATH = "/mcp";
+function mcpEndpointUrl(origin) {
+  return `${origin.trim().replace(/\/+$/, "")}${MCP_ENDPOINT_PATH}`;
+}
+
+// dist/merge-settings.js
+function isHalfcycleEntry(entry, halfcycleCommands) {
+  return entry.hooks.some((h) => halfcycleCommands.has(h.command));
+}
+function mergeSettings(existing, generated) {
+  const merged = { ...existing };
+  if (generated.$schema !== void 0) {
+    merged.$schema = generated.$schema;
+  }
+  const generatedHooks = generated.hooks ?? {};
+  const halfcycleCommands = /* @__PURE__ */ new Set();
+  for (const entries of Object.values(generatedHooks)) {
+    for (const entry of entries) {
+      for (const h of entry.hooks)
+        halfcycleCommands.add(h.command);
+    }
+  }
+  const existingHooks = existing.hooks ?? {};
+  const mergedHooks = {};
+  const events = /* @__PURE__ */ new Set([...Object.keys(existingHooks), ...Object.keys(generatedHooks)]);
+  for (const event of events) {
+    const developerEntries = (existingHooks[event] ?? []).filter((entry) => !isHalfcycleEntry(entry, halfcycleCommands));
+    const halfcycleEntries = generatedHooks[event] ?? [];
+    mergedHooks[event] = [...developerEntries, ...halfcycleEntries];
+  }
+  merged.hooks = mergedHooks;
+  merged.permissions = mergePermissions(existing.permissions, generated.permissions);
+  return merged;
+}
+function mergePermissions(existing, generated) {
+  if (existing === void 0 && generated === void 0)
+    return void 0;
+  const result = { ...existing ?? {} };
+  const generatedDeny = generated?.deny ?? [];
+  if (generatedDeny.length > 0) {
+    const theirs = existing?.deny ?? [];
+    const seen = new Set(theirs);
+    result.deny = [...theirs, ...generatedDeny.filter((p) => !seen.has(p))];
+  }
+  return result;
+}
+
+// dist/scan.js
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+
+// ../events/dist/result.js
+import { z as z2 } from "zod";
+
+// ../core/dist/guard-record.js
+import { z } from "zod";
+var severitySchema = z.enum(["info", "warn", "block"]);
+var channelSchema = z.enum(["stable", "candidate", "rented"]);
+var matcherKindSchema = z.enum(["grep", "ast", "integrationTest", "llm"]);
+var matcherConfigSchema = z.record(z.string(), z.unknown());
+var grepMatcherSchema = z.object({ kind: z.literal("grep"), config: matcherConfigSchema }).strict();
+var astMatcherSchema = z.object({ kind: z.literal("ast"), config: matcherConfigSchema }).strict();
+var integrationTestMatcherSchema = z.object({ kind: z.literal("integrationTest"), config: matcherConfigSchema }).strict();
+var llmMatcherSchema = z.object({ kind: z.literal("llm"), config: matcherConfigSchema }).strict();
+var matcherSchema = z.discriminatedUnion("kind", [
+  grepMatcherSchema,
+  astMatcherSchema,
+  integrationTestMatcherSchema,
+  llmMatcherSchema
+]);
+
+// ../events/dist/result.js
+var firedGuardSchema = z2.object({
+  guardId: z2.string(),
+  patternRef: z2.string(),
+  severity: severitySchema,
+  explanation: z2.string()
+}).strict();
+var resultEnvelopeSchema = z2.object({
+  guardsFired: z2.array(firedGuardSchema),
+  severity: severitySchema.nullable(),
+  blocking: z2.boolean(),
+  explanation: z2.string()
+}).strict();
+var wireErrorSchema = z2.object({
+  statusCode: z2.number(),
+  error: z2.string(),
+  message: z2.string()
+}).strict();
+
+// ../events/dist/telemetry.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 (INV-015)");
+var guardEvalOutcomeSchema = z3.enum([
+  "evaluated",
+  "infra-error",
+  "contract-error",
+  "unconfigured"
+]);
+var guardEvalRunSchema = z3.object({
+  // `runId`/`outcome` are the E2 run-observability additions, declared
+  // field-level-OPTIONAL as the FIRST (expand) step of an expand-contract
+  // migration. Every new record populated by the migrated writer (T-07)
+  // carries both; a legacy line predating the amendment carries neither and
+  // must still parse (the mixed-era guard-eval log the Build-Record reader
+  // assembles from, and the runner emit not yet migrated). So the presence
+  // refinement below is skipped for a legacy line (no `outcome`), and the
+  // per-writer guarantee lives with the writer + reader-normalisation (T-07),
+  // where the schema may then be tightened to required. runId is uuid-checked
+  // WHEN present; outcome is enum-checked when present.
+  runId: z3.string().uuid().optional(),
+  engagementId: z3.string().optional(),
+  runType: z3.enum(["hook", "ci"]),
+  occurredAt: utcIso8601,
+  outcome: guardEvalOutcomeSchema.optional(),
+  failureReason: z3.string().optional(),
+  phase: z3.string().optional(),
+  scope: z3.record(z3.string(), z3.unknown()),
+  cost: z3.record(z3.string(), z3.unknown()).optional(),
+  result: resultEnvelopeSchema.optional()
+}).strict().superRefine((run, ctx) => {
+  if (run.outcome === void 0)
+    return;
+  if (run.outcome === "evaluated" && run.result === void 0) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      path: ["result"],
+      message: "result is required when outcome is 'evaluated'"
+    });
+  }
+  if (run.outcome !== "evaluated" && run.result !== void 0) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      path: ["result"],
+      message: "result is only present when outcome is 'evaluated'"
+    });
+  }
+  if (run.outcome !== "unconfigured" && run.engagementId === void 0) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      path: ["engagementId"],
+      message: "engagementId is required unless outcome is 'unconfigured'"
+    });
+  }
+});
+
+// ../events/dist/engagement-lifecycle.js
+import { z as z4 } from "zod";
+var utcIso86012 = 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 (INV-015)");
+var engagementTypeSchema = z4.enum(["client"]);
+var lifecycleStatusSchema = z4.enum(["active", "delivering", "closed"]);
+var createEngagementRequestSchema = z4.object({
+  name: z4.string(),
+  region: z4.string(),
+  engagementType: engagementTypeSchema
+}).strict();
+var createEngagementResponseSchema = z4.object({
+  engagementId: z4.string(),
+  name: z4.string(),
+  region: z4.string(),
+  status: lifecycleStatusSchema,
+  createdAt: utcIso86012,
+  sessionToken: z4.string()
+}).strict();
+var engagementStatusResponseSchema = z4.object({
+  engagementId: z4.string(),
+  name: z4.string(),
+  region: z4.string(),
+  status: lifecycleStatusSchema,
+  installLinked: z4.boolean(),
+  createdAt: utcIso86012,
+  updatedAt: utcIso86012
+}).strict();
+var linkInstallationRequestSchema = z4.object({
+  installationId: z4.string(),
+  engagementId: z4.string()
+}).strict();
+var startBuildRequestSchema = z4.object({
+  engagementId: z4.string()
+}).strict();
+var startBuildResponseSchema = z4.object({
+  engagementId: z4.string(),
+  status: lifecycleStatusSchema,
+  enqueuedAt: utcIso86012
+}).strict();
+var acceptanceOutcomeSchema = z4.object({
+  verdict: z4.enum(["clean", "defects"]),
+  findings: z4.number().int().nonnegative(),
+  findingsDetail: z4.array(z4.object({ summary: z4.string() }).strict())
+}).strict();
+var phaseCloseDecisionSchema = z4.discriminatedUnion("decision", [
+  z4.object({
+    decision: z4.literal("done-when-met"),
+    /** Who is closing the phase. */
+    actor: z4.string()
+  }).strict(),
+  z4.object({
+    decision: z4.literal("override"),
+    /** Who is closing it anyway. */
+    actor: z4.string(),
+    /** Why, in their own words. */
+    reason: z4.string()
+  }).strict()
+]);
+var acceptPhaseRequestSchema = z4.object({
+  phase: z4.string(),
+  acceptanceOutcome: acceptanceOutcomeSchema,
+  close: phaseCloseDecisionSchema.optional()
+}).strict();
+var coeFindingRequestSchema = z4.object({
+  phase: z4.string(),
+  description: z4.string(),
+  addRateTag: z4.enum(["seam-new", "seam-repeat", "model-limitation"]),
+  mappedPatternRef: z4.string().nullable()
+}).strict();
+var coeFindingResponseSchema = z4.object({
+  findingId: z4.string(),
+  engagementId: z4.string(),
+  phase: z4.string(),
+  description: z4.string(),
+  addRateTag: z4.enum(["seam-new", "seam-repeat", "model-limitation"]),
+  mappedPatternRef: z4.string().nullable(),
+  createdAt: utcIso86012
+}).strict();
+var phaseEntryDecisionSchema = z4.discriminatedUnion("decision", [
+  z4.object({
+    decision: z4.literal("entry-condition-met"),
+    /** Who attests. */
+    actor: z4.string(),
+    /** What makes the entry condition hold, in the attester's own words. */
+    evidence: z4.string()
+  }).strict(),
+  z4.object({
+    decision: z4.literal("override"),
+    /** Who is opening it anyway. */
+    actor: z4.string(),
+    /** Why, in the operator's own words. */
+    reason: z4.string()
+  }).strict()
+]);
+var openPhaseRequestSchema = z4.object({
+  phase: z4.string().nullable(),
+  entry: phaseEntryDecisionSchema
+}).strict();
+var phaseEntryDecisionRecordSchema = z4.object({
+  decisionId: z4.string(),
+  decision: z4.enum(["entry-condition-met", "override"]),
+  actor: z4.string(),
+  /** The evidence (attestation) or the reason (override) — one basis per row. */
+  justification: z4.string(),
+  blockingFinding: z4.string().nullable(),
+  decidedAt: utcIso86012
+}).strict();
+var openPhaseResponseSchema = z4.object({
+  engagement: engagementStatusResponseSchema,
+  /** What is open now. `null` is project scope. */
+  phase: z4.string().nullable(),
+  /** What was open before this decision. `null` is project scope. */
+  previousPhase: z4.string().nullable(),
+  decision: phaseEntryDecisionRecordSchema
+}).strict();
+
+// ../events/dist/device-auth.js
+import { z as z5 } from "zod";
+var utcIso86013 = z5.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/, "must be a UTC ISO-8601 timestamp ending in Z (INV-015)");
+var DEVICE_AUTH_STATUS = {
+  /** The poll: minted, nobody has acted yet. Keep polling. 200. */
+  PENDING: "pending",
+  /** The poll: approved, and the credential is in this body. Once only. 200. */
+  APPROVED: "approved",
+  /** Confirm: the decision was recorded (approve or decline). 200. */
+  RECORDED: "recorded",
+  /** The human refused at the confirmation page. 400 on the poll. */
+  DECLINED: "declined",
+  /** The code's absolute expiry has passed. 400. */
+  EXPIRED: "expired",
+  /** Never minted, or already spent. 400. */
+  UNKNOWN: "unknown",
+  /** Confirm: neither `approve` nor `decline` was named. Nothing was bound. 400. */
+  INVALID_DECISION: "invalid-decision",
+  /** Confirm: an approval arrived with no signed-in identity. 400. */
+  IDENTITY_REQUIRED: "identity-required",
+  /** This deployment has no `SIGNIN_BASE_URL` / `DEVICE_AUTH_CONFIRM_SECRET`. 503. */
+  NOT_CONFIGURED: "not-configured",
+  /** Confirm: the shared confirmation secret was missing or wrong. 401. */
+  UNAUTHORIZED: "unauthorized",
+  /** Confirm: the code was already approved, declined or claimed. 409. */
+  ALREADY_DECIDED: "already-decided"
+};
+var DEVICE_POLL_REFUSALS = [
+  DEVICE_AUTH_STATUS.DECLINED,
+  DEVICE_AUTH_STATUS.EXPIRED,
+  DEVICE_AUTH_STATUS.UNKNOWN
+];
+var deviceAuthStartResponseSchema = z5.object({
+  deviceCode: z5.string().min(1),
+  userCode: z5.string().min(1),
+  verificationUrl: z5.string().min(1),
+  expiresAt: utcIso86013,
+  pollIntervalMs: z5.number().int().positive()
+}).strict();
+var devicePollPendingSchema = z5.object({
+  status: z5.literal(DEVICE_AUTH_STATUS.PENDING),
+  pollIntervalMs: z5.number().int().positive()
+}).strict();
+var devicePollApprovedSchema = z5.object({
+  status: z5.literal(DEVICE_AUTH_STATUS.APPROVED),
+  accountId: z5.string().min(1),
+  credential: z5.string().min(1),
+  expiresAt: utcIso86013
+}).strict();
+var deviceAuthRefusalSchema = z5.object({
+  status: z5.enum([
+    DEVICE_AUTH_STATUS.DECLINED,
+    DEVICE_AUTH_STATUS.EXPIRED,
+    DEVICE_AUTH_STATUS.UNKNOWN,
+    DEVICE_AUTH_STATUS.INVALID_DECISION,
+    DEVICE_AUTH_STATUS.IDENTITY_REQUIRED,
+    DEVICE_AUTH_STATUS.NOT_CONFIGURED,
+    DEVICE_AUTH_STATUS.UNAUTHORIZED,
+    DEVICE_AUTH_STATUS.ALREADY_DECIDED
+  ]),
+  message: z5.string().min(1)
+}).strict();
+var devicePollResponseSchema = z5.union([
+  devicePollPendingSchema,
+  devicePollApprovedSchema,
+  deviceAuthRefusalSchema
+]);
+var deviceConfirmRequestSchema = z5.object({
+  userCode: z5.string().min(1),
+  decision: z5.enum(["approve", "decline"]),
+  externalAuthId: z5.string().min(1).optional(),
+  email: z5.string().optional()
+}).strict();
+var deviceConfirmRecordedSchema = z5.object({
+  status: z5.literal(DEVICE_AUTH_STATUS.RECORDED),
+  accountId: z5.string().min(1).optional()
+}).strict();
+var deviceConfirmResponseSchema = z5.union([
+  deviceConfirmRecordedSchema,
+  deviceAuthRefusalSchema
+]);
+var LOOPBACK_REDIRECT_HOST = "127.0.0.1";
+var LOOPBACK_PORT_MIN = 1024;
+var LOOPBACK_PORT_MAX = 65535;
+var LOOPBACK_CALLBACK_PATH = "/halfcycle-cli-callback";
+var LOOPBACK_QUERY_PORT = "loopback_port";
+var LOOPBACK_QUERY_STATE = "loopback_state";
+var LOOPBACK_QUERY_RESULT = "result";
+var LOOPBACK_RESULT = {
+  APPROVED: "approved",
+  DECLINED: "declined"
+};
+function loopbackVerificationUrl(verificationUrl, target) {
+  let url;
+  try {
+    url = new URL(verificationUrl);
+  } catch {
+    return verificationUrl;
+  }
+  url.searchParams.set(LOOPBACK_QUERY_PORT, String(target.port));
+  url.searchParams.set(LOOPBACK_QUERY_STATE, target.state);
+  return url.toString();
+}
+
+// dist/scan.js
+var HALFCYCLE_STATE_FORMAT = "halfcycle-state-file/v1";
+var HALFCYCLE_STATE_NOTE = [
+  "This file is a local cache written ONCE when Halfcycle was installed. It is not a",
+  "record of what this project has done, and it is never updated as work happens.",
+  'An empty or missing "layers" means the install-time scan found no pre-existing',
+  "artefacts on disk \u2014 it does NOT mean nothing has been done since, and it is not",
+  "evidence that any step is unfinished or any approval is outstanding.",
+  "The authoritative position lives in the Halfcycle service: call the",
+  "halfcycle_resolve tool to ask where this project stands. Do not answer that",
+  "question from this file."
+].join(" ");
+var LAYER_ARTEFACT_PATHS = {
+  l0: ["ENGAGEMENT.md"],
+  l1: ["docs/product-spec.md"],
+  l2: ["docs/architecture-overview.md"],
+  l3: ["docs/invariants.md"],
+  l4: ["docs/features"],
+  l5: ["docs/phases"]
+};
+function scanLayers(targetRepo, scannedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  const layers = {};
+  for (const [layer, paths] of Object.entries(LAYER_ARTEFACT_PATHS)) {
+    const found = paths.filter((p) => existsSync2(join4(targetRepo, p)));
+    if (found.length > 0) {
+      layers[layer] = {
+        value: "asserted",
+        source: "bootstrap-scan",
+        foundPaths: found,
+        scannedAt
+      };
+    }
+  }
+  return { format: HALFCYCLE_STATE_FORMAT, note: HALFCYCLE_STATE_NOTE, layers };
+}
+function runBootstrapScan(targetRepo) {
+  const statePath = join4(targetRepo, ".halfcycle", "state.json");
+  if (existsSync2(statePath)) {
+    const existing = JSON.parse(readFileSync4(statePath, "utf-8"));
+    return { state: existing, ran: false };
+  }
+  const state = scanLayers(targetRepo);
+  mkdirSync3(join4(targetRepo, ".halfcycle"), { recursive: true });
+  writeFileSync3(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+  return { state, ran: true };
+}
+
+// dist/install.js
+var ZONE_B_DIR = ".workbench";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname2(__filename);
+function findBundleRoot(startDir) {
+  let candidate = startDir;
+  for (let i = 0; i < 4; i++) {
+    const manifest = join5(candidate, ".claude-plugin", "plugin.json");
+    try {
+      if (existsSync3(manifest))
+        return candidate;
+    } catch {
+    }
+    candidate = dirname2(candidate);
+  }
+  return join5(startDir, "..");
+}
+var BUNDLE_ROOT = findBundleRoot(__dirname);
+function resolveVendoredBinary() {
+  const candidates = [
+    join5(BUNDLE_ROOT, "bin", "bin.bundle.mjs"),
+    join5(BUNDLE_ROOT, "..", "runner", "dist", "bin.bundle.mjs")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync3(candidate))
+      return candidate;
+  }
+  throw new Error(`[bundle install] Cannot find the self-contained guard binary bin.bundle.mjs. Run the runner's "bundle" script (pnpm --filter @halfcycle/runner run build) so the vendored artefact exists before installing. Looked in: ${candidates.join(", ")}.`);
+}
+var WRITE_ALLOWLIST = [
+  ".claude/commands",
+  ".claude/hooks",
+  ".claude/settings.json",
+  ".halfcycle",
+  ".halfcycle/bundle.json",
+  ".halfcycle/bin",
+  "docs/build-records",
+  "test/fixtures/captured",
+  ".env.example",
+  ".mcp.json",
+  ZONE_B_DIR
+];
+function isAllowlisted(targetRelPath) {
+  const normalised = targetRelPath.replace(/\\/g, "/");
+  return WRITE_ALLOWLIST.some((prefix) => {
+    const p = prefix.replace(/\\/g, "/");
+    return normalised === p || normalised.startsWith(p + "/");
+  });
+}
+function readPluginManifest() {
+  const manifestPath = join5(BUNDLE_ROOT, ".claude-plugin", "plugin.json");
+  const raw = readFileSync5(manifestPath, "utf-8");
+  return JSON.parse(raw);
+}
+function copyManifestCommands(manifest, targetRepo, report) {
+  const commandsTargetDir = join5(targetRepo, ".claude", "commands");
+  for (const cmd of manifest.commands ?? []) {
+    const srcFile = join5(BUNDLE_ROOT, ".claude-plugin", cmd.path);
+    if (!existsSync3(srcFile)) {
+      throw new Error(`[bundle install] plugin.json declares command "${cmd.name}" at "${cmd.path}", but no file exists there (${srcFile}). The manifest and commands/ must agree.`);
+    }
+    const destFile = join5(commandsTargetDir, `${cmd.name}.md`);
+    const content = readFileSync5(srcFile, "utf-8");
+    const rel = relative(targetRepo, destFile).replace(/\\/g, "/");
+    record(report, writeCollisionSafe(destFile, targetRepo, content), rel);
+  }
+}
+function writeAllowlisted(targetAbsPath, targetRepoRoot, content, writtenPaths) {
+  const rel = relative(targetRepoRoot, targetAbsPath).replace(/\\/g, "/");
+  if (!isAllowlisted(rel)) {
+    throw new Error(`[bundle install] Write-allowlist violation: attempted to write "${rel}". Only the method surface and scaffolding paths are writable.`);
+  }
+  mkdirSync4(dirname2(targetAbsPath), { recursive: true });
+  writeFileSync4(targetAbsPath, content, "utf-8");
+  writtenPaths.push(rel);
+}
+function writeCollisionSafe(targetAbsPath, targetRepoRoot, content) {
+  const rel = relative(targetRepoRoot, targetAbsPath).replace(/\\/g, "/");
+  if (!isAllowlisted(rel)) {
+    throw new Error(`[bundle install] Write-allowlist violation: attempted to write "${rel}". Only the method surface and scaffolding paths are writable.`);
+  }
+  if (existsSync3(targetAbsPath)) {
+    const current = readFileSync5(targetAbsPath, "utf-8");
+    return current === content ? "skipped" : "collided";
+  }
+  mkdirSync4(dirname2(targetAbsPath), { recursive: true });
+  writeFileSync4(targetAbsPath, content, "utf-8");
+  return "written";
+}
+function record(report, outcome, rel) {
+  const bucket = {
+    written: report.writtenPaths,
+    skipped: report.skippedPaths,
+    collided: report.collidedPaths
+  };
+  bucket[outcome].push(rel);
+}
+var DENY_PATTERNS = [
+  "Bash(rm -rf:*)",
+  "Bash(git push --force:*)",
+  "Bash(git push -f:*)",
+  "Bash(git reset --hard:*)",
+  "Bash(pnpm publish:*)",
+  "Bash(npm publish:*)",
+  "Bash(gh repo delete:*)",
+  "Bash(git push --no-verify:*)",
+  "Bash(git commit --no-verify:*)"
+];
+var WRITE_CAPABLE_TOOLS = ["Edit", "MultiEdit", "NotebookEdit", "Write"];
+var USER_PROMPT_REMINDER_SENTENCE = "Where this project stands, and what order to work in, is recorded in the Halfcycle service and nowhere in this repository \u2014 call halfcycle_resolve before you answer or plan, because the files here will look complete and current and still be wrong about position.";
+function generateSettingsJson() {
+  const settings = {
+    $schema: "https://json.schemastore.org/claude-code-settings.json",
+    permissions: {
+      // deny ONLY. See DENY_PATTERNS — an allow list evaporates under bypass mode
+      // and is the machine owner's grant to make, not ours.
+      deny: [...DENY_PATTERNS]
+    },
+    hooks: {
+      SessionStart: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: "bash ./.claude/hooks/session-start-marker.sh",
+              timeout: 5
+            }
+          ]
+        }
+      ],
+      UserPromptSubmit: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: "bash ./.claude/hooks/user-prompt-reminder.sh",
+              timeout: 5
+            }
+          ]
+        }
+      ],
+      PostToolUse: [
+        {
+          matcher: WRITE_CAPABLE_TOOLS.join("|"),
+          hooks: [
+            {
+              type: "command",
+              command: "bash ./.claude/hooks/guard-runner.sh hook post-tool-use",
+              timeout: 60
+            }
+          ]
+        }
+      ],
+      SubagentStop: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: "bash ./.claude/hooks/guard-runner.sh hook subagent-stop",
+              timeout: 60
+            }
+          ]
+        }
+      ]
+    }
+  };
+  return JSON.stringify(settings, null, 2) + "\n";
+}
+var VENDORED_BIN_REL = ".halfcycle/bin/bin.bundle.mjs";
+function generateGuardRunnerWrapper() {
+  return `#!/usr/bin/env bash
+# Governance hook wrapper \u2014 generated by the Halfcycle installer.
+#
+# Loads this engagement's credentials so the guard runner has its GUARD_SERVICE_*
+# values when Claude Code fires PostToolUse / SubagentStop, then exec's the
+# SELF-CONTAINED binary vendored at ${VENDORED_BIN_REL} \u2014 a path inside this
+# project, so the hook resolves in any checkout of it.
+#
+# The runner itself reads only process.env, so env loading lives here in the hook
+# wiring rather than inside the binary.
+#
+# NO CREDENTIAL LIVES IN THIS REPOSITORY. See the resolution block below.
+PROJECT_DIR="\${CLAUDE_PROJECT_DIR:-.}"
+
+${engagementResolutionShell()}
+
+# A missing store is NOT an error here: on a CI runner there is no per-user store
+# and the credentials arrive in the environment instead. Exec either way and let
+# the runner say what it found \u2014 its never-configured branch is loud and non-zero
+# on purpose, and a wrapper that exited quietly here would hide it.
+if halfcycle_env_file "$PROJECT_DIR"; then
+  set -a
+  . "$HALFCYCLE_ENV_FILE"
+  set +a
+fi
+
+exec node "$PROJECT_DIR/${VENDORED_BIN_REL}" "$@"
+`;
+}
+function generateSessionStartMarker() {
+  return `#!/usr/bin/env bash
+# Session-start marker \u2014 generated by the Halfcycle installer.
+# Writes the current git HEAD SHA to a temp file so SubagentStop can
+# diff against session-start rather than just HEAD at stop time.
+REPO_ROOT="\${CLAUDE_PROJECT_DIR:-$(git rev-parse --show-toplevel 2>/dev/null)}"
+if [ -z "$REPO_ROOT" ]; then exit 0; fi
+HASH="$(echo -n "$REPO_ROOT" | shasum -a 256 | cut -c1-12)"
+MARKER_FILE="\${TMPDIR%/}/halfcycle-session-\${HASH}.ref"
+git -C "$REPO_ROOT" rev-parse HEAD > "$MARKER_FILE" 2>/dev/null || true
+exit 0
+`;
+}
+function generateUserPromptReminderHook() {
+  return `#!/usr/bin/env bash
+# UserPromptSubmit house-rule reminder \u2014 generated by the Halfcycle installer.
+#
+# Injects ONE plain-text sentence into context on every prompt (F-2(c),
+# W8-T-05b) \u2014 the per-turn twin of the house rule W8-T-05a put in the client's
+# CLAUDE.md, in its "Top rules (read first)" block. Byte-identical sentence,
+# one home: RULE_SENTENCE_PLAIN in the method repo's own position-house-rule
+# test governs it \u2014 reword there and here together, in the same commit.
+#
+# FAILS OPEN. This hook's stdout is always plain text, never JSON, so it
+# cannot form a {"decision":"block",...} body (UserPromptSubmit's only way to
+# hold the turn). But a write failure here (a closed stdout, say) must still
+# never wedge or stall a session, so any error exits 0 with no output rather
+# than propagate.
+trap 'exit 0' ERR
+set -e
+printf '%s\\n' '${USER_PROMPT_REMINDER_SENTENCE}'
+exit 0
+`;
+}
+function generateCiStanza() {
+  return `# Halfcycle guard CI job \u2014 generated by the Halfcycle installer.
+# Paste this job into your CI workflow. It assumes no package manager and no
+# monorepo tooling: it runs the self-contained guard binary vendored at
+# .halfcycle/bin/, so it works in a Python or Go repository as well as a Node
+# one \u2014 the only prerequisite is Node 20 to run the bundled binary.
+#
+# WHICH BRANCH MODEL THIS ASSUMES: none. It works on pull-request branches AND on
+# commits pushed straight to the default branch, which is the shape most
+# Halfcycle engagements settle on. \`fetch-depth\` is what makes that true: the
+# check needs the commit BEFORE the one it is evaluating, and the default
+# shallow checkout does not have it. With \`fetch-depth: 0\` the check fails loudly
+# if it cannot work out what to evaluate \u2014 it will not pass quietly having
+# evaluated nothing.
+#
+# halfcycle-guard-ci:
+#   runs-on: ubuntu-latest
+#   steps:
+#     - uses: actions/checkout@v4
+#       with:
+#         # REQUIRED. 0 = full history. The check diffs against the commit before
+#         # HEAD (or the fork point on a branch); the default depth of 1 has
+#         # neither. Do not lower this.
+#         fetch-depth: 0
+#     - uses: actions/setup-node@v4
+#       with:
+#         node-version: '20'
+#     - name: Halfcycle guard CI check
+#       env:
+#         GUARD_SERVICE_URL: \${{ secrets.GUARD_SERVICE_URL }}
+#         GUARD_SERVICE_TOKEN: \${{ secrets.GUARD_SERVICE_TOKEN }}
+#         GUARD_ENGAGEMENT_ID: \${{ secrets.GUARD_ENGAGEMENT_ID }}
+#       run: node ./.halfcycle/bin/bin.bundle.mjs ci
+#
+# The job prints the diff base it used and how many files it evaluated, on every
+# run. If that line says 0 files on a commit that changed something, the base is
+# wrong \u2014 set HALFCYCLE_DIFF_BASE in the env block above to name it explicitly
+# (on a GitHub push event, \${{ github.event.before }} is the right value).
+`;
+}
+var ENV_EXAMPLE_NAMES = [
+  "GUARD_SERVICE_URL",
+  "GUARD_SERVICE_TOKEN",
+  "GUARD_ENGAGEMENT_ID",
+  "HALFCYCLE_SERVICE_URL",
+  "HALFCYCLE_MCP_URL",
+  "HALFCYCLE_TOKEN",
+  // T-10 — declared because it is now WRITTEN into the credential store, and
+  // `install-guard-config.test.ts`'s INV-004 check requires every written name to
+  // be named here too (`HALFCYCLE_ENGAGEMENT_ID` is the one deliberate exception,
+  // recorded in the spec). Optional at runtime — the runner's own telemetry
+  // emission is fail-open when it is absent — but a name that is written and never
+  // declared is exactly what this generated section exists to prevent.
+  "CONTROL_TELEMETRY_URL"
+];
+function generateEnvExampleSection() {
+  return `
+# ---------------------------------------------------------------------------
+# Halfcycle runner (generated by the Halfcycle installer \u2014 names only, no values)
+# ---------------------------------------------------------------------------
+# YOU DO NOT NEED TO SET ANY OF THESE ON YOUR OWN MACHINE, and there is nowhere in
+# this repository to put them. \`npx halfcycle\` writes this engagement's credential
+# to $HOME/.halfcycle, owner-only, outside every checkout; the guard hook and the
+# MCP headers helper read it from there. Nothing Halfcycle writes a secret into
+# this tree, so there is no file here to leak, ignore or clean up.
+#
+# These names are declared because they ARE read from the environment in one
+# place: a CI job, which has no browser and no per-user store and supplies them as
+# workflow secrets (see .halfcycle/ci-stanza.yml). HALFCYCLE_TOKEN set in the
+# environment also takes precedence over the stored credential everywhere, which is
+# the escape hatch for running as a specific identity.
+GUARD_SERVICE_URL=<argType:runtime>
+GUARD_SERVICE_TOKEN=<argType:runtime>
+GUARD_ENGAGEMENT_ID=<argType:runtime>
+# TWO ORIGINS, TWO SERVICES (T-22). HALFCYCLE_SERVICE_URL is the Halfcycle
+# CONTROL plane \u2014 it serves engagement creation and the board's first-visit
+# code. HALFCYCLE_MCP_URL is the method-delivery service, which serves /mcp and
+# nothing else here. You configure the first; the platform reports the second on
+# create, so it is written for you and .mcp.json carries the composed address.
+HALFCYCLE_SERVICE_URL=<argType:runtime>
+HALFCYCLE_MCP_URL=<argType:runtime>
+HALFCYCLE_TOKEN=<argType:runtime>
+# CONTROL_TELEMETRY_URL (T-10) \u2014 the platform reports this on create/join, same as
+# HALFCYCLE_MCP_URL. OPTIONAL: absent, guard-eval telemetry is silently disabled
+# and the guard loop itself is unaffected \u2014 this name is declared only because it
+# is one this installer now writes to the machine-level store, same as every name
+# above it.
+CONTROL_TELEMETRY_URL=<argType:runtime>
+`;
+}
+var MCP_REGISTRATION_REL = ".mcp.json";
+var MCP_HEADERS_HELPER_REL = ".halfcycle/mcp-headers.sh";
+var MCP_HEADERS_HELPER_COMMAND = `/bin/sh -c 'd=$(pwd); while [ ! -f "$d/${MCP_HEADERS_HELPER_REL}" ] && [ "$d" != / ]; do d=$(dirname "$d"); done; [ -f "$d/${MCP_HEADERS_HELPER_REL}" ] || { echo "halfcycle: ${MCP_HEADERS_HELPER_REL} not found at or above $(pwd); re-run npx halfcycle" >&2; exit 1; }; exec /bin/sh "$d/${MCP_HEADERS_HELPER_REL}"'`;
+function generateMcpHeadersHelper() {
+  return `#!/bin/sh
+# Halfcycle MCP connection headers \u2014 generated by the Halfcycle installer.
+#
+# Claude Code runs this at MCP connection time, from the session's cwd, and merges
+# its stdout into the connection headers for the "halfcycle" server in .mcp.json.
+#
+# It exists because \${VAR} expansion in .mcp.json reads the PROCESS environment
+# only: nothing loads a credential into a session, so a referenced
+# \${HALFCYCLE_TOKEN} expanded to nothing and the server was silently absent from
+# the tool list.
+#
+# This file is tracked and holds NO secret. NEITHER DOES ANY OTHER FILE IN THIS
+# REPOSITORY (T-09): the credential lives at machine level, outside every checkout,
+# and this script READS one line out of it (never sources \u2014 a credential store is
+# not code).
+set -eu
+
+# The project root is resolved from THIS SCRIPT'S OWN LOCATION, never from the
+# caller's working directory. Claude Code runs the helper from the SESSION's cwd,
+# and a session started in a subdirectory still finds the root .mcp.json \u2014 so a
+# relative read here silently produced no credential for anyone who started the
+# session in any subdirectory of a monorepo.
+SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+PROJECT_ROOT=$(CDPATH= cd -- "$SCRIPT_DIR/.." && pwd)
+
+${engagementResolutionShell()}
+
+# HALFCYCLE_TOKEN in the environment WINS, and it is the CI arm: a job with no
+# browser and no per-user store exports the credential, and a stale store on a
+# long-lived runner must not silently win over it. Same order, and the same reason,
+# as the CLI's own resolver (\`resolve-credential.ts\`).
+TOKEN=\${HALFCYCLE_TOKEN:-}
+
+if [ -z "$TOKEN" ]; then
+  if ! halfcycle_env_file "$PROJECT_ROOT"; then
+    case $HALFCYCLE_ENV_PROBLEM in
+      no-pin)
+        echo "halfcycle: no .halfcycle/bundle.json in $PROJECT_ROOT, so this repository has no Halfcycle engagement." >&2
+        echo "halfcycle: run \\"npx halfcycle\\" here to install one." >&2 ;;
+      no-id)
+        echo "halfcycle: $PROJECT_ROOT/.halfcycle/bundle.json names no engagement id." >&2
+        echo "halfcycle: run \\"npx halfcycle\\" here to rewrite it." >&2 ;;
+      no-home)
+        echo "halfcycle: HOME is not set, so the credential store cannot be located." >&2 ;;
+      *)
+        echo "halfcycle: this machine holds no credential for engagement $HALFCYCLE_ENV_ENGAGEMENT." >&2
+        echo "halfcycle: run \\"npx halfcycle\\" in this repository \u2014 it will sign you in through your browser if needed, and write the credential to $HOME/.halfcycle, outside this repository." >&2 ;;
+    esac
+    exit 1
+  fi
+  ENV_FILE="$HALFCYCLE_ENV_FILE"
+
+  # Last assignment wins, matching the shell's own \`.\` semantics. An optional
+  # leading \`export \` is tolerated because a hand-edited store may use one.
+  LINE=$(grep '^[[:space:]]*\\(export[[:space:]][[:space:]]*\\)\\{0,1\\}HALFCYCLE_TOKEN=' "$ENV_FILE" | tail -n 1)
+  TOKEN=\${LINE#*HALFCYCLE_TOKEN=}
+  TOKEN=$(printf '%s' "$TOKEN" | tr -d '\\r')
+
+  # Strip one layer of matching quotes. The store is WRITTEN single-quoted (both
+  # writers use the same shq: this installer and Studio's provider), because
+  # guard-runner.sh SOURCES the same file and an unquoted value carrying a space
+  # would execute its own remainder. This reader greps rather than sources, so it
+  # has to undo the quoting itself \u2014 and it must land on the same value the
+  # sourcing consumer gets, or one file has two answers.
+  case $TOKEN in
+    '"'*'"') TOKEN=\${TOKEN#'"'}; TOKEN=\${TOKEN%'"'} ;;
+    "'"*"'")
+      TOKEN=\${TOKEN#"'"}; TOKEN=\${TOKEN%"'"}
+      # \u2026and undo shq's embedded-quote escape, '\\'' -> '. The backslash is matched
+      # through a BRACKET EXPRESSION on purpose. MEASURED, on GNU sed 4.9 (Linux,
+      # the CI platform) and BSD sed (macOS), feeding each the script from a file so
+      # no shell quoting is in the way:
+      #
+      #   s/'[\\]''/'/g   a'\\''b -> a'b     both      <- shipped
+      #   s/'\\''/'/g     a'\\''b -> a'\\''b   both      <- matches NOTHING, exit 0
+      #
+      # A bare \\' in a BRE is undefined by POSIX, and the obvious pattern therefore
+      # does not fail loudly \u2014 it silently substitutes nothing, on BOTH platforms,
+      # and the token then travels with four stray characters in it. The bracket
+      # expression makes the backslash literal by a construction POSIX does define.
+      TOKEN=$(printf '%s' "$TOKEN" | sed "s/'[\\]''/'/g") ;;
+  esac
+
+  if [ -z "$TOKEN" ]; then
+    echo "halfcycle: HALFCYCLE_TOKEN is absent or empty in $ENV_FILE." >&2
+    echo "halfcycle: run \\"npx halfcycle\\" in this repository to rewrite this machine's credential." >&2
+    exit 1
+  fi
+fi
+
+# JSON-escape: backslash first, then double quote. A token carrying either would
+# otherwise emit invalid JSON, and invalid JSON is dropped SILENTLY \u2014 the
+# connection succeeds carrying no Authorization header at all.
+ESCAPED=$(printf '%s' "$TOKEN" | sed -e 's/\\\\/\\\\\\\\/g' -e 's/"/\\\\"/g')
+
+printf '{"Authorization":"Bearer %s"}\\n' "$ESCAPED"
+`;
+}
+function generateMcpRegistration(existing, mcpOrigin) {
+  let base = { mcpServers: {} };
+  if (existing !== null) {
+    const parsed = JSON.parse(existing);
+    if (parsed !== null && typeof parsed === "object") {
+      base = { mcpServers: {}, ...parsed };
+    }
+  }
+  if (typeof base.mcpServers !== "object" || base.mcpServers === null) {
+    base.mcpServers = {};
+  }
+  base.mcpServers["halfcycle"] = {
+    type: "http",
+    url: mcpEndpointUrl(mcpOrigin),
+    headersHelper: MCP_HEADERS_HELPER_COMMAND
+  };
+  return JSON.stringify(base, null, 2) + "\n";
+}
+function reconcileEnvExample(targetRepo) {
+  const envExamplePath = join5(targetRepo, ".env.example");
+  const section = generateEnvExampleSection();
+  if (!existsSync3(envExamplePath)) {
+    mkdirSync4(dirname2(envExamplePath), { recursive: true });
+    writeFileSync4(envExamplePath, section.trimStart(), "utf-8");
+    return "written";
+  }
+  const existing = readFileSync5(envExamplePath, "utf-8");
+  const missing = ENV_EXAMPLE_NAMES.filter((name) => !existing.includes(name));
+  if (missing.length === 0)
+    return "skipped";
+  writeFileSync4(envExamplePath, existing + section, "utf-8");
+  return "written";
+}
+var REQUIRED_GITIGNORE_ENTRIES = [".halfcycle/state.json", `${ZONE_B_DIR}/`];
+function gitignoreCovers(content) {
+  const lines = new Set(content.split("\n").map((l) => l.trim()));
+  return REQUIRED_GITIGNORE_ENTRIES.every((entry) => lines.has(entry));
+}
+function reconcileGitignore(targetRepo) {
+  const gitignorePath = join5(targetRepo, ".gitignore");
+  const header = "# Halfcycle \u2014 machine-local secrets/state and Zone-B (never push to client remote)";
+  try {
+    if (!existsSync3(gitignorePath)) {
+      const body = [header, ...REQUIRED_GITIGNORE_ENTRIES].join("\n") + "\n";
+      writeFileSync4(gitignorePath, body, "utf-8");
+      return "written";
+    }
+    const existing = readFileSync5(gitignorePath, "utf-8");
+    if (gitignoreCovers(existing))
+      return "skipped";
+    const existingLines = new Set(existing.split("\n").map((l) => l.trim()));
+    const toAdd = REQUIRED_GITIGNORE_ENTRIES.filter((entry) => !existingLines.has(entry));
+    const suffix = (existing.endsWith("\n") ? "" : "\n") + `
+${header}
+` + toAdd.join("\n") + "\n";
+    writeFileSync4(gitignorePath, existing + suffix, "utf-8");
+    return "written";
+  } catch {
+    return "failed";
+  }
+}
+function writeBundlePin(targetRepoRoot, version, engagementId, engagementType, writtenPaths) {
+  const pin = {
+    version,
+    engagementId,
+    engagementType,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const pinPath = join5(targetRepoRoot, ".halfcycle", "bundle.json");
+  writeAllowlisted(pinPath, targetRepoRoot, JSON.stringify(pin, null, 2) + "\n", writtenPaths);
+}
+function readBundlePin(targetRepoRoot) {
+  const pinPath = join5(targetRepoRoot, ".halfcycle", "bundle.json");
+  if (!existsSync3(pinPath))
+    return null;
+  return JSON.parse(readFileSync5(pinPath, "utf-8"));
+}
+function readPinnedEngagement(targetRepoRoot, home) {
+  const pin = readBundlePin(targetRepoRoot);
+  const engagementId = pin?.engagementId;
+  if (engagementId === void 0 || engagementId === "")
+    return null;
+  const stored = readEngagementEnv(engagementId, home);
+  const fromStore = stored === null ? void 0 : toCredential(stored);
+  if (fromStore !== void 0) {
+    return { engagementId, credential: fromStore, fromLegacyEnvLocal: false };
+  }
+  const legacy = readLegacyEnvLocal(targetRepoRoot);
+  const fromLegacy = legacy === null ? void 0 : toCredential(legacy);
+  return {
+    engagementId,
+    credential: fromLegacy,
+    fromLegacyEnvLocal: fromLegacy !== void 0
+  };
+}
+function readLegacyEnvLocal(targetRepoRoot) {
+  try {
+    return parseEnvText(readFileSync5(join5(targetRepoRoot, LEGACY_ENV_LOCAL_REL), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+var CREDENTIAL_REQUIRED_KEYS = [
+  "HALFCYCLE_SERVICE_URL",
+  "HALFCYCLE_TOKEN",
+  "HALFCYCLE_MCP_URL",
+  "GUARD_SERVICE_URL"
+];
+function missingRequiredKeys(found) {
+  const serviceUrl = (process.env["HALFCYCLE_SERVICE_URL"]?.trim() ?? "") || (found["HALFCYCLE_SERVICE_URL"] ?? "");
+  const resolved = { ...found, HALFCYCLE_SERVICE_URL: serviceUrl };
+  return CREDENTIAL_REQUIRED_KEYS.filter((key) => (resolved[key] ?? "") === "");
+}
+function toCredential(found) {
+  if (missingRequiredKeys(found).length > 0)
+    return void 0;
+  const controlTelemetryUrl = found["CONTROL_TELEMETRY_URL"];
+  return {
+    serviceUrl: (process.env["HALFCYCLE_SERVICE_URL"]?.trim() ?? "") || (found["HALFCYCLE_SERVICE_URL"] ?? ""),
+    token: found["HALFCYCLE_TOKEN"] ?? "",
+    mcpUrl: found["HALFCYCLE_MCP_URL"] ?? "",
+    guardUrl: found["GUARD_SERVICE_URL"] ?? "",
+    ...controlTelemetryUrl ? { controlTelemetryUrl } : {}
+  };
+}
+function checkDrift(targetRepoRoot) {
+  const manifest = readPluginManifest();
+  const pin = readBundlePin(targetRepoRoot);
+  const installed = pin?.version ?? null;
+  const current = manifest.version;
+  return { drifted: installed !== current, installed, current };
+}
+function writeProjectIdentity(targetRepo) {
+  const path = join5(targetRepo, ".halfcycle", "project.json");
+  const { identity } = mintOrReadIdentity(targetRepo);
+  const serialized = JSON.stringify(identity, null, 2) + "\n";
+  if (existsSync3(path) && readFileSync5(path, "utf-8") === serialized)
+    return "skipped";
+  writeFileSync4(path, serialized, "utf-8");
+  return "written";
+}
+function writeEngagementCredential(credential, engagementId, home) {
+  const values = {
+    HALFCYCLE_SERVICE_URL: credential.serviceUrl,
+    // T-22 — the second origin, persisted for the developer and for any tool that
+    // wants it by name. NOTHING EXPANDS IT ANY MORE: since T-24 the installer
+    // composes the endpoint and writes it into `.mcp.json` as a literal, so this
+    // key no longer feeds the registration. (It read "the registration expands to
+    // `/mcp` against an empty string" until T-24 removed the expansion; a comment
+    // describing a mechanism that no longer exists is how the next reader builds
+    // on a claim that is not true.)
+    HALFCYCLE_MCP_URL: credential.mcpUrl,
+    HALFCYCLE_TOKEN: credential.token,
+    HALFCYCLE_ENGAGEMENT_ID: engagementId,
+    // FW-4 (F-29) — the three the hook this same module generates requires. The
+    // guard origin is a third deployed service the platform reports on create;
+    // the token is the one per-engagement credential under the name the runner
+    // reads; the id is the engagement the guard service binds the body to.
+    GUARD_SERVICE_URL: credential.guardUrl,
+    GUARD_SERVICE_TOKEN: credential.token,
+    GUARD_ENGAGEMENT_ID: engagementId,
+    // T-10 — the eighth key. Written as '' when the plane has not reported one
+    // (never `undefined`, for the exact reason the comment above this function
+    // measures: a loose `Record<string, string>` let a missing key write the
+    // literal string "undefined" with a clean typecheck. An empty value here reads
+    // back as absent — `toCredential` treats a blank CONTROL_TELEMETRY_URL as no
+    // telemetry origin, same as every other optional field on `DeviceCredential`.
+    CONTROL_TELEMETRY_URL: credential.controlTelemetryUrl ?? ""
+  };
+  return writeEngagementEnv(engagementId, values, home);
+}
+var LEGACY_ENV_LOCAL_REL = ".env.local";
+function migrateLegacyEnvLocal(targetRepo, stored) {
+  const path = join5(targetRepo, LEGACY_ENV_LOCAL_REL);
+  if (!existsSync3(path))
+    return { outcome: "absent", unbacked: [], missingForAdoption: [] };
+  let raw;
+  try {
+    raw = readFileSync5(path, "utf-8");
+  } catch {
+    return { outcome: "failed", unbacked: [], missingForAdoption: [] };
+  }
+  const inFile = parseEnvText(raw);
+  const present = ENGAGEMENT_ENV_KEYS.filter((key) => key in inFile);
+  if (present.length === 0)
+    return { outcome: "absent", unbacked: [], missingForAdoption: [] };
+  const storeUnusable = missingRequiredKeys(stored).length > 0;
+  const unbacked = present.filter((key) => (inFile[key] ?? "") !== "" && (storeUnusable || (stored[key] ?? "") === ""));
+  if (unbacked.length > 0) {
+    return { outcome: "kept", unbacked, missingForAdoption: missingRequiredKeys(inFile) };
+  }
+  const ours = new Set(ENGAGEMENT_ENV_KEYS);
+  const kept = raw.split("\n").filter((line) => {
+    const eq = line.indexOf("=");
+    if (eq === -1)
+      return true;
+    return !ours.has(line.slice(0, eq).replace(/^\s*export\s+/, "").trim());
+  });
+  const substantive = kept.filter((line) => line.trim() !== "" && !line.trim().startsWith("# Halfcycle"));
+  try {
+    if (substantive.length === 0) {
+      rmSync(path);
+      return { outcome: "removed", unbacked: [], missingForAdoption: [] };
+    }
+    writeFileSync4(path, kept.join("\n"), "utf-8");
+    return { outcome: "stripped", unbacked: [], missingForAdoption: [] };
+  } catch {
+    return { outcome: "failed", unbacked: [], missingForAdoption: [] };
+  }
+}
+async function install(options) {
+  const { targetRepo, engagementId, engagementType, credential, home } = options;
+  if (!existsSync3(targetRepo)) {
+    throw new Error(`[bundle install] Target repo does not exist: ${targetRepo}`);
+  }
+  const manifest = readPluginManifest();
+  const report = {
+    writtenPaths: [],
+    skippedPaths: [],
+    mergedPaths: [],
+    collidedPaths: []
+  };
+  copyManifestCommands(manifest, targetRepo, report);
+  const capturedDir = join5(targetRepo, "test", "fixtures", "captured");
+  const capturedManifest = join5(capturedDir, "manifest.json");
+  if (!existsSync3(capturedManifest)) {
+    const srcManifest = join5(BUNDLE_ROOT, "scaffolding", "test", "fixtures", "captured", "manifest.json");
+    writeAllowlisted(capturedManifest, targetRepo, readFileSync5(srcManifest, "utf-8"), report.writtenPaths);
+  } else {
+    report.skippedPaths.push("test/fixtures/captured/manifest.json");
+  }
+  const vendoredBinSrc = resolveVendoredBinary();
+  const vendoredBinDest = join5(targetRepo, ".halfcycle", "bin", "bin.bundle.mjs");
+  record(report, writeCollisionSafe(vendoredBinDest, targetRepo, readFileSync5(vendoredBinSrc, "utf-8")), ".halfcycle/bin/bin.bundle.mjs");
+  const settingsPath = join5(targetRepo, ".claude", "settings.json");
+  const settingsPreexisted = existsSync3(settingsPath);
+  const generatedSettings = JSON.parse(generateSettingsJson());
+  const existingSettings = settingsPreexisted ? JSON.parse(readFileSync5(settingsPath, "utf-8")) : {};
+  const mergedSettings = mergeSettings(existingSettings, generatedSettings);
+  const mergedSettingsText = JSON.stringify(mergedSettings, null, 2) + "\n";
+  mkdirSync4(dirname2(settingsPath), { recursive: true });
+  writeFileSync4(settingsPath, mergedSettingsText, "utf-8");
+  (settingsPreexisted ? report.mergedPaths : report.writtenPaths).push(".claude/settings.json");
+  for (const [name, content] of [
+    ["guard-runner.sh", generateGuardRunnerWrapper()],
+    ["session-start-marker.sh", generateSessionStartMarker()],
+    ["user-prompt-reminder.sh", generateUserPromptReminderHook()]
+  ]) {
+    const hookPath = join5(targetRepo, ".claude", "hooks", name);
+    record(report, writeCollisionSafe(hookPath, targetRepo, content), `.claude/hooks/${name}`);
+  }
+  const ciStanzaPath = join5(targetRepo, ".halfcycle", "ci-stanza.yml");
+  record(report, writeCollisionSafe(ciStanzaPath, targetRepo, generateCiStanza()), ".halfcycle/ci-stanza.yml");
+  record(report, reconcileEnvExample(targetRepo), ".env.example");
+  if (credential) {
+    const helperPath = join5(targetRepo, MCP_HEADERS_HELPER_REL);
+    record(report, writeCollisionSafe(helperPath, targetRepo, generateMcpHeadersHelper()), MCP_HEADERS_HELPER_REL);
+    const mcpPath = join5(targetRepo, MCP_REGISTRATION_REL);
+    const existingMcp = existsSync3(mcpPath) ? readFileSync5(mcpPath, "utf-8") : null;
+    const mcpContent = generateMcpRegistration(existingMcp, credential.mcpUrl);
+    if (existingMcp === null) {
+      writeAllowlisted(mcpPath, targetRepo, mcpContent, report.writtenPaths);
+    } else if (existingMcp !== mcpContent) {
+      writeAllowlisted(mcpPath, targetRepo, mcpContent, report.mergedPaths);
+    } else {
+      report.skippedPaths.push(MCP_REGISTRATION_REL);
+    }
+  } else {
+    report.skippedPaths.push(`${MCP_REGISTRATION_REL} (no MCP origin \u2014 no credential supplied)`);
+  }
+  const gitignoreOutcome = reconcileGitignore(targetRepo);
+  if (gitignoreOutcome === "failed") {
+    report.skippedPaths.push(".gitignore (write failed \u2014 see credential refusal)");
+  } else {
+    record(report, gitignoreOutcome, ".gitignore");
+  }
+  record(report, writeProjectIdentity(targetRepo), ".halfcycle/project.json");
+  const credentialPath = engagementEnvPath(engagementId, home);
+  if (credential) {
+    record(report, writeEngagementCredential(credential, engagementId, home), credentialPath);
+  } else {
+    report.skippedPaths.push(`${credentialPath} (no credential supplied)`);
+  }
+  const stored = readEngagementEnv(engagementId, home) ?? {};
+  const migration = migrateLegacyEnvLocal(targetRepo, stored);
+  switch (migration.outcome) {
+    case "removed":
+      report.writtenPaths.push(".env.local (REMOVED \u2014 the credential now lives outside this repository)");
+      break;
+    case "stripped":
+      report.writtenPaths.push(".env.local (Halfcycle keys REMOVED \u2014 your own entries are untouched; the credential now lives outside this repository)");
+      break;
+    case "kept":
+      report.skippedPaths.push(`.env.local (KEPT \u2014 nothing removed: this repository still holds the only copy of ${migration.unbacked.join(", ")}, and the store at ${credentialPath} does not)`);
+      break;
+    case "failed":
+      report.skippedPaths.push(".env.local (could not be rewritten \u2014 DELETE IT BY HAND: it holds a credential this repository no longer needs)");
+      break;
+    case "absent":
+      break;
+  }
+  writeBundlePin(targetRepo, manifest.version, engagementId, engagementType, report.writtenPaths);
+  const scanResult = runBootstrapScan(targetRepo);
+  return {
+    version: manifest.version,
+    writtenPaths: report.writtenPaths,
+    skippedPaths: report.skippedPaths,
+    mergedPaths: report.mergedPaths,
+    collidedPaths: report.collidedPaths,
+    bootstrapScanRan: scanResult.ran,
+    legacyCredentialKept: migration.outcome === "kept" ? { keys: migration.unbacked, missing: migration.missingForAdoption } : null
+  };
+}
+
+// dist/create-engagement.js
+var CreateEngagementRefused = class extends Error {
+  status;
+  serverMessage;
+  errorCode;
+  constructor(status, serverMessage, errorCode, message) {
+    super(message);
+    this.status = status;
+    this.serverMessage = serverMessage;
+    this.errorCode = errorCode;
+    this.name = "CreateEngagementRefused";
+  }
+  /**
+   * Is this a refusal of the CALLER's credential — the arm signing in again can fix?
+   *
+   * `PublicStartDisabled` is excluded even though it is a 403, and that exclusion is
+   * the whole reason this is a method rather than a status comparison at the call
+   * site: the flag gates the DEPLOYMENT, identically for every caller, so no
+   * credential and no sign-in changes the answer. Treating it as an auth refusal
+   * would send a developer through a browser handoff to arrive at the same 403.
+   *
+   * **THIS IS THE CREATE ROUTE'S DERIVATION AND THE JOIN CALLER MUST NOT USE IT
+   * (T-24).** On the join route a 403 has two causes that share a status AND a
+   * discriminant (`error: 'Forbidden'`), so nothing on this object can tell them
+   * apart: the credential may be a live engagement token carrying no account, or the
+   * engagement id may not resolve. Signing in again cannot fix the second, and
+   * treating it as though it could would discard a good credential, walk the
+   * developer through a browser, and arrive at the identical 403 — a remedy that
+   * loops. `bin.ts`'s join path therefore retries on `401` ALONE, at the call site,
+   * where the reason can be written down. See `joinPinnedEngagement` there.
+   */
+  get authRefused() {
+    if (this.errorCode === "PublicStartDisabled")
+      return false;
+    return this.status === 401 || this.status === 403;
+  }
+};
+function planeRefusal(detail) {
+  let body;
+  try {
+    body = JSON.parse(detail);
+  } catch {
+    return void 0;
+  }
+  if (typeof body !== "object" || body === null)
+    return void 0;
+  const candidate = body;
+  if (typeof candidate.message !== "string" || candidate.message.trim() === "")
+    return void 0;
+  const hasDiscriminant = typeof candidate.error === "string" || typeof candidate.statusCode === "number" || typeof candidate.status === "string";
+  if (!hasDiscriminant)
+    return void 0;
+  return {
+    message: candidate.message,
+    error: typeof candidate.error === "string" ? candidate.error : void 0
+  };
+}
+var CONTROL_ORIGIN_HINT = "HALFCYCLE_SERVICE_URL must be the Halfcycle CONTROL origin \u2014 the one that serves /engagements and /board/enter-codes. The MCP server runs at a different address, and the platform supplies that one itself; you do not configure it.";
+async function createEngagement(baseUrl, name, credential) {
+  return requestEngagementValues(`${baseUrl.replace(/\/+$/, "")}/engagements`, name ? { name } : {}, credential, { action: "Create-engagement", nothingHappened: "No engagement was created", route: "POST /engagements" });
+}
+async function joinEngagement(baseUrl, engagementId, credential) {
+  return requestEngagementValues(`${baseUrl.replace(/\/+$/, "")}/engagements/${encodeURIComponent(engagementId)}/join`, {}, credential, {
+    action: "Join-engagement",
+    nothingHappened: "No credential was minted",
+    route: "POST /engagements/:engagementId/join"
+  });
+}
+async function requestEngagementValues(url, requestBody, credential, shape) {
+  const bearer = credential?.trim();
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...bearer ? { authorization: `Bearer ${bearer}` } : {}
+      },
+      body: JSON.stringify(requestBody)
+    });
+  } catch (err) {
+    throw new Error(`[bundle install] Could not reach the Halfcycle control plane at ${url}: ${err instanceof Error ? err.message : String(err)}. ${shape.nothingHappened}. ` + CONTROL_ORIGIN_HINT);
+  }
+  if (!res.ok) {
+    const detail = await res.text().catch(() => "");
+    const refusal = res.status === 404 ? void 0 : planeRefusal(detail);
+    if (refusal) {
+      throw new CreateEngagementRefused(res.status, refusal.message, refusal.error, `[bundle install] ${shape.action} failed: ${url} returned ${res.status}. ${refusal.message} ${shape.nothingHappened}.`);
+    }
+    const wrongOrigin = res.status === 404 ? `That address answered, but it does not serve ${shape.route} \u2014 so it is not the control plane. ` : "";
+    throw new Error(`[bundle install] ${shape.action} failed: ${url} returned ${res.status}. ${wrongOrigin}${detail ? `Response: ${detail.slice(0, 300)}. ` : ""}${shape.nothingHappened}. ` + CONTROL_ORIGIN_HINT);
+  }
+  const body = await res.json().catch(() => null);
+  if (!body || typeof body.engagementId !== "string" || typeof body.sessionToken !== "string") {
+    throw new Error(`[bundle install] ${shape.action} response from ${url} did not carry {engagementId, sessionToken}. ${shape.nothingHappened}. ` + CONTROL_ORIGIN_HINT);
+  }
+  for (const [field, value] of [
+    ["engagementId", body.engagementId],
+    ["sessionToken", body.sessionToken]
+  ]) {
+    if (value.trim() === "") {
+      throw new Error(`[bundle install] The Halfcycle plane at ${url} answered with a blank ${field} (the field is present but empty). An install cannot proceed on it: it would be written into this engagement's credential store, read back as a configured value, and every guard evaluation would fail against it for the life of the engagement. ${shape.nothingHappened} and nothing was written. ` + CONTROL_ORIGIN_HINT);
+    }
+  }
+  if (typeof body.mcpUrl !== "string" || body.mcpUrl.trim() === "") {
+    throw new Error(`[bundle install] The Halfcycle plane at ${url} created an engagement but did not say where its MCP server lives (no mcpUrl on the response). Without that address the install would write an MCP registration pointing nowhere, so nothing was written. Either that plane is older than this installer, or ${url} is not a Halfcycle control plane.`);
+  }
+  if (typeof body.guardUrl !== "string" || body.guardUrl.trim() === "") {
+    throw new Error(`[bundle install] The Halfcycle plane at ${url} created an engagement but did not say where its guard service lives (no guardUrl on the response). Without that address the install would wire a guard hook that evaluates nothing, so nothing was written. Either that plane is older than this installer, or ${url} is not a Halfcycle control plane.`);
+  }
+  const controlTelemetryUrl = typeof body.controlTelemetryUrl === "string" && body.controlTelemetryUrl.trim() !== "" ? body.controlTelemetryUrl.trim().replace(/\/+$/, "") : void 0;
+  return {
+    engagementId: body.engagementId,
+    sessionToken: body.sessionToken,
+    mcpUrl: body.mcpUrl.trim().replace(/\/+$/, ""),
+    guardUrl: body.guardUrl.trim().replace(/\/+$/, ""),
+    ...controlTelemetryUrl !== void 0 ? { controlTelemetryUrl } : {}
+  };
+}
+
+// dist/device-signin.js
+import { spawn } from "node:child_process";
+import { platform as platform3 } from "node:os";
+
+// dist/loopback-signin.js
+import { createServer } from "node:http";
+import { randomBytes, timingSafeEqual } from "node:crypto";
+var LOOPBACK_PORT_ENV = "HALFCYCLE_LOOPBACK_PORT";
+var DEFAULT_STILL_WAITING_MS = 15e3;
+function completionPage(result) {
+  const headline = result === LOOPBACK_RESULT.APPROVED ? "Signed in. You can close this tab and return to your terminal." : "Sign-in declined. Nothing was created. You can close this tab.";
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Halfcycle</title></head><body style="font:16px/1.5 system-ui;padding:3rem"><p>${headline}</p></body></html>`;
+}
+function isLoopbackPeer(remoteAddress) {
+  if (remoteAddress === void 0)
+    return false;
+  const addr = remoteAddress.startsWith("::ffff:") ? remoteAddress.slice("::ffff:".length) : remoteAddress;
+  return addr === "::1" || /^127\./.test(addr);
+}
+function statesMatch(presented, expected) {
+  const a = Buffer.from(presented, "utf8");
+  const b = Buffer.from(expected, "utf8");
+  if (a.length !== b.length)
+    return false;
+  return timingSafeEqual(a, b);
+}
+function createCallbackHandler(state, onCallback) {
+  return (req, res) => {
+    if (!isLoopbackPeer(req.socket.remoteAddress)) {
+      res.writeHead(403).end();
+      return;
+    }
+    if (req.method !== "GET") {
+      res.writeHead(405).end();
+      return;
+    }
+    const url = new URL(req.url ?? "/", `http://${LOOPBACK_REDIRECT_HOST}`);
+    if (url.pathname !== LOOPBACK_CALLBACK_PATH) {
+      res.writeHead(404).end();
+      return;
+    }
+    const presented = url.searchParams.get(LOOPBACK_QUERY_STATE) ?? "";
+    if (!statesMatch(presented, state)) {
+      res.writeHead(403, { "content-type": "text/plain; charset=utf-8" });
+      res.end("This is not the sign-in this terminal is waiting for.\n");
+      return;
+    }
+    const declared = url.searchParams.get(LOOPBACK_QUERY_RESULT);
+    const result = declared === LOOPBACK_RESULT.DECLINED ? LOOPBACK_RESULT.DECLINED : LOOPBACK_RESULT.APPROVED;
+    res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+    res.end(completionPage(result));
+    onCallback({ result });
+  };
+}
+function requestedPort(env) {
+  const raw = env[LOOPBACK_PORT_ENV]?.trim();
+  if (raw === void 0 || raw === "")
+    return { port: 0 };
+  if (!/^[0-9]+$/.test(raw)) {
+    return { problem: `${LOOPBACK_PORT_ENV} is set to "${raw}", which is not a port number` };
+  }
+  const port = Number.parseInt(raw, 10);
+  if (port < LOOPBACK_PORT_MIN || port > LOOPBACK_PORT_MAX) {
+    return {
+      problem: `${LOOPBACK_PORT_ENV} is set to ${port}, outside the range this flow allows (${LOOPBACK_PORT_MIN}-${LOOPBACK_PORT_MAX})`
+    };
+  }
+  return { port };
+}
+async function bindLoopback(env = process.env) {
+  const wanted = requestedPort(env);
+  if ("problem" in wanted)
+    return { bound: false, reason: wanted.problem };
+  const state = randomBytes(32).toString("hex");
+  let pending = null;
+  let deliver = null;
+  const server = createServer(createCallbackHandler(state, (callback) => {
+    if (deliver)
+      deliver(callback);
+    else
+      pending = callback;
+  }));
+  const bindProblem = await new Promise((resolve2) => {
+    const onError = (err) => {
+      resolve2(`${err.code ?? "bind failed"} on ${LOOPBACK_REDIRECT_HOST}:${wanted.port}`);
+    };
+    server.once("error", onError);
+    server.listen({ host: LOOPBACK_REDIRECT_HOST, port: wanted.port }, () => {
+      server.removeListener("error", onError);
+      resolve2(null);
+    });
+  });
+  if (bindProblem !== null) {
+    server.close();
+    return { bound: false, reason: `the local callback port could not be opened (${bindProblem})` };
+  }
+  const address = server.address();
+  if (address === null || typeof address === "string") {
+    await closeServer(server);
+    return { bound: false, reason: "the local callback port could not be read back after binding" };
+  }
+  return {
+    bound: true,
+    target: { port: address.port, state },
+    boundAddress: address.address,
+    waitForCallback: ({ timeoutMs, onStillWaiting, stillWaitingMs = DEFAULT_STILL_WAITING_MS }) => new Promise((resolve2) => {
+      if (pending !== null) {
+        resolve2(pending);
+        return;
+      }
+      const startedAt = Date.now();
+      const ticker = onStillWaiting === void 0 ? null : setInterval(() => onStillWaiting(Date.now() - startedAt), stillWaitingMs);
+      const finish = (value) => {
+        if (ticker !== null)
+          clearInterval(ticker);
+        clearTimeout(timer);
+        deliver = null;
+        resolve2(value);
+      };
+      const timer = setTimeout(() => finish(null), Math.max(0, timeoutMs));
+      deliver = finish;
+    }),
+    close: () => closeServer(server)
+  };
+}
+function closeServer(server) {
+  return new Promise((resolve2) => {
+    server.closeAllConnections();
+    server.close(() => resolve2());
+  });
+}
+
+// dist/device-signin.js
+var SignInRefused = class extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "SignInRefused";
+  }
+};
+var SIGN_IN_TIMED_OUT = "timed-out";
+var SIGN_IN_TIMEOUT_MESSAGE = "Sign-in timed out: the Halfcycle plane stopped answering while this terminal was waiting for the browser. Nothing was created. Check your connection and run the command again.";
+var SIGN_IN_NON_INTERACTIVE_MESSAGE = "Halfcycle needs a signed-in account and this looks like a non-interactive run (CI is set), so there is no browser to sign in with. Set HALFCYCLE_TOKEN in the environment to a Halfcycle credential and run this again. Nothing was created.";
+var DEADLINE_SLACK_INTERVALS = 1;
+var STILL_WAITING_MS = 15e3;
+function defaultWrite(text) {
+  process.stdout.write(text);
+}
+function defaultSleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function browserOpenCommand(os, url) {
+  if (os === "darwin")
+    return { command: "open", args: [url] };
+  if (os === "win32")
+    return { command: "cmd", args: ["/c", "start", "", url] };
+  return { command: "xdg-open", args: [url] };
+}
+function isOpenableUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+var BROWSER_OPEN_GRACE_MS = 3e3;
+async function openBrowser(url, env = process.env) {
+  if ((env["HALFCYCLE_NO_BROWSER"] ?? "").trim() !== "") {
+    return { opened: false, reason: "HALFCYCLE_NO_BROWSER is set in this environment" };
+  }
+  if (!isOpenableUrl(url)) {
+    return { opened: false, reason: "the sign-in address is not an http(s) URL this CLI will open" };
+  }
+  const { command, args: args2 } = browserOpenCommand(platform3(), url);
+  return new Promise((resolve2) => {
+    let child;
+    try {
+      child = spawn(command, args2, { stdio: "ignore", env });
+    } catch (err) {
+      resolve2({
+        opened: false,
+        reason: `${command} could not be run (${err instanceof Error ? err.message : String(err)})`
+      });
+      return;
+    }
+    let settled = false;
+    const settle = (attempt) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve2(attempt);
+    };
+    const timer = setTimeout(() => {
+      child.unref();
+      settle({ opened: true });
+    }, BROWSER_OPEN_GRACE_MS);
+    timer.unref?.();
+    child.on("error", (err) => {
+      settle({ opened: false, reason: `${command} could not be run (${err.code ?? err.message})` });
+    });
+    child.on("exit", (code, signal) => {
+      if (code === 0) {
+        settle({ opened: true });
+        return;
+      }
+      settle({
+        opened: false,
+        reason: `${command} exited ${signal !== null ? `on ${signal}` : String(code)}`
+      });
+    });
+  });
+}
+function isNonInteractive(env = process.env) {
+  const ci = (env["CI"] ?? "").trim().toLowerCase();
+  return ci !== "" && ci !== "0" && ci !== "false";
+}
+async function startDeviceAuth(serviceUrl) {
+  const url = `${serviceUrl.replace(/\/+$/, "")}/auth/device/start`;
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: "{}"
+    });
+  } catch (err) {
+    throw new SignInRefused(SIGN_IN_TIMED_OUT, `Could not reach the Halfcycle plane at ${url} to start a sign-in: ${err instanceof Error ? err.message : String(err)}. Nothing was created.`);
+  }
+  const body = await res.json().catch(() => null);
+  if (res.status !== 201) {
+    const refusal = tryRefusal(body);
+    throw new SignInRefused(refusal?.status ?? String(res.status), refusal?.message ?? `Sign-in could not be started: ${url} answered ${res.status}. Nothing was created.`);
+  }
+  const parsed = deviceAuthStartResponseSchema.safeParse(body);
+  if (!parsed.success) {
+    throw new SignInRefused(SIGN_IN_TIMED_OUT, `The Halfcycle plane at ${url} answered a sign-in start this client cannot read. Either that plane is older than this installer, or the address is not a Halfcycle control plane. Nothing was created.`);
+  }
+  return parsed.data;
+}
+function tryRefusal(body) {
+  if (typeof body !== "object" || body === null)
+    return void 0;
+  const candidate = body;
+  if (typeof candidate.status !== "string" || typeof candidate.message !== "string") {
+    return void 0;
+  }
+  return { status: candidate.status, message: candidate.message };
+}
+async function pollForCredential(serviceUrl, started, deps = {}) {
+  const write = deps.write ?? defaultWrite;
+  const sleep = deps.sleep ?? defaultSleep;
+  const now = deps.now ?? Date.now;
+  const url = `${serviceUrl.replace(/\/+$/, "")}/auth/device/token`;
+  const interval = started.pollIntervalMs;
+  const deadline = new Date(started.expiresAt).getTime() + interval * DEADLINE_SLACK_INTERVALS;
+  const startedAt = now();
+  let announcedAt = startedAt;
+  for (; ; ) {
+    let body;
+    let reachable = true;
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ deviceCode: started.deviceCode })
+      });
+      body = await res.json().catch(() => null);
+    } catch {
+      reachable = false;
+    }
+    if (reachable) {
+      const parsed = devicePollResponseSchema.safeParse(body);
+      if (parsed.success) {
+        const answer = parsed.data;
+        if (answer.status === DEVICE_AUTH_STATUS.APPROVED)
+          return answer;
+        if (answer.status !== DEVICE_AUTH_STATUS.PENDING) {
+          throw new SignInRefused(answer.status, answer.message);
+        }
+      }
+    }
+    if (now() >= deadline) {
+      throw new SignInRefused(SIGN_IN_TIMED_OUT, SIGN_IN_TIMEOUT_MESSAGE);
+    }
+    if (now() - announcedAt >= STILL_WAITING_MS) {
+      announcedAt = now();
+      write(`[halfcycle] Still waiting for the browser (${Math.round((announcedAt - startedAt) / 1e3)}s). Code: ${started.userCode}
+`);
+    }
+    await sleep(interval);
+  }
+}
+var LOOPBACK_TIMEOUT_MESSAGE = "Sign-in timed out: the browser never came back to this terminal. Nothing was created. Run the command again \u2014 or, if this machine cannot hand the browser back (a remote session, a container), run it with HALFCYCLE_NO_BROWSER=1 to use the code-based sign-in instead.";
+var LOOPBACK_COLLECT_ATTEMPTS = 3;
+async function collectDecidedCredential(serviceUrl, started, deps) {
+  const sleep = deps.sleep ?? defaultSleep;
+  const url = `${serviceUrl.replace(/\/+$/, "")}/auth/device/token`;
+  let lastProblem = LOOPBACK_TIMEOUT_MESSAGE;
+  for (let attempt = 0; attempt < LOOPBACK_COLLECT_ATTEMPTS; attempt++) {
+    if (attempt > 0)
+      await sleep(started.pollIntervalMs);
+    let body;
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ deviceCode: started.deviceCode })
+      });
+      body = await res.json().catch(() => null);
+    } catch (err) {
+      lastProblem = `The browser finished signing you in, but this terminal could not reach the Halfcycle plane to collect the credential: ${err instanceof Error ? err.message : String(err)}. Run the command again.`;
+      continue;
+    }
+    const parsed = devicePollResponseSchema.safeParse(body);
+    if (!parsed.success)
+      continue;
+    const answer = parsed.data;
+    if (answer.status === DEVICE_AUTH_STATUS.APPROVED)
+      return answer;
+    if (answer.status !== DEVICE_AUTH_STATUS.PENDING) {
+      throw new SignInRefused(answer.status, answer.message);
+    }
+  }
+  throw new SignInRefused(SIGN_IN_TIMED_OUT, lastProblem);
+}
+async function signIn(serviceUrl, deps = {}) {
+  const write = deps.write ?? defaultWrite;
+  const now = deps.now ?? Date.now;
+  const env = deps.env ?? process.env;
+  if (isNonInteractive(env)) {
+    throw new SignInRefused(SIGN_IN_TIMED_OUT, SIGN_IN_NON_INTERACTIVE_MESSAGE);
+  }
+  write(`[halfcycle] Halfcycle needs an account before it can create an engagement \u2014 signing you in through your browser.
+`);
+  const bind = await bindLoopback(env);
+  let closed = false;
+  const closeListener = async () => {
+    if (bind.bound && !closed) {
+      closed = true;
+      await bind.close();
+    }
+  };
+  try {
+    const started = await startDeviceAuth(serviceUrl);
+    if (bind.bound) {
+      const url = loopbackVerificationUrl(started.verificationUrl, bind.target);
+      const attempt = await openBrowser(url, env);
+      if (attempt.opened) {
+        write(`[halfcycle] Opened your browser to finish signing in. This terminal is waiting.
+`);
+        const deadline = new Date(started.expiresAt).getTime() + started.pollIntervalMs * DEADLINE_SLACK_INTERVALS;
+        const callback = await bind.waitForCallback({
+          timeoutMs: deadline - now(),
+          onStillWaiting: (elapsed) => (
+            // NO CODE IN THIS LINE. The device-code path prints the code here
+            // because a human is comparing it; on this path there is nothing to
+            // compare and criterion 1 is that none is displayed AT ALL.
+            write(`[halfcycle] Still waiting for the browser (${Math.round(elapsed / 1e3)}s).
+`)
+          )
+        });
+        await closeListener();
+        if (callback === null) {
+          throw new SignInRefused(SIGN_IN_TIMED_OUT, LOOPBACK_TIMEOUT_MESSAGE);
+        }
+        const approved = await collectDecidedCredential(serviceUrl, started, deps);
+        write(`[halfcycle] Signed in as account ${approved.accountId} \u2014 continuing.
+`);
+        return {
+          accountId: approved.accountId,
+          credential: approved.credential,
+          expiresAt: approved.expiresAt
+        };
+      }
+      await closeListener();
+      write(`[halfcycle] Falling back to the code-based sign-in: ${attempt.reason}.
+`);
+    } else {
+      write(`[halfcycle] Falling back to the code-based sign-in: ${bind.reason}.
+`);
+    }
+    return await deviceCodeSignIn(serviceUrl, started, env, deps);
+  } finally {
+    await closeListener();
+  }
+}
+async function deviceCodeSignIn(serviceUrl, started, env, deps) {
+  const write = deps.write ?? defaultWrite;
+  write(`[halfcycle] Your sign-in code: ${started.userCode}
+`);
+  const attempt = await openBrowser(started.verificationUrl, env);
+  if (attempt.opened) {
+    write(`[halfcycle] Opened your browser at ${started.verificationUrl}
+`);
+  } else {
+    write(`[halfcycle] Open this address to sign in: ${started.verificationUrl}
+`);
+  }
+  write(`[halfcycle] Check the code on that page matches the one above, then sign in. This terminal is waiting.
+`);
+  const approved = await pollForCredential(serviceUrl, started, deps);
+  write(`[halfcycle] Signed in as account ${approved.accountId} \u2014 continuing.
+`);
+  return {
+    accountId: approved.accountId,
+    credential: approved.credential,
+    expiresAt: approved.expiresAt
+  };
+}
+
+// dist/resolve-credential.js
+async function obtainCredential(serviceUrl, opts = {}) {
+  const env = opts.env ?? process.env;
+  const fromEnv = env["HALFCYCLE_TOKEN"]?.trim();
+  if (fromEnv)
+    return { credential: fromEnv, source: "environment" };
+  const stored = readStoredCredential(serviceUrl, opts.home);
+  if (stored) {
+    return { credential: stored.credential, source: "stored", accountId: stored.accountId };
+  }
+  const signedIn = await signIn(serviceUrl, opts);
+  writeStoredCredential(serviceUrl, {
+    accountId: signedIn.accountId,
+    credential: signedIn.credential,
+    expiresAt: signedIn.expiresAt
+  }, opts.home);
+  return {
+    credential: signedIn.credential,
+    source: "browser-handoff",
+    accountId: signedIn.accountId
+  };
+}
+async function replaceRefusedCredential(serviceUrl, refused, opts = {}) {
+  if (refused.source !== "stored")
+    return null;
+  forgetStoredCredential(serviceUrl, opts.home);
+  const signedIn = await signIn(serviceUrl, opts);
+  writeStoredCredential(serviceUrl, {
+    accountId: signedIn.accountId,
+    credential: signedIn.credential,
+    expiresAt: signedIn.expiresAt
+  }, opts.home);
+  return {
+    credential: signedIn.credential,
+    source: "browser-handoff",
+    accountId: signedIn.accountId
+  };
+}
+function refusedCredentialRemedy(source) {
+  switch (source) {
+    case "environment":
+      return "That credential came from HALFCYCLE_TOKEN in this environment, and it takes precedence over any saved sign-in \u2014 so running this again will present the same value and get the same answer. Replace it with a live credential, or unset it to sign in through the browser instead.";
+    case "stored":
+      return "That was this machine's saved sign-in and it has been discarded. Run the command again to sign in through your browser.";
+    case "browser-handoff":
+      return "That credential was issued by this sign-in moments ago, so signing in again would produce the same result. This is a problem on the Halfcycle plane rather than with your account.";
+  }
+}
+
+// dist/mint-board-code.js
+async function mintBoardEnterCode(baseUrl, sessionToken) {
+  const url = `${baseUrl.replace(/\/+$/, "")}/board/enter-codes`;
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${sessionToken}`
+      },
+      body: "{}"
+    });
+  } catch (err) {
+    throw new Error(`[bundle install] Could not reach the Halfcycle board mint endpoint at ${url}: ${err instanceof Error ? err.message : String(err)}.`);
+  }
+  if (!res.ok) {
+    throw new Error(`[bundle install] Board code mint failed: ${url} returned ${res.status}.`);
+  }
+  const body = await res.json().catch(() => null);
+  if (!body || typeof body.enterCode !== "string" || typeof body.engagementId !== "string" || typeof body.boardUrl !== "string" || typeof body.expiresAt !== "string") {
+    throw new Error(`[bundle install] Board code mint response from ${url} did not carry {enterCode, engagementId, boardUrl, expiresAt}.`);
+  }
+  return {
+    enterCode: body.enterCode,
+    engagementId: body.engagementId,
+    boardUrl: body.boardUrl,
+    expiresAt: body.expiresAt
+  };
+}
+
+// dist/probe-mcp.js
+var PROBE_TIMEOUT_MS = 5e3;
+async function probeMcpOrigin(mcpUrl) {
+  const url = mcpEndpointUrl(mcpUrl);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initialize", params: {} }),
+      signal: controller.signal
+    });
+  } catch (err) {
+    return {
+      reached: false,
+      problem: controller.signal.aborted ? `it did not answer within ${PROBE_TIMEOUT_MS / 1e3} seconds` : `it could not be reached (${err instanceof Error ? err.message : String(err)})`
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+  if (res.status === 404) {
+    return { reached: false, problem: "that address answered, but it serves no /mcp endpoint" };
+  }
+  if (!res.ok) {
+    return { reached: false, problem: `it answered ${res.status}` };
+  }
+  const body = await res.json().catch(() => null);
+  const name = body?.result?.serverInfo?.name;
+  if (typeof name !== "string" || name === "") {
+    return { reached: false, problem: "it answered, but not as an MCP server" };
+  }
+  return { reached: true, serverName: name };
+}
+
+// dist/build-record/types.js
+var BUILD_RECORD_FORMAT = "halfcycle-build-record/v1";
+function projectSeedGuard(fired, includeExplanation) {
+  const seed = {
+    patternRef: fired.patternRef,
+    severity: fired.severity
+  };
+  if (includeExplanation && fired.explanation)
+    seed.explanation = fired.explanation;
+  return seed;
+}
+
+// dist/build-record/sources.js
+import { readFileSync as readFileSync6, existsSync as existsSync4 } from "node:fs";
+import { createHash } from "node:crypto";
+import { join as join6 } from "node:path";
+import { execFileSync as execFileSync2 } from "node:child_process";
+var MissingSourceError = class extends Error {
+  constructor(sourceName, detail) {
+    super(`[build-record] missing required source: ${sourceName} \u2014 ${detail}`);
+    this.name = "MissingSourceError";
+  }
+};
+function projectSeedGuards(runs) {
+  const byRef = /* @__PURE__ */ new Map();
+  for (const run of runs) {
+    if (!run.result)
+      continue;
+    for (const fired of run.result.guardsFired) {
+      const seed = projectSeedGuard(
+        fired,
+        /* includeExplanation */
+        false
+      );
+      const existing = byRef.get(seed.patternRef);
+      if (!existing) {
+        byRef.set(seed.patternRef, seed);
+      } else if (existing.severity !== seed.severity) {
+        byRef.set(seed.patternRef, pickHigherSeverity(existing, seed));
+      }
+    }
+  }
+  return [...byRef.values()].sort((a, b) => a.patternRef.localeCompare(b.patternRef));
+}
+var SEVERITY_ORDINAL = { info: 0, warn: 1, block: 2 };
+function pickHigherSeverity(a, b) {
+  return (SEVERITY_ORDINAL[a.severity] ?? -1) >= (SEVERITY_ORDINAL[b.severity] ?? -1) ? a : b;
+}
+function normalizeLegacyLine(parsed) {
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return parsed;
+  }
+  const record2 = parsed;
+  if (record2["outcome"] !== void 0)
+    return parsed;
+  return {
+    ...record2,
+    runId: record2["runId"] ?? syntheticRunId(record2),
+    outcome: "evaluated"
+  };
+}
+function syntheticRunId(record2) {
+  const key = [
+    record2["engagementId"],
+    record2["occurredAt"],
+    record2["runType"],
+    record2["phase"]
+  ].join("|");
+  const hex = createHash("sha256").update(`legacy-guard-eval-run:${key}`).digest("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
+function readGuardEvalLog(logDir, phaseId) {
+  const logPath = join6(logDir, `phase-${phaseId}.jsonl`);
+  if (!existsSync4(logPath)) {
+    throw new MissingSourceError("guard-eval log", `no runner guard-eval log at ${logPath} for phase ${phaseId}`);
+  }
+  const raw = readFileSync6(logPath, "utf-8");
+  const runs = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "")
+      continue;
+    const parsed = JSON.parse(trimmed);
+    runs.push(guardEvalRunSchema.parse(normalizeLegacyLine(parsed)));
+  }
+  return runs;
+}
+function readOrchestrationState(phasesDir, phaseId) {
+  const statePath = join6(phasesDir, `phase-${phaseId}-orchestration-state.json`);
+  if (!existsSync4(statePath)) {
+    throw new MissingSourceError("orchestration state", `no orchestration-state file at ${statePath} for phase ${phaseId}`);
+  }
+  const parsed = JSON.parse(readFileSync6(statePath, "utf-8"));
+  if (!parsed.tasks || typeof parsed.tasks !== "object") {
+    throw new MissingSourceError("orchestration state", `${statePath} has no tasks map`);
+  }
+  const tasks = {};
+  for (const [id, t] of Object.entries(parsed.tasks)) {
+    if (!t || typeof t.status !== "string") {
+      throw new MissingSourceError("orchestration state", `task ${id} has no status`);
+    }
+    tasks[id] = { status: t.status };
+  }
+  return { tasks };
+}
+function readGitClose(repoRoot) {
+  let closeCommit;
+  let closedDate;
+  try {
+    closeCommit = execFileSync2("git", ["-C", repoRoot, "rev-parse", "--short", "HEAD"], {
+      encoding: "utf-8"
+    }).trim();
+    closedDate = execFileSync2("git", ["-C", repoRoot, "show", "-s", "--format=%cs", "HEAD"], { encoding: "utf-8" }).trim();
+  } catch (err) {
+    throw new MissingSourceError("git HEAD", `cannot resolve close commit/date in ${repoRoot}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (!closeCommit)
+    throw new MissingSourceError("git HEAD", `empty commit sha in ${repoRoot}`);
+  if (!closedDate)
+    throw new MissingSourceError("git HEAD", `empty commit date in ${repoRoot}`);
+  return { closeCommit, closedDate };
+}
+function validateNarrated(narrated) {
+  const req = (v, name) => {
+    if (v === void 0 || v === null || v === "") {
+      throw new MissingSourceError("narrated artefact", `${name} is missing`);
+    }
+  };
+  req(narrated.engagement, "engagement");
+  req(narrated.engagementType, "engagementType");
+  req(narrated.phase?.name, "phase.name");
+  req(narrated.status, "status");
+  req(narrated.thesis, "thesis");
+  req(narrated.delivered, "delivered");
+  req(narrated.acceptance, "acceptance");
+  req(narrated.acceptance?.verdict, "acceptance.verdict");
+  req(narrated.gatesEarnedKeep, "gatesEarnedKeep");
+  req(narrated.instruments, "instruments");
+  if (!Array.isArray(narrated.deviations)) {
+    throw new MissingSourceError("narrated artefact", "deviations must be an array");
+  }
+  return narrated;
+}
+function loadSources(opts) {
+  const orchestration = readOrchestrationState(opts.phasesDir, opts.phaseId);
+  const guardEvalRuns = readGuardEvalLog(opts.guardEvalLogDir, opts.phaseId);
+  const git2 = readGitClose(opts.repoRoot);
+  const narrated = validateNarrated(opts.narrated);
+  if (!Array.isArray(opts.touchedInvariants)) {
+    throw new MissingSourceError("feature-spec Touches", "touchedInvariants must be an array");
+  }
+  return {
+    orchestration,
+    narrated,
+    git: git2,
+    guardEvalRuns,
+    touchedInvariants: opts.touchedInvariants
+  };
+}
+
+// dist/build-record/assemble.js
+var LANDED_STATES = /* @__PURE__ */ new Set(["merged", "done"]);
+var CANCELLED_STATE = "cancelled";
+function deriveTasks(orchestration) {
+  const ids = Object.keys(orchestration.tasks);
+  const cancelled = ids.filter((id) => orchestration.tasks[id].status === CANCELLED_STATE).sort((a, b) => a.localeCompare(b));
+  const landed = ids.filter((id) => LANDED_STATES.has(orchestration.tasks[id].status)).length;
+  return { planned: ids.length, landed, cancelled };
+}
+function deriveThesisHeld(acceptance) {
+  if (acceptance.verdict !== "clean")
+    return false;
+  for (const dw of Object.values(acceptance.doneWhen)) {
+    if (dw.result === "dropped")
+      continue;
+    if (dw.result !== "pass")
+      return false;
+  }
+  return true;
+}
+function deriveInvariantsExercised(touched) {
+  return [...new Set(touched)].sort((a, b) => a.localeCompare(b));
+}
+function assembleBuildRecord(sources) {
+  const { narrated, git: git2, orchestration } = sources;
+  return {
+    format: BUILD_RECORD_FORMAT,
+    engagement: narrated.engagement,
+    engagementType: narrated.engagementType,
+    phase: { id: narrated.phase.id, name: narrated.phase.name },
+    status: narrated.status,
+    closedDate: git2.closedDate,
+    closeCommit: git2.closeCommit,
+    thesis: narrated.thesis,
+    thesisHeld: deriveThesisHeld(narrated.acceptance),
+    delivered: narrated.delivered,
+    seedGuards: projectSeedGuards(sources.guardEvalRuns),
+    acceptance: narrated.acceptance,
+    gatesEarnedKeep: narrated.gatesEarnedKeep,
+    instruments: narrated.instruments,
+    invariantsExercised: deriveInvariantsExercised(sources.touchedInvariants),
+    deviations: narrated.deviations,
+    tasks: deriveTasks(orchestration)
+  };
+}
+
+// dist/build-record/template.js
+function severityLabel(seed) {
+  return `\`${seed.patternRef}\` (severity \`${seed.severity}\`)`;
+}
+function renderDoneWhenRows(record2) {
+  const rows = [];
+  for (const [key, dw] of Object.entries(record2.acceptance.doneWhen)) {
+    const mark = dw.result === "pass" ? "\u2705" : dw.result === "dropped" ? "\u2014" : dw.result;
+    rows.push(`| ${key} | ${mark} | ${dw.detail} |`);
+  }
+  return rows.join("\n");
+}
+function renderBuildRecordMarkdown(record2) {
+  const { phase } = record2;
+  const guardsList = record2.seedGuards.map(severityLabel).join(", ");
+  const lines = [
+    // Fixed prose (vault-canonical template) + projected title slots.
+    `# Build Record \u2014 Phase ${phase.id}: ${phase.name}`,
+    "",
+    `**Format:** \`${record2.format}\` (markdown + JSON pair; portable, readable without Halfcycle systems)`,
+    "",
+    "> This Build Record was assembled automatically at phase close by the method bundle (`packages/bundle`). Every data field below is projected from the companion JSON \u2014 no record content is hand-authored.",
+    "",
+    `**Engagement:** ${record2.engagement} (${record2.engagementType})`,
+    `**Phase:** ${phase.id} \u2014 ${phase.name}`,
+    `**Status:** ${record2.status.toUpperCase()} \xB7 **Closed:** ${record2.closedDate} \xB7 **Close commit:** \`${record2.closeCommit}\``,
+    `**Companion:** [\`phase-${phase.id}.json\`](phase-${phase.id}.json)`,
+    "",
+    "## What this phase proved",
+    "",
+    `${record2.thesis} **Thesis held: ${record2.thesisHeld ? "yes" : "no"}.**`,
+    "",
+    "## Delivered",
+    "",
+    `- **Packages:** ${record2.delivered.packages.join(", ")}`,
+    `- **Services:** ${record2.delivered.services.join(", ")}`,
+    `- **Tools:** ${record2.delivered.tools.join(", ")}`,
+    `- **Dogfood:** ${record2.delivered.dogfood}`,
+    "",
+    guardsList ? `Guards evaluated (INV-007-safe results): ${guardsList}. *(Guard \`channel\`/\`version\` are guard-asset metadata, excluded from the v1 record \u2014 INV-007/INV-001.)*` : "No guards fired during this phase.",
+    "",
+    `## Acceptance (independent walk \u2014 walker ${record2.acceptance.walker})`,
+    "",
+    `**Verdict:** ${record2.acceptance.verdict} \xB7 **Findings:** ${record2.acceptance.findings}`,
+    "",
+    "| Done-when | Result | Evidence |",
+    "|---|---|---|",
+    renderDoneWhenRows(record2),
+    ""
+  ];
+  if (record2.acceptance.inv002ProdBypassProbe) {
+    lines.push(`**INV-002 production bypass probe:** ${record2.acceptance.inv002ProdBypassProbe.result} \u2014 ${record2.acceptance.inv002ProdBypassProbe.detail}`, "");
+  }
+  lines.push("## Gates that earned their keep", "", `**${record2.gatesEarnedKeep.defectsCaughtPreHuman}** defects were caught by the gates before the human walk; the walk itself found **${record2.gatesEarnedKeep.bugsReachingHumanWalk}**. Named: ${record2.gatesEarnedKeep.named.join("; ")}.`, "", "## Instruments", "", `- **Marginal-cost self-accounting:** ${record2.instruments.marginalCostSelfAccounting}`, `- **COE add-rate:** seam-new ${record2.instruments.coeAddRate.seamNew}, seam-repeat ${record2.instruments.coeAddRate.seamRepeat}, model-limitation ${record2.instruments.coeAddRate.modelLimitation}. ${record2.instruments.coeAddRate.notes}`, "", "## Invariants exercised", "", record2.invariantsExercised.join(", "), "", "## Deviations & decisions recorded", "", ...record2.deviations.map((d) => `- ${d}`), "", "## Tasks", "", `- **Planned:** ${record2.tasks.planned} \xB7 **Landed:** ${record2.tasks.landed} \xB7 **Cancelled:** ${record2.tasks.cancelled.length > 0 ? record2.tasks.cancelled.join(", ") : "none"}`, "");
+  return lines.join("\n");
+}
+
+// dist/build-record/write.js
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join7, resolve, relative as relative2, isAbsolute } from "node:path";
+var BUILD_RECORD_DIR = join7("docs", "build-records");
+function serialiseRecordJson(record2) {
+  return JSON.stringify(record2, null, 2) + "\n";
+}
+function writeBuildRecord(repoRoot, record2) {
+  const outDir = resolve(repoRoot, BUILD_RECORD_DIR);
+  const expected = resolve(repoRoot, BUILD_RECORD_DIR);
+  const rel = relative2(expected, outDir);
+  if (rel !== "" || isAbsolute(rel)) {
+    throw new Error(`[build-record] refusing to write outside ${BUILD_RECORD_DIR}`);
+  }
+  mkdirSync5(outDir, { recursive: true });
+  const jsonPath = join7(outDir, `phase-${record2.phase.id}.json`);
+  const mdPath = join7(outDir, `phase-${record2.phase.id}.md`);
+  writeFileSync5(jsonPath, serialiseRecordJson(record2), "utf-8");
+  writeFileSync5(mdPath, renderBuildRecordMarkdown(record2), "utf-8");
+  return { jsonPath, mdPath };
+}
+
+// dist/build-record/index.js
+function assemblePhaseBuildRecord(opts) {
+  const sources = loadSources({
+    repoRoot: opts.repoRoot,
+    phasesDir: opts.phasesDir,
+    guardEvalLogDir: opts.guardEvalLogDir,
+    phaseId: opts.phaseId,
+    narrated: opts.narrated,
+    touchedInvariants: opts.touchedInvariants
+  });
+  const record2 = assembleBuildRecord(sources);
+  return writeBuildRecord(opts.repoRoot, record2);
+}
+
+// dist/open-phase.js
+import { readFileSync as readFileSync7 } from "node:fs";
+import { join as join8 } from "node:path";
+var OpenPhaseRefused = class extends Error {
+  status;
+  finding;
+  constructor(status, message, finding) {
+    super(message);
+    this.status = status;
+    this.finding = finding;
+    this.name = "OpenPhaseRefused";
+  }
+};
+var OPEN_PHASE_ENV_KEYS = [
+  "HALFCYCLE_SERVICE_URL",
+  "HALFCYCLE_TOKEN",
+  "HALFCYCLE_ENGAGEMENT_ID"
+];
+function readRepoCredential(repoRoot, env = process.env, home) {
+  const pinned = readPinnedEngagementId(repoRoot);
+  const fromStore = pinned === null ? null : readEngagementEnv(pinned, home);
+  const looked = pinned === null ? `${join8(repoRoot, ".halfcycle", "bundle.json")} (which names no engagement)` : engagementEnvPath(pinned, home);
+  const values = {};
+  for (const key of OPEN_PHASE_ENV_KEYS) {
+    const value = (env[key] ?? fromStore?.[key] ?? "").trim();
+    if (value === "") {
+      throw new Error(`[halfcycle] ${key} is not set \u2014 it is neither in this shell's environment nor in ${looked}. That file is written by \`npx halfcycle\`; if this repo has no Halfcycle install yet, or this machine has never installed this engagement, run the installer here first.`);
+    }
+    values[key] = value;
+  }
+  return {
+    serviceUrl: values["HALFCYCLE_SERVICE_URL"].replace(/\/+$/, ""),
+    token: values["HALFCYCLE_TOKEN"],
+    engagementId: values["HALFCYCLE_ENGAGEMENT_ID"]
+  };
+}
+function readPinnedEngagementId(repoRoot) {
+  try {
+    const pin = JSON.parse(readFileSync7(join8(repoRoot, ".halfcycle", "bundle.json"), "utf-8"));
+    const id = pin[PIN_ENGAGEMENT_ID_FIELD];
+    return typeof id === "string" && id !== "" ? id : null;
+  } catch {
+    return null;
+  }
+}
+async function openPhase(credential, phase, entry) {
+  const parsed = phaseEntryDecisionSchema.safeParse(entry);
+  if (!parsed.success) {
+    throw new Error(`[halfcycle] The entry decision is not a decision this platform accepts: ${parsed.error.issues.map((i) => i.message).join("; ")}.`);
+  }
+  const url = `${credential.serviceUrl}/engagements/${encodeURIComponent(credential.engagementId)}/phase`;
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${credential.token}`
+      },
+      body: JSON.stringify({ phase, entry })
+    });
+  } catch (err) {
+    throw new Error(`[halfcycle] Could not reach the Halfcycle control plane at ${url}: ${err instanceof Error ? err.message : String(err)}. No phase was opened.`);
+  }
+  if (!res.ok) {
+    const body2 = await res.json().catch(() => null);
+    const message = typeof body2?.message === "string" ? body2.message : `${url} returned ${res.status}.`;
+    const finding = typeof body2?.finding === "string" ? body2.finding : null;
+    throw new OpenPhaseRefused(res.status, message, finding);
+  }
+  const body = await res.json().catch(() => null);
+  if (!body || !(typeof body.phase === "string" || body.phase === null) || !(typeof body.previousPhase === "string" || body.previousPhase === null) || typeof body.decision !== "object" || body.decision === null || typeof body.decision.decisionId !== "string") {
+    throw new Error(`[halfcycle] The response from ${url} did not carry { phase, previousPhase, decision }. The phase may or may not have moved \u2014 read the engagement's decision history before retrying.`);
+  }
+  return {
+    phase: body.phase,
+    previousPhase: body.previousPhase,
+    decision: body.decision
+  };
+}
+
+// dist/close-phase.js
+var ClosePhaseRefused = class extends Error {
+  status;
+  finding;
+  code;
+  constructor(status, message, finding, code) {
+    super(message);
+    this.status = status;
+    this.finding = finding;
+    this.code = code;
+    this.name = "ClosePhaseRefused";
+  }
+};
+async function closePhase(credential, phase, outcome, close) {
+  const parsed = acceptanceOutcomeSchema.safeParse(outcome);
+  if (!parsed.success) {
+    throw new Error(`[halfcycle] That is not an acceptance outcome this platform accepts: ${parsed.error.issues.map((i) => i.message).join("; ")}.`);
+  }
+  const parsedClose = phaseCloseDecisionSchema.safeParse(close);
+  if (!parsedClose.success) {
+    throw new Error(`[halfcycle] That is not a phase-close decision this platform accepts: ${parsedClose.error.issues.map((i) => i.message).join("; ")}.`);
+  }
+  const url = `${credential.serviceUrl}/engagements/${encodeURIComponent(credential.engagementId)}/accept`;
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${credential.token}`
+      },
+      body: JSON.stringify({ phase, acceptanceOutcome: outcome, close })
+    });
+  } catch (err) {
+    throw new Error(`[halfcycle] Could not reach the Halfcycle control plane at ${url}: ${err instanceof Error ? err.message : String(err)}. The phase was not closed.`);
+  }
+  if (!res.ok) {
+    const body2 = await res.json().catch(() => null);
+    const message = typeof body2?.message === "string" ? body2.message : `${url} returned ${res.status}.`;
+    const finding = typeof body2?.finding === "string" ? body2.finding : void 0;
+    const code = typeof body2?.error === "string" ? body2.error : void 0;
+    throw new ClosePhaseRefused(res.status, message, finding, code);
+  }
+  const body = await res.json().catch(() => null);
+  if (!body || typeof body.engagementId !== "string" || typeof body.status !== "string") {
+    throw new Error(`[halfcycle] The response from ${url} did not carry { engagementId, status }. The phase may or may not have closed \u2014 read the engagement's status before retrying.`);
+  }
+  return { engagementId: body.engagementId, status: body.status };
+}
+
+// dist/cli-contract.js
+var CLI_VERBS = ["install", "check-drift", "build-record", "open-phase", "close-phase"];
+var CONTRACTS = [
+  // `install`, `check-drift` and `build-record` take positionals and no required
+  // flags. They are declared so the verb set has ONE home — a remedy naming a verb
+  // this CLI does not have is the same defect as one missing a flag.
+  { verb: "install", required: [], conditional: [] },
+  { verb: "check-drift", required: [], conditional: [] },
+  { verb: "build-record", required: [], conditional: [] },
+  {
+    verb: "open-phase",
+    required: [
+      {
+        flag: "--actor",
+        takesValue: true,
+        missingMessage: "halfcycle open-phase: --actor is required \u2014 the decision is recorded, and an unattributed decision is what that record exists to prevent."
+      },
+      {
+        flag: "--evidence",
+        orFlags: ["--override"],
+        takesValue: true,
+        missingMessage: 'halfcycle open-phase: --evidence is required (or --override --reason "\u2026") \u2014 an entry condition asserted without evidence asserts nothing.'
+      }
+    ],
+    conditional: [
+      {
+        whenPresent: "--override",
+        thenRequires: "--reason",
+        takesValue: true,
+        missingMessage: "halfcycle open-phase: --override requires --reason \u2014 an override with no reason is a silent skip wearing a decision."
+      }
+    ]
+  },
+  {
+    verb: "close-phase",
+    // Declaration order is the order a rendered invocation names them, and the
+    // order refusals fire in. `--verdict` leads because that is how the usage line
+    // and every printed remedy already read.
+    required: [
+      {
+        flag: "--verdict",
+        takesValue: true,
+        missingMessage: `halfcycle close-phase: --verdict must be "clean" or "defects" \u2014 it is the acceptance walk's own verdict (INV-009) and nothing derives it for you.`
+      },
+      {
+        flag: "--actor",
+        takesValue: true,
+        missingMessage: "halfcycle close-phase: --actor is required \u2014 closing a phase decides whether the method re-serves at the next one, and that decision is recorded. An unattributed close is what the record exists to prevent."
+      }
+    ],
+    conditional: [
+      {
+        whenPresent: "--override",
+        thenRequires: "--reason",
+        takesValue: true,
+        missingMessage: "halfcycle close-phase: --override requires --reason \u2014 an override with no reason is a silent skip wearing a decision."
+      }
+    ]
+  }
+];
+function contractFor(verb) {
+  return CONTRACTS.find((c) => c.verb === verb);
+}
+function carries(tokens, flag, takesValue) {
+  const i = tokens.indexOf(flag);
+  if (i < 0)
+    return false;
+  if (!takesValue)
+    return true;
+  const value = tokens[i + 1];
+  if (value === void 0 || value.startsWith("--"))
+    return false;
+  return value.trim().length > 0;
+}
+function missingRequirements(verb, tokens) {
+  const contract = contractFor(verb);
+  if (!contract) {
+    return [
+      {
+        flag: verb,
+        message: `halfcycle: unknown command "${verb}" \u2014 the verbs are ${CLI_VERBS.join(", ")}.`
+      }
+    ];
+  }
+  const shortfalls = [];
+  for (const req of contract.required) {
+    const satisfied = carries(tokens, req.flag, req.takesValue) || (req.orFlags ?? []).some((alt) => tokens.includes(alt));
+    if (!satisfied)
+      shortfalls.push({ flag: req.flag, message: req.missingMessage });
+  }
+  for (const cond of contract.conditional) {
+    if (!tokens.includes(cond.whenPresent))
+      continue;
+    if (!carries(tokens, cond.thenRequires, cond.takesValue)) {
+      shortfalls.push({ flag: cond.thenRequires, message: cond.missingMessage });
+    }
+  }
+  return shortfalls;
+}
+function requirementMessage(verb, flag) {
+  const contract = contractFor(verb);
+  const req = contract?.required.find((r) => r.flag === flag);
+  return req?.missingMessage ?? `halfcycle ${verb}: ${flag} is required.`;
+}
+function runnableInvocation(verb, phase) {
+  const contract = contractFor(verb);
+  const flags = (contract?.required ?? []).map((req) => `${req.flag} ${PLACEHOLDERS[req.flag] ?? '"\u2026"'}`).join(" ");
+  return `halfcycle ${verb} ${phase}${flags ? ` ${flags}` : ""}`;
+}
+var PLACEHOLDERS = {
+  "--verdict": "<clean|defects>",
+  "--actor": '"you"',
+  "--evidence": '"\u2026"'
+};
+
+// dist/bin.js
+var args = process.argv.slice(2);
+var MIN_HEADERS_HELPER_VERSION = "2.1.118";
+var MIN_HEADER_ROTATION_VERSION = "2.1.193";
+function compareVersions(a, b) {
+  const pa = a.split(".").map((p) => Number.parseInt(p, 10));
+  const pb = b.split(".").map((p) => Number.parseInt(p, 10));
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const x = Number.isFinite(pa[i]) ? pa[i] : 0;
+    const y = Number.isFinite(pb[i]) ? pb[i] : 0;
+    if (x !== y)
+      return x - y;
+  }
+  return 0;
+}
+function reportClaudeCodeVersion() {
+  let raw;
+  try {
+    raw = execFileSync3("claude", ["--version"], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return;
+  }
+  const found = /(\d+\.\d+\.\d+)/.exec(raw);
+  if (!found)
+    return;
+  const version = found[1];
+  if (compareVersions(version, MIN_HEADERS_HELPER_VERSION) >= 0) {
+    process.stdout.write(`[halfcycle] Claude Code ${version} detected \u2014 new enough for the credential helper.
+`);
+    return;
+  }
+  process.stdout.write(`[halfcycle] WARNING: Claude Code ${version} is older than ${MIN_HEADERS_HELPER_VERSION}, which ignores the credential helper this install wrote. The Halfcycle server will connect with no credential and every call will fail \u2014 upgrade Claude Code, then re-open this folder.
+`);
+}
+var USAGE = `  halfcycle [install] [target-repo] [engagement-id] [self-build|client]
+         install into target (default: the current directory)
+  halfcycle check-drift <target-repo>
+  halfcycle build-record <phase-id> [--repo <root>]
+  halfcycle open-phase <phase|--none> --actor "\u2026" (--evidence "\u2026" | --override --reason "\u2026") [--repo <root>]
+  halfcycle close-phase <phase> --verdict <clean|defects> --actor "\u2026" [--finding "\u2026"]\u2026 [--override --reason "\u2026"] [--repo <root>]
+`;
+function isHalfcycleMonorepo(dir) {
+  try {
+    const pkg = JSON.parse(readFileSync8(join9(dir, "package.json"), "utf-8"));
+    return pkg.name === "halfcycle-monorepo";
+  } catch {
+    return false;
+  }
+}
+async function createOwnedEngagement(serviceUrl) {
+  let credential = await obtainCredential(serviceUrl);
+  for (; ; ) {
+    try {
+      return await createEngagement(serviceUrl, void 0, credential.credential);
+    } catch (err) {
+      if (!(err instanceof CreateEngagementRefused) || !err.authRefused)
+        throw err;
+      const replacement = await replaceRefusedCredential(serviceUrl, credential);
+      if (replacement === null) {
+        throw new SignInRefused(`create-${err.status}`, `${err.serverMessage} ${refusedCredentialRemedy(credential.source)} No engagement was created.`);
+      }
+      process.stdout.write(`[halfcycle] Your saved Halfcycle sign-in was refused \u2014 signing you in again.
+`);
+      credential = replacement;
+    }
+  }
+}
+var JOIN_REFUSED_LOCAL_REMEDY = "No credential was minted and nothing was written. This repository is pinned to that engagement by .halfcycle/bundle.json \u2014 check that the id in it is the one you meant. To start a NEW engagement here instead, remove that file and re-run.";
+async function joinPinnedEngagement(serviceUrl, engagementId) {
+  let credential = await obtainCredential(serviceUrl);
+  for (; ; ) {
+    try {
+      return await joinEngagement(serviceUrl, engagementId, credential.credential);
+    } catch (err) {
+      if (!(err instanceof CreateEngagementRefused))
+        throw err;
+      if (err.status === 403) {
+        throw new SignInRefused(`join-${err.status}`, `${err.serverMessage} ${JOIN_REFUSED_LOCAL_REMEDY}`);
+      }
+      if (err.status !== 401) {
+        throw err;
+      }
+      const replacement = await replaceRefusedCredential(serviceUrl, credential);
+      if (replacement === null) {
+        throw new SignInRefused(`join-${err.status}`, `${err.serverMessage} ${refusedCredentialRemedy(credential.source)} No credential was minted and nothing was written.`);
+      }
+      process.stdout.write(`[halfcycle] Your saved Halfcycle sign-in was refused \u2014 signing you in again.
+`);
+      credential = replacement;
+    }
+  }
+}
+async function main() {
+  const [cmd, ...rest] = args;
+  if (cmd === "--help" || cmd === "-h" || cmd === "help") {
+    process.stdout.write(`halfcycle \u2014 install and drive the Halfcycle method in a repository.
+
+Usage:
+${USAGE}`);
+    process.exit(0);
+    return;
+  }
+  const bareTarget = cmd !== void 0 && !cmd.startsWith("-") && !/^(check-drift|build-record|open-phase|close-phase)$/.test(cmd);
+  if (cmd === "install" || cmd === void 0 || bareTarget) {
+    const positionals = cmd === "install" ? rest : args;
+    const targetRepo = positionals[0] ?? process.cwd();
+    const engagementIdArg = positionals[1];
+    const engagementTypeRaw = positionals[2] ?? "client";
+    if (isHalfcycleMonorepo(targetRepo)) {
+      process.stderr.write(`halfcycle: refusing to install into the Halfcycle monorepo itself (${targetRepo}).
+  The bare form installs into the CURRENT directory, and this directory is the
+  product's own source tree \u2014 installing here would write over tracked files.
+  To see what this CLI does:      halfcycle --help
+  To install into a real project: halfcycle <path-to-that-repo>
+`);
+      process.exit(1);
+      return;
+    }
+    if (engagementTypeRaw !== "self-build" && engagementTypeRaw !== "client") {
+      process.stderr.write(`halfcycle: engagement type must be "self-build" or "client", got "${engagementTypeRaw}"
+`);
+      process.exit(1);
+      return;
+    }
+    try {
+      const serviceUrl = process.env.HALFCYCLE_SERVICE_URL?.trim();
+      const pinned = engagementIdArg === void 0 ? readPinnedEngagement(targetRepo) : null;
+      let engagementId = engagementIdArg ?? pinned?.engagementId ?? "engagement-001";
+      let credential;
+      if (pinned) {
+        credential = pinned.credential;
+        process.stdout.write(`[halfcycle] Re-using the engagement already pinned in this repo: ${pinned.engagementId}
+`);
+        if (credential === void 0 && serviceUrl) {
+          const joined = await joinPinnedEngagement(serviceUrl, pinned.engagementId);
+          credential = {
+            serviceUrl,
+            token: joined.sessionToken,
+            mcpUrl: joined.mcpUrl,
+            guardUrl: joined.guardUrl,
+            // T-10 — optional; absent on a plane that has not configured
+            // CONTROL_TELEMETRY_URL yet. `writeEngagementCredential` writes '' for
+            // an absent value, never `undefined` verbatim.
+            controlTelemetryUrl: joined.controlTelemetryUrl
+          };
+          process.stdout.write(`[halfcycle] Joined engagement ${joined.engagementId} \u2014 this credential is yours. Everyone else's keeps working; nobody was signed out and nothing was pasted.
+`);
+        } else if (credential === void 0) {
+          process.stdout.write(`[halfcycle] This machine holds no credential for it, and HALFCYCLE_SERVICE_URL is not
+[halfcycle] set \u2014 so there is no plane to ask for one. Nothing will be minted, and the
+[halfcycle] board link and MCP calls will not work until it is. Looked in
+[halfcycle] ${engagementEnvPath(pinned.engagementId)}.
+[halfcycle] Set that variable and re-run to get a credential of your own for this
+[halfcycle] engagement. To start a NEW engagement instead, remove
+[halfcycle] .halfcycle/bundle.json first.
+`);
+        } else if (pinned.fromLegacyEnvLocal) {
+          process.stdout.write(`[halfcycle] Its credential is in this repository's .env.local \u2014 an install from before
+[halfcycle] credentials moved out of the tree. It is being copied to
+[halfcycle] ${engagementEnvPath(pinned.engagementId)} and taken back out of .env.local.
+[halfcycle] Anything else that file holds is untouched.
+`);
+        }
+      } else if (serviceUrl && engagementIdArg === void 0) {
+        const created = await createOwnedEngagement(serviceUrl);
+        engagementId = created.engagementId;
+        credential = {
+          serviceUrl,
+          token: created.sessionToken,
+          mcpUrl: created.mcpUrl,
+          // FW-4 (F-29) — the THIRD origin. Without it the install writes the
+          // guard hook and none of the three variables that hook requires, so
+          // every edit fails open and no guard ever runs.
+          guardUrl: created.guardUrl,
+          // T-10 — the FOURTH origin, optional. Absent on a plane that has not
+          // configured CONTROL_TELEMETRY_URL yet; the runner's own telemetry
+          // emission is fail-open on that absence.
+          controlTelemetryUrl: created.controlTelemetryUrl
+        };
+        process.stdout.write(`[halfcycle] Created engagement ${created.engagementId}
+`);
+      }
+      const result = await install({
+        targetRepo,
+        engagementId,
+        engagementType: engagementTypeRaw,
+        credential
+      });
+      process.stdout.write(`[halfcycle] Installed v${result.version} into ${targetRepo}
+`);
+      process.stdout.write(`[halfcycle] Written: ${result.writtenPaths.length} paths
+`);
+      if (result.mergedPaths.length > 0) {
+        process.stdout.write(`[halfcycle] Merged: ${result.mergedPaths.join(", ")}
+`);
+      }
+      if (result.skippedPaths.length > 0) {
+        process.stdout.write(`[halfcycle] Skipped (already present): ${result.skippedPaths.join(", ")}
+`);
+      }
+      if (result.collidedPaths.length > 0) {
+        process.stdout.write(`[halfcycle] Collided (a name you already use \u2014 NOT overwritten): ${result.collidedPaths.join(", ")}
+`);
+      }
+      if (result.legacyCredentialKept !== null) {
+        const { keys, missing } = result.legacyCredentialKept;
+        process.stdout.write(`[halfcycle] .env.local was KEPT, not migrated \u2014 nothing was removed from it.
+[halfcycle] This repository still holds the only copy of ${keys.join(", ")},
+[halfcycle] and ${engagementEnvPath(engagementId)} does not.
+[halfcycle] The move needs ${missing.join(" and ")}, which this repository does not have:
+[halfcycle] it was installed before ${missing.length === 1 ? "that key" : "those keys"} existed. Add ${missing.length === 1 ? "it" : "them"} to .env.local (or export
+[halfcycle] ${missing.length === 1 ? "it" : "them"}) and re-run, and the credential moves out of the tree.
+`);
+      }
+      if (credential) {
+        const probe = await probeMcpOrigin(credential.mcpUrl);
+        if (probe.reached) {
+          process.stdout.write(`[halfcycle] Method delivery (MCP): ${credential.mcpUrl} \u2014 reachable (${probe.serverName})
+`);
+        } else {
+          process.stdout.write(`[halfcycle] Method delivery (MCP): ${credential.mcpUrl} \u2014 NOT reachable: ${probe.problem}.
+[halfcycle] The Halfcycle commands will have no method context until that address answers. This is the SECOND of two origins and the platform supplied it, so it is not your HALFCYCLE_SERVICE_URL (${credential.serviceUrl}) that is wrong \u2014 that one just worked. It is recorded as HALFCYCLE_MCP_URL in this engagement's credential store; re-run this installer once the service is up.
+`);
+        }
+      }
+      if (credential) {
+        process.stdout.write(`[halfcycle] Guard evaluation: ON \u2014 the hook evaluates against ${credential.guardUrl}. Credentials (${GUARD_ENV_KEYS.join(", ")}) are in ${engagementEnvPath(engagementId)}, outside this repository; the hook loads them itself, so you do not export anything and nothing here can be committed.
+`);
+      } else {
+        const remedy = pinned ? `Set HALFCYCLE_SERVICE_URL to the Halfcycle CONTROL origin and re-run \u2014 this repo is pinned to engagement ${pinned.engagementId}, and with a plane to ask, the installer mints you a credential of your own for it, at ${engagementEnvPath(pinned.engagementId)}. To start a NEW engagement here instead, remove .halfcycle/bundle.json and re-run.` : engagementIdArg !== void 0 ? `This install named engagement ${engagementIdArg} explicitly, which skips the create that mints a credential. This repo is now pinned to it, so re-run \`npx halfcycle\` with no id and the installer will mint you a credential of your own for it. To start a NEW engagement instead, remove .halfcycle/bundle.json and re-run.` : `Set HALFCYCLE_SERVICE_URL to the Halfcycle CONTROL origin and re-run this installer.`;
+        process.stdout.write(`[halfcycle] Guard evaluation: OFF \u2014 this install had no credential, so no guard will run in this repository and edits are unguarded. ${remedy}
+`);
+      }
+      if (credential) {
+        process.stdout.write(`[halfcycle] Your credential is at ${engagementEnvPath(engagementId)} \u2014 outside this repository, readable only by you. .mcp.json reads it at connection time through .halfcycle/mcp-headers.sh, so there is no token in this tree to commit and nothing for you to export.
+`);
+        process.stdout.write(`[halfcycle] Expect a workspace trust prompt the first time you open this folder \u2014 the helper is a shell command, and Claude Code will not run it until you accept. Needs Claude Code ${MIN_HEADERS_HELPER_VERSION} or newer (${MIN_HEADER_ROTATION_VERSION}+ to re-authenticate a rotated token without restarting).
+`);
+        process.stdout.write(`[halfcycle] If Halfcycle tools appear but every call returns 401, the helper could not read HALFCYCLE_TOKEN from ${engagementEnvPath(engagementId)} \u2014 re-run this installer.
+`);
+        reportClaudeCodeVersion();
+      }
+      if (credential) {
+        try {
+          const minted = await mintBoardEnterCode(credential.serviceUrl, credential.token);
+          process.stdout.write(`[halfcycle] Your board (first visit): ${minted.boardUrl}
+`);
+          process.stdout.write(`[halfcycle] First-visit code \u2014 single use, expires ${minted.expiresAt}; paste it on that page, and re-run this installer for a fresh one: ${minted.enterCode}
+`);
+        } catch {
+          process.stdout.write("[halfcycle] Your board: no first-visit code was issued just now \u2014 re-run this installer to get one.\n");
+        }
+      }
+      process.exit(0);
+    } catch (err) {
+      if (err instanceof SignInRefused) {
+        process.stderr.write(`halfcycle: ${err.message}
+`);
+        process.exit(1);
+        return;
+      }
+      process.stderr.write(`halfcycle install failed: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+    return;
+  }
+  if (cmd === "check-drift") {
+    const targetRepo = rest[0];
+    if (!targetRepo) {
+      process.stderr.write("halfcycle-bundle: usage: halfcycle-bundle check-drift <target-repo>\n");
+      process.exit(1);
+      return;
+    }
+    try {
+      const { drifted, installed, current } = checkDrift(targetRepo);
+      if (drifted) {
+        process.stdout.write(`[halfcycle-bundle] DRIFT DETECTED: installed=${installed ?? "none"} current=${current}
+[halfcycle-bundle] Re-run "halfcycle-bundle install ${targetRepo}" to sync.
+`);
+        process.exit(2);
+      } else {
+        process.stdout.write(`[halfcycle-bundle] Bundle in sync: v${current}
+`);
+        process.exit(0);
+      }
+    } catch (err) {
+      process.stderr.write(`halfcycle-bundle check-drift failed: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+    return;
+  }
+  if (cmd === "build-record") {
+    const phaseArg = rest[0];
+    const repoRoot = rest.includes("--repo") ? rest[rest.indexOf("--repo") + 1] : process.cwd();
+    if (!phaseArg || !/^\d+$/.test(phaseArg)) {
+      process.stderr.write("halfcycle-bundle: usage: halfcycle-bundle build-record <phase-id> [--repo <root>]\n");
+      process.exit(1);
+      return;
+    }
+    const phaseId = Number(phaseArg);
+    try {
+      const inputPath = join9(repoRoot, ".workbench", "build-record", `phase-${phaseId}.input.json`);
+      const input = JSON.parse(readFileSync8(inputPath, "utf-8"));
+      const result = assemblePhaseBuildRecord({
+        repoRoot,
+        phasesDir: join9(repoRoot, "docs", "phases"),
+        guardEvalLogDir: input.guardEvalLogDir ?? join9(repoRoot, ".workbench", "guard-eval-log"),
+        phaseId,
+        narrated: input.narrated,
+        touchedInvariants: input.touchedInvariants
+      });
+      process.stdout.write(`[halfcycle-bundle] Build Record written:
+  ${result.jsonPath}
+  ${result.mdPath}
+`);
+      process.exit(0);
+    } catch (err) {
+      process.stderr.write(`halfcycle-bundle build-record failed: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+    return;
+  }
+  if (cmd === "open-phase") {
+    const repoRoot = flagValue(rest, "--repo") ?? process.cwd();
+    const toProjectScope = rest.includes("--none");
+    const phaseArg = firstPositional(rest);
+    if (!toProjectScope && !phaseArg) {
+      process.stderr.write('halfcycle open-phase: name the phase to open, or pass --none to return to project scope.\n  halfcycle open-phase <phase> --actor "you" --evidence "what makes the entry condition hold"\n  halfcycle open-phase <phase> --actor "you" --override --reason "why you are opening it anyway"\n');
+      process.exit(2);
+      return;
+    }
+    const openShortfalls = missingRequirements("open-phase", rest);
+    if (openShortfalls.length > 0) {
+      process.stderr.write(`${openShortfalls[0].message}
+`);
+      process.exit(2);
+      return;
+    }
+    const actor = flagValue(rest, "--actor") ?? "";
+    let entry;
+    if (rest.includes("--override")) {
+      entry = { decision: "override", actor, reason: flagValue(rest, "--reason") ?? "" };
+    } else {
+      entry = { decision: "entry-condition-met", actor, evidence: flagValue(rest, "--evidence") ?? "" };
+    }
+    try {
+      const credential = readRepoCredential(repoRoot);
+      const opened = await openPhase(credential, toProjectScope ? null : phaseArg, entry);
+      const what = opened.phase === null ? "project scope" : `phase "${opened.phase}"`;
+      const from = opened.previousPhase === null ? "project scope" : `phase "${opened.previousPhase}"`;
+      process.stdout.write(`[halfcycle] Moved from ${from} to ${what}.
+`);
+      process.stdout.write(`[halfcycle] Recorded as ${opened.decision.decision} by ${opened.decision.actor} at ${opened.decision.decidedAt}.
+`);
+      if (opened.decision.blockingFinding) {
+        process.stdout.write(`[halfcycle] This decision CROSSED: ${opened.decision.blockingFinding}
+`);
+      }
+      process.exit(0);
+    } catch (err) {
+      if (err instanceof OpenPhaseRefused) {
+        process.stderr.write(`halfcycle open-phase: refused (${err.status}). ${err.message}
+`);
+        if (err.finding) {
+          process.stderr.write(`halfcycle open-phase: blocking finding \u2014 ${err.finding}
+`);
+        }
+        if (err.status === 409) {
+          const stuck = err.finding?.match(/^phase '([^']+)' is still open/)?.[1];
+          process.stderr.write(`halfcycle open-phase: close the phase first \u2014 \`${runnableInvocation("close-phase", stuck ?? "<phase>")}\` (add --finding "\u2026" once per finding when the verdict is defects) \u2014 or re-run with --override --reason "\u2026", which is recorded, not waived.
+`);
+        }
+        process.exit(1);
+        return;
+      }
+      process.stderr.write(`halfcycle open-phase failed: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+    return;
+  }
+  if (cmd === "close-phase") {
+    const repoRoot = flagValue(rest, "--repo") ?? process.cwd();
+    const phaseArg = firstPositional(rest);
+    if (!phaseArg) {
+      process.stderr.write('halfcycle close-phase: name the phase you are closing.\n  halfcycle close-phase <phase> --verdict clean --actor "you"\n  halfcycle close-phase <phase> --verdict defects --actor "you" --finding "what is still wrong"\n');
+      process.exit(2);
+      return;
+    }
+    const closeShortfalls = missingRequirements("close-phase", rest);
+    if (closeShortfalls.length > 0) {
+      process.stderr.write(`${closeShortfalls[0].message}
+`);
+      process.exit(2);
+      return;
+    }
+    const closeActor = flagValue(rest, "--actor") ?? "";
+    let closeDecision;
+    if (rest.includes("--override")) {
+      closeDecision = { decision: "override", actor: closeActor, reason: flagValue(rest, "--reason") ?? "" };
+    } else {
+      closeDecision = { decision: "done-when-met", actor: closeActor };
+    }
+    const verdict = flagValue(rest, "--verdict");
+    if (verdict !== "clean" && verdict !== "defects") {
+      process.stderr.write(`${requirementMessage("close-phase", "--verdict")}
+`);
+      process.exit(2);
+      return;
+    }
+    const findingsDetail = [];
+    for (let i = 0; i < rest.length; i++) {
+      if (rest[i] !== "--finding")
+        continue;
+      const summary = rest[i + 1];
+      if (summary === void 0 || summary.startsWith("--")) {
+        process.stderr.write("halfcycle close-phase: --finding needs a summary after it.\n");
+        process.exit(2);
+        return;
+      }
+      findingsDetail.push({ summary });
+      i++;
+    }
+    if (verdict === "defects" && findingsDetail.length === 0) {
+      process.stderr.write('halfcycle close-phase: --verdict defects with no --finding says the phase failed and declines to say how. Give at least one --finding "\u2026", or close it clean.\n');
+      process.exit(2);
+      return;
+    }
+    if (verdict === "clean" && findingsDetail.length > 0) {
+      process.stderr.write("halfcycle close-phase: --verdict clean was passed alongside --finding. A clean verdict means the walk found nothing outstanding; pick one.\n");
+      process.exit(2);
+      return;
+    }
+    try {
+      const credential = readRepoCredential(repoRoot);
+      const closed = await closePhase(credential, phaseArg, {
+        verdict,
+        findings: findingsDetail.length,
+        findingsDetail
+      }, closeDecision);
+      process.stdout.write(`[halfcycle] Phase "${phaseArg}" closed as ${verdict}${findingsDetail.length > 0 ? ` with ${findingsDetail.length} finding(s)` : ""} by ${closeDecision.actor}. The engagement is now ${closed.status}.
+`);
+      if (closeDecision.decision === "override") {
+        process.stdout.write(`[halfcycle] This close was an OVERRIDE: ${closeDecision.reason}
+`);
+      }
+      process.stdout.write(`[halfcycle] Open the next phase with: halfcycle open-phase <phase> --actor "you" --evidence "\u2026"
+`);
+      process.exit(0);
+    } catch (err) {
+      if (err instanceof ClosePhaseRefused) {
+        process.stderr.write(`halfcycle close-phase: refused (${err.status}). ${err.message}
+`);
+        if (err.finding) {
+          process.stderr.write(`halfcycle close-phase: outstanding work \u2014 ${err.finding}
+`);
+          process.stderr.write(`halfcycle close-phase: close it anyway with \`halfcycle close-phase ${phaseArg} --verdict ${verdict} --actor "${closeActor}" --override --reason "\u2026"\` \u2014 recorded, not waived.
+`);
+        } else if (err.code === "PhaseAlreadyClosed") {
+          process.stderr.write("halfcycle close-phase: this phase is already closed \u2014 open the next one instead of accepting it twice.\n");
+        }
+        process.exit(1);
+        return;
+      }
+      process.stderr.write(`halfcycle close-phase failed: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+    return;
+  }
+  process.stderr.write(`halfcycle: unknown command "${cmd ?? ""}"
+
+Usage:
+${USAGE}`);
+  process.exit(1);
+}
+function flagValue(argv, name) {
+  const i = argv.indexOf(name);
+  if (i < 0 || i + 1 >= argv.length)
+    return void 0;
+  const value = argv[i + 1];
+  return value === void 0 || value.startsWith("--") ? void 0 : value;
+}
+function firstPositional(argv) {
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("--"))
+        i++;
+      continue;
+    }
+    return arg;
+  }
+  return void 0;
+}
+main().catch((err) => {
+  process.stderr.write(`halfcycle: unexpected error: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=bin.js.map