halfcycle 0.3.37 → 0.3.39

package/.claude-plugin/plugin.json

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

package/README.md

@@ -146,6 +146,8 @@ This matters enough to be specific about.
 
 **Halfcycle never holds or proxies your Claude credential.** Inference runs on your own Claude Code, on your own subscription or seats. We are not a hosted runtime reselling you inference.
 
+**Your own Halfcycle credential lives outside this repository, in a file named `env` under your home directory — never in anything you'd commit.** Closing a phase rewrites it, to clear which phase was open, and it is also renewed there automatically to keep your connection current. Nothing else changes it.
+
 **What the checks receive is the shape of a change, not its contents.** File paths, structural shapes, environment variable names and how they are used, the tables a write touches, route signatures, outbound host names. There is no file body and no diff in the request.
 
 **Source excerpts are off, at both ends, for every engagement today.** The wire format does have a field for them, so the honest version of this is a conditional statement rather than a flat one, and it rests on three things rather than on our good intentions: your runner does not attach an excerpt unless you turn a flag on, and that flag is off by default; anything that does arrive for an engagement that has not opted in is stripped on our side before the checks or any model see it; and there is no way to opt in today, because nothing in the product can set that flag. If that ever changes, our privacy policy changes with it, and it is the policy — not this paragraph — that states the guarantee.

package/bin/bin.bundle.mjs

@@ -15289,7 +15289,9 @@ var engagementCredentialResponseSchema = external_exports.object({
   sessionToken: external_exports.string(),
   mcpUrl: external_exports.string(),
   guardUrl: external_exports.string(),
-  controlTelemetryUrl: external_exports.string()
+  controlTelemetryUrl: external_exports.string(),
+  methodVersion: external_exports.string().optional(),
+  consoleUrl: external_exports.string().optional()
 }).strict();
 var ciTokenExchangeResponseSchema = external_exports.object({
   token: external_exports.string(),
@@ -15357,7 +15359,7 @@ function hookReply(event) {
   };
 }
 function infraWarningText(message) {
-  return `[Halfcycle] WARNING: Guard service unavailable \u2014 ${message}. Session continues (fail-open).`;
+  return `[Halfcycle] WARNING: Guard service unavailable \u2014 ${message}. The session continues without checks.`;
 }
 function localFaultText(message) {
   return `[Halfcycle] WARNING: Local fault \u2014 ${message}. The guard service was not contacted. Session continues (fail-open).`;
@@ -15434,11 +15436,8 @@ function classifyFailure(failure) {
   return {
     kind: "service",
     message: failure.message,
-    // Unchanged wording for this class ON PURPOSE — a genuine outage still says
-    // exactly what it said before, and still fails open locally. This task moved
-    // ONE condition out of this branch; it did not redefine the branch.
-    label: "infrastructure failure",
-    reason: `infrastructure failure: ${failure.message}`
+    label: "service unavailable",
+    reason: failure.message
   };
 }
 var CREDENTIAL_REJECTED_EXIT_TOOL_USE = UNCONFIGURED_EXIT_TOOL_USE;

package/dist/bin.js

@@ -234,6 +234,11 @@ function looksLikeSecret(text) {
 var MCP_REGISTRATION_REL = ".mcp.json";
 var MCP_SERVER_KEY = "halfcycle";
 
+// ../core/dist/shell-quote.js
+function quoteForShell(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
 // ../events/dist/result.js
 import { z as z2 } from "zod";
 var firedGuardSchema = z2.object({
@@ -606,9 +611,14 @@ var closedBySchema = z4.discriminatedUnion("kind", [
   z4.object({ kind: z4.literal("account-removed") }).strict(),
   z4.object({ kind: z4.literal("not-recorded") }).strict()
 ]);
+var STEP_NAME_MAX = 200;
+var stepNameSchema = plainText(STEP_NAME_MAX).refine((v) => v.trim().length > 0, {
+  message: "must not be blank"
+});
 var unfinishedStepSchema = z4.object({
   stepId: plainText(),
-  state: z4.enum(["parked", "failed"])
+  state: z4.enum(["parked", "failed"]),
+  name: stepNameSchema.optional()
 }).strict();
 var crossedSchema = z4.discriminatedUnion("kind", [
   z4.object({ kind: z4.literal("none") }).strict(),
@@ -1217,7 +1227,9 @@ var engagementCredentialResponseSchema = z10.object({
   sessionToken: z10.string(),
   mcpUrl: z10.string(),
   guardUrl: z10.string(),
-  controlTelemetryUrl: z10.string()
+  controlTelemetryUrl: z10.string(),
+  methodVersion: z10.string().optional(),
+  consoleUrl: z10.string().optional()
 }).strict();
 var ciTokenExchangeResponseSchema = z10.object({
   token: z10.string(),
@@ -2708,9 +2720,10 @@ function previousPinForEngagement(targetRepoRoot, engagementId) {
 function nonEmpty(value) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
 }
-function writeBundlePin(targetRepoRoot, version, engagementId, engagementType, accountId, writtenPaths) {
+function writeBundlePin(targetRepoRoot, version, engagementId, engagementType, accountId, methodVersion, writtenPaths) {
   const previous = previousPinForEngagement(targetRepoRoot, engagementId);
   const carried = nonEmpty(accountId) ?? nonEmpty(previous?.accountId);
+  const carriedMethodVersion = nonEmpty(methodVersion) ?? nonEmpty(previous?.methodVersion);
   const installedAt = nonEmpty(previous?.installedAt) ?? (/* @__PURE__ */ new Date()).toISOString();
   const projectPage = projectPageUrl(engagementId);
   const pin = {
@@ -2719,6 +2732,7 @@ function writeBundlePin(targetRepoRoot, version, engagementId, engagementType, a
     engagementType,
     installedAt,
     ...carried !== void 0 ? { accountId: carried } : {},
+    ...carriedMethodVersion !== void 0 ? { methodVersion: carriedMethodVersion } : {},
     ...projectPage !== void 0 ? { projectPage } : {}
   };
   const pinPath = join5(targetRepoRoot, BUNDLE_PIN_REL);
@@ -2794,7 +2808,7 @@ function checkDrift(targetRepoRoot) {
   const pin = readBundlePin(targetRepoRoot);
   const installed = pin?.version ?? null;
   const current = manifest.version;
-  return { drifted: installed !== current, installed, current };
+  return { drifted: installed !== current, installed, current, methodVersion: pin?.methodVersion ?? null };
 }
 function writeProjectIdentity(targetRepo) {
   const path = join5(targetRepo, PROJECT_IDENTITY_REL);
@@ -3025,7 +3039,7 @@ async function install(options) {
     case "absent":
       break;
   }
-  writeBundlePin(targetRepo, manifest.version, engagementId, engagementType, accountId, report.writtenPaths);
+  writeBundlePin(targetRepo, manifest.version, engagementId, engagementType, accountId, credential?.methodVersion, report.writtenPaths);
   noteFile(draft, targetRepo, BUNDLE_PIN_REL, "written");
   noteFile(draft, targetRepo, CREW_ROSTER_REL, writeCrewRoster(targetRepo, report));
   const scanResult = runBootstrapScan(targetRepo);
@@ -3599,7 +3613,7 @@ function planeRefusal(detail) {
     reason: typeof candidate.reason === "string" ? candidate.reason : void 0
   };
 }
-var CONTROL_ORIGIN_HINT = `This CLI talks to ${DEFAULT_CONTROL_ORIGIN}; it must be the 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 configure neither.`;
+var CONTROL_ORIGIN_HINT = `This CLI talks to ${DEFAULT_CONTROL_ORIGIN}; it must be the CONTROL origin \u2014 the one that serves /engagements. The MCP server runs at a different address, and the platform supplies that one itself; you configure neither.`;
 async function createEngagement(baseUrl, name, credential, derivedName) {
   return requestEngagementValues(
     `${baseUrl.replace(/\/+$/, "")}/engagements`,
@@ -3679,12 +3693,16 @@ async function requestEngagementValues(url, requestBody, credential, shape) {
     }).join(", ");
     throw new Error(`[bundle install] ${shape.action} response from ${url} is not the credential response this CLI is built to read (${fields}). ${shape.nothingHappened}. Either that service is a different version from this installer, or ${url} is not a Halfcycle service.`);
   }
+  const consoleUrl = typeof body.consoleUrl === "string" && body.consoleUrl.trim() !== "" ? body.consoleUrl.trim() : void 0;
+  const methodVersion = typeof body.methodVersion === "string" && body.methodVersion.trim() !== "" ? body.methodVersion.trim() : void 0;
   return {
     engagementId: body.engagementId,
     sessionToken: body.sessionToken,
     mcpUrl: body.mcpUrl.trim().replace(/\/+$/, ""),
     guardUrl: body.guardUrl.trim().replace(/\/+$/, ""),
-    ...controlTelemetryUrl !== void 0 ? { controlTelemetryUrl } : {}
+    ...controlTelemetryUrl !== void 0 ? { controlTelemetryUrl } : {},
+    ...consoleUrl !== void 0 ? { consoleUrl } : {},
+    ...methodVersion !== void 0 ? { methodVersion } : {}
   };
 }
 
@@ -4295,37 +4313,6 @@ async function joinPinnedEngagement(serviceUrl, engagementId, targetRepo, deps =
   }
 }
 
-// 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, token) {
@@ -4407,20 +4394,127 @@ import { basename as basename2, join as join6, resolve as resolve2, relative as
 
 // dist/build-record/render-v2.js
 var HIDDEN = /[\p{Cc}\p{Zl}\p{Zp}\p{Default_Ignorable_Code_Point}]/u;
-var MARKDOWN_SPECIAL = /* @__PURE__ */ new Set(["\\", "`", "*", "_", "[", "]", "<", "|", "~", "#", "&", "$"]);
+var SPACE = new RegExp("\\p{Zs}", "u");
+var WORD = /[\p{L}\p{N}]/u;
+var ASCII_PUNCTUATION = /[!-/:-@[-`{-~]/;
+var CHARACTER_REFERENCE = /^#?[A-Za-z0-9]+;/;
+var PAIRED = ["*", "_", "~", "$"];
+function codeSpanMask(cps) {
+  const mask = cps.map(() => false);
+  const runs = [];
+  for (let i = 0; i < cps.length; ) {
+    if (cps[i] !== "`") {
+      i++;
+      continue;
+    }
+    let j = i;
+    while (j < cps.length && cps[j] === "`")
+      j++;
+    runs.push({ start: i, length: j - i });
+    i = j;
+  }
+  for (let k = 0; k < runs.length; ) {
+    const open = runs[k];
+    let m = k + 1;
+    while (m < runs.length && runs[m].length !== open.length)
+      m++;
+    if (m === runs.length) {
+      k++;
+      continue;
+    }
+    const close = runs[m];
+    for (let i = open.start; i < close.start + close.length; i++)
+      mask[i] = true;
+    k = m + 1;
+  }
+  return mask;
+}
+function escapeMask(cps, inSpan) {
+  const n = cps.length;
+  const escape = cps.map(() => false);
+  const isSpace = (i) => i >= 0 && i < n && SPACE.test(cps[i]) && !HIDDEN.test(cps[i]);
+  const isWord = (i) => i >= 0 && i < n && WORD.test(cps[i]);
+  const rest = (i) => cps.slice(i).join("");
+  for (let i = 0; i < n; i++) {
+    if (inSpan[i])
+      continue;
+    const ch = cps[i];
+    const next = i + 1 < n ? cps[i + 1] : null;
+    switch (ch) {
+      case "\\":
+        escape[i] = next === null || ASCII_PUNCTUATION.test(next);
+        break;
+      case "<":
+        escape[i] = next !== null && !isSpace(i + 1) && rest(i + 1).includes(">");
+        break;
+      case "&":
+        escape[i] = CHARACTER_REFERENCE.test(rest(i + 1));
+        break;
+      case "]":
+        escape[i] = next === "(";
+        break;
+      case "[":
+      case "{":
+        escape[i] = (next === "+" || next === "-") && (rest(i + 2).includes(`${next}]`) || rest(i + 2).includes(`${next}}`));
+        break;
+      default:
+        break;
+    }
+  }
+  for (let i = 0; i < n; ) {
+    if (inSpan[i] || cps[i] !== "#") {
+      i++;
+      continue;
+    }
+    let j = i;
+    while (j < n && cps[j] === "#" && !inSpan[j])
+      j++;
+    let k = j;
+    while (k < n && isSpace(k))
+      k++;
+    if (k === n && (i === 0 || isSpace(i - 1)))
+      for (let m = i; m < j; m++)
+        escape[m] = true;
+    i = j;
+  }
+  for (const c of PAIRED) {
+    const live = [];
+    for (let i = 0; i < n; ) {
+      if (inSpan[i] || cps[i] !== c) {
+        i++;
+        continue;
+      }
+      let j = i;
+      while (j < n && cps[j] === c && !inSpan[j])
+        j++;
+      const inert = c !== "$" && (isSpace(i - 1) && isSpace(j) || c === "_" && isWord(i - 1) && isWord(j));
+      if (!inert)
+        live.push({ start: i, end: j });
+      i = j;
+    }
+    if (live.length < 2)
+      continue;
+    for (const run of live)
+      for (let m = run.start; m < run.end; m++)
+        escape[m] = true;
+  }
+  return escape;
+}
 function printRecordText(text) {
   if (text === "")
     return "(blank)";
+  const cps = [...text];
+  const escape = escapeMask(cps, codeSpanMask(cps));
   let out = "";
-  for (const ch of text) {
+  cps.forEach((ch, i) => {
     if (HIDDEN.test(ch)) {
       out += `U+${ch.codePointAt(0).toString(16).toUpperCase().padStart(4, "0")}`;
-    } else if (MARKDOWN_SPECIAL.has(ch)) {
+    } else if (escape[i]) {
       out += `\\${ch}`;
     } else {
       out += ch;
     }
-  }
+  });
   return out;
 }
 function makePrinter() {
@@ -4510,12 +4604,18 @@ function headline(observed, attested, checks) {
       if (problemsReported) {
         return "**Closed with problems reported.** Halfcycle saw nothing outstanding, and the person closing the phase reported problems found in its acceptance walk.";
       }
-      return checks === "not-observed" ? "**Closed with nothing outstanding, but no checks ran.** Halfcycle saw nothing outstanding, and the person closing the phase stated its finish conditions were met, but Halfcycle has no record of any check running during this phase, so this is not a clean result." : "**Closed cleanly.** Halfcycle saw nothing outstanding, and the person closing the phase stated its finish conditions were met.";
+      return checks === "not-observed" ? "**Closed with nothing outstanding, but no check on record.** Halfcycle saw nothing outstanding, and the person closing the phase stated its finish conditions were met, but Halfcycle has no record of any check running during this phase, so this is not a clean result." : "**Closed cleanly.** Halfcycle saw nothing outstanding, and the person closing the phase stated its finish conditions were met.";
     case "unfinished-steps":
     case "clean-over-findings":
-      return met ? "**Closed over outstanding work.** Halfcycle saw work still outstanding, and the person closing the phase stated its finish conditions were met anyway." : "**Closed over outstanding work.** Halfcycle saw work still outstanding, and the person closing the phase chose to override it.";
+      if (!met) {
+        return "**Closed over outstanding work.** Halfcycle saw work still outstanding, and the person closing the phase chose to override it.";
+      }
+      return problemsReported ? "**Closed over outstanding work.** Halfcycle saw work still outstanding, and the person closing the phase closed it as it stood, reporting problems found in its acceptance walk." : "**Closed over outstanding work.** Halfcycle saw work still outstanding, and the person closing the phase stated its finish conditions were met anyway.";
     case "not-recorded":
-      return met ? "**Outstanding work not recorded.** Halfcycle has no record of what was outstanding at this close. The person closing the phase stated its finish conditions were met." : "**Outstanding work not recorded.** Halfcycle has no record of what was outstanding at this close. The person closing the phase chose to override.";
+      if (!met) {
+        return "**Outstanding work not recorded.** Halfcycle has no record of what was outstanding at this close. The person closing the phase chose to override.";
+      }
+      return problemsReported ? "**Outstanding work not recorded.** Halfcycle has no record of what was outstanding at this close. The person closing the phase reported problems found in its acceptance walk." : "**Outstanding work not recorded.** Halfcycle has no record of what was outstanding at this close. The person closing the phase stated its finish conditions were met.";
   }
 }
 function closedAtText(closedAt, p) {
@@ -4534,30 +4634,38 @@ function signedInAs(closedBy, p) {
       return "not recorded for this close";
   }
 }
+var OUTSTANDING_LABEL = "- Outstanding work in Halfcycle's own records of this phase (the method's steps, and problems recorded against the phase): ";
 function outstanding(crossed, p) {
   switch (crossed.kind) {
     case "none":
-      return ["- Outstanding work Halfcycle could see: none."];
+      return [`${OUTSTANDING_LABEL}none.`];
     case "not-recorded":
-      return ["- Outstanding work Halfcycle could see: not recorded for this close."];
+      return [`${OUTSTANDING_LABEL}not recorded for this close.`];
     case "clean-over-findings":
-      return [
-        `- Outstanding work Halfcycle could see: ${counted(crossed.findings, "problem", "problems")} recorded against this phase.`
-      ];
+      return [`${OUTSTANDING_LABEL}${counted(crossed.findings, "problem", "problems")} recorded against this phase.`];
     case "unfinished-steps":
       return [
-        `- Outstanding work Halfcycle could see: ${counted(crossed.steps.length, "step", "steps")} of the method left unfinished. Each is shown by the method's own label for it:`,
-        ...crossed.steps.map((step) => `  - Step: ${p.text(step.stepId)} \u2014 ${step.state === "failed" ? "failed" : "set aside unfinished"}`)
+        `${OUTSTANDING_LABEL}${counted(crossed.steps.length, "step", "steps")} of the method left unfinished. ${shownBy(crossed.steps)}`,
+        ...crossed.steps.map((step) => `  - Step: ${p.text(step.name ?? step.stepId)} \u2014 ${step.state === "failed" ? "failed" : "set aside unfinished"}`)
       ];
   }
 }
-function machines(coverage) {
+function shownBy(steps) {
+  const named = steps.filter((s) => s.name !== void 0).length;
+  if (named === 0)
+    return "Each is shown by the method's own label for it:";
+  if (named === steps.length)
+    return "Each is shown by the method's own name for it:";
+  return "Each is shown by the method's own name for it, or by its label where the record holds no name:";
+}
+function machines(coverage, checks) {
   const label = "- Computers signed in to Halfcycle for this project when the phase closed: ";
   if (coverage === null)
     return `${label}not recorded.`;
   if (coverage.enrolled === 0)
     return `${label}none.`;
-  return `${label}${String(coverage.enrolled)}. Of these, ${String(coverage.conformant)} had reported Halfcycle's checks as fully set up.`;
+  const line = `${label}${String(coverage.enrolled)}. Of these, ${String(coverage.conformant)} had reported Halfcycle's checks as fully set up.`;
+  return checks === "not-observed" && coverage.conformant > 0 ? `${line} Set up is not the same as running: Halfcycle has no record of any check running during this phase.` : line;
 }
 function walkLines(walk, p) {
   const label = "> - Acceptance walk (the finished work tried as a user would, by someone other than its builder): ";
@@ -4577,9 +4685,15 @@ function walkLines(walk, p) {
 function statedOrNot(value, p) {
   return value === null ? "Not stated by the client." : p.text(value);
 }
+function decisionLine(attested) {
+  if (attested.decision === "override") {
+    return "> - Decision: close the phase by override, without stating its finish conditions were met.";
+  }
+  return attested.walk !== null && attested.walk.verdict === "defects" ? "> - Decision: close the phase as it stood, with the problems its acceptance walk found." : "> - Decision: the phase's agreed finish conditions were met.";
+}
 function renderStated(attested, p) {
   const lines = [
-    attested.decision === "done-when-met" ? "> - Decision: the phase's agreed finish conditions were met." : "> - Decision: close the phase by override, without stating its finish conditions were met.",
+    decisionLine(attested),
     `> - Name given: ${attested.actor === null ? "removed with the account that made this close" : p.text(attested.actor)}`,
     `> - Reason given: ${attested.reason === null ? "none." : p.text(attested.reason)}`,
     ...walkLines(attested.walk, p),
@@ -4607,7 +4721,7 @@ function renderClose(heading, observed, attested, checks, p) {
       `- Closed at: ${closedAtText(observed.closedAt, p)}`,
       `- Signed in as: ${signedInAs(observed.closedBy, p)}`,
       ...outstanding(observed.crossed, p),
-      machines(observed.seatCoverage)
+      machines(observed.seatCoverage, checks)
     ].join("\n"),
     STATED_LABEL,
     renderStated(attested, p)
@@ -4868,8 +4982,7 @@ async function obtainBuildRecord(credential, repoRoot, phase, io = NODE_RECORD_P
   };
 }
 function refetchCommand(phase) {
-  const quoted = /^[A-Za-z0-9._+-]+$/.test(phase) ? phase : `'${phase.replace(/'/g, `'\\''`)}'`;
-  return `npx halfcycle@latest build-record ${quoted}`;
+  return `npx halfcycle@latest build-record ${quoteForShell(phase)}`;
 }
 
 // dist/open-phase.js
@@ -4878,10 +4991,12 @@ import { join as join7 } from "node:path";
 var OpenPhaseRefused = class extends Error {
   status;
   finding;
-  constructor(status, message, finding) {
+  previousPhase;
+  constructor(status, message, finding, previousPhase = null) {
     super(message);
     this.status = status;
     this.finding = finding;
+    this.previousPhase = previousPhase;
     this.name = "OpenPhaseRefused";
   }
 };
@@ -4960,7 +5075,8 @@ async function openPhase(credential, phase, entry, home) {
     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 previousPhase = typeof body2?.previousPhase === "string" ? body2.previousPhase : null;
+    throw new OpenPhaseRefused(res.status, message, finding, previousPhase);
   }
   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") {
@@ -5186,7 +5302,7 @@ function requirementMessage(verb, flag) {
 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}` : ""}`;
+  return `halfcycle ${verb} ${quoteForShell(phase)}${flags ? ` ${flags}` : ""}`;
 }
 var PLACEHOLDERS = {
   "--verdict": "<clean|defects>",
@@ -6113,7 +6229,12 @@ ${USAGE}`);
             // 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
+            controlTelemetryUrl: joined.controlTelemetryUrl,
+            // T-01 (Connect Phase 4 follow-ups) — optional; absent on a control
+            // deployment that predates it. The join route's own stamped pin,
+            // which can be older than this deployment's current default.
+            consoleUrl: joined.consoleUrl,
+            methodVersion: joined.methodVersion
           };
           foundLine = `this repo is pinned to one of your projects \u2014 joining it as you (${shortId(joined.engagementId)})`;
         }
@@ -6137,7 +6258,12 @@ ${USAGE}`);
           // 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
+          controlTelemetryUrl: created.controlTelemetryUrl,
+          // T-01 (Connect Phase 4 follow-ups) — optional; absent on a control
+          // deployment that predates it. The create route's own deployment
+          // default at the moment this engagement was stamped.
+          consoleUrl: created.consoleUrl,
+          methodVersion: created.methodVersion
         };
         foundLine = `no Halfcycle project here yet \u2014 creating one (${shortId(created.engagementId)})`;
         if (verbose) {
@@ -6239,16 +6365,14 @@ ${USAGE}`);
         process.stdout.write(`[halfcycle] Claude Code will then ask whether to use a new MCP server. The cursor starts on "Continue without using this MCP server" \u2014 choose to use it instead; without it Halfcycle will not connect.
 `);
       }
-      if (credential) {
-        try {
-          const minted = await mintBoardEnterCode(credential.serviceUrl, credential.token);
-          process.stdout.write(`[halfcycle] Your project's page \u2014 how it is going, the agents working on it, and your other projects (first visit): ${minted.boardUrl}
+      if (credential?.consoleUrl !== void 0) {
+        const colour = decideColour(currentEnvironment(quiet));
+        process.stdout.write(`${ink("key", `[halfcycle] Your project's console: ${credential.consoleUrl}`, colour)}
 `);
-          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}
+      }
+      if (credential?.methodVersion !== void 0) {
+        process.stdout.write(`[halfcycle] Method version: ${credential.methodVersion}
 `);
-        } catch {
-          process.stdout.write("[halfcycle] Your project's page: no first-visit code was issued just now \u2014 re-run this installer to get one.\n");
-        }
       }
       process.exit(0);
     } catch (err) {
@@ -6295,7 +6419,9 @@ ${USAGE}`);
       return;
     }
     try {
-      const { drifted, installed, current } = checkDrift(targetRepo2);
+      const { drifted, installed, current, methodVersion } = checkDrift(targetRepo2);
+      process.stdout.write(`[halfcycle-bundle] Method version: ${methodVersion ?? "not recorded"}
+`);
       if (drifted) {
         process.stdout.write(`[halfcycle-bundle] DRIFT DETECTED: installed=${installed ?? "none"} current=${current}
 [halfcycle-bundle] Re-run "halfcycle-bundle install ${targetRepo2}" to sync.
@@ -6367,8 +6493,13 @@ ${USAGE}`);
       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}.
+      if (opened.previousPhase === opened.phase) {
+        process.stdout.write(opened.phase === null ? "[halfcycle] Already at project scope \u2014 nothing moved.\n" : `[halfcycle] Phase "${opened.phase}" is already open \u2014 nothing moved.
 `);
+      } else {
+        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) {
@@ -6385,8 +6516,7 @@ halfcycle open-phase: until ${opened.stampFailure.path} can be written, guard ev
       process.exit(0);
     } catch (err) {
       if (err instanceof InvalidPhaseIdentityError) {
-        process.stderr.write(`halfcycle open-phase: ${err.message}
-halfcycle open-phase: a phase name has to work as a single folder name on this machine \u2014 that is what this machine files its guard evaluations under. Nothing was opened.
+        process.stderr.write(`halfcycle open-phase: '${String(err.identity)}' cannot be used as a phase name \u2014 it has to work as a single folder name on this machine. Nothing was opened.
 `);
         process.exit(2);
         return;
@@ -6399,8 +6529,7 @@ halfcycle open-phase: a phase name has to work as a single folder name on this m
 `);
         }
         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.stderr.write(`halfcycle open-phase: close the phase first \u2014 \`${runnableInvocation("close-phase", err.previousPhase ?? "<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);
@@ -6511,17 +6640,22 @@ halfcycle close-phase: until ${closed.stampFailure.path} can be written, guard e
         return;
       }
       if (err instanceof ClosePhaseRefused) {
+        if (err.finding) {
+          process.stderr.write(`halfcycle close-phase: refused (${err.status}).
+`);
+          process.stderr.write(`halfcycle close-phase: outstanding work \u2014 ${plainOutstandingFinding(err.finding)}
+`);
+          process.stderr.write(`halfcycle close-phase: close it anyway with \`halfcycle close-phase ${quoteForShell(phaseArg)} --verdict ${verdict} --actor ${quoteForShell(closeActor)} --override --reason "\u2026"\` \u2014 recorded, not waived.
+`);
+          process.exit(1);
+          return;
+        }
         process.stderr.write(`halfcycle close-phase: refused (${err.status}). ${err.message}
 `);
         if (err.status === 400) {
           process.stderr.write("halfcycle close-phase: Nothing was closed.\n");
         }
-        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") {
+        if (err.code === "PhaseAlreadyClosed") {
           process.stderr.write("halfcycle close-phase: to close a phase again, open it again first.\nhalfcycle close-phase: To get a closed phase's Build Record: npx halfcycle@latest build-record <the phase that closed>\n");
         }
         process.exit(1);
@@ -6560,6 +6694,9 @@ function readStatementFlags(argv) {
   }
   return { thesis, outcome, deviations };
 }
+function plainOutstandingFinding(finding) {
+  return finding.replace(/\(attempted-failed\)/g, "(attempted, and did not finish)");
+}
 function writtenLines(written) {
   return `[halfcycle] Build Record written:
   ${written.mdPath}