halfcycle 0.11.1 → 0.12.0-rc.2

package/dist/cli.js

@@ -285,12 +285,71 @@ function looksLikeSecret(text) {
 var MCP_REGISTRATION_REL = ".mcp.json";
 var MCP_SERVER_KEY = "halfcycle";
 
+// ../core/dist/release-version.js
+var RELEASE_VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
+function isReleaseVersion(value) {
+  return typeof value === "string" && RELEASE_VERSION_PATTERN.test(value);
+}
+function significant(part) {
+  const trimmed = part.replace(/^0+/, "");
+  return trimmed === "" ? "0" : trimmed;
+}
+function compareReleaseVersions(a, b) {
+  if (!isReleaseVersion(a) || !isReleaseVersion(b)) {
+    throw new TypeError("compareReleaseVersions takes two MAJOR.MINOR.PATCH versions");
+  }
+  const pa = a.split(".").map(significant);
+  const pb = b.split(".").map(significant);
+  for (let i = 0; i < 3; i++) {
+    const x = pa[i];
+    const y = pb[i];
+    if (x.length !== y.length)
+      return x.length - y.length;
+    if (x !== y)
+      return x < y ? -1 : 1;
+  }
+  return 0;
+}
+
+// ../core/dist/release-tag.js
+var PRE_RELEASE_VERSION_PATTERN = /^(\d+\.\d+\.\d+)-rc\.\d+$/;
+var PACKAGE_COMMAND = "npx halfcycle";
+var COMMAND_FORMS = /npx halfcycle(?:@latest|(?![@\p{L}\p{N}-]))/gu;
+function isPreReleaseVersion(value) {
+  return typeof value === "string" && PRE_RELEASE_VERSION_PATTERN.test(value);
+}
+function releaseOfVersion(value) {
+  if (typeof value !== "string")
+    return void 0;
+  if (isReleaseVersion(value))
+    return value;
+  const match = PRE_RELEASE_VERSION_PATTERN.exec(value);
+  return match === null ? void 0 : match[1];
+}
+function releaseTagOfVersion(version) {
+  return isPreReleaseVersion(version) ? "next" : "latest";
+}
+function halfcycleCommand(version) {
+  return `${PACKAGE_COMMAND}@${releaseTagOfVersion(version)}`;
+}
+function bareHalfcycleCommand(version) {
+  return releaseTagOfVersion(version) === "next" ? `${PACKAGE_COMMAND}@next` : PACKAGE_COMMAND;
+}
+function rewriteHalfcycleCommands(text, tag) {
+  if (tag === "latest")
+    return text;
+  return text.replace(COMMAND_FORMS, `${PACKAGE_COMMAND}@${tag}`);
+}
+
 // ../core/dist/shell-quote.js
 function quoteForShell(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
-var HALFCYCLE_COMMAND = "npx halfcycle@latest";
-var DOCTOR_LINE = "Run `npx halfcycle doctor` to check set up, sign-in, connection, checks and version.";
+var HALFCYCLE_COMMAND = halfcycleCommand();
+function doctorLine(version) {
+  return `Run \`${bareHalfcycleCommand(version)} doctor\` to check set up, sign-in, connection, checks and version.`;
+}
+var DOCTOR_LINE = doctorLine();
 
 // ../core/dist/folder-trust.js
 var CLAUDE_STATE_FILENAME = ".claude.json";
@@ -561,32 +620,6 @@ function typedPhaseReference(phase, number) {
   return phase.includes(":") && number !== null ? String(number) : phase;
 }
 
-// ../core/dist/release-version.js
-var RELEASE_VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
-function isReleaseVersion(value) {
-  return typeof value === "string" && RELEASE_VERSION_PATTERN.test(value);
-}
-function significant(part) {
-  const trimmed = part.replace(/^0+/, "");
-  return trimmed === "" ? "0" : trimmed;
-}
-function compareReleaseVersions(a, b) {
-  if (!isReleaseVersion(a) || !isReleaseVersion(b)) {
-    throw new TypeError("compareReleaseVersions takes two MAJOR.MINOR.PATCH versions");
-  }
-  const pa = a.split(".").map(significant);
-  const pb = b.split(".").map(significant);
-  for (let i = 0; i < 3; i++) {
-    const x = pa[i];
-    const y = pb[i];
-    if (x.length !== y.length)
-      return x.length - y.length;
-    if (x !== y)
-      return x < y ? -1 : 1;
-  }
-  return 0;
-}
-
 // ../core/dist/github-address.js
 var GITHUB_REPOSITORY_ADDRESS = /^https:\/\/github\.com\/[A-Za-z0-9][A-Za-z0-9-]{0,38}\/(?!\.{1,2}$)[A-Za-z0-9._-]{1,100}$/;
 var HOST = "[Gg][Ii][Tt][Hh][Uu][Bb]\\.[Cc][Oo][Mm]";
@@ -603,8 +636,14 @@ var REMOTE_FORMS = [
 ];
 
 // ../core/dist/sign-in.js
-var SIGN_IN_COMMAND = '"npx halfcycle"';
-var HOOK_REMEDY = `Run ${SIGN_IN_COMMAND} in the project folder to sign in.`;
+function signInCommand(version) {
+  return `"${bareHalfcycleCommand(version)}"`;
+}
+var SIGN_IN_COMMAND = signInCommand();
+function hookRemedy(version) {
+  return `Run ${signInCommand(version)} in the project folder to sign in.`;
+}
+var HOOK_REMEDY = hookRemedy();
 
 // ../core/dist/task-plan.js
 import { z as z2 } from "zod";
@@ -1977,7 +2016,7 @@ function codexHookCommand(script, args2) {
   const invocation = `cd "$(git rev-parse --show-toplevel)" && bash ./${script}`;
   return args2 === void 0 ? invocation : `${invocation} ${args2}`;
 }
-var CODEX_WINDOWS_NOT_SET_UP = "Halfcycle checks did not run because Halfcycle is not set up in this folder or any folder above it; run npx halfcycle in the project folder.";
+var CODEX_WINDOWS_NOT_SET_UP = `Halfcycle checks did not run because Halfcycle is not set up in this folder or any folder above it; run ${bareHalfcycleCommand()} in the project folder.`;
 var CODEX_WINDOWS_NO_GIT_BASH = "Halfcycle checks did not run because Git for Windows was not found; install Git for Windows, then open a new session.";
 function codexHookCommandWindows(script, args2) {
   const tick = (text) => "`" + text + "`";
@@ -2118,26 +2157,52 @@ function parseWorkerReportFields(blockLines) {
   }
   return fields;
 }
+function backtickRun(text, at) {
+  let n = 0;
+  while (text[at + n] === "`")
+    n++;
+  return n;
+}
 function splitOutsideBackticks(text) {
   const parts = [];
   let buf = "";
-  let inTick = false;
-  for (let i = 0; i < text.length; i++) {
+  let i = 0;
+  while (i < text.length) {
     const ch = text[i];
-    if (ch === "`")
-      inTick = !inTick;
-    if (!inTick && ch === ";") {
+    if (ch === "`") {
+      const open = backtickRun(text, i);
+      let close = -1;
+      for (let j = i + open; j < text.length; ) {
+        if (text[j] !== "`") {
+          j++;
+          continue;
+        }
+        const run = backtickRun(text, j);
+        if (run === open) {
+          close = j;
+          break;
+        }
+        j += run;
+      }
+      const end = close === -1 ? i + open : close + open;
+      buf += text.slice(i, end);
+      i = end;
+      continue;
+    }
+    if (ch === ";") {
       parts.push(buf);
       buf = "";
+      i += 1;
       continue;
     }
-    if (!inTick && text.startsWith(" \xB7 ", i)) {
+    if (text.startsWith(" \xB7 ", i)) {
       parts.push(buf);
       buf = "";
-      i += 2;
+      i += 3;
       continue;
     }
     buf += ch;
+    i += 1;
   }
   parts.push(buf);
   return parts.map((p) => p.trim()).filter(Boolean);
@@ -2487,15 +2552,14 @@ if (switchedOn) {
 }
 
 // dist/bin.js
-import { existsSync as existsSync16, statSync as statSync2, writeSync as writeSync4 } from "node:fs";
+import { existsSync as existsSync17, statSync as statSync3, writeSync as writeSync4 } from "node:fs";
 
 // dist/install.js
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync5, readFileSync as readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync6, lstatSync, mkdirSync as mkdirSync5, readFileSync as readFileSync7, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname3, isAbsolute as isAbsolute2, join as join7, posix as posix2, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { dirname as dirname4, isAbsolute as isAbsolute2, join as join8, posix as posix2, relative, resolve } from "node:path";
 
 // ../events/dist/result.js
 import { z as z3 } from "zod";
@@ -4141,8 +4205,8 @@ var TIME_MEASURED_SENTENCE = "Measured by Halfcycle from what happened in your s
 function timePhaseElapsedSentenceOf(elapsedSeconds) {
   return `${timeDurationLabelOf(elapsedSeconds)} since this phase opened.`;
 }
-function timeUsageTotalTokensOf(usage3) {
-  return usage3.inputTokens + usage3.outputTokens + usage3.cacheWriteTokens + usage3.cacheReadTokens;
+function timeUsageTotalTokensOf(usage5) {
+  return usage5.inputTokens + usage5.outputTokens + usage5.cacheWriteTokens + usage5.cacheReadTokens;
 }
 var TIME_NO_RECORD_SENTENCE = "Halfcycle has not recorded any time for this phase yet. It records at the end of each reply in a session on this project.";
 function timeSummaryIsEmpty(summary) {
@@ -4176,25 +4240,25 @@ var TIME_PERMISSION_PROMPT_LABEL = "Waiting for you to allow an action";
 function timePermissionPromptLineOf(seconds) {
   return seconds === 0 ? void 0 : `${TIME_PERMISSION_PROMPT_LABEL} ${timeDurationLabelOf(seconds)}`;
 }
-function timeUsageNotCachedTokensOf(usage3) {
-  return usage3.inputTokens + usage3.outputTokens + usage3.cacheWriteTokens;
+function timeUsageNotCachedTokensOf(usage5) {
+  return usage5.inputTokens + usage5.outputTokens + usage5.cacheWriteTokens;
 }
-function timeUsageLeadSentenceOf(usage3) {
-  if (usage3.state === "not-available") {
+function timeUsageLeadSentenceOf(usage5) {
+  if (usage5.state === "not-available") {
     return "Usage not available: your coding agent keeps no usage record Halfcycle can read.";
   }
-  const n = timeCountLabelOf(timeUsageNotCachedTokensOf(usage3));
-  if (usage3.state === "partly-recorded") {
+  const n = timeCountLabelOf(timeUsageNotCachedTokensOf(usage5));
+  if (usage5.state === "partly-recorded") {
     return `At least ${n} tokens not read from the cache, as your coding agent recorded them. Some sessions' usage could not be read.`;
   }
   return `${n} tokens not read from the cache, as your coding agent recorded them.`;
 }
-function timeUsageInAllSentenceOf(usage3) {
-  if (usage3.state === "not-available")
+function timeUsageInAllSentenceOf(usage5) {
+  if (usage5.state === "not-available")
     return void 0;
-  const all = timeCountLabelOf(timeUsageTotalTokensOf(usage3));
-  const cached = timeCountLabelOf(usage3.cacheReadTokens);
-  const lead = usage3.state === "partly-recorded" ? `At least ${all}` : all;
+  const all = timeCountLabelOf(timeUsageTotalTokensOf(usage5));
+  const cached = timeCountLabelOf(usage5.cacheReadTokens);
+  const lead = usage5.state === "partly-recorded" ? `At least ${all}` : all;
   return `${lead} in all; ${cached} of them were read back from the cache.`;
 }
 function timeReviewsSentenceOf(reviews) {
@@ -5487,7 +5551,9 @@ var openPhaseRequestSchema = z18.object({
   entry: phaseEntryDecisionSchema,
   startCommit: closeCommitSchema.optional(),
   sortingId: sortingIdSchema.optional(),
-  sizeId: projectSizeIdSchema.optional()
+  sizeId: projectSizeIdSchema.optional(),
+  // Present, and true, only when this phase is opened as a regression phase.
+  regression: z18.literal(true).optional()
 }).strict().refine((v) => v.phase !== null || v.startCommit === void 0, {
   message: "is sent only when a phase is opened",
   path: ["startCommit"]
@@ -5497,6 +5563,9 @@ var openPhaseRequestSchema = z18.object({
 }).refine((v) => v.phase !== null || v.sizeId === void 0, {
   message: "is sent only when a phase is opened",
   path: ["sizeId"]
+}).refine((v) => v.phase !== null || v.regression === void 0, {
+  message: "is sent only when a phase is opened",
+  path: ["regression"]
 });
 var phaseEntryDecisionRecordSchema = z18.object({
   decisionId: z18.string(),
@@ -5799,6 +5868,11 @@ var SMALL_CREW = Object.freeze([
 function isSmallCrewCallsign(callsign) {
   return SMALL_CREW.includes(callsign);
 }
+function crewOfProjectSize(size) {
+  if (size !== "small")
+    return CREW_ROSTER;
+  return CREW_ROSTER.filter((member) => isSmallCrewCallsign(member.callsign));
+}
 var crewLayerSchema = methodLayerSchema.extract(["l0", "l1", "l2", "l3", "l4", "l5"]);
 var crewRoleLayersSchema = z19.object({
   leads: z19.array(crewLayerSchema),
@@ -6502,9 +6576,8 @@ function paceClockOf(at, now) {
   }
   return `${day} ${clock}`;
 }
-function paceP1Of(n, minutes) {
-  const first = `Halfcycle suggests running ${paceAgentsOf(n)} at once.`;
-  return minutes === null ? first : `${first} The work should take about ${timeDurationLabelOf(minutes * 60)}.`;
+function paceP1Of(n, _minutes) {
+  return `Halfcycle suggests running ${paceAgentsOf(n)} at once.`;
 }
 var PACE_NO_BUILD_PLAN = "Halfcycle has no build plan for this phase yet, so it cannot say how long the work will take.";
 var PACE_P2 = "This is a careful start, so your allowance lasts. It leaves room for your own work.";
@@ -6517,27 +6590,30 @@ function paceP6Of(k) {
   return `It will probably pause ${k === 1 ? "once" : `${String(k)} times`} while your usage window resets.`;
 }
 var PACE_P7 = 'Or say how much of your allowance to keep free, like "keep 30% free", or how much this build may use, like "use up to 70%".';
-var PACE_P8 = 'For these to work, run "npx halfcycle" once more in this project.';
-function paceStartLinesOf(s, promptScriptBehind2 = false) {
+function paceP8Of(version) {
+  return `For these to work, run "${bareHalfcycleCommand(version)}" once more in this project.`;
+}
+var PACE_P8 = paceP8Of();
+function paceStartLinesOf(s, promptScriptBehind2 = false, version) {
   const limit = s.limitTokens !== void 0 && s.expectedTokens !== void 0 ? { expected: s.expectedTokens, limit: s.limitTokens, multiple: s.multiple ?? null, setBy: s.limitSetBy ?? "default" } : null;
-  const usage3 = buildStartUsageLinesOf({ workMinutes: s.workMinutes, limit, weekCeilingTokens: s.weekCeilingTokens });
-  const lines = [paceP1Of(s.number, s.minutes), ...usage3.work];
+  const usage5 = buildStartUsageLinesOf({ workMinutes: s.workMinutes, limit, weekCeilingTokens: s.weekCeilingTokens });
+  const lines = [paceP1Of(s.number, s.minutes), ...usage5.work];
   if (s.minutes === null)
     lines.push(PACE_NO_BUILD_PLAN);
   if (s.keepFreePercent === 0)
     lines.push(PACE_P5);
   else
     lines.push(s.knownWindow !== null ? paceP3Of(s.keepFreePercent) : PACE_P2);
-  if (usage3.limit.length > 0) {
-    lines.push(...usage3.limit);
+  if (usage5.limit.length > 0) {
+    lines.push(...usage5.limit);
     if (s.firstGuess === true)
       lines.push(LIMIT_L1B);
   }
   if (s.pauses > 0)
     lines.push(paceP6Of(s.pauses));
-  lines.push(PACE_P4, PACE_P7, ...usage3.change);
+  lines.push(PACE_P4, PACE_P7, ...usage5.change);
   if (promptScriptBehind2)
-    lines.push(PACE_P8);
+    lines.push(paceP8Of(version));
   return lines;
 }
 function paceS1Of(window, k, until, now, keepFreePercent) {
@@ -6703,6 +6779,17 @@ function aboutShareOf(percent) {
   return percent < 0.5 ? planSharePercentWordsOf(percent) : `about ${planSharePercentWordsOf(percent)}`;
 }
 var PLAN_USAGE_CAVEAT = "These figures are estimates. Many things affect usage, and some of them are outside Halfcycle's control.";
+var SMALL_PROJECT_WORK_START = "A small project like this is usually about ";
+var SMALL_PROJECT_WORK_NOTE = "When your plan is written, this phase gets its own figure, counted from the time each task in it is given.";
+function sizeAnswerPrintedLinesOf(usage5) {
+  const out = [];
+  for (const line of usage5) {
+    out.push(line);
+    if (line.startsWith(SMALL_PROJECT_WORK_START))
+      out.push(SMALL_PROJECT_WORK_NOTE);
+  }
+  return out;
+}
 function phaseWorkLineOf(minutes) {
   return `This phase is about ${timeDurationLabelOf(minutes * 60)} of agent work.`;
 }
@@ -6809,19 +6896,43 @@ function limitUsedShareTextOf(used, limit, weekCeilingTokens) {
   return figureThenCaveat(`This phase has used ${ofYourWeek(used, weekCeilingTokens)}, out of a limit of ${aboutShareOf(weekPercentOf(limit, weekCeilingTokens))}.`);
 }
 
+// ../events/dist/regression-line.js
+import { z as z26 } from "zod";
+var REGRESSION_EVERY_MIN = 1;
+var REGRESSION_EVERY_MAX = 20;
+var REGRESSION_EVERY_RANGE_REFUSAL = "The number of phases between regressions must be from 1 to 20. Nothing was changed.";
+var regressionEverySchema = z26.number().int({ message: REGRESSION_EVERY_RANGE_REFUSAL }).min(REGRESSION_EVERY_MIN, { message: REGRESSION_EVERY_RANGE_REFUSAL }).max(REGRESSION_EVERY_MAX, { message: REGRESSION_EVERY_RANGE_REFUSAL });
+var regressionClosedSinceSchema = z26.number().int().min(0);
+var REGRESSION_LINE_MAX = 200;
+var regressionLineSchema = z26.string().min(1).max(REGRESSION_LINE_MAX);
+var regressionEveryRequestSchema = z26.object({
+  // How many phases may close before a regression phase is due, 1 to 20.
+  every: regressionEverySchema
+}).strict();
+var regressionEveryResponseSchema = z26.object({
+  // The number now stored.
+  every: regressionEverySchema,
+  // The line as it reads now, or null when there is none to show.
+  line: regressionLineSchema.nullable()
+}).strict();
+
 // ../events/dist/client-version.js
 var CHAT_APPROVAL_CLIENT_VERSION = "0.4.7";
 function clientMeetsChatApprovalFloor(version) {
-  return isReleaseVersion(version) && compareReleaseVersions(version, CHAT_APPROVAL_CLIENT_VERSION) >= 0;
+  const release = releaseOfVersion(version);
+  return release !== void 0 && compareReleaseVersions(release, CHAT_APPROVAL_CLIENT_VERSION) >= 0;
 }
 var TYPED_APPROVAL_OFF_SENTENCE = "Approving by typing is switched off for now.";
 var HEADLESS_CANNOT_APPROVE = "(a headless session cannot approve, by design)";
 var TYPED_REVIEW_OFF_SENTENCE = "Reviewing by typing is switched off for now.";
-var CLIENT_UPDATE_SENTENCE = `To approve by typing in a session, Halfcycle needs updating: run \`${HALFCYCLE_COMMAND}\` in this project's folder, then reopen your session and ask again.`;
+function clientUpdateSentence(version) {
+  return `To approve by typing in a session, Halfcycle needs updating: run \`${halfcycleCommand(version)}\` in this project's folder, then reopen your session and ask again.`;
+}
+var CLIENT_UPDATE_SENTENCE = clientUpdateSentence();
 
 // ../events/dist/device-auth.js
-import { z as z26 } from "zod";
-var utcIso86013 = z26.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/, "must be a UTC ISO-8601 timestamp ending in Z");
+import { z as z27 } from "zod";
+var utcIso86013 = z27.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/, "must be a UTC ISO-8601 timestamp ending in Z");
 var DEVICE_AUTH_STATUS = {
   /** The poll: minted, nobody has acted yet. Keep polling. 200. */
   PENDING: "pending",
@@ -6862,25 +6973,25 @@ var DEVICE_POLL_REFUSALS = [
   DEVICE_AUTH_STATUS.EXPIRED,
   DEVICE_AUTH_STATUS.UNKNOWN
 ];
-var deviceAuthStartResponseSchema = z26.object({
-  deviceCode: z26.string().min(1),
-  userCode: z26.string().min(1),
-  verificationUrl: z26.string().min(1),
+var deviceAuthStartResponseSchema = z27.object({
+  deviceCode: z27.string().min(1),
+  userCode: z27.string().min(1),
+  verificationUrl: z27.string().min(1),
   expiresAt: utcIso86013,
-  pollIntervalMs: z26.number().int().positive()
+  pollIntervalMs: z27.number().int().positive()
 }).strict();
-var devicePollPendingSchema = z26.object({
-  status: z26.literal(DEVICE_AUTH_STATUS.PENDING),
-  pollIntervalMs: z26.number().int().positive()
+var devicePollPendingSchema = z27.object({
+  status: z27.literal(DEVICE_AUTH_STATUS.PENDING),
+  pollIntervalMs: z27.number().int().positive()
 }).strict();
-var devicePollApprovedSchema = z26.object({
-  status: z26.literal(DEVICE_AUTH_STATUS.APPROVED),
-  accountId: z26.string().min(1),
-  credential: z26.string().min(1),
+var devicePollApprovedSchema = z27.object({
+  status: z27.literal(DEVICE_AUTH_STATUS.APPROVED),
+  accountId: z27.string().min(1),
+  credential: z27.string().min(1),
   expiresAt: utcIso86013
 }).strict();
-var deviceAuthRefusalSchema = z26.object({
-  status: z26.enum([
+var deviceAuthRefusalSchema = z27.object({
+  status: z27.enum([
     DEVICE_AUTH_STATUS.DECLINED,
     DEVICE_AUTH_STATUS.EXPIRED,
     DEVICE_AUTH_STATUS.UNKNOWN,
@@ -6891,25 +7002,25 @@ var deviceAuthRefusalSchema = z26.object({
     DEVICE_AUTH_STATUS.ALREADY_DECIDED,
     DEVICE_AUTH_STATUS.TERMS_REQUIRED
   ]),
-  message: z26.string().min(1)
+  message: z27.string().min(1)
 }).strict();
-var devicePollResponseSchema = z26.union([
+var devicePollResponseSchema = z27.union([
   devicePollPendingSchema,
   devicePollApprovedSchema,
   deviceAuthRefusalSchema
 ]);
-var deviceConfirmRequestSchema = z26.object({
-  userCode: z26.string().min(1),
-  decision: z26.enum(["approve", "decline"]),
-  externalAuthId: z26.string().min(1).optional(),
-  email: z26.string().optional(),
-  acceptTerms: z26.boolean().optional()
+var deviceConfirmRequestSchema = z27.object({
+  userCode: z27.string().min(1),
+  decision: z27.enum(["approve", "decline"]),
+  externalAuthId: z27.string().min(1).optional(),
+  email: z27.string().optional(),
+  acceptTerms: z27.boolean().optional()
 }).strict();
-var deviceConfirmRecordedSchema = z26.object({
-  status: z26.literal(DEVICE_AUTH_STATUS.RECORDED),
-  accountId: z26.string().min(1).optional()
+var deviceConfirmRecordedSchema = z27.object({
+  status: z27.literal(DEVICE_AUTH_STATUS.RECORDED),
+  accountId: z27.string().min(1).optional()
 }).strict();
-var deviceConfirmResponseSchema = z26.union([
+var deviceConfirmResponseSchema = z27.union([
   deviceConfirmRecordedSchema,
   deviceAuthRefusalSchema
 ]);
@@ -6938,67 +7049,87 @@ function loopbackVerificationUrl(verificationUrl, target) {
 }
 
 // ../events/dist/project-page.js
-function projectPageUrl(engagementId) {
-  return isEngagementId(engagementId) ? `${DASHBOARD_URL}/${encodeURIComponent(engagementId)}` : void 0;
+var SERVICE_HOST = /^(?:control|delivery)(-[a-z0-9]+)?\.halfcycle\.ai$/;
+function consoleOrigin(serviceAddress) {
+  const trimmed = serviceAddress?.trim();
+  if (!trimmed)
+    return DASHBOARD_URL;
+  let host;
+  try {
+    host = new URL(trimmed.includes("://") ? trimmed : `https://${trimmed}`).hostname.toLowerCase();
+  } catch {
+    return DASHBOARD_URL;
+  }
+  const suffix = SERVICE_HOST.exec(host)?.[1];
+  return suffix === void 0 ? DASHBOARD_URL : `https://app${suffix}.halfcycle.ai`;
+}
+function projectPageUrl(engagementId, serviceAddress) {
+  return isEngagementId(engagementId) ? `${consoleOrigin(serviceAddress)}/${encodeURIComponent(engagementId)}` : void 0;
 }
-function systemViewUrl(engagementId, phase) {
-  const page = projectPageUrl(engagementId);
+function systemViewUrl(engagementId, phase, serviceAddress) {
+  const page = projectPageUrl(engagementId, serviceAddress);
   if (page === void 0)
     return void 0;
   return `${page}/console/system-view?${new URLSearchParams({ phase }).toString()}`;
 }
-function requestAccessSentence(engagementId) {
-  const page = projectPageUrl(engagementId) ?? "this project's page on Halfcycle";
+function requestAccessSentence(engagementId, serviceAddress) {
+  const page = projectPageUrl(engagementId, serviceAddress) ?? "this project's page on Halfcycle";
   return `To ask for access, open ${page} signed in as this account and choose "Request access". Then let the project's owner know, so they can approve it.`;
 }
 
 // ../events/dist/join-refusal.js
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var NOT_THIS_ACCOUNT_REASON = "not-this-account";
 var JOIN_REFUSAL_STATUS = 403;
-var notThisAccountRefusalSchema = z27.object({
-  statusCode: z27.literal(JOIN_REFUSAL_STATUS),
-  error: z27.string(),
-  message: z27.string(),
-  reason: z27.literal(NOT_THIS_ACCOUNT_REASON)
+var notThisAccountRefusalSchema = z28.object({
+  statusCode: z28.literal(JOIN_REFUSAL_STATUS),
+  error: z28.string(),
+  message: z28.string(),
+  reason: z28.literal(NOT_THIS_ACCOUNT_REASON)
 }).strict();
-var joinRefusalSchema = z27.union([notThisAccountRefusalSchema, wireErrorSchema]);
+var joinRefusalSchema = z28.union([notThisAccountRefusalSchema, wireErrorSchema]);
 function isNotThisAccountRefusal(body) {
   return typeof body === "object" && body !== null && body.reason === NOT_THIS_ACCOUNT_REASON;
 }
 
 // ../events/dist/account-identity.js
-import { z as z28 } from "zod";
-var accountIdentitySchema = z28.object({
-  accountId: z28.string().min(1),
-  email: z28.string().min(1).optional()
+import { z as z29 } from "zod";
+var accountIdentitySchema = z29.object({
+  accountId: z29.string().min(1),
+  email: z29.string().min(1).optional()
 }).strict();
 function safeParseAccountIdentity(payload) {
   return accountIdentitySchema.safeParse(payload);
 }
 
 // ../events/dist/credential-wire.js
-import { z as z29 } from "zod";
-var engagementCredentialResponseSchema = z29.object({
-  engagementId: z29.string(),
-  sessionToken: z29.string(),
-  mcpUrl: z29.string(),
-  guardUrl: z29.string(),
-  controlTelemetryUrl: z29.string(),
-  methodVersion: z29.string().optional(),
-  consoleUrl: z29.string().optional()
+import { z as z30 } from "zod";
+var engagementCredentialResponseSchema = z30.object({
+  engagementId: z30.string(),
+  sessionToken: z30.string(),
+  mcpUrl: z30.string(),
+  guardUrl: z30.string(),
+  controlTelemetryUrl: z30.string(),
+  methodVersion: z30.string().optional(),
+  consoleUrl: z30.string().optional()
 }).strict();
-var ciTokenExchangeResponseSchema = z29.object({
-  token: z29.string(),
+var ciTokenExchangeResponseSchema = z30.object({
+  token: z30.string(),
   expiresAt: utcIso8601,
-  engagementId: z29.string()
+  engagementId: z30.string()
 }).strict();
 var NO_CREDENTIAL_PLACEHOLDER = "halfcycle:no-credential";
 var NOT_THIS_ACCOUNT_PLACEHOLDER = "halfcycle:not-this-account";
 var UPDATE_CLAUDE_CODE_PLACEHOLDER = "halfcycle:update-claude-code";
 var SWITCH_ACCOUNT_ANSWER = 'answer "s" when asked';
-var NO_CREDENTIAL_SENTENCE = 'Halfcycle is not connected: this machine has no working Halfcycle credential for this project. Run "npx halfcycle" in the project folder to sign in again.';
-var NOT_THIS_ACCOUNT_SENTENCE = `Halfcycle is not connected: this project belongs to another Halfcycle account. To switch, run "npx halfcycle" in this project and ${SWITCH_ACCOUNT_ANSWER}.`;
+function noCredentialSentence(version) {
+  return `Halfcycle is not connected: this machine has no working Halfcycle credential for this project. Run "${bareHalfcycleCommand(version)}" in the project folder to sign in again.`;
+}
+var NO_CREDENTIAL_SENTENCE = noCredentialSentence();
+function notThisAccountSentence(version) {
+  return `Halfcycle is not connected: this project belongs to another Halfcycle account. To switch, run "${bareHalfcycleCommand(version)}" in this project and ${SWITCH_ACCOUNT_ANSWER}.`;
+}
+var NOT_THIS_ACCOUNT_SENTENCE = notThisAccountSentence();
 var UPDATE_CLAUDE_CODE_SENTENCE = "Halfcycle is not connected: this Claude Code version does not name the server it connects to, so no credential was sent. Update Claude Code, then reopen.";
 var NO_NODE_SENTENCE = "Halfcycle is not connected: Node is not installed, or not on the path this session uses, so nothing here is checked. Install Node, then reopen.";
 var FOLDER_NOT_TRUSTED_SENTENCE = "Folder not yet trusted. Open this folder once in interactive Claude Code and trust it; then headless runs work.";
@@ -7009,19 +7140,19 @@ var PLACEHOLDER_SENTENCES = Object.freeze({
 });
 
 // ../events/dist/project-engagement.js
-import { z as z30 } from "zod";
-var projectIdSchema = z30.string().uuid();
-var projectEngagementRequestSchema = z30.object({
-  derivedName: z30.string()
+import { z as z31 } from "zod";
+var projectIdSchema = z31.string().uuid();
+var projectEngagementRequestSchema = z31.object({
+  derivedName: z31.string()
 }).strict();
 
 // ../events/dist/phase-record.js
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 
 // ../events/dist/build-record-v4.js
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var BUILD_RECORD_V4_FORMAT = "halfcycle-build-record/v4";
-var recordReviewClaimSchema = z31.object({
+var recordReviewClaimSchema = z32.object({
   ...reviewClaimAnswerSchema.shape,
   note: reviewNoteSchema.nullable()
 }).strict().superRefine((c, ctx) => {
@@ -7029,19 +7160,19 @@ var recordReviewClaimSchema = z31.object({
     ctx.addIssue({ code: "custom", path: ["note"], message: "carries the owner's note exactly on a reject" });
   }
 });
-var recordCallSchema = z31.object(workCallSchema.shape).omit({ at: true }).strict().superRefine((c, ctx) => checkReadCallHow(c, ctx));
-var recordReviewV4Schema = z31.object({
+var recordCallSchema = z32.object(workCallSchema.shape).omit({ at: true }).strict().superRefine((c, ctx) => checkReadCallHow(c, ctx));
+var recordReviewV4Schema = z32.object({
   ...recordReviewSchema.shape,
-  claims: z31.array(recordReviewClaimSchema).max(REVIEW_CLAIMS_MAX),
-  calls: z31.array(recordCallSchema)
+  claims: z32.array(recordReviewClaimSchema).max(REVIEW_CLAIMS_MAX),
+  calls: z32.array(recordCallSchema)
 }).strict().superRefine((v, ctx) => checkRecordReview(v, ctx));
-var buildRecordV4Schema = z31.object({
+var buildRecordV4Schema = z32.object({
   ...buildRecordV3Schema.shape,
-  format: z31.literal(BUILD_RECORD_V4_FORMAT),
+  format: z32.literal(BUILD_RECORD_V4_FORMAT),
   path: phasePathSchema,
   review: recordReviewV4Schema
 }).strict().superRefine((record2, ctx) => checkReviewedRecord(record2, ctx));
-var buildRecordSchema = z31.discriminatedUnion("format", [
+var buildRecordSchema = z32.discriminatedUnion("format", [
   buildRecordV2Schema,
   buildRecordV3Schema,
   buildRecordV4Schema
@@ -7073,81 +7204,81 @@ function removalsOf(record2) {
 }
 
 // ../events/dist/phase-record.js
-var phaseRecordRefusalReasonSchema = z32.enum([
+var phaseRecordRefusalReasonSchema = z33.enum([
   "still-open",
   "reopened",
   "never-opened",
   "never-closed",
   "closed-before-records"
 ]);
-var phaseRecordRecordSchema = z32.object({
-  outcome: z32.literal("record"),
+var phaseRecordRecordSchema = z33.object({
+  outcome: z33.literal("record"),
   phase: phaseNameSchema,
   record: buildRecordSchema
 }).strict().refine((body) => body.record.phase === body.phase, {
   message: "the record is for a different phase than the one asked for",
   path: ["record", "phase"]
 });
-var phaseRecordWithheldSchema = z32.object({
-  outcome: z32.literal("withheld"),
+var phaseRecordWithheldSchema = z33.object({
+  outcome: z33.literal("withheld"),
   phase: phaseNameSchema,
-  sequence: z32.number().int().min(1),
+  sequence: z33.number().int().min(1),
   closedAt: utcIso8601,
-  message: z32.string()
+  message: z33.string()
 }).strict();
 var phaseRecordRefusedSchema = wireErrorSchema.extend({
-  outcome: z32.literal("refused"),
+  outcome: z33.literal("refused"),
   phase: phaseNameSchema,
-  statusCode: z32.literal(409),
-  error: z32.literal("PhaseRecordRefused"),
+  statusCode: z33.literal(409),
+  error: z33.literal("PhaseRecordRefused"),
   reason: phaseRecordRefusalReasonSchema
 }).strict();
-var phaseRecordResponseSchema = z32.discriminatedUnion("outcome", [
+var phaseRecordResponseSchema = z33.discriminatedUnion("outcome", [
   phaseRecordRecordSchema,
   phaseRecordWithheldSchema,
   phaseRecordRefusedSchema
 ]);
 
 // ../events/dist/scope-chat.js
-import { z as z33 } from "zod";
-var chatScopeApproveRequestSchema = z33.object({
-  act: z33.literal("approve"),
+import { z as z34 } from "zod";
+var chatScopeApproveRequestSchema = z34.object({
+  act: z34.literal("approve"),
   reference: phaseIdentitySchema,
   planVersion: planVersionSchema
 }).strict();
-var chatScopeSendBackRequestSchema = z33.object({
-  act: z33.literal("send-back"),
+var chatScopeSendBackRequestSchema = z34.object({
+  act: z34.literal("send-back"),
   reference: phaseIdentitySchema,
   planVersion: planVersionSchema,
   note: scopeNoteWireSchema.optional()
 }).strict();
-var chatScopeRequestSchema = z33.discriminatedUnion("act", [
+var chatScopeRequestSchema = z34.discriminatedUnion("act", [
   chatScopeApproveRequestSchema,
   chatScopeSendBackRequestSchema
 ]);
 var CHAT_SCOPE_ACTS = SCOPE_ACTS;
-var chatScopeRecordedSchema = z33.object({
-  outcome: z33.literal("recorded"),
-  act: z33.enum(CHAT_SCOPE_ACTS),
+var chatScopeRecordedSchema = z34.object({
+  outcome: z34.literal("recorded"),
+  act: z34.enum(CHAT_SCOPE_ACTS),
   phase: scopePhaseSchema,
   planVersion: planVersionSchema
 }).strict();
-var chatScopeAlreadyApprovedSchema = z33.object({
-  outcome: z33.literal("already-approved"),
-  replanNeeded: z33.boolean()
+var chatScopeAlreadyApprovedSchema = z34.object({
+  outcome: z34.literal("already-approved"),
+  replanNeeded: z34.boolean()
 }).strict();
-var chatScopeRefusedSchema = z33.object({
-  outcome: z33.literal("refused"),
-  problems: z33.array(systemDescriptionProblemSchema).min(1)
+var chatScopeRefusedSchema = z34.object({
+  outcome: z34.literal("refused"),
+  problems: z34.array(systemDescriptionProblemSchema).min(1)
 }).strict();
-var chatAmbiguousSchema = z33.object({
-  outcome: z33.literal("ambiguous"),
-  phases: z33.array(scopePhaseSchema).min(2)
+var chatAmbiguousSchema = z34.object({
+  outcome: z34.literal("ambiguous"),
+  phases: z34.array(scopePhaseSchema).min(2)
 }).strict();
 function bareOutcome(outcome) {
-  return z33.object({ outcome: z33.literal(outcome) }).strict();
+  return z34.object({ outcome: z34.literal(outcome) }).strict();
 }
-var chatScopeResultSchema = z33.discriminatedUnion("outcome", [
+var chatScopeResultSchema = z34.discriminatedUnion("outcome", [
   chatScopeRecordedSchema,
   chatScopeAlreadyApprovedSchema,
   chatScopeRefusedSchema,
@@ -7162,19 +7293,19 @@ var chatScopeResultSchema = z33.discriminatedUnion("outcome", [
 ]);
 
 // ../events/dist/review-chat.js
-import { z as z34 } from "zod";
-var chatReviewAcceptRequestSchema = z34.object({
-  act: z34.literal("accept"),
+import { z as z35 } from "zod";
+var chatReviewAcceptRequestSchema = z35.object({
+  act: z35.literal("accept"),
   reference: phaseIdentitySchema,
-  reviewVersion: z34.number().int().min(0),
-  parts: z34.array(systemPartIdSchema).max(REVIEW_PARTS_MAX),
-  waitingClaims: z34.literal(true).optional()
+  reviewVersion: z35.number().int().min(0),
+  parts: z35.array(systemPartIdSchema).max(REVIEW_PARTS_MAX),
+  waitingClaims: z35.literal(true).optional()
 }).strict();
 function notedRequest(act) {
-  return z34.object({
-    act: z34.literal(act),
+  return z35.object({
+    act: z35.literal(act),
     reference: phaseIdentitySchema,
-    reviewVersion: z34.number().int().min(0),
+    reviewVersion: z35.number().int().min(0),
     part: systemPartIdSchema,
     note: reviewNoteWireSchema
   }).strict();
@@ -7183,14 +7314,14 @@ var chatReviewQuestionRequestSchema = notedRequest("question");
 var chatReviewSendBackRequestSchema = notedRequest("send-back");
 var chatReviewCarryRequestSchema = notedRequest("carry");
 var chatReviewDropRequestSchema = notedRequest("drop");
-var chatReviewRejectRequestSchema = z34.object({
-  act: z34.literal("reject"),
+var chatReviewRejectRequestSchema = z35.object({
+  act: z35.literal("reject"),
   reference: phaseIdentitySchema,
-  reviewVersion: z34.number().int().min(0),
+  reviewVersion: z35.number().int().min(0),
   task: buildTaskIdSchema,
   note: reviewNoteWireSchema
 }).strict();
-var chatReviewRequestSchema = z34.discriminatedUnion("act", [
+var chatReviewRequestSchema = z35.discriminatedUnion("act", [
   chatReviewAcceptRequestSchema,
   chatReviewQuestionRequestSchema,
   chatReviewSendBackRequestSchema,
@@ -7199,12 +7330,12 @@ var chatReviewRequestSchema = z34.discriminatedUnion("act", [
   chatReviewRejectRequestSchema
 ]);
 function bareOutcome2(outcome) {
-  return z34.object({ outcome: z34.literal(outcome) }).strict();
+  return z35.object({ outcome: z35.literal(outcome) }).strict();
 }
 function notTheConsoleNotDecidable(option) {
   return option !== reviewNotDecidableSchema;
 }
-var chatReviewResultSchema = z34.discriminatedUnion("outcome", [
+var chatReviewResultSchema = z35.discriminatedUnion("outcome", [
   reviewPartsNotDecidableSchema,
   ...reviewDecisionResultSchema.options.filter(notTheConsoleNotDecidable),
   bareOutcome2("show-first"),
@@ -7212,15 +7343,15 @@ var chatReviewResultSchema = z34.discriminatedUnion("outcome", [
   chatAmbiguousSchema,
   bareOutcome2("nothing-waiting")
 ]);
-var reviewAnswerRequestSchema = z34.object({
+var reviewAnswerRequestSchema = z35.object({
   part: systemPartIdSchema,
   answer: statementText(REVIEW_ANSWER_MAX)
 }).strict();
-var reviewAnswerRecordedSchema = z34.object({
-  outcome: z34.literal("recorded"),
+var reviewAnswerRecordedSchema = z35.object({
+  outcome: z35.literal("recorded"),
   name: systemPartSchema.shape.name
 }).strict();
-var reviewAnswerResultSchema = z34.discriminatedUnion("outcome", [
+var reviewAnswerResultSchema = z35.discriminatedUnion("outcome", [
   reviewAnswerRecordedSchema,
   bareOutcome2("no-question"),
   reviewRefusedSchema,
@@ -7228,27 +7359,27 @@ var reviewAnswerResultSchema = z34.discriminatedUnion("outcome", [
 ]);
 
 // ../events/dist/owner-waits.js
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 
 // ../events/dist/owner-wait-answer.js
-import { z as z35 } from "zod";
-var ownerWaitShortIdSchema = z35.string().regex(/^[0-9a-f]{8}$/);
+import { z as z36 } from "zod";
+var ownerWaitShortIdSchema = z36.string().regex(/^[0-9a-f]{8}$/);
 var OWNER_WAIT_ANSWER_ACTS = ["approve", "decline"];
-var ownerWaitAnswerActSchema = z35.enum(OWNER_WAIT_ANSWER_ACTS);
-var ownerWaitChatRequestSchema = z35.discriminatedUnion("act", [
-  z35.object({ act: z35.literal("approve"), wait: ownerWaitShortIdSchema }).strict(),
-  z35.object({ act: z35.literal("decline"), wait: ownerWaitShortIdSchema, note: scopeNoteWireSchema }).strict()
+var ownerWaitAnswerActSchema = z36.enum(OWNER_WAIT_ANSWER_ACTS);
+var ownerWaitChatRequestSchema = z36.discriminatedUnion("act", [
+  z36.object({ act: z36.literal("approve"), wait: ownerWaitShortIdSchema }).strict(),
+  z36.object({ act: z36.literal("decline"), wait: ownerWaitShortIdSchema, note: scopeNoteWireSchema }).strict()
 ]);
 function bareOutcome3(outcome) {
-  return z35.object({ outcome: z35.literal(outcome) }).strict();
+  return z36.object({ outcome: z36.literal(outcome) }).strict();
 }
-var ownerWaitChatResultSchema = z35.discriminatedUnion("outcome", [
-  z35.object({
-    outcome: z35.literal("recorded"),
+var ownerWaitChatResultSchema = z36.discriminatedUnion("outcome", [
+  z36.object({
+    outcome: z36.literal("recorded"),
     act: ownerWaitAnswerActSchema,
-    question: z35.string().min(1)
+    question: z36.string().min(1)
   }).strict(),
-  z35.object({ outcome: z35.literal("refused"), problems: z35.array(systemDescriptionProblemSchema).min(1) }).strict(),
+  z36.object({ outcome: z36.literal("refused"), problems: z36.array(systemDescriptionProblemSchema).min(1) }).strict(),
   bareOutcome3("not-owner"),
   bareOutcome3("no-owner"),
   bareOutcome3("not-found"),
@@ -7270,7 +7401,7 @@ var OWNER_WAIT_ITEMS = Object.freeze([
   Object.freeze({ id: "change-standing-rule", words: "Changing a standing rule." })
 ]);
 var OWNER_WAIT_ITEM_IDS = Object.freeze(OWNER_WAIT_ITEMS.map((item) => item.id));
-var ownerWaitItemIdSchema = z36.enum(OWNER_WAIT_ITEM_IDS);
+var ownerWaitItemIdSchema = z37.enum(OWNER_WAIT_ITEM_IDS);
 var OWNER_WAIT_FIXED_COUNT = OWNER_WAIT_ITEMS.length;
 var OWNER_WAIT_ADDITIONS_MAX = 20;
 var OWNER_WAIT_TEXT_MAX = 240;
@@ -7280,23 +7411,23 @@ function ownerWaitItemOf(id) {
     throw new Error(`no owner-wait item ${id}`);
   return item;
 }
-var ownerWaitItemRefSchema = z36.union([
-  z36.number().int().min(1),
-  z36.string().uuid({ message: "must be a number from 1 to 6, or the id shown beside an added item" })
+var ownerWaitItemRefSchema = z37.union([
+  z37.number().int().min(1),
+  z37.string().uuid({ message: "must be a number from 1 to 6, or the id shown beside an added item" })
 ]);
 var ownerWaitText = descriptionText(OWNER_WAIT_TEXT_MAX);
-var ownerWaitAddRequestSchema = z36.object({
-  engagementId: z36.string().min(1),
+var ownerWaitAddRequestSchema = z37.object({
+  engagementId: z37.string().min(1),
   text: ownerWaitText,
   reason: ownerWaitText
 }).strict();
-var ownerWaitAddResultSchema = z36.discriminatedUnion("outcome", [
-  z36.object({ outcome: z36.literal("added"), id: z36.string().uuid(), addedAt: utcIso8601 }).strict(),
-  z36.object({ outcome: z36.literal("refused"), reason: z36.literal("too-many") }).strict()
+var ownerWaitAddResultSchema = z37.discriminatedUnion("outcome", [
+  z37.object({ outcome: z37.literal("added"), id: z37.string().uuid(), addedAt: utcIso8601 }).strict(),
+  z37.object({ outcome: z37.literal("refused"), reason: z37.literal("too-many") }).strict()
 ]);
-var ownerWaitUndoableSchema = z36.enum(["yes", "no"]);
-var ownerWaitDeclareRequestSchema = z36.object({
-  engagementId: z36.string().min(1),
+var ownerWaitUndoableSchema = z37.enum(["yes", "no"]);
+var ownerWaitDeclareRequestSchema = z37.object({
+  engagementId: z37.string().min(1),
   item: ownerWaitItemRefSchema,
   question: ownerWaitText,
   recommendation: ownerWaitText,
@@ -7309,47 +7440,47 @@ var ownerWaitDeclareRequestSchema = z36.object({
   path: ["how"]
 });
 var OWNER_WAIT_DECLARE_REFUSALS = ["no-open-phase", "unknown-item", "say-if-undoable"];
-var ownerWaitDeclareResultSchema = z36.discriminatedUnion("outcome", [
-  z36.object({ outcome: z36.literal("recorded"), id: z36.string().uuid(), say: z36.string().min(1) }).strict(),
-  z36.object({
-    outcome: z36.literal("go-ahead"),
-    id: z36.string().uuid(),
-    callId: z36.number().int().positive(),
-    say: z36.string().min(1)
+var ownerWaitDeclareResultSchema = z37.discriminatedUnion("outcome", [
+  z37.object({ outcome: z37.literal("recorded"), id: z37.string().uuid(), say: z37.string().min(1) }).strict(),
+  z37.object({
+    outcome: z37.literal("go-ahead"),
+    id: z37.string().uuid(),
+    callId: z37.number().int().positive(),
+    say: z37.string().min(1)
   }).strict(),
-  z36.object({ outcome: z36.literal("refused"), reason: z36.enum(OWNER_WAIT_DECLARE_REFUSALS) }).strict()
+  z37.object({ outcome: z37.literal("refused"), reason: z37.enum(OWNER_WAIT_DECLARE_REFUSALS) }).strict()
 ]);
-var ownerWaitAddedItemSchema = z36.object({
-  id: z36.string().uuid(),
-  words: z36.string().min(1),
-  reason: z36.string().min(1),
+var ownerWaitAddedItemSchema = z37.object({
+  id: z37.string().uuid(),
+  words: z37.string().min(1),
+  reason: z37.string().min(1),
   addedAt: utcIso8601
 }).strict();
-var ownerWaitListSchema = z36.object({
-  fixed: z36.array(z36.object({ id: ownerWaitItemIdSchema, words: z36.string().min(1) }).strict()).length(OWNER_WAIT_FIXED_COUNT),
-  added: z36.array(ownerWaitAddedItemSchema).max(OWNER_WAIT_ADDITIONS_MAX)
+var ownerWaitListSchema = z37.object({
+  fixed: z37.array(z37.object({ id: ownerWaitItemIdSchema, words: z37.string().min(1) }).strict()).length(OWNER_WAIT_FIXED_COUNT),
+  added: z37.array(ownerWaitAddedItemSchema).max(OWNER_WAIT_ADDITIONS_MAX)
 }).strict();
-var ownerWaitDeclarationSchema = z36.object({
-  id: z36.string().uuid(),
+var ownerWaitDeclarationSchema = z37.object({
+  id: z37.string().uuid(),
   fixedItem: ownerWaitItemIdSchema.nullable(),
-  addition: z36.object({ id: z36.string().uuid(), words: z36.string().min(1) }).strict().nullable(),
-  question: z36.string().min(1),
-  recommendation: z36.string().min(1),
+  addition: z37.object({ id: z37.string().uuid(), words: z37.string().min(1) }).strict().nullable(),
+  question: z37.string().min(1),
+  recommendation: z37.string().min(1),
   task: buildTaskIdSchema.nullable(),
   declaredAt: utcIso8601
 }).strict().refine((d) => d.fixedItem === null !== (d.addition === null), {
   message: "names exactly one item: a fixed one or an added one",
   path: ["fixedItem"]
 });
-var ownerWaitDeclarationsSchema = z36.object({ declarations: z36.array(ownerWaitDeclarationSchema) }).strict();
-var ownerWaitOpenSchema = z36.object({
+var ownerWaitDeclarationsSchema = z37.object({ declarations: z37.array(ownerWaitDeclarationSchema) }).strict();
+var ownerWaitOpenSchema = z37.object({
   wait: ownerWaitShortIdSchema,
   task: buildTaskIdSchema.nullable(),
-  question: z36.string().min(1),
-  recommendation: z36.string().min(1),
+  question: z37.string().min(1),
+  recommendation: z37.string().min(1),
   declaredAt: utcIso8601
 }).strict();
-var ownerWaitsOpenSchema = z36.object({ waits: z36.array(ownerWaitOpenSchema) }).strict();
+var ownerWaitsOpenSchema = z37.object({ waits: z37.array(ownerWaitOpenSchema) }).strict();
 function ownerWaitItemPhraseOf(item) {
   const cut = item.words.split(", such as ")[0] ?? item.words;
   const bare = cut.endsWith(".") ? cut.slice(0, -1) : cut;
@@ -7368,15 +7499,15 @@ function ownerWaitClosedLineOf(item, question2) {
 var OWNER_WAIT_DECLARATIONS_READ_FAILED = "Halfcycle could not read the decisions that waited for you.";
 
 // ../events/dist/autonomy.js
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 var AUTONOMY_CHANGED_IN = ["console", "chat"];
-var autonomyChangedInSchema = z37.enum(AUTONOMY_CHANGED_IN);
-var autonomySettingsSchema = z37.object({
-  on: z37.boolean(),
+var autonomyChangedInSchema = z38.enum(AUTONOMY_CHANGED_IN);
+var autonomySettingsSchema = z38.object({
+  on: z38.boolean(),
   // whether builds run on their own
-  mayPublish: z37.boolean(),
+  mayPublish: z38.boolean(),
   // whether builds may publish or release without waiting
-  maySpend: z37.boolean(),
+  maySpend: z38.boolean(),
   // whether builds may spend money or sign up without waiting
   changedAt: utcIso8601.nullable(),
   // when the setting last changed; null if never
@@ -7386,37 +7517,37 @@ var autonomySettingsSchema = z37.object({
   message: "says when and where it changed, or neither",
   path: ["changedIn"]
 });
-var autonomyChangeRequestSchema = z37.object({
-  on: z37.boolean(),
+var autonomyChangeRequestSchema = z38.object({
+  on: z38.boolean(),
   // the switch
-  mayPublish: z37.boolean(),
+  mayPublish: z38.boolean(),
   // the publish box
-  maySpend: z37.boolean()
+  maySpend: z38.boolean()
   // the spend box
 }).strict();
 var AUTONOMY_CHAT_ACTS = ["on", "off"];
-var autonomyChatActSchema = z37.enum(AUTONOMY_CHAT_ACTS);
-var autonomyChatRequestSchema = z37.object({
+var autonomyChatActSchema = z38.enum(AUTONOMY_CHAT_ACTS);
+var autonomyChatRequestSchema = z38.object({
   act: autonomyChatActSchema
   // what the owner typed
 }).strict();
-var autonomyChatResultSchema = z37.discriminatedUnion("outcome", [
-  z37.object({
-    outcome: z37.literal("recorded"),
-    on: z37.boolean()
+var autonomyChatResultSchema = z38.discriminatedUnion("outcome", [
+  z38.object({
+    outcome: z38.literal("recorded"),
+    on: z38.boolean()
     // whether builds now run on their own
   }).strict(),
-  z37.object({ outcome: z37.literal("not-owner") }).strict(),
-  z37.object({ outcome: z37.literal("no-owner") }).strict(),
-  z37.object({ outcome: z37.literal("not-offered") }).strict(),
-  z37.object({ outcome: z37.literal("unavailable") }).strict()
+  z38.object({ outcome: z38.literal("not-owner") }).strict(),
+  z38.object({ outcome: z38.literal("no-owner") }).strict(),
+  z38.object({ outcome: z38.literal("not-offered") }).strict(),
+  z38.object({ outcome: z38.literal("unavailable") }).strict()
 ]);
-var autonomyStateSchema = z37.object({
-  on: z37.boolean(),
+var autonomyStateSchema = z38.object({
+  on: z38.boolean(),
   // whether builds run on their own
-  mayPublish: z37.boolean(),
+  mayPublish: z38.boolean(),
   // whether builds may publish or release without waiting
-  maySpend: z37.boolean()
+  maySpend: z38.boolean()
   // whether builds may spend money or sign up without waiting
 }).strict();
 var autonomyStateFileSchema = autonomyStateSchema.extend({
@@ -7425,8 +7556,8 @@ var autonomyStateFileSchema = autonomyStateSchema.extend({
 }).strict();
 var AUTONOMY_STATE_FILE_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var AUTONOMY_ACTIVITY_KINDS = ["went-ahead", "waiting", "approved", "closed", "waiting-on-owner"];
-var autonomyActivityKindSchema = z37.enum(AUTONOMY_ACTIVITY_KINDS);
-var autonomyActivityRowSchema = z37.object({
+var autonomyActivityKindSchema = z38.enum(AUTONOMY_ACTIVITY_KINDS);
+var autonomyActivityRowSchema = z38.object({
   kind: autonomyActivityKindSchema,
   // what happened
   phase: scopePhaseSchema,
@@ -7477,11 +7608,11 @@ var autonomyActivityRowSchema = z37.object({
     ctx.addIssue({ code: "custom", message: "says how to undo it exactly when it can be undone", path: ["how"] });
   }
 });
-var autonomyActivitySchema = z37.object({
-  rows: z37.array(autonomyActivityRowSchema)
+var autonomyActivitySchema = z38.object({
+  rows: z38.array(autonomyActivityRowSchema)
   // newest first
 }).strict();
-var savedIdSchema = z37.string().min(1).max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "must be lower-case letters, digits and single hyphens");
+var savedIdSchema = z38.string().min(1).max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "must be lower-case letters, digits and single hyphens");
 var SAVED_REF_PREFIX = "refs/halfcycle/saved/";
 function savedRefOf(id) {
   return `${SAVED_REF_PREFIX}${id}`;
@@ -7520,33 +7651,33 @@ function isGitFolderSegment(segment) {
   return t === ".git" || /^git~\d+$/.test(t);
 }
 var SAVED_PATH_KEPT_IN = ["commit", "copy"];
-var savedPathSchema = z37.object({
-  path: z37.string().max(4096).refine(isProjectRelativePath, { message: "must be a path inside the project" }),
+var savedPathSchema = z38.object({
+  path: z38.string().max(4096).refine(isProjectRelativePath, { message: "must be a path inside the project" }),
   // the file, relative to the project
-  keptIn: z37.enum(SAVED_PATH_KEPT_IN)
+  keptIn: z38.enum(SAVED_PATH_KEPT_IN)
   // in the save's commit, or copied beside this file
 }).strict();
-var savedCommitSchema = z37.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/, "must be a full commit hash");
-var savedBranchSchema = z37.object({
-  name: z37.string().min(1).max(255).refine((n) => !hasControlCharacter(n) && !n.startsWith("-") && !n.includes("..") && n !== "HEAD", {
+var savedCommitSchema = z38.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/, "must be a full commit hash");
+var savedBranchSchema = z38.object({
+  name: z38.string().min(1).max(255).refine((n) => !hasControlCharacter(n) && !n.startsWith("-") && !n.includes("..") && n !== "HEAD", {
     message: "must be a branch name"
   }),
   // the branch's name
   commit: savedCommitSchema
   // the commit it pointed at
 }).strict();
-var savedSchema = z37.object({
+var savedSchema = z38.object({
   id: savedIdSchema,
   // what restore is typed with
   savedAt: utcIso8601,
   // when the copy was made
-  ref: z37.string().min(1),
+  ref: z38.string().min(1),
   // where the saved commit is kept
-  what: z37.string().min(1).max(2e3),
+  what: z38.string().min(1).max(2e3),
   // what the action would have changed, in words
-  paths: z37.array(savedPathSchema),
+  paths: z38.array(savedPathSchema),
   // every saved file
-  branches: z37.array(savedBranchSchema)
+  branches: z38.array(savedBranchSchema)
   // every saved line of work
 }).strict().refine((s) => s.ref === savedRefOf(s.id), { message: "must be the ref of this save", path: ["ref"] });
 function autonomyA13(accepted, carried) {
@@ -7600,23 +7731,23 @@ function recordedClaimLine(claim) {
 var NO_UNCHECKED_CLAIMS_LINE = "No agent said a check passes that Halfcycle never ran.";
 
 // ../events/dist/relayed-choices.js
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 var RELAYED_CHOICES_FILENAME = "relayed.json";
 var RELAYED_SAID_MAX = 80;
-var relayedChoiceSchema = z38.object({
+var relayedChoiceSchema = z39.object({
   at: utcIso8601,
-  said: z38.string().min(1).max(RELAYED_SAID_MAX)
+  said: z39.string().min(1).max(RELAYED_SAID_MAX)
 }).strict();
-var relayedChoicesFileSchema = z38.object({
+var relayedChoicesFileSchema = z39.object({
   phase: phaseNameSchema,
-  entries: z38.array(relayedChoiceSchema)
+  entries: z39.array(relayedChoiceSchema)
 }).strict();
 function relayedChoiceLineOf(entry) {
   return `On ${paceWhenOf(new Date(entry.at))} "${entry.said}" reached Halfcycle through Codex, which cannot show who typed it. Halfcycle could not confirm that you typed it, and it let this phase use more of your allowance.`;
 }
 
 // ../events/dist/tier-figures.js
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 var TIER_ORDER = ["fast", "standard", "deep"];
 function tierRankOf(tier) {
   return TIER_ORDER.indexOf(tier);
@@ -7649,15 +7780,15 @@ function routeNoSuchTaskLineOf(task) {
   return `"${task}" is not a task in the plan. Check the task id, then run this again.`;
 }
 var ROUTING_FILENAME = "routing.json";
-var routingRecordSchema = z39.object({
-  phase: z39.string().min(1).max(200),
-  cheapStarted: z39.array(z39.string().min(1).max(200)).max(2e3)
+var routingRecordSchema = z40.object({
+  phase: z40.string().min(1).max(200),
+  cheapStarted: z40.array(z40.string().min(1).max(200)).max(2e3)
 }).strict();
 var PHASE_MODEL_NAME_MAX = 64;
-var phaseModelsFileSchema = z39.object({
-  phase: z39.string().min(1).max(200),
-  openedAt: z39.string().min(1).max(64),
-  tasks: z39.record(z39.string().min(1).max(200), z39.record(z39.string().min(1).max(PHASE_MODEL_NAME_MAX), z39.number().int().min(0)))
+var phaseModelsFileSchema = z40.object({
+  phase: z40.string().min(1).max(200),
+  openedAt: z40.string().min(1).max(64),
+  tasks: z40.record(z40.string().min(1).max(200), z40.record(z40.string().min(1).max(PHASE_MODEL_NAME_MAX), z40.number().int().min(0)))
 }).strict();
 function inAttemptOrder(attempts) {
   return [...attempts].sort((a, b) => a.attempt - b.attempt);
@@ -7715,9 +7846,9 @@ var CHECKS_IF_STILL_UNREPORTED = "If still unreported: Codex, approve in /hooks;
 var CHECKS_GONE_QUIET = "Halfcycle's checks have not reported from this machine lately.";
 
 // dist/engagement-credential.js
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { platform as platform2 } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 
 // dist/account-credential.js
 import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -7776,6 +7907,46 @@ function forgetStoredCredential(serviceUrl, home) {
   return true;
 }
 
+// dist/own-version.js
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
+import { fileURLToPath } from "node:url";
+var moduleDir = dirname2(fileURLToPath(import.meta.url));
+function findBundleRoot(startDir) {
+  let candidate = startDir;
+  for (let i = 0; i < 4; i++) {
+    const manifest = join3(candidate, ".claude-plugin", "plugin.json");
+    try {
+      if (existsSync2(manifest))
+        return candidate;
+    } catch {
+    }
+    candidate = dirname2(candidate);
+  }
+  return join3(startDir, "..");
+}
+var BUNDLE_ROOT = findBundleRoot(moduleDir);
+function bundleVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync2(join3(BUNDLE_ROOT, "package.json"), "utf-8"));
+    return typeof pkg.version === "string" ? pkg.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var cachedVersion;
+function ownVersion() {
+  if (cachedVersion === void 0)
+    cachedVersion = { value: bundleVersion() };
+  return cachedVersion.value;
+}
+function ownCommand() {
+  return halfcycleCommand(ownVersion());
+}
+function ownBareCommand() {
+  return bareHalfcycleCommand(ownVersion());
+}
+
 // dist/engagement-credential.js
 var ENGAGEMENTS_DIR = ENGAGEMENTS_DIR_NAME;
 var ENV_FILENAME = ENGAGEMENT_ENV_FILENAME;
@@ -7783,7 +7954,7 @@ var HALFCYCLE_DIR = HALFCYCLE_DIR_NAME;
 var InvalidEngagementIdError = class extends Error {
   constructor(engagementId) {
     const shown2 = JSON.stringify(engagementId.length > 80 ? `${engagementId.slice(0, 80)}\u2026` : engagementId);
-    super(`${shown2} is not a Halfcycle project id, so it cannot name a folder on this machine and nothing was written. A project id looks like 3f2a1c4e-8b7d-4e2f-9a61-0c5d7e8f9b10. If it is the "${PIN_ENGAGEMENT_ID_FIELD}" in .halfcycle/bundle.json, delete that file and run "npx halfcycle" again: this repository is then set up as a new Halfcycle project.`);
+    super(`${shown2} is not a Halfcycle project id, so it cannot name a folder on this machine and nothing was written. A project id looks like 3f2a1c4e-8b7d-4e2f-9a61-0c5d7e8f9b10. If it is the "${PIN_ENGAGEMENT_ID_FIELD}" in .halfcycle/bundle.json, delete that file and run "${ownBareCommand()}" again: this repository is then set up as a new Halfcycle project.`);
     this.name = "InvalidEngagementIdError";
   }
 };
@@ -7793,13 +7964,13 @@ function assertEngagementId(engagementId) {
 }
 function engagementStateDir(engagementId, home) {
   assertEngagementId(engagementId);
-  return join3(halfcycleHome(home), ENGAGEMENTS_DIR, engagementId);
+  return join4(halfcycleHome(home), ENGAGEMENTS_DIR, engagementId);
 }
 function engagementEnvPath(engagementId, home) {
-  return join3(engagementStateDir(engagementId, home), ENV_FILENAME);
+  return join4(engagementStateDir(engagementId, home), ENV_FILENAME);
 }
 function notThisAccountMarkerPath(engagementId, home) {
-  return join3(engagementStateDir(engagementId, home), NOT_THIS_ACCOUNT_MARKER_FILENAME);
+  return join4(engagementStateDir(engagementId, home), NOT_THIS_ACCOUNT_MARKER_FILENAME);
 }
 function writeNotThisAccountMarker(engagementId, home) {
   const dir = engagementStateDir(engagementId, home);
@@ -7829,7 +8000,7 @@ function reconcileEnvText2(existing, values, keys = ENGAGEMENT_ENV_KEYS) {
 }
 function readEngagementEnv(engagementId, home) {
   try {
-    return parseEnvText(readFileSync2(engagementEnvPath(engagementId, home), "utf-8"));
+    return parseEnvText(readFileSync3(engagementEnvPath(engagementId, home), "utf-8"));
   } catch {
     return null;
   }
@@ -7839,7 +8010,7 @@ function writeEngagementEnv(engagementId, values, home, keys = ENGAGEMENT_ENV_KE
   const dir = engagementStateDir(engagementId, home);
   let existing;
   try {
-    existing = readFileSync2(path, "utf-8");
+    existing = readFileSync3(path, "utf-8");
   } catch {
     existing = null;
   }
@@ -7870,7 +8041,7 @@ function engagementResolutionShell() {
   return `# --- Halfcycle credential resolution (generated; do not edit) ----------------
 # THE CREDENTIAL IS NOT IN THIS REPOSITORY. It lives at
 #   $HOME/${HALFCYCLE_DIR}/${ENGAGEMENTS_DIR}/<engagement-id>/${ENV_FILENAME}
-# written owner-only by \`npx halfcycle\`. What this repository holds is the
+# written owner-only by \`${bareHalfcycleCommand()}\`. 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
@@ -7924,8 +8095,8 @@ halfcycle_env_file() {
 
 // dist/identity.js
 import { execFileSync } from "node:child_process";
-import { existsSync as existsSync2, linkSync, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname2, isAbsolute, join as join4 } from "node:path";
+import { existsSync as existsSync3, linkSync, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3, isAbsolute, join as join5 } 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.';
 var PROJECT_IDENTITY_REL = ".halfcycle/project.json";
@@ -8056,7 +8227,7 @@ function readIgnoredPaths(targetRepoRoot, paths) {
   const toplevel = git(targetRepoRoot, ["rev-parse", "--show-toplevel"]);
   if (toplevel === null)
     return null;
-  return ignored.map((entry) => isAbsolute(entry.source) ? entry : { ...entry, source: join4(toplevel, entry.source) });
+  return ignored.map((entry) => isAbsolute(entry.source) ? entry : { ...entry, source: join5(toplevel, entry.source) });
 }
 function mintIdentity(targetRepoRoot) {
   return {
@@ -8067,10 +8238,10 @@ function mintIdentity(targetRepoRoot) {
   };
 }
 function plannedRemoteRepair(targetRepoRoot) {
-  const path = join4(targetRepoRoot, PROJECT_IDENTITY_REL);
+  const path = join5(targetRepoRoot, PROJECT_IDENTITY_REL);
   let onDisk;
   try {
-    const parsed = JSON.parse(readFileSync3(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
       return null;
     onDisk = parsed;
@@ -8089,7 +8260,7 @@ function plannedRemoteRepair(targetRepoRoot) {
   });
 }
 function replaceProjectIdentityFile(targetRepoRoot, text) {
-  const path = join4(targetRepoRoot, PROJECT_IDENTITY_REL);
+  const path = join5(targetRepoRoot, PROJECT_IDENTITY_REL);
   const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
   try {
     writeFileSync3(temporary, text, { encoding: "utf-8", flag: "wx" });
@@ -8100,8 +8271,8 @@ function replaceProjectIdentityFile(targetRepoRoot, text) {
   }
 }
 function planProjectIdentity(targetRepoRoot) {
-  const path = join4(targetRepoRoot, PROJECT_IDENTITY_REL);
-  if (!existsSync2(path)) {
+  const path = join5(targetRepoRoot, PROJECT_IDENTITY_REL);
+  if (!existsSync3(path)) {
     return { action: "add", after: serializeProjectIdentity(mintIdentity(targetRepoRoot)) };
   }
   const repaired = plannedRemoteRepair(targetRepoRoot);
@@ -8109,7 +8280,7 @@ function planProjectIdentity(targetRepoRoot) {
     return { action: "change", after: repaired };
   let current;
   try {
-    current = readFileSync3(path, "utf-8");
+    current = readFileSync4(path, "utf-8");
   } catch {
     current = null;
   }
@@ -8119,8 +8290,8 @@ function serializeProjectIdentity(identity) {
   return JSON.stringify(identity, null, 2) + "\n";
 }
 function createProjectIdentityFile(targetRepoRoot, text) {
-  const path = join4(targetRepoRoot, PROJECT_IDENTITY_REL);
-  mkdirSync3(dirname2(path), { recursive: true });
+  const path = join5(targetRepoRoot, PROJECT_IDENTITY_REL);
+  mkdirSync3(dirname3(path), { recursive: true });
   const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
   try {
     writeFileSync3(temporary, text ?? serializeProjectIdentity(mintIdentity(targetRepoRoot)), {
@@ -8139,8 +8310,8 @@ function createProjectIdentityFile(targetRepoRoot, text) {
 }
 
 // dist/install-plan.js
-import { existsSync as existsSync4, readFileSync as readFileSync5 } from "node:fs";
-import { join as join6, posix } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "node:fs";
+import { join as join7, posix } from "node:path";
 
 // dist/install-manifest.js
 import { Buffer as Buffer2 } from "node:buffer";
@@ -8278,11 +8449,15 @@ function parseManifest(text) {
     "hooksCreated",
     "permissionsCreated",
     "denyCreated",
-    "statusLineSha256"
+    "statusLineSha256",
+    "attributionSha256"
   ], '"settings"');
   if (s["statusLineSha256"] !== void 0 && (typeof s["statusLineSha256"] !== "string" || !HEX64.test(s["statusLineSha256"]))) {
     throw new UnreadableManifestError('"settings.statusLineSha256" is not a hash');
   }
+  if (s["attributionSha256"] !== void 0 && (typeof s["attributionSha256"] !== "string" || !HEX64.test(s["attributionSha256"]))) {
+    throw new UnreadableManifestError('"settings.attributionSha256" is not a hash');
+  }
   const settings = {
     created: bool(s["created"], "settings.created"),
     adopted: bool(s["adopted"], "settings.adopted"),
@@ -8293,7 +8468,8 @@ function parseManifest(text) {
     hooksCreated: bool(s["hooksCreated"], "settings.hooksCreated"),
     permissionsCreated: bool(s["permissionsCreated"], "settings.permissionsCreated"),
     denyCreated: bool(s["denyCreated"], "settings.denyCreated"),
-    ...typeof s["statusLineSha256"] === "string" ? { statusLineSha256: s["statusLineSha256"] } : {}
+    ...typeof s["statusLineSha256"] === "string" ? { statusLineSha256: s["statusLineSha256"] } : {},
+    ...typeof s["attributionSha256"] === "string" ? { attributionSha256: s["attributionSha256"] } : {}
   };
   let mcp;
   if (raw["mcp"] !== void 0) {
@@ -8400,6 +8576,7 @@ function recordSettings(draft, observed) {
     return;
   }
   const statusLineSha256 = observed.statusLineSha256 ?? prev.statusLineSha256;
+  const attributionSha256 = observed.attributionSha256 ?? prev.attributionSha256;
   draft.settings = {
     created: prev.created,
     adopted: prev.adopted,
@@ -8410,7 +8587,8 @@ function recordSettings(draft, observed) {
     hooksCreated: prev.hooksCreated,
     permissionsCreated: prev.permissionsCreated,
     denyCreated: prev.denyCreated,
-    ...statusLineSha256 !== void 0 ? { statusLineSha256 } : {}
+    ...statusLineSha256 !== void 0 ? { statusLineSha256 } : {},
+    ...attributionSha256 !== void 0 ? { attributionSha256 } : {}
   };
 }
 function recordDenyRetired(draft, hashes) {
@@ -8491,8 +8669,8 @@ function union(a, b) {
 }
 
 // dist/scan.js
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join6 } from "node:path";
 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",
@@ -8515,7 +8693,7 @@ var LAYER_ARTEFACT_PATHS = {
 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) => existsSync3(join5(targetRepo, p)));
+    const found = paths.filter((p) => existsSync4(join6(targetRepo, p)));
     if (found.length > 0) {
       layers[layer] = {
         value: "asserted",
@@ -8529,17 +8707,17 @@ function scanLayers(targetRepo, scannedAt = (/* @__PURE__ */ new Date()).toISOSt
 }
 var BOOTSTRAP_STATE_REL = ".halfcycle/state.json";
 function planBootstrapScan(targetRepo) {
-  const statePath = join5(targetRepo, BOOTSTRAP_STATE_REL);
-  if (existsSync3(statePath)) {
-    const existing = JSON.parse(readFileSync4(statePath, "utf-8"));
+  const statePath = join6(targetRepo, BOOTSTRAP_STATE_REL);
+  if (existsSync4(statePath)) {
+    const existing = JSON.parse(readFileSync5(statePath, "utf-8"));
     return { state: existing, text: null };
   }
   const state = scanLayers(targetRepo);
   return { state, text: JSON.stringify(state, null, 2) + "\n" };
 }
 function writeBootstrapState(targetRepo, text) {
-  mkdirSync4(join5(targetRepo, ".halfcycle"), { recursive: true });
-  writeFileSync4(join5(targetRepo, BOOTSTRAP_STATE_REL), text, "utf-8");
+  mkdirSync4(join6(targetRepo, ".halfcycle"), { recursive: true });
+  writeFileSync4(join6(targetRepo, BOOTSTRAP_STATE_REL), text, "utf-8");
 }
 
 // dist/install-plan.js
@@ -8681,7 +8859,7 @@ function kindOf(rel) {
 }
 var STEPS = /* @__PURE__ */ new WeakMap();
 function planInstall(options) {
-  const { targetRepo, engagementId, engagementType, credential, home, env, createdByAccountId } = options;
+  const { targetRepo, engagementId, engagementType, credential, home, env, createdByAccountId, serviceUrl } = options;
   const preview = engagementId === void 0;
   if (!preview) {
     assertEngagementId(engagementId);
@@ -8689,12 +8867,12 @@ function planInstall(options) {
       throw new Error("[halfcycle] a plan for a project needs its kind as well as its id.");
     }
   }
-  if (!existsSync4(targetRepo)) {
+  if (!existsSync5(targetRepo)) {
     throw new Error(`[halfcycle] Target repo does not exist: ${targetRepo}`);
   }
   const writeSet = closedWriteSet();
   const previous = readPreviousManifest(targetRepo);
-  const dirsBefore = new Set([...writeSet.dirs].filter((dir) => existsSync4(join6(targetRepo, dir))));
+  const dirsBefore = new Set([...writeSet.dirs].filter((dir) => existsSync5(join7(targetRepo, dir))));
   const { version, commands } = planCommandStubs(targetRepo, previous, writeSet);
   const codexSkills = planCodexSkills(targetRepo, previous, writeSet);
   const vendored = planVendoredBinary(targetRepo);
@@ -8716,12 +8894,12 @@ function planInstall(options) {
   const gitattributes = planGitattributes(targetRepo);
   const identity = planProjectIdentity(targetRepo);
   if (identity.after === null)
-    readFileSync5(join6(targetRepo, PROJECT_IDENTITY_REL));
+    readFileSync6(join7(targetRepo, PROJECT_IDENTITY_REL));
   const credentialPlan = !preview && credential !== void 0 ? planEngagementCredential(credential, engagementId, home) : null;
   const credentialWrite = credentialPlan === null ? null : { outcome: credentialPlan.outcome, existed: credentialPlan.existed, path: engagementEnvPath(engagementId, home) };
   const storedAfter = credentialPlan?.storedAfter ?? (preview ? Object.fromEntries(ENGAGEMENT_ENV_KEYS.map((key) => [key, "supplied at sign-in"])) : readEngagementEnv(engagementId, home) ?? {});
   const legacy = migrateLegacyEnvLocal(targetRepo, storedAfter);
-  const pin = preview ? planBundlePinPreview(targetRepo, version, home) : planBundlePin(targetRepo, version, engagementId, engagementType, createdByAccountId, credential?.methodVersion);
+  const pin = preview ? planBundlePinPreview(targetRepo, version, home) : planBundlePin(targetRepo, version, engagementId, engagementType, createdByAccountId, credential?.methodVersion, credential?.serviceUrl ?? serviceUrl);
   const crew = planCrewRoster(targetRepo);
   const crewProfiles = planCrewProfiles(targetRepo, previous, writeSet);
   const scan = { text: planBootstrapScan(targetRepo).text };
@@ -8849,7 +9027,7 @@ function entriesOf(steps, record2) {
     }
   };
   const pending = (rel) => {
-    const there = existsSync4(join6(targetRepo, rel));
+    const there = existsSync5(join7(targetRepo, rel));
     entries.push({ path: rel, action: there ? "change" : "add", kind: kindOf(rel), bytes: PENDING });
   };
   steps.commands.forEach(fromFile);
@@ -8897,7 +9075,7 @@ function entriesOf(steps, record2) {
         action: "leave",
         kind: "codex-server",
         bytes: null,
-        ...existsSync4(join6(targetRepo, CODEX_CONFIG_REL2)) ? { yours: true } : {}
+        ...existsSync5(join7(targetRepo, CODEX_CONFIG_REL2)) ? { yours: true } : {}
       });
       break;
   }
@@ -8976,10 +9154,10 @@ function applyInstallPlan(plan) {
   putPlannedCodexHooks(targetRepo, steps.codexHooks);
   putPlannedCodexConfig(targetRepo, steps.codexConfig);
   const gitignore = putPlannedGitignore(targetRepo, steps.gitignore);
-  const gitignorePath = join6(targetRepo, GITIGNORE_REL);
-  const gitignoreAfter = existsSync4(gitignorePath) ? readFileSync5(gitignorePath, "utf-8") : null;
+  const gitignorePath = join7(targetRepo, GITIGNORE_REL);
+  const gitignoreAfter = existsSync5(gitignorePath) ? readFileSync6(gitignorePath, "utf-8") : null;
   const gitattributes = putPlannedGitattributes(targetRepo, steps.gitattributes);
-  const gitattributesAfter = readTextOrNull(join6(targetRepo, GITATTRIBUTES_REL));
+  const gitattributesAfter = readTextOrNull(join7(targetRepo, GITATTRIBUTES_REL));
   writeProjectIdentity(targetRepo, steps.identity);
   const credential = steps.credential;
   const credentialOutcome = steps.credentialWrite !== null && credential !== void 0 ? writeEngagementCredential(credential, engagementId, steps.home) : null;
@@ -9000,9 +9178,9 @@ function applyInstallPlan(plan) {
     gitattributesAfter,
     credential: credentialOutcome,
     legacy,
-    bytesAfter: (rel) => readFileSync5(join6(targetRepo, rel)),
-    dirExistsAfter: (dir) => existsSync4(join6(targetRepo, dir)),
-    stateExistsAfter: existsSync4(join6(targetRepo, BOOTSTRAP_STATE_REL))
+    bytesAfter: (rel) => readFileSync6(join7(targetRepo, rel)),
+    dirExistsAfter: (dir) => existsSync5(join7(targetRepo, dir)),
+    stateExistsAfter: existsSync5(join7(targetRepo, BOOTSTRAP_STATE_REL))
   });
   const record2 = planInstallRecord(targetRepo, manifestText);
   putPlannedFile(targetRepo, record2);
@@ -9057,7 +9235,7 @@ function withoutHalfcycleCommands(entry, halfcycleCommands) {
   const remaining = entry.hooks.filter((h) => !isHalfcycleCommand(h, halfcycleCommands));
   return remaining.length > 0 ? { ...entry, hooks: remaining } : null;
 }
-function mergeSettings(existing, generated, retiredOurs, statusLine) {
+function mergeSettings(existing, generated, retiredOurs, statusLine, attribution) {
   const merged = { ...existing };
   if (generated.$schema !== void 0) {
     merged.$schema = generated.$schema;
@@ -9083,6 +9261,9 @@ function mergeSettings(existing, generated, retiredOurs, statusLine) {
   if (statusLine !== void 0 && !("statusLine" in existing)) {
     merged.statusLine = { ...statusLine };
   }
+  if (attribution !== void 0 && !("attribution" in existing) && !("includeCoAuthoredBy" in existing)) {
+    merged.attribution = { ...attribution };
+  }
   return merged;
 }
 function isPlainRecord(value) {
@@ -9360,8 +9541,8 @@ function crewProfileRel(agent, callsign) {
 }
 function crewProfileTarget(targetRepo, rel) {
   const folder2 = rel.startsWith(`${CLAUDE_AGENTS_DIR}/`) ? CLAUDE_AGENTS_DIR : CODEX_AGENTS_DIR;
-  const target = resolve(join7(targetRepo, rel));
-  if (dirname3(target) !== resolve(targetRepo, folder2)) {
+  const target = resolve(join8(targetRepo, rel));
+  if (dirname4(target) !== resolve(targetRepo, folder2)) {
     throw new Error(`[halfcycle] crew profile "${rel}" does not sit directly in ${folder2}.`);
   }
   return target;
@@ -9444,41 +9625,25 @@ function renderCrewProfiles(roster = CREW_ROSTER) {
     ])
   ];
 }
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname3(__filename);
-function findBundleRoot(startDir) {
-  let candidate = startDir;
-  for (let i = 0; i < 4; i++) {
-    const manifest = join7(candidate, ".claude-plugin", "plugin.json");
-    try {
-      if (existsSync5(manifest))
-        return candidate;
-    } catch {
-    }
-    candidate = dirname3(candidate);
-  }
-  return join7(startDir, "..");
-}
-var BUNDLE_ROOT = findBundleRoot(__dirname);
 function resolveVendoredBinary() {
   const candidates = [
-    join7(BUNDLE_ROOT, "bin", "bin.bundle.mjs"),
-    join7(BUNDLE_ROOT, "..", "runner", "dist", "bin.bundle.mjs")
+    join8(BUNDLE_ROOT, "bin", "bin.bundle.mjs"),
+    join8(BUNDLE_ROOT, "..", "runner", "dist", "bin.bundle.mjs")
   ];
   for (const candidate of candidates) {
-    if (existsSync5(candidate))
+    if (existsSync6(candidate))
       return candidate;
   }
   throw new Error(`[halfcycle] Cannot find the self-contained guard binary bin.bundle.mjs. This copy of the halfcycle package is incomplete \u2014 reinstall it, or rebuild it if you are working on it. Looked in: ${candidates.join(", ")}.`);
 }
 function resolvePreFilterShell() {
   const candidates = [
-    join7(BUNDLE_ROOT, "bin", PRE_FILTER_SHELL_FILENAME),
-    join7(BUNDLE_ROOT, "..", "runner", "dist", PRE_FILTER_SHELL_FILENAME)
+    join8(BUNDLE_ROOT, "bin", PRE_FILTER_SHELL_FILENAME),
+    join8(BUNDLE_ROOT, "..", "runner", "dist", PRE_FILTER_SHELL_FILENAME)
   ];
   for (const candidate of candidates) {
-    if (existsSync5(candidate))
-      return readFileSync6(candidate, "utf-8");
+    if (existsSync6(candidate))
+      return readFileSync7(candidate, "utf-8");
   }
   throw new Error(`[halfcycle] Cannot find ${PRE_FILTER_SHELL_FILENAME}. This copy of the halfcycle package is incomplete \u2014 reinstall it, or rebuild it if you are working on it. Looked in: ${candidates.join(", ")}.`);
 }
@@ -9517,7 +9682,7 @@ function isAllowlisted(targetRelPath) {
 var CREW_ROSTER_REL = ".halfcycle/crew.json";
 var CAPTURED_INDEX_REL = "test/fixtures/captured/manifest.json";
 function capturedIndexScaffold() {
-  return join7(BUNDLE_ROOT, "scaffolding", "test", "fixtures", "captured", "manifest.json");
+  return join8(BUNDLE_ROOT, "scaffolding", "test", "fixtures", "captured", "manifest.json");
 }
 var GITIGNORE_REL = ".gitignore";
 var GITATTRIBUTES_REL = ".gitattributes";
@@ -9586,20 +9751,22 @@ function closedWriteSet() {
       ...lfRules([...Object.keys(OWNED_GENERATED_HEADERS), ...RETIRED_WRITE_SET_FILES])
     ]),
     generatedSha256: sha256OfWhatThisVersionWrites(commands),
-    statusLineSha256: /* @__PURE__ */ new Set([canonicalSha256(HALFCYCLE_STATUS_LINE)])
+    statusLineSha256: /* @__PURE__ */ new Set([canonicalSha256(HALFCYCLE_STATUS_LINE)]),
+    attributionSha256: /* @__PURE__ */ new Set([canonicalSha256(HALFCYCLE_ATTRIBUTION)])
   };
 }
 function sha256OfWhatThisVersionWrites(commands) {
   const out = /* @__PURE__ */ new Map();
   const fromFile = (rel, src) => {
-    if (existsSync5(src))
-      out.set(rel, fileSha256(readFileSync6(src)));
+    if (existsSync6(src))
+      out.set(rel, fileSha256(readFileSync7(src)));
   };
   for (const cmd of commands) {
-    const srcFile = join7(BUNDLE_ROOT, ".claude-plugin", cmd.path);
-    fromFile(commandStubRel(cmd.name), srcFile);
-    if (existsSync5(srcFile)) {
-      out.set(skillRel(cmd.name), fileSha256(Buffer.from(codexSkillContent(cmd.name, readFileSync6(srcFile, "utf-8")), "utf-8")));
+    const srcFile = join8(BUNDLE_ROOT, ".claude-plugin", cmd.path);
+    if (existsSync6(srcFile)) {
+      const text = commandFileText(readFileSync7(srcFile, "utf-8"), ownVersion());
+      out.set(commandStubRel(cmd.name), fileSha256(Buffer.from(text, "utf-8")));
+      out.set(skillRel(cmd.name), fileSha256(Buffer.from(codexSkillContent(cmd.name, text), "utf-8")));
     }
   }
   for (const [rel, content] of hookScriptsThisVersionWrites())
@@ -9616,7 +9783,7 @@ function bytesAreOurs(path, bytes, recorded, writeSet) {
 }
 function readPreviousManifest(targetRepo) {
   try {
-    return parseManifest(readFileSync6(join7(targetRepo, INSTALL_MANIFEST_REL), "utf-8"));
+    return parseManifest(readFileSync7(join8(targetRepo, INSTALL_MANIFEST_REL), "utf-8"));
   } catch {
     return null;
   }
@@ -9646,7 +9813,8 @@ function recordSettingsMerge(draft, existing, generated, preexisted, merged) {
     hooksCreated: existing.hooks === void 0,
     permissionsCreated: existing.permissions === void 0,
     denyCreated: existing.permissions?.deny === void 0,
-    ...ourStatusLineSha256(merged) !== void 0 ? { statusLineSha256: ourStatusLineSha256(merged) } : {}
+    ...ourStatusLineSha256(merged) !== void 0 ? { statusLineSha256: ourStatusLineSha256(merged) } : {},
+    ...attributionWrittenThisRun(existing, merged) ? { attributionSha256: canonicalSha256(HALFCYCLE_ATTRIBUTION) } : {}
   });
 }
 function ourStatusLineSha256(settings) {
@@ -9655,6 +9823,11 @@ function ourStatusLineSha256(settings) {
   const hash = canonicalSha256(settings["statusLine"]);
   return hash === canonicalSha256(HALFCYCLE_STATUS_LINE) ? hash : void 0;
 }
+function attributionWrittenThisRun(existing, merged) {
+  if ("attribution" in existing || "includeCoAuthoredBy" in existing)
+    return false;
+  return "attribution" in merged && canonicalSha256(merged["attribution"]) === canonicalSha256(HALFCYCLE_ATTRIBUTION);
+}
 function recordMcpMerge(draft, existingText, writtenText) {
   const before = existingText === null ? void 0 : JSON.parse(existingText);
   const servers = isPlainObject3(before) ? before["mcpServers"] : void 0;
@@ -9720,8 +9893,8 @@ function findNotShared(targetRepo, manifest, collidedPaths) {
     for (let dir = posix2.dirname(rel); dir !== "."; dir = posix2.dirname(dir)) {
       let plain = dirVerdicts.get(dir);
       if (plain === void 0) {
-        const abs = join7(targetRepo, dir);
-        plain = !lstatOrNull(abs)?.isSymbolicLink() && lstatOrNull(join7(abs, ".git")) === null;
+        const abs = join8(targetRepo, dir);
+        plain = !lstatOrNull(abs)?.isSymbolicLink() && lstatOrNull(join8(abs, ".git")) === null;
         dirVerdicts.set(dir, plain);
       }
       if (!plain)
@@ -9735,7 +9908,7 @@ function findNotShared(targetRepo, manifest, collidedPaths) {
       ...merged,
       INSTALL_MANIFEST_REL
     ])
-  ].filter((rel) => !collided.has(rel)).filter((rel) => lstatOrNull(join7(targetRepo, rel)) !== null).filter(travelsThroughPlainDirs).sort();
+  ].filter((rel) => !collided.has(rel)).filter((rel) => lstatOrNull(join8(targetRepo, rel)) !== null).filter(travelsThroughPlainDirs).sort();
   const ignored = readIgnoredPaths(targetRepo, paths);
   if (ignored === null)
     return null;
@@ -9758,7 +9931,7 @@ function lstatOrNull(path) {
 }
 function readFileOrNull(path) {
   try {
-    return readFileSync6(path, "utf-8");
+    return readFileSync7(path, "utf-8");
   } catch {
     return null;
   }
@@ -9767,8 +9940,8 @@ function isPlainObject3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function readPluginManifest() {
-  const manifestPath = join7(BUNDLE_ROOT, ".claude-plugin", "plugin.json");
-  const raw = readFileSync6(manifestPath, "utf-8");
+  const manifestPath = join8(BUNDLE_ROOT, ".claude-plugin", "plugin.json");
+  const raw = readFileSync7(manifestPath, "utf-8");
   return JSON.parse(raw);
 }
 function parseCommandStub(raw, name) {
@@ -9811,6 +9984,9 @@ function codexSkillBody(name, sourceBody) {
   }
   return transformed;
 }
+function commandFileText(source, version) {
+  return rewriteHalfcycleCommands(source, releaseTagOfVersion(version));
+}
 function codexSkillContent(name, sourceRaw) {
   const { description, body } = parseCommandStub(sourceRaw, name);
   const transformed = codexSkillBody(name, body);
@@ -9823,14 +9999,14 @@ ${transformed}`;
 function planManifestCommands(manifest, targetRepo, previous, writeSet) {
   const recordedFiles = new Map((previous?.files ?? []).filter((file) => writeSet.files.has(file.path)).map((file) => [file.path, file]));
   return (manifest.commands ?? []).map((cmd) => {
-    const srcFile = join7(BUNDLE_ROOT, ".claude-plugin", cmd.path);
-    if (!existsSync5(srcFile)) {
+    const srcFile = join8(BUNDLE_ROOT, ".claude-plugin", cmd.path);
+    if (!existsSync6(srcFile)) {
       throw new Error(`[halfcycle] plugin.json declares command "${cmd.name}" at "${cmd.path}", but no file exists there (${srcFile}). The manifest and commands/ must agree.`);
     }
     const rel = commandStubRel(cmd.name);
-    const content = readFileSync6(srcFile, "utf-8");
+    const content = commandFileText(readFileSync7(srcFile, "utf-8"), ownVersion());
     const recorded = recordedFiles.get(rel);
-    const planned = decideCollisionSafe(join7(targetRepo, rel), targetRepo, content, (current) => bytesAreOurs(rel, current, recorded, writeSet));
+    const planned = decideCollisionSafe(join8(targetRepo, rel), targetRepo, content, (current) => bytesAreOurs(rel, current, recorded, writeSet));
     return { ...planned, editedCollided: planned.outcome === "collided" && recorded !== void 0 };
   });
 }
@@ -9840,8 +10016,8 @@ function putPlannedFile(targetRepoRoot, planned) {
   if (!isAllowlisted(planned.rel)) {
     throw new Error(`[halfcycle] Write-allowlist violation: attempted to write "${planned.rel}". Only the method surface and scaffolding paths are writable.`);
   }
-  const target = join7(targetRepoRoot, planned.rel);
-  mkdirSync5(dirname3(target), { recursive: true });
+  const target = join8(targetRepoRoot, planned.rel);
+  mkdirSync5(dirname4(target), { recursive: true });
   writeFileSync5(target, planned.text, "utf-8");
 }
 function writeAllowlisted(targetAbsPath, targetRepoRoot, content, writtenPaths) {
@@ -9851,7 +10027,7 @@ function writeAllowlisted(targetAbsPath, targetRepoRoot, content, writtenPaths)
   }
   if (readFileOrNull(targetAbsPath) === content)
     return;
-  mkdirSync5(dirname3(targetAbsPath), { recursive: true });
+  mkdirSync5(dirname4(targetAbsPath), { recursive: true });
   writeFileSync5(targetAbsPath, content, "utf-8");
   writtenPaths.push(rel);
 }
@@ -9860,7 +10036,7 @@ function decideCollisionSafe(targetAbsPath, targetRepoRoot, content, isOurs) {
   if (!isAllowlisted(rel)) {
     throw new Error(`[halfcycle] Write-allowlist violation: attempted to write "${rel}". Only the method surface and scaffolding paths are writable.`);
   }
-  const current = existsSync5(targetAbsPath) ? readFileSync6(targetAbsPath) : null;
+  const current = existsSync6(targetAbsPath) ? readFileSync7(targetAbsPath) : null;
   const text = inLineEndingOf(current?.toString("utf-8") ?? null, content);
   if (current === null)
     return { rel, text, outcome: "written", replacedExisting: false };
@@ -9888,7 +10064,7 @@ function decideOwned(targetAbsPath, targetRepoRoot, content) {
   const text = inLineEndingOf(current, content);
   if (current === text)
     return { rel, text, outcome: "skipped", replacedExisting: false };
-  return { rel, text, outcome: "written", replacedExisting: existsSync5(targetAbsPath) };
+  return { rel, text, outcome: "written", replacedExisting: existsSync6(targetAbsPath) };
 }
 var GENERATED_HEADER_LINE_INDEX = 1;
 function decideOwnedGenerated(targetAbsPath, targetRepoRoot, content, generatedMarker) {
@@ -9896,9 +10072,9 @@ function decideOwnedGenerated(targetAbsPath, targetRepoRoot, content, generatedM
   if (!isAllowlisted(rel)) {
     throw new Error(`[halfcycle] Write-allowlist violation: attempted to write "${rel}". Only the method surface and scaffolding paths are writable.`);
   }
-  if (!existsSync5(targetAbsPath))
+  if (!existsSync6(targetAbsPath))
     return { rel, text: content, outcome: "written", replacedExisting: false };
-  const current = readFileSync6(targetAbsPath, "utf-8");
+  const current = readFileSync7(targetAbsPath, "utf-8");
   if (current === content)
     return { rel, text: content, outcome: "skipped", replacedExisting: false };
   const headerLine = current.split("\n")[GENERATED_HEADER_LINE_INDEX] ?? "";
@@ -9914,7 +10090,7 @@ function recordOwnedGenerated(report, planned) {
   return planned.outcome;
 }
 function recordOwned(report, targetAbsPath, targetRepoRoot, content, rel) {
-  const existedBefore = existsSync5(targetAbsPath);
+  const existedBefore = existsSync6(targetAbsPath);
   const outcome = writeOwned(targetAbsPath, targetRepoRoot, content);
   record(report, outcome, rel);
   if (outcome === "written" && existedBefore)
@@ -9936,8 +10112,8 @@ var DENY_PATTERNS = [
 ];
 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 readExistingSettings(targetRepo) {
-  const settingsPath = join7(targetRepo, SETTINGS_REL);
-  return existsSync5(settingsPath) ? JSON.parse(readFileSync6(settingsPath, "utf-8")) : void 0;
+  const settingsPath = join8(targetRepo, SETTINGS_REL);
+  return existsSync6(settingsPath) ? JSON.parse(readFileSync7(settingsPath, "utf-8")) : void 0;
 }
 var SettingsParseRefused = class extends Error {
   constructor(message) {
@@ -9946,33 +10122,37 @@ var SettingsParseRefused = class extends Error {
   }
 };
 function settingsParseRefusal(targetRepo, err) {
-  const file = join7(targetRepo, SETTINGS_REL);
+  const file = join8(targetRepo, SETTINGS_REL);
   const offset = /position (\d+)/.exec(err instanceof Error ? err.message : "")?.[1];
   let where = "";
   if (offset !== void 0) {
-    const before = readFileSync6(file, "utf-8").slice(0, Number(offset)).split("\n");
+    const before = readFileSync7(file, "utf-8").slice(0, Number(offset)).split("\n");
     where = ` (line ${before.length}, column ${before[before.length - 1].length + 1})`;
   }
-  return `${file} could not be read as JSON${where} \u2014 fix it and run "npx halfcycle" again.`;
+  return `${file} could not be read as JSON${where} \u2014 fix it and run "${ownBareCommand()}" again.`;
 }
 var SETTINGS_SCHEMA = "https://json.schemastore.org/claude-code-settings.json";
 var HALFCYCLE_STATUS_LINE = Object.freeze({
   type: "command",
   command: 'bash "$CLAUDE_PROJECT_DIR"/.claude/hooks/guard-runner.sh statusline'
 });
+var HALFCYCLE_ATTRIBUTION = Object.freeze({
+  commit: "",
+  pr: ""
+});
 function statusLineSetElsewhere(targetRepo, home = homedir3(), env = process.env) {
-  const places = [join7(targetRepo, ".claude", "settings.local.json"), join7(home, ".claude", "settings.json")];
+  const places = [join8(targetRepo, ".claude", "settings.local.json"), join8(home, ".claude", "settings.json")];
   const configDir = env["CLAUDE_CONFIG_DIR"];
   if (configDir !== void 0 && configDir !== "") {
-    const expanded = configDir === "~" ? home : configDir.startsWith("~/") ? join7(home, configDir.slice(2)) : configDir;
-    places.push(join7(isAbsolute2(expanded) ? expanded : resolve(expanded), "settings.json"));
+    const expanded = configDir === "~" ? home : configDir.startsWith("~/") ? join8(home, configDir.slice(2)) : configDir;
+    places.push(join8(isAbsolute2(expanded) ? expanded : resolve(expanded), "settings.json"));
   }
   return places.some((path) => {
-    if (!existsSync5(path))
+    if (!existsSync6(path))
       return false;
     let value;
     try {
-      value = JSON.parse(readFileSync6(path, "utf-8"));
+      value = JSON.parse(readFileSync7(path, "utf-8"));
     } catch {
       return true;
     }
@@ -10315,8 +10495,10 @@ ${GENERATED_USER_PROMPT_SCOPE_HEADER} the Halfcycle installer, now also for the
 # "autonomy on" or "autonomy off". Also lets the person who is typing let one
 # step Halfcycle paused run once, by typing "allow", or "allow" and the step's
 # number ("allow 2"), as the whole prompt, and change
-# how a build is paced, by typing "faster", "run 5 agents", "keep 30% free" or
-# "use up to 70%" as the whole prompt, and answer a phase's usage limit by
+# how many agents a build runs, by typing "faster", "run 5 agents", "run 20
+# agents at once", "max pace" or "as many agents as possible", or how much is
+# kept free, by typing "keep 30% free" or "use up to 70%", as the whole prompt,
+# with or without a build running, and answer a phase's usage limit by
 # typing "keep going", "stop", "limit it to 1.5 times" or "limit it to 10% of
 # the week" as the whole prompt.
 #
@@ -10325,7 +10507,7 @@ ${GENERATED_USER_PROMPT_SCOPE_HEADER} the Halfcycle installer, now also for the
 # any whitespace (typed, or escaped in the input), with "approve ", "send back ",
 # "accept ", "question ", "carry ", "drop ", "reject " or "autonomy ", in any case,
 # or is "allow" (alone, or with spaces and a number of up to four digits), one
-# of the five pacing phrases or one of the usage-limit phrases
+# of the pacing phrases or one of the usage-limit phrases
 # and nothing else but whitespace,
 # it exits 0 with no output, and Node never starts. A quote inside any other field arrives
 # escaped, so no other field (the folder the session is in, for one) can read as
@@ -10353,7 +10535,11 @@ IFS= read -r -d '' HC_INPUT || true
 # \\u escape, or as the UTF-8 bytes of a Unicode space. Compared byte for byte.
 HC_LEAD='[[:space:]]|\\\\[nrtf]|\\\\u(000[9a-d]|0020|00a0|1680|200[0-9a]|202[89f]|205f|3000|feff)'
 HC_LEAD="$HC_LEAD|"$'\\xc2\\xa0|\\xe1\\x9a\\x80|\\xe2\\x80[\\x80-\\x8a\\xa8\\xa9\\xaf]|\\xe2\\x81\\x9f|\\xe3\\x80\\x80|\\xef\\xbb\\xbf'
-if ! printf '%s' "$HC_INPUT" | LC_ALL=C grep -Eiq "\\"prompt\\"[[:space:]]*:[[:space:]]*\\"($HC_LEAD)*((approve|send back|accept|question|carry|drop|reject|autonomy|decline) |allow( +[0-9]{1,4})?($HC_LEAD)*\\"|(faster|go faster|run [0-9]{1,3} agents?|keep [0-9]{1,3}% free|use up to [0-9]{1,3}%|keep going|stop|stop here|limit it to [0-9]{1,9}(\\.[0-9]{1,2})? (times|million|billion|million tokens|billion tokens)|limit it to [0-9]{1,3}% of the week)($HC_LEAD)*\\")"; then
+# The pace phrases, matched whole after an optional "please" (the verb's own
+# reading is the same set or narrower): a number of agents, the most, faster, a
+# vague amount it answers with an ask for a number, or a free share.
+HC_PACE='((run|use|start|go)( +with| +at)? +)?(up +to +|the +)?(faster|more +agents|(-?[0-9]+(\\.[0-9]+)?|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty) +agents?|(max|maximum|full|top) +(pace|speed)|(max|maximum)( +possible)?( +number +of)? +agents|as +many +agents +as +(possible|you +can)|(lots +of|a +lot +of|loads +of|plenty +of|many|some|several|a +few|a +bunch +of) +agents)( +(at +once|at +a +time|in +parallel|concurrently|simultaneously|together))?|keep +[0-9]{1,3}% +free|use +up +to +[0-9]{1,3}%'
+if ! printf '%s' "$HC_INPUT" | LC_ALL=C grep -Eiq "\\"prompt\\"[[:space:]]*:[[:space:]]*\\"($HC_LEAD)*((approve|send back|accept|question|carry|drop|reject|autonomy|decline) |allow( +[0-9]{1,4})?($HC_LEAD)*\\"|(keep going|stop|stop here|limit it to [0-9]{1,9}(\\.[0-9]{1,2})? (times|million|billion|million tokens|billion tokens)|limit it to [0-9]{1,3}% of the week)($HC_LEAD)*\\"|(please,? +)?($HC_PACE)(,? +please)?[.!]*($HC_LEAD)*\\")"; then
   exit 0
 fi
 
@@ -10446,12 +10632,12 @@ function removeRetiredGeneratedFile(targetRepo, rel, headerLineIndex, knownHeade
   return decided === "removed" ? removePlannedRetiredFile(targetRepo, rel) : decided;
 }
 function decideRetiredRemoval(targetRepo, rel, headerLineIndex, knownHeaderHashes) {
-  const path = join7(targetRepo, rel);
-  if (!existsSync5(path))
+  const path = join8(targetRepo, rel);
+  if (!existsSync6(path))
     return "absent";
   let raw;
   try {
-    raw = readFileSync6(path, "utf-8");
+    raw = readFileSync7(path, "utf-8");
   } catch {
     return "failed";
   }
@@ -10465,7 +10651,7 @@ function decideRetiredRemoval(targetRepo, rel, headerLineIndex, knownHeaderHashe
 }
 function removePlannedRetiredFile(targetRepo, rel) {
   try {
-    rmSync2(join7(targetRepo, rel));
+    rmSync2(join8(targetRepo, rel));
   } catch {
     return "failed";
   }
@@ -10486,7 +10672,7 @@ var MCP_HEADERS_HELPER_COMMAND = `node -e "${nodeFloorProgram([
   `const u=p.dirname(d);`,
   `if(u===d)break;`,
   `d=u}`,
-  `console.error('halfcycle: no ${VENDORED_BIN_REL} at or above '+process.cwd()+'; run npx halfcycle in the project folder');`,
+  `console.error('halfcycle: no ${VENDORED_BIN_REL} at or above '+process.cwd()+'; run ${ownBareCommand()} in the project folder');`,
   `process.exit(1)`
 ].join(""))}"`;
 var CODEX_ADDRESS_PATTERN = /^https?:\/\/[A-Za-z0-9.-]+(:[0-9]{1,5})?(\/[A-Za-z0-9._-]+)*\/mcp$/;
@@ -10510,7 +10696,7 @@ function codexMcpHeadersHelperCommand(address) {
     `if(u===d)break;`,
     `d=u}`,
     `if(b===''){`,
-    `console.error('halfcycle: no ${VENDORED_BIN_REL} at or above '+process.cwd()+'; run npx halfcycle in the project folder');`,
+    `console.error('halfcycle: no ${VENDORED_BIN_REL} at or above '+process.cwd()+'; run ${ownBareCommand()} in the project folder');`,
     `n()}else{`,
     `const r=c.spawnSync(process.execPath,[b,'mcp-headers','--url','${address}'],{stdio:['ignore','pipe','inherit']});`,
     `if(r.status===0&&r.stdout&&r.stdout.length){o=1;process.stdout.write(r.stdout)}else{n()}}`,
@@ -10848,9 +11034,9 @@ function gitignoreCovers(content) {
   return REQUIRED_GITIGNORE_ENTRIES.every((entry) => lines.has(entry));
 }
 function planGitignore(targetRepo) {
-  const gitignorePath = join7(targetRepo, GITIGNORE_REL);
+  const gitignorePath = join8(targetRepo, GITIGNORE_REL);
   const header = GITIGNORE_HEADER;
-  const before = existsSync5(gitignorePath) ? readFileSync6(gitignorePath, "utf-8") : null;
+  const before = existsSync6(gitignorePath) ? readFileSync7(gitignorePath, "utf-8") : null;
   if (before === null) {
     return { before, after: [header, ...REQUIRED_GITIGNORE_ENTRIES].join("\n") + "\n", outcome: "written" };
   }
@@ -10866,7 +11052,7 @@ function putPlannedGitignore(targetRepo, planned) {
   if (planned.outcome !== "written" || planned.after === null)
     return planned.outcome;
   try {
-    writeFileSync5(join7(targetRepo, GITIGNORE_REL), planned.after, "utf-8");
+    writeFileSync5(join8(targetRepo, GITIGNORE_REL), planned.after, "utf-8");
     return "written";
   } catch {
     return "failed";
@@ -10875,7 +11061,7 @@ function putPlannedGitignore(targetRepo, planned) {
 var GITATTRIBUTES_HEADER = "# Halfcycle \u2014 generated scripts keep LF line endings";
 function readTextOrNull(path) {
   try {
-    return readFileSync6(path, "utf-8");
+    return readFileSync7(path, "utf-8");
   } catch {
     return null;
   }
@@ -10885,12 +11071,12 @@ function lfRules(paths) {
 }
 var REQUIRED_GITATTRIBUTES_RULES = lfRules(Object.keys(OWNED_GENERATED_HEADERS));
 function planGitattributes(targetRepo) {
-  const path = join7(targetRepo, GITATTRIBUTES_REL);
+  const path = join8(targetRepo, GITATTRIBUTES_REL);
   const rules = REQUIRED_GITATTRIBUTES_RULES;
   const before = readTextOrNull(path);
   if (lstatOrNull(path)?.isSymbolicLink() === true)
     return { before, after: before, outcome: "failed" };
-  if (!existsSync5(path)) {
+  if (!existsSync6(path)) {
     return { before, after: [GITATTRIBUTES_HEADER, ...rules].join("\n") + "\n", outcome: "written" };
   }
   if (before === null)
@@ -10908,7 +11094,7 @@ function putPlannedGitattributes(targetRepo, planned) {
   if (planned.outcome !== "written" || planned.after === null)
     return planned.outcome;
   try {
-    writeAllowlisted(join7(targetRepo, GITATTRIBUTES_REL), targetRepo, planned.after, []);
+    writeAllowlisted(join8(targetRepo, GITATTRIBUTES_REL), targetRepo, planned.after, []);
     return "written";
   } catch {
     return "failed";
@@ -10927,12 +11113,12 @@ function previousPinForEngagement(targetRepoRoot, engagementId) {
 function nonEmpty(value) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
 }
-function planBundlePin(targetRepoRoot, version, engagementId, engagementType, createdByAccountId, methodVersion) {
+function planBundlePin(targetRepoRoot, version, engagementId, engagementType, createdByAccountId, methodVersion, serviceUrl) {
   const previous = previousPinForEngagement(targetRepoRoot, engagementId);
   const carried = pinCreatedByAccountId(previous) ?? nonEmpty(createdByAccountId);
   const carriedMethodVersion = nonEmpty(methodVersion) ?? nonEmpty(previous?.methodVersion);
   const installedAt = nonEmpty(previous?.installedAt) ?? (/* @__PURE__ */ new Date()).toISOString();
-  const projectPage = projectPageUrl(engagementId);
+  const projectPage = projectPageUrl(engagementId, serviceUrl);
   const pin = {
     version,
     engagementId,
@@ -10942,7 +11128,7 @@ function planBundlePin(targetRepoRoot, version, engagementId, engagementType, cr
     ...carriedMethodVersion !== void 0 ? { methodVersion: carriedMethodVersion } : {},
     ...projectPage !== void 0 ? { projectPage } : {}
   };
-  const current = readFileOrNull(join7(targetRepoRoot, BUNDLE_PIN_REL));
+  const current = readFileOrNull(join8(targetRepoRoot, BUNDLE_PIN_REL));
   const text = inLineEndingOf(current, JSON.stringify(pin, null, 2) + "\n");
   return {
     rel: BUNDLE_PIN_REL,
@@ -10970,10 +11156,10 @@ function planBundlePinPreview(targetRepoRoot, version, home) {
   if (pinned === null || pinned.engagementId !== existing.engagementId || pinned.credential === void 0) {
     return null;
   }
-  return planBundlePin(targetRepoRoot, version, existing.engagementId, existing.engagementType, void 0, void 0);
+  return planBundlePin(targetRepoRoot, version, existing.engagementId, existing.engagementType, void 0, void 0, pinned.credential.serviceUrl);
 }
 function writeBundlePin(targetRepoRoot, planned, writtenPaths) {
-  const pinPath = join7(targetRepoRoot, BUNDLE_PIN_REL);
+  const pinPath = join8(targetRepoRoot, BUNDLE_PIN_REL);
   writeAllowlisted(pinPath, targetRepoRoot, planned.text, writtenPaths);
 }
 function updatePinnedMethodVersion(repoRoot, engagementId, version) {
@@ -10985,7 +11171,7 @@ function updatePinnedMethodVersion(repoRoot, engagementId, version) {
   }
   if (pin === null || pin.engagementId !== engagementId)
     return;
-  const pinPath = join7(repoRoot, BUNDLE_PIN_REL);
+  const pinPath = join8(repoRoot, BUNDLE_PIN_REL);
   const updated = { ...pin, methodVersion: version };
   const pinText = inLineEndingOf(readFileOrNull(pinPath), JSON.stringify(updated, null, 2) + "\n");
   try {
@@ -11005,17 +11191,17 @@ function renderCrewRoster() {
 }
 function writeCrewRoster(targetRepoRoot, report) {
   const rendered = renderCrewRoster();
-  const crewPath = join7(targetRepoRoot, CREW_ROSTER_REL);
+  const crewPath = join8(targetRepoRoot, CREW_ROSTER_REL);
   return recordOwned(report, crewPath, targetRepoRoot, rendered, CREW_ROSTER_REL);
 }
 function pinCreatedByAccountId(pin) {
   return nonEmpty(pin?.createdByAccountId) ?? nonEmpty(pin?.accountId);
 }
 function readBundlePin(targetRepoRoot) {
-  const pinPath = join7(targetRepoRoot, BUNDLE_PIN_REL);
-  if (!existsSync5(pinPath))
+  const pinPath = join8(targetRepoRoot, BUNDLE_PIN_REL);
+  if (!existsSync6(pinPath))
     return null;
-  return JSON.parse(readFileSync6(pinPath, "utf-8"));
+  return JSON.parse(readFileSync7(pinPath, "utf-8"));
 }
 function readPinnedEngagement(targetRepoRoot, home) {
   const pin = readBundlePin(targetRepoRoot);
@@ -11038,7 +11224,7 @@ function readPinnedEngagement(targetRepoRoot, home) {
 }
 function readLegacyEnvLocal(targetRepoRoot) {
   try {
-    return parseEnvText(readFileSync6(join7(targetRepoRoot, LEGACY_ENV_LOCAL_REL), "utf-8"));
+    return parseEnvText(readFileSync7(join8(targetRepoRoot, LEGACY_ENV_LOCAL_REL), "utf-8"));
   } catch {
     return null;
   }
@@ -11090,7 +11276,7 @@ function writeEngagementCredential(credential, engagementId, home) {
 function planEngagementCredential(credential, engagementId, home) {
   let existing;
   try {
-    existing = readFileSync6(engagementEnvPath(engagementId, home), "utf-8");
+    existing = readFileSync7(engagementEnvPath(engagementId, home), "utf-8");
   } catch {
     existing = null;
   }
@@ -11133,12 +11319,12 @@ function engagementCredentialValues(credential, engagementId) {
 }
 var LEGACY_ENV_LOCAL_REL = ".env.local";
 function migrateLegacyEnvLocal(targetRepo, stored) {
-  const path = join7(targetRepo, LEGACY_ENV_LOCAL_REL);
-  if (!existsSync5(path))
+  const path = join8(targetRepo, LEGACY_ENV_LOCAL_REL);
+  if (!existsSync6(path))
     return { outcome: "absent", unbacked: [], missingForAdoption: [] };
   let raw;
   try {
-    raw = readFileSync6(path, "utf-8");
+    raw = readFileSync7(path, "utf-8");
   } catch {
     return { outcome: "failed", unbacked: [], missingForAdoption: [] };
   }
@@ -11164,7 +11350,7 @@ function migrateLegacyEnvLocal(targetRepo, stored) {
   return { outcome: "stripped", unbacked: [], missingForAdoption: [], keptText: kept.join("\n") };
 }
 function applyLegacyMigration(targetRepo, decided) {
-  const path = join7(targetRepo, LEGACY_ENV_LOCAL_REL);
+  const path = join8(targetRepo, LEGACY_ENV_LOCAL_REL);
   try {
     if (decided.outcome === "removed") {
       rmSync2(path);
@@ -11190,23 +11376,23 @@ function planCodexSkills(targetRepo, previous, writeSet) {
   const manifest = readPluginManifest();
   const recordedFiles = new Map((previous?.files ?? []).filter((file) => writeSet.files.has(file.path)).map((file) => [file.path, file]));
   return (manifest.commands ?? []).map((cmd) => {
-    const srcFile = join7(BUNDLE_ROOT, ".claude-plugin", cmd.path);
-    if (!existsSync5(srcFile)) {
+    const srcFile = join8(BUNDLE_ROOT, ".claude-plugin", cmd.path);
+    if (!existsSync6(srcFile)) {
       throw new Error(`[halfcycle] plugin.json declares command "${cmd.name}" at "${cmd.path}", but no file exists there (${srcFile}). The manifest and commands/ must agree.`);
     }
     const rel = skillRel(cmd.name);
-    const content = codexSkillContent(cmd.name, readFileSync6(srcFile, "utf-8"));
+    const content = codexSkillContent(cmd.name, commandFileText(readFileSync7(srcFile, "utf-8"), ownVersion()));
     const recorded = recordedFiles.get(rel);
-    const planned = decideCollisionSafe(join7(targetRepo, rel), targetRepo, content, (current) => bytesAreOurs(rel, current, recorded, writeSet));
+    const planned = decideCollisionSafe(join8(targetRepo, rel), targetRepo, content, (current) => bytesAreOurs(rel, current, recorded, writeSet));
     return { ...planned, editedCollided: planned.outcome === "collided" && recorded !== void 0 };
   });
 }
 function planVendoredBinary(targetRepo) {
-  return decideOwned(join7(targetRepo, ".halfcycle", "bin", "bin.bundle.mjs"), targetRepo, readFileSync6(resolveVendoredBinary(), "utf-8"));
+  return decideOwned(join8(targetRepo, ".halfcycle", "bin", "bin.bundle.mjs"), targetRepo, readFileSync7(resolveVendoredBinary(), "utf-8"));
 }
 function planSettings(targetRepo, previous, home, env) {
-  const settingsPath = join7(targetRepo, SETTINGS_REL);
-  const preexisted = existsSync5(settingsPath);
+  const settingsPath = join8(targetRepo, SETTINGS_REL);
+  const preexisted = existsSync6(settingsPath);
   const generated = JSON.parse(generateSettingsJson());
   let existing;
   try {
@@ -11216,7 +11402,7 @@ function planSettings(targetRepo, previous, home, env) {
   }
   const retiredOurs = retiredRulesThisInstallAdded(previous);
   const statusLine = statusLineSetElsewhere(targetRepo, home, env) ? void 0 : HALFCYCLE_STATUS_LINE;
-  const merged = mergeSettings(existing, generated, retiredOurs, statusLine);
+  const merged = mergeSettings(existing, generated, retiredOurs, statusLine, HALFCYCLE_ATTRIBUTION);
   const current = readFileOrNull(settingsPath);
   const text = inLineEndingOf(current, JSON.stringify(merged, null, 2) + "\n");
   const file = {
@@ -11230,11 +11416,11 @@ function planSettings(targetRepo, previous, home, env) {
   return { file, preexisted, existing, generated, merged, retiredOurs };
 }
 function planHookScripts(targetRepo) {
-  return hookScriptsThisVersionWrites().map(([rel, content]) => decideOwnedGenerated(join7(targetRepo, rel), targetRepo, content, OWNED_GENERATED_HEADERS[rel]));
+  return hookScriptsThisVersionWrites().map(([rel, content]) => decideOwnedGenerated(join8(targetRepo, rel), targetRepo, content, OWNED_GENERATED_HEADERS[rel]));
 }
 function planMcpRegistration(targetRepo, credential) {
-  const mcpPath = join7(targetRepo, MCP_REGISTRATION_REL);
-  const existing = existsSync5(mcpPath) ? readFileSync6(mcpPath, "utf-8") : null;
+  const mcpPath = join8(targetRepo, MCP_REGISTRATION_REL);
+  const existing = existsSync6(mcpPath) ? readFileSync7(mcpPath, "utf-8") : null;
   if (credential === void 0)
     return { kind: "none", existing };
   if (credential === "pending")
@@ -11246,11 +11432,11 @@ function planMcpRegistration(targetRepo, credential) {
 function putPlannedMcp(targetRepo, planned) {
   if (planned.kind !== "write" || planned.outcome === "skipped")
     return;
-  writeAllowlisted(join7(targetRepo, MCP_REGISTRATION_REL), targetRepo, planned.text, []);
+  writeAllowlisted(join8(targetRepo, MCP_REGISTRATION_REL), targetRepo, planned.text, []);
 }
 function fileInFolderPlace(root, rel) {
   for (let dir = posix2.dirname(rel); dir !== "."; dir = posix2.dirname(dir)) {
-    const found = lstatOrNull(join7(root, dir));
+    const found = lstatOrNull(join8(root, dir));
     if (found !== null && !found.isDirectory())
       return true;
   }
@@ -11259,7 +11445,7 @@ function fileInFolderPlace(root, rel) {
 function symlinkOnPath(root, rel) {
   let current = root;
   for (const segment of rel.split("/")) {
-    current = join7(current, segment);
+    current = join8(current, segment);
     try {
       if (lstatSync(current).isSymbolicLink())
         return true;
@@ -11280,14 +11466,14 @@ function planCodexHooks(targetRepo) {
   });
   if (symlinkOnPath(targetRepo, CODEX_HOOKS_REL2))
     return leave("link", null);
-  const folder2 = lstatOrNull(join7(targetRepo, posix2.dirname(CODEX_HOOKS_REL2)));
+  const folder2 = lstatOrNull(join8(targetRepo, posix2.dirname(CODEX_HOOKS_REL2)));
   if (folder2 !== null && !folder2.isDirectory())
     return leave("unreadable", null);
-  const path = join7(targetRepo, CODEX_HOOKS_REL2);
+  const path = join8(targetRepo, CODEX_HOOKS_REL2);
   let before = null;
   if (lstatOrNull(path) !== null) {
     try {
-      before = readFileSync6(path, "utf-8");
+      before = readFileSync7(path, "utf-8");
     } catch {
       return leave("unreadable", null);
     }
@@ -11321,13 +11507,13 @@ function planCodexHooks(targetRepo) {
 function putPlannedCodexHooks(targetRepo, planned) {
   if (planned.outcome !== "written" || planned.text === null)
     return;
-  writeAllowlisted(join7(targetRepo, CODEX_HOOKS_REL2), targetRepo, planned.text, []);
+  writeAllowlisted(join8(targetRepo, CODEX_HOOKS_REL2), targetRepo, planned.text, []);
 }
 function readCodexConfig(targetRepo) {
-  const folder2 = lstatOrNull(join7(targetRepo, posix2.dirname(CODEX_CONFIG_REL2)));
+  const folder2 = lstatOrNull(join8(targetRepo, posix2.dirname(CODEX_CONFIG_REL2)));
   if (folder2 !== null && !folder2.isDirectory())
     return "unreadable";
-  const path = join7(targetRepo, CODEX_CONFIG_REL2);
+  const path = join8(targetRepo, CODEX_CONFIG_REL2);
   const stat = lstatOrNull(path);
   if (stat === null)
     return { text: null };
@@ -11335,7 +11521,7 @@ function readCodexConfig(targetRepo) {
     return "unreadable";
   let bytes;
   try {
-    bytes = readFileSync6(path);
+    bytes = readFileSync7(path);
   } catch {
     return "unreadable";
   }
@@ -11381,10 +11567,10 @@ function planCodexConfig(targetRepo, credential) {
 function putPlannedCodexConfig(targetRepo, planned) {
   if (planned.outcome !== "written" || planned.text === null)
     return;
-  writeAllowlisted(join7(targetRepo, CODEX_CONFIG_REL2), targetRepo, planned.text, []);
+  writeAllowlisted(join8(targetRepo, CODEX_CONFIG_REL2), targetRepo, planned.text, []);
 }
 function planCrewRoster(targetRepo) {
-  return decideOwned(join7(targetRepo, CREW_ROSTER_REL), targetRepo, renderCrewRoster());
+  return decideOwned(join8(targetRepo, CREW_ROSTER_REL), targetRepo, renderCrewRoster());
 }
 function planCrewProfiles(targetRepo, previous, writeSet) {
   const recordedFiles = new Map((previous?.files ?? []).filter((file) => writeSet.files.has(file.path)).map((file) => [file.path, file]));
@@ -11399,7 +11585,7 @@ function planCrewProfiles(targetRepo, previous, writeSet) {
   });
 }
 function planInstallRecord(targetRepo, text) {
-  return decideOwned(join7(targetRepo, INSTALL_MANIFEST_REL), targetRepo, text);
+  return decideOwned(join8(targetRepo, INSTALL_MANIFEST_REL), targetRepo, text);
 }
 function accountInstall(steps, actual) {
   const { targetRepo, writeSet, pin } = steps;
@@ -11627,7 +11813,7 @@ function mcpHasHalfcycleEntry(text) {
 function writeMissingSelfBuildCrewProfiles(targetRepoRoot, report) {
   for (const { rel, text } of renderCrewProfiles()) {
     const target = crewProfileTarget(targetRepoRoot, rel);
-    if (existsSync5(target))
+    if (existsSync6(target))
       continue;
     writeAllowlisted(target, targetRepoRoot, text, report.writtenPaths);
   }
@@ -11635,7 +11821,7 @@ function writeMissingSelfBuildCrewProfiles(targetRepoRoot, report) {
 function installSelfBuild(options) {
   const { targetRepo, engagementId, credential, freshlyMinted, home } = options;
   assertEngagementId(engagementId);
-  if (!existsSync5(targetRepo)) {
+  if (!existsSync6(targetRepo)) {
     throw new Error(`[halfcycle] Target repo does not exist: ${targetRepo}`);
   }
   const report = {
@@ -11646,7 +11832,7 @@ function installSelfBuild(options) {
     editedCollidedPaths: [],
     replacedPaths: []
   };
-  const at = (rel) => join7(targetRepo, rel);
+  const at = (rel) => join8(targetRepo, rel);
   const version = readPluginManifest().version;
   const existingMcp = readFileOrNull(at(MCP_REGISTRATION_REL));
   const mcpText = existingMcp === null || !mcpHasHalfcycleEntry(existingMcp) ? inLineEndingOf(existingMcp, generateMcpRegistration(existingMcp, credential.mcpUrl)) : null;
@@ -11657,18 +11843,18 @@ function installSelfBuild(options) {
   if (mcpText !== null) {
     writeAllowlisted(at(MCP_REGISTRATION_REL), targetRepo, mcpText, report.writtenPaths);
   }
-  if (!existsSync5(at(VENDORED_BIN_REL))) {
-    recordOwned(report, at(VENDORED_BIN_REL), targetRepo, readFileSync6(resolveVendoredBinary(), "utf-8"), VENDORED_BIN_REL);
+  if (!existsSync6(at(VENDORED_BIN_REL))) {
+    recordOwned(report, at(VENDORED_BIN_REL), targetRepo, readFileSync7(resolveVendoredBinary(), "utf-8"), VENDORED_BIN_REL);
   }
-  if (!existsSync5(at(SELF_BUILD_GITIGNORE_REL))) {
+  if (!existsSync6(at(SELF_BUILD_GITIGNORE_REL))) {
     writeAllowlisted(at(SELF_BUILD_GITIGNORE_REL), targetRepo, SELF_BUILD_GITIGNORE_TEXT, report.writtenPaths);
   }
-  if (!existsSync5(at(CREW_ROSTER_REL))) {
+  if (!existsSync6(at(CREW_ROSTER_REL))) {
     writeCrewRoster(targetRepo, report);
   }
   writeMissingSelfBuildCrewProfiles(targetRepo, report);
-  if (!existsSync5(at(BUNDLE_PIN_REL))) {
-    writeBundlePin(targetRepo, planBundlePin(targetRepo, version, engagementId, "self-build", void 0, credential.methodVersion), report.writtenPaths);
+  if (!existsSync6(at(BUNDLE_PIN_REL))) {
+    writeBundlePin(targetRepo, planBundlePin(targetRepo, version, engagementId, "self-build", void 0, credential.methodVersion, credential.serviceUrl), report.writtenPaths);
   }
   return { writtenPaths: report.writtenPaths, credentialWritten };
 }
@@ -11695,20 +11881,20 @@ import { randomBytes, timingSafeEqual } from "node:crypto";
 var LOOPBACK_PORT_ENV = "HALFCYCLE_LOOPBACK_PORT";
 var DEFAULT_STILL_WAITING_MS = 15e3;
 var COMPLETION_REDIRECT_SECONDS = 2;
-function onwardTarget(engagementId) {
-  const projectPage = projectPageUrl(engagementId);
+function onwardTarget(engagementId, serviceUrl) {
+  const projectPage = projectPageUrl(engagementId, serviceUrl);
   if (projectPage !== void 0) {
     return { href: projectPage, label: "Go to your project's page" };
   }
-  return { href: DASHBOARD_URL, label: "Go to your projects" };
+  return { href: consoleOrigin(serviceUrl), label: "Go to your projects" };
 }
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-function completionPage(result, engagementId) {
+function completionPage(result, engagementId, serviceUrl) {
   const approved = result === LOOPBACK_RESULT.APPROVED;
   const headline2 = approved ? "Signed in. You can close this tab and return to your terminal." : "Sign-in declined. Nothing was created. You can close this tab.";
-  const onward = approved ? onwardTarget(engagementId) : null;
+  const onward = approved ? onwardTarget(engagementId, serviceUrl) : null;
   const href = onward === null ? "" : escapeHtml(onward.href);
   const refresh = onward === null ? "" : `<meta http-equiv="refresh" content="${COMPLETION_REDIRECT_SECONDS};url=${href}">`;
   const successLink = onward === null ? "" : `<p><a href="${href}" style="color:#19d3ff">${escapeHtml(onward.label)}</a></p>`;
@@ -11727,7 +11913,7 @@ function statesMatch(presented, expected) {
     return false;
   return timingSafeEqual(a, b);
 }
-function createCallbackHandler(state, onCallback, engagementId) {
+function createCallbackHandler(state, onCallback, engagementId, serviceUrl) {
   return (req, res) => {
     if (!isLoopbackPeer(req.socket.remoteAddress)) {
       res.writeHead(403).end();
@@ -11751,7 +11937,7 @@ function createCallbackHandler(state, onCallback, engagementId) {
     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, engagementId));
+    res.end(completionPage(result, engagementId, serviceUrl));
     onCallback({ result });
   };
 }
@@ -11770,7 +11956,7 @@ function requestedPort(env) {
   }
   return { port };
 }
-async function bindLoopback(env = process.env, engagementId) {
+async function bindLoopback(env = process.env, engagementId, serviceUrl) {
   const wanted = requestedPort(env);
   if ("problem" in wanted)
     return { bound: false, reason: wanted.problem };
@@ -11783,7 +11969,7 @@ async function bindLoopback(env = process.env, engagementId) {
       deliver(callback);
     else
       pending = callback;
-  }, engagementId));
+  }, engagementId, serviceUrl));
   const bindProblem = await new Promise((resolve9) => {
     const onError = (err) => {
       resolve9(`${err.code ?? "bind failed"} on ${LOOPBACK_REDIRECT_HOST}:${wanted.port}`);
@@ -11841,12 +12027,12 @@ function closeServer(server) {
 }
 
 // dist/sign-in-attempt.js
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync7, realpathSync, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync8, realpathSync, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 var ATTEMPT_FILENAME = "sign-in-attempt.json";
 function attemptPath(home) {
-  return join8(home ?? homedir4(), HALFCYCLE_DIR_NAME, ATTEMPT_FILENAME);
+  return join9(home ?? homedir4(), HALFCYCLE_DIR_NAME, ATTEMPT_FILENAME);
 }
 function realFolder(folder2) {
   try {
@@ -11858,7 +12044,7 @@ function realFolder(folder2) {
 function recordSignInAttempt(folder2, expiresAt, home) {
   try {
     const path = attemptPath(home);
-    mkdirSync6(join8(home ?? homedir4(), HALFCYCLE_DIR_NAME), { recursive: true, mode: 448 });
+    mkdirSync6(join9(home ?? homedir4(), HALFCYCLE_DIR_NAME), { recursive: true, mode: 448 });
     const record2 = { folder: realFolder(folder2), expiresAt };
     writeFileSync6(path, `${JSON.stringify(record2)}
 `, { mode: 384 });
@@ -11875,7 +12061,7 @@ function clearSignInAttempt(home) {
 }
 function readSignInAttempt(home) {
   try {
-    const parsed = JSON.parse(readFileSync7(attemptPath(home), "utf-8"));
+    const parsed = JSON.parse(readFileSync8(attemptPath(home), "utf-8"));
     if (typeof parsed !== "object" || parsed === null)
       return null;
     const { folder: folder2, expiresAt } = parsed;
@@ -12144,7 +12330,7 @@ async function signIn(serviceUrl, deps = {}) {
   }
   write2(`[halfcycle] Halfcycle needs an account before it can ${deps.reason ?? DEFAULT_SIGN_IN_REASON} \u2014 signing you in through your browser.
 `);
-  const bind = await bindLoopback(env, deps.onwardEngagementId);
+  const bind = await bindLoopback(env, deps.onwardEngagementId, serviceUrl);
   let closed = false;
   const closeListener = async () => {
     if (bind.bound && !closed) {
@@ -12716,7 +12902,7 @@ function installFailureLine() {
     if (code === 0 || verdict)
       return;
     try {
-      writeSync(2, `${DOCTOR_LINE}
+      writeSync(2, `${doctorLine(ownVersion())}
 `);
     } catch {
     }
@@ -12917,6 +13103,9 @@ function onlyDate(iso) {
   return match?.[1] ?? iso;
 }
 function actClause(act) {
+  if (act.kind === "create" && act.folderAlreadyHasProject === true) {
+    return `pick up this folder's project for that account, and install into ${act.targetRepo}`;
+  }
   return act.kind === "create" ? `create a NEW project for that account, and install into ${act.targetRepo}` : `join the project this repository is pinned to (${act.engagementId}) as that account, and install into ${act.targetRepo}`;
 }
 function wrongAccountConsequence(act) {
@@ -13095,7 +13284,7 @@ function isProjectOwnedElsewhere(result) {
 }
 async function createOwnedEngagement(serviceUrl, targetRepo, projectId, callerDeps = {}) {
   const deps = { ...callerDeps, attemptFolder: targetRepo };
-  let credential = await confirmActingIdentity(serviceUrl, await obtainCredential(serviceUrl, deps), { kind: "create", targetRepo }, deps);
+  let credential = await confirmActingIdentity(serviceUrl, await obtainCredential(serviceUrl, deps), { kind: "create", targetRepo, folderAlreadyHasProject: deps.folderAlreadyHasProject }, deps);
   for (; ; ) {
     try {
       return {
@@ -13169,9 +13358,9 @@ async function joinPinnedEngagement(serviceUrl, engagementId, targetRepo, deps =
 
 // dist/pre-create-checks.js
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync8, realpathSync as realpathSync2 } from "node:fs";
-import { delimiter, dirname as dirname4, join as join9 } from "node:path";
-var KEPT_FOLDER_ID_LINE = 'Nothing on the Halfcycle service needs undoing, and this folder keeps its project id, so running "npx halfcycle" again picks up where it left off.';
+import { existsSync as existsSync7, readFileSync as readFileSync9, realpathSync as realpathSync2 } from "node:fs";
+import { delimiter, dirname as dirname5, join as join10 } from "node:path";
+var KEPT_FOLDER_ID_LINE = `Nothing on the Halfcycle service needs undoing, and this folder keeps its project id, so running "${ownBareCommand()}" again picks up where it left off.`;
 var PreCreateRefused = class extends Error {
   constructor(message) {
     super(message);
@@ -13207,14 +13396,14 @@ function refuseSystemFolder(targetRepo, platform6 = process.platform) {
   };
   const target = key(targetRepo);
   if (SYSTEM_FOLDERS.some((folder2) => key(folder2) === target)) {
-    throw new PreCreateRefused(`${targetRepo} is a system folder \u2014 run "npx halfcycle" inside a project folder.`);
+    throw new PreCreateRefused(`${targetRepo} is a system folder \u2014 run "${ownBareCommand()}" inside a project folder.`);
   }
 }
 function refuseInsideProject(targetRepo) {
   let folder2 = realOrLiteral(targetRepo);
-  for (let parent = dirname4(folder2); parent !== folder2; folder2 = parent, parent = dirname4(parent)) {
-    if (existsSync6(join9(parent, BUNDLE_PIN_REL))) {
-      throw new PreCreateRefused(`${targetRepo} is inside the Halfcycle project at ${parent} \u2014 open that folder in your coding agent instead, or run "npx halfcycle" in a folder outside it.`);
+  for (let parent = dirname5(folder2); parent !== folder2; folder2 = parent, parent = dirname5(parent)) {
+    if (existsSync7(join10(parent, BUNDLE_PIN_REL))) {
+      throw new PreCreateRefused(`${targetRepo} is inside the Halfcycle project at ${parent} \u2014 open that folder in your coding agent instead, or run "${ownBareCommand()}" in a folder outside it.`);
     }
   }
 }
@@ -13234,16 +13423,16 @@ async function offerGitForWindows() {
   const yes = isInteractiveRun() && /^\s*y(es)?\s*$/i.test(await askLine("Git for Windows is not installed, and Claude Code needs it to run Halfcycle. Install it now with winget? [y/N] "));
   if (yes && runWingetInstall())
     return true;
-  throw new PreCreateRefused(`Git for Windows is needed and is not installed \u2014 install it with "${GIT_INSTALL_COMMAND}" or from ${GIT_DOWNLOAD_PAGE}, then open a new terminal and run "npx halfcycle" again.`);
+  throw new PreCreateRefused(`Git for Windows is needed and is not installed \u2014 install it with "${GIT_INSTALL_COMMAND}" or from ${GIT_DOWNLOAD_PAGE}, then open a new terminal and run "${ownBareCommand()}" again.`);
 }
 function gitBashPath(env) {
-  const onPath = (env["PATH"] ?? "").split(delimiter).filter((dir) => dir !== "" && existsSync6(join9(dir, "git.exe"))).map((dir) => join9(dir, "..", "bin", "bash.exe"));
+  const onPath = (env["PATH"] ?? "").split(delimiter).filter((dir) => dir !== "" && existsSync7(join10(dir, "git.exe"))).map((dir) => join10(dir, "..", "bin", "bash.exe"));
   const candidates = [
     env["CLAUDE_CODE_GIT_BASH_PATH"],
     ...onPath,
-    env["ProgramFiles"] === void 0 ? void 0 : join9(env["ProgramFiles"], "Git", "bin", "bash.exe")
+    env["ProgramFiles"] === void 0 ? void 0 : join10(env["ProgramFiles"], "Git", "bin", "bash.exe")
   ];
-  return candidates.find((file) => file !== void 0 && file !== "" && existsSync6(file));
+  return candidates.find((file) => file !== void 0 && file !== "" && existsSync7(file));
 }
 function hasGitBash(env) {
   return gitBashPath(env) !== void 0;
@@ -13252,10 +13441,10 @@ function runWingetInstall() {
   return spawnSync("winget", [...GIT_INSTALL_ARGS], { stdio: "inherit" }).status === 0;
 }
 function unreadableProjectRefusal(targetRepo) {
-  return `${join9(targetRepo, PROJECT_IDENTITY_REL)} could not be read as a Halfcycle project file \u2014 delete the .halfcycle folder in ${targetRepo} and run "npx halfcycle" again to start a new project here.`;
+  return `${join10(targetRepo, PROJECT_IDENTITY_REL)} could not be read as a Halfcycle project file \u2014 delete the .halfcycle folder in ${targetRepo} and run "${ownBareCommand()}" again to start a new project here.`;
 }
 function cannotWriteRefusal(targetRepo) {
-  return `cannot write to ${targetRepo} \u2014 run "npx halfcycle" in a folder you can write to.`;
+  return `cannot write to ${targetRepo} \u2014 run "${ownBareCommand()}" in a folder you can write to.`;
 }
 function claimFolderId(targetRepo) {
   const planned = planProjectIdentity(targetRepo);
@@ -13272,7 +13461,7 @@ function claimFolderId(targetRepo) {
 function readFolderId(targetRepo) {
   let folderId;
   try {
-    const text = readFileSync8(join9(targetRepo, PROJECT_IDENTITY_REL), "utf-8");
+    const text = readFileSync9(join10(targetRepo, PROJECT_IDENTITY_REL), "utf-8");
     folderId = JSON.parse(text)?.projectId;
   } catch {
     return void 0;
@@ -13295,7 +13484,7 @@ function folderMissingRefusal(targetRepo) {
   return `halfcycle: no such directory: ${targetRepo}`;
 }
 function folderIsFileRefusal(targetRepo) {
-  return `halfcycle: ${targetRepo} is a file \u2014 run "npx halfcycle" with a project folder instead.`;
+  return `halfcycle: ${targetRepo} is a file \u2014 run "${ownBareCommand()}" with a project folder instead.`;
 }
 function monorepoRefusal(targetRepo) {
   return `halfcycle: refusing to install into the Halfcycle monorepo itself (${targetRepo}).
@@ -13305,7 +13494,7 @@ function monorepoRefusal(targetRepo) {
   To install into a real project: halfcycle <path-to-that-repo>`;
 }
 function homeFolderRefusal(targetRepo) {
-  return `halfcycle: refusing to set up in your home folder (${targetRepo}). Run "npx halfcycle" inside a project folder.`;
+  return `halfcycle: refusing to set up in your home folder (${targetRepo}). Run "${ownBareCommand()}" inside a project folder.`;
 }
 function isHomeFolder(dir) {
   try {
@@ -13318,16 +13507,16 @@ function isHomeFolder(dir) {
 }
 
 // dist/preview.js
-import { accessSync, constants, existsSync as existsSync7, readFileSync as readFileSync10, statSync } from "node:fs";
-import { join as join11 } from "node:path";
+import { accessSync, constants, existsSync as existsSync9, readFileSync as readFileSync12, statSync } from "node:fs";
+import { join as join13 } from "node:path";
 
 // dist/halfcycle-monorepo.js
-import { readFileSync as readFileSync9 } from "node:fs";
-import { join as join10 } from "node:path";
+import { readFileSync as readFileSync10 } from "node:fs";
+import { join as join11 } from "node:path";
 var MONOREPO_PACKAGE_NAME = "halfcycle-monorepo";
 function isHalfcycleMonorepo(dir) {
   try {
-    const pkg = JSON.parse(readFileSync9(join10(dir, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync10(join11(dir, "package.json"), "utf-8"));
     return pkg.name === MONOREPO_PACKAGE_NAME;
   } catch {
     return false;
@@ -13337,131 +13526,10 @@ function isSelfBuildInstallForm(engagementIdArg, engagementTypeArg) {
   return engagementIdArg !== void 0 && engagementTypeArg === "self-build";
 }
 
-// dist/preview.js
-var CLAUDE_MD_REL = "CLAUDE.md";
-var AGENTS_IMPORT_LINE = "@AGENTS.md";
-var WORDS = {
-  intro: "Halfcycle would set up this folder like this. Nothing has been written.",
-  remove: "an older Halfcycle file this version no longer uses",
-  claudeMdWillAdd: "already holds your own instructions; your first session will add one line to it, pointing to AGENTS.md",
-  claudeMdAlreadyPoints: "already holds your own instructions, including the line pointing to AGENTS.md",
-  signIn: "  This project's sign-in, kept on this computer for you only, in your home folder's .halfcycle folder.",
-  newProject: "  A new project on Halfcycle's service for this folder, made when you sign in.",
-  gitForWindows: "  Git for Windows, which Claude Code needs: setting up will ask before installing it with winget.",
-  firstSession: "Your first session will then write your project's own files as you answer its questions, starting with AGENTS.md and CLAUDE.md, which hold your project's own instructions.",
-  toSetUp: `To set up for real, run: ${HALFCYCLE_COMMAND}`,
-  planFailed: "halfcycle: setting up this folder would stop on a file that could not be read. Nothing has been written; fix that file, then run the preview again."
-};
-function runPreview(targetRepo, options) {
-  const refusal3 = previewRefusal(targetRepo, options);
-  if (refusal3 !== void 0)
-    return { refusal: refusal3 };
-  let plan;
-  try {
-    plan = planInstall({ targetRepo, env: options.env, home: options.home });
-  } catch {
-    return { refusal: WORDS.planFailed };
-  }
-  if (plan.refusal !== void 0)
-    return { refusal: plan.refusal };
-  return {
-    text: renderPreview(plan, gitBashPath(options.env) === void 0 && options.platform === "win32", claudeMdLine(targetRepo))
-  };
-}
-function claudeMdLine(targetRepo) {
-  const path = join11(targetRepo, CLAUDE_MD_REL);
-  if (!existsSync7(path))
-    return void 0;
-  let text;
-  try {
-    text = readFileSync10(path, "utf-8");
-  } catch {
-    return WORDS.claudeMdWillAdd;
-  }
-  return text.includes(AGENTS_IMPORT_LINE) ? WORDS.claudeMdAlreadyPoints : WORDS.claudeMdWillAdd;
-}
-function previewRefusal(targetRepo, options) {
-  if (!existsSync7(targetRepo))
-    return folderMissingRefusal(targetRepo);
-  if (!statSync(targetRepo).isDirectory())
-    return folderIsFileRefusal(targetRepo);
-  if (isHalfcycleMonorepo(targetRepo))
-    return monorepoRefusal(targetRepo);
-  if (isHomeFolder(targetRepo))
-    return homeFolderRefusal(targetRepo);
-  try {
-    refuseSystemFolder(targetRepo, options.platform);
-    refuseInsideProject(targetRepo);
-  } catch (err) {
-    if (err instanceof PreCreateRefused)
-      return err.message;
-    throw err;
-  }
-  try {
-    accessSync(targetRepo, constants.W_OK);
-  } catch {
-    return cannotWriteRefusal(targetRepo);
-  }
-  if (existsSync7(join11(targetRepo, PROJECT_IDENTITY_REL)) && readFolderId(targetRepo) === void 0) {
-    return unreadableProjectRefusal(targetRepo);
-  }
-  try {
-    checkSettingsParse(targetRepo);
-  } catch (err) {
-    if (err instanceof PreCreateRefused)
-      return err.message;
-    throw err;
-  }
-  return void 0;
-}
-function wordsOf(entry) {
-  const words = PREVIEW_WORDS[entry.kind];
-  switch (entry.action) {
-    case "add":
-      return words.add;
-    case "change":
-      return words.change;
-    case "remove":
-      return WORDS.remove;
-    case "leave":
-      return entry.yours === true ? words.yours : words.leave;
-  }
-}
-var HEADINGS = [
-  ["add", "Add:"],
-  ["change", "Change:"],
-  ["remove", "Remove:"],
-  ["leave", "Leave alone:"]
-];
-function outsideLine2(outside) {
-  return outside.kind === "sign-in" ? WORDS.signIn : WORDS.newProject;
-}
-function renderPreview(plan, missingGitForWindows, claudeMdWords) {
-  const lines = [WORDS.intro];
-  for (const [action, heading] of HEADINGS) {
-    const rows = plan.entries.filter((entry) => entry.action === action);
-    const claudeMdRow = action === "leave" && claudeMdWords !== void 0;
-    if (rows.length === 0 && !claudeMdRow)
-      continue;
-    lines.push("", heading);
-    for (const entry of rows)
-      lines.push(`  ${entry.path} \u2014 ${wordsOf(entry)}`);
-    if (claudeMdRow)
-      lines.push(`  ${CLAUDE_MD_REL} \u2014 ${claudeMdWords}`);
-  }
-  lines.push("", "Outside this folder:");
-  for (const outside of plan.outside)
-    lines.push(outsideLine2(outside));
-  if (missingGitForWindows)
-    lines.push(WORDS.gitForWindows);
-  lines.push("", WORDS.firstSession, "", WORDS.toSetUp);
-  return lines.join("\n");
-}
-
 // dist/local-allow.js
-import { spawnSync as spawnSync2 } from "node:child_process";
+import { execFileSync as execFileSync3 } from "node:child_process";
 import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync11, rmSync as rmSync4, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname5, join as join12 } from "node:path";
+import { dirname as dirname6, join as join12 } from "node:path";
 var LOCAL_SETTINGS_REL2 = ".claude/settings.local.json";
 var LOCAL_ALLOW_RECORD_REL = ".halfcycle/local-allow.json";
 var LOCAL_ALLOW_EDIT_MODE = "acceptEdits";
@@ -13469,6 +13537,7 @@ var SCRIPTS = ["test", "build", "lint", "typecheck"];
 var SCRIPT_RUNNERS = ["npm run", "pnpm", "pnpm run", "yarn", "bun run"];
 var HALFCYCLE_TOOLS_RULE = `mcp__${MCP_SERVER_KEY}`;
 var bash = (command) => `Bash(${command}:*)`;
+var INSTALLED_HOOK_SCRIPTS = Object.keys(OWNED_GENERATED_HEADERS).filter((path) => path.startsWith(".claude/hooks/"));
 var LOCAL_ALLOW_RULES = [
   ...SCRIPT_RUNNERS.flatMap((runner) => SCRIPTS.map((script) => bash(`${runner} ${script}`))),
   bash("npm test"),
@@ -13478,8 +13547,14 @@ var LOCAL_ALLOW_RULES = [
   bash("cargo test"),
   bash("cargo build"),
   bash("cargo check"),
+  bash("cargo run"),
+  bash("go run"),
   bash("pytest"),
   bash("python -m pytest"),
+  bash("bun test"),
+  bash("bun build"),
+  bash("deno test"),
+  bash("deno check"),
   bash("make test"),
   bash("make build"),
   bash("git status"),
@@ -13509,11 +13584,20 @@ var LOCAL_ALLOW_RULES = [
   bash("go mod tidy"),
   bash("go get"),
   bash("cargo add"),
+  bash("pip install"),
+  bash("pip3 install"),
+  bash("bundle install"),
   bash("node"),
   bash("npx"),
   bash("pnpm exec"),
   bash("bunx"),
+  bash("python3"),
+  bash("python"),
+  bash("ruby"),
+  bash("deno run"),
+  bash("bundle exec"),
   "Bash(node_modules/.bin/*)",
+  ...INSTALLED_HOOK_SCRIPTS.flatMap((path) => [bash(`./${path}`), bash(`bash ${path}`), bash(`bash ./${path}`)]),
   bash("mkdir"),
   bash("touch"),
   bash("cp"),
@@ -13537,10 +13621,10 @@ var LOCAL_ALLOW_RULES = [
   HALFCYCLE_TOOLS_RULE
 ];
 var LOCAL_ALLOW_QUESTION = "Let your coding agent work without asking on this computer? It would run your tests and builds, install packages, run local tools, make and move files, use git locally, run Halfcycle, and edit files in this project without a permission prompt. Pushing, publishing, deploying to production, deleting and changing anything on GitHub still ask. This is saved only on this computer, in .claude/settings.local.json, which is not committed.\nType yes to allow it, or press Enter to keep asking: ";
-var LOCAL_ALLOW_ON_LINE = "Your coding agent can now work without asking on this computer. To undo it, run: npx halfcycle@latest allow --remove";
-var LOCAL_ALLOW_OFF_LINE = "Your coding agent will ask before it runs commands. To stop most of those questions on this computer, run: npx halfcycle@latest allow";
+var LOCAL_ALLOW_ON_LINE = `Your coding agent can now work without asking on this computer. To undo it, run: ${ownCommand()} allow --remove`;
+var LOCAL_ALLOW_OFF_LINE = `Your coding agent will ask before it runs commands. To stop most of those questions on this computer, run: ${ownCommand()} allow`;
 var LOCAL_ALLOW_TRACKED_LINE = "Your .claude/settings.local.json is committed to git, so Halfcycle will not add rules to it. Remove it from git first if you want them.";
-var LOCAL_ALLOW_UNREADABLE_LINE = "Halfcycle did not change .claude/settings.local.json because it is not a JSON object it can add to. Fix the file, then run: npx halfcycle@latest allow";
+var LOCAL_ALLOW_UNREADABLE_LINE = `Halfcycle did not change .claude/settings.local.json because it is not a JSON object it can add to. Fix the file, then run: ${ownCommand()} allow`;
 var LOCAL_ALLOW_NOTHING_TO_REMOVE_LINE = "Halfcycle has not added any rules on this computer, so there is nothing to remove.";
 var LOCAL_ALLOW_REMOVED_LINE = "Halfcycle took out the rules it added. Everything you had stays.";
 function isYes(answer) {
@@ -13550,12 +13634,12 @@ function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function trackedByGit(repo) {
-  const run = spawnSync2("git", ["ls-files", "--error-unmatch", "--", LOCAL_SETTINGS_REL2], {
-    cwd: repo,
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "ignore"]
-  });
-  return run.status === 0;
+  try {
+    execFileSync3("git", ["-C", repo, "ls-files", "--error-unmatch", "--", LOCAL_SETTINGS_REL2], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
 }
 function readRecord2(repo) {
   const path = join12(repo, LOCAL_ALLOW_RECORD_REL);
@@ -13576,7 +13660,7 @@ function readRecord2(repo) {
 }
 function writeRecord(repo, record2) {
   const path = join12(repo, LOCAL_ALLOW_RECORD_REL);
-  mkdirSync7(dirname5(path), { recursive: true });
+  mkdirSync7(dirname6(path), { recursive: true });
   writeFileSync7(path, JSON.stringify({ rules: record2.rules, defaultMode: record2.defaultMode, before: record2.before }, null, 2) + "\n");
 }
 function holdsLocalAllowRecord(repo) {
@@ -13627,7 +13711,7 @@ function writeLocalAllow(repo) {
   if (setsMode)
     permissions["defaultMode"] = LOCAL_ALLOW_EDIT_MODE;
   const next = { ...settings, permissions };
-  mkdirSync7(dirname5(path), { recursive: true });
+  mkdirSync7(dirname6(path), { recursive: true });
   writeFileSync7(path, render(next, text));
   const earlier = readRecord2(repo);
   writeRecord(repo, {
@@ -13733,12 +13817,257 @@ function localAllowClosingLine(repo, said) {
     return writeLocalAllow(repo).line;
   return holdsLocalAllowRecord(repo) ? LOCAL_ALLOW_ON_LINE : LOCAL_ALLOW_OFF_LINE;
 }
+var ENABLED_SERVERS_KEY = "enabledMcpjsonServers";
+var DISABLED_SERVERS_KEY = "disabledMcpjsonServers";
+function registersOwnServer(repo) {
+  const path = join12(repo, MCP_REGISTRATION_REL);
+  const registration = parseObject(existsSync8(path) ? readFileSync11(path, "utf8") : null);
+  const servers = registration?.["mcpServers"];
+  return isObject2(servers) && isObject2(servers[MCP_SERVER_KEY]);
+}
+function stringsIn(value) {
+  return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+}
+function approveOwnServer(repo) {
+  const plan = planOwnServerApproval(repo, registersOwnServer(repo));
+  if (plan.after !== null) {
+    const path = join12(repo, LOCAL_SETTINGS_REL2);
+    mkdirSync7(dirname6(path), { recursive: true });
+    writeFileSync7(path, plan.after);
+  }
+  return plan.outcome;
+}
+function planOwnServerApproval(repo, registered) {
+  const path = join12(repo, LOCAL_SETTINGS_REL2);
+  const text = existsSync8(path) ? readFileSync11(path, "utf8") : null;
+  const unchanged = (outcome) => ({ outcome, before: text, after: null });
+  if (!registered)
+    return unchanged("no-server");
+  if (trackedByGit(repo))
+    return unchanged("tracked");
+  const settings = text === null ? {} : parseObject(text);
+  if (settings === null)
+    return unchanged("unreadable");
+  const permissionsRaw = settings["permissions"];
+  if (permissionsRaw !== void 0 && !isObject2(permissionsRaw))
+    return unchanged("unreadable");
+  const allowRaw = permissionsRaw?.["allow"];
+  const enabledRaw = settings[ENABLED_SERVERS_KEY];
+  if (allowRaw !== void 0 && !Array.isArray(allowRaw))
+    return unchanged("unreadable");
+  if (enabledRaw !== void 0 && !Array.isArray(enabledRaw))
+    return unchanged("unreadable");
+  if (stringsIn(settings[DISABLED_SERVERS_KEY]).includes(MCP_SERVER_KEY))
+    return unchanged("declined");
+  const enables = !stringsIn(enabledRaw).includes(MCP_SERVER_KEY);
+  const allows = !stringsIn(allowRaw).includes(HALFCYCLE_TOOLS_RULE);
+  if (!enables && !allows)
+    return unchanged("approved");
+  const next = { ...settings };
+  if (enables)
+    next[ENABLED_SERVERS_KEY] = [...Array.isArray(enabledRaw) ? enabledRaw : [], MCP_SERVER_KEY];
+  if (allows) {
+    const permissions = { ...permissionsRaw ?? {} };
+    permissions["allow"] = [...Array.isArray(allowRaw) ? allowRaw : [], HALFCYCLE_TOOLS_RULE];
+    next["permissions"] = permissions;
+  }
+  const after = render(next, text);
+  return { outcome: "approved", before: text, after: after === text ? null : after };
+}
+function removeOwnServerApproval(repo) {
+  const path = join12(repo, LOCAL_SETTINGS_REL2);
+  if (!existsSync8(path) || trackedByGit(repo))
+    return false;
+  const text = readFileSync11(path, "utf8");
+  const settings = parseObject(text);
+  if (settings === null)
+    return false;
+  const next = { ...settings };
+  let changed = false;
+  const enabled = next[ENABLED_SERVERS_KEY];
+  if (Array.isArray(enabled) && enabled.includes(MCP_SERVER_KEY)) {
+    const kept = enabled.filter((name) => name !== MCP_SERVER_KEY);
+    if (kept.length > 0)
+      next[ENABLED_SERVERS_KEY] = kept;
+    else
+      delete next[ENABLED_SERVERS_KEY];
+    changed = true;
+  }
+  const permissions = next["permissions"];
+  if (isObject2(permissions) && Array.isArray(permissions["allow"]) && permissions["allow"].includes(HALFCYCLE_TOOLS_RULE)) {
+    const nextPermissions = { ...permissions };
+    const kept = permissions["allow"].filter((rule) => rule !== HALFCYCLE_TOOLS_RULE);
+    if (kept.length > 0)
+      nextPermissions["allow"] = kept;
+    else
+      delete nextPermissions["allow"];
+    if (Object.keys(nextPermissions).length > 0)
+      next["permissions"] = nextPermissions;
+    else
+      delete next["permissions"];
+    changed = true;
+  }
+  if (!changed)
+    return false;
+  if (Object.keys(next).length === 0)
+    rmSync4(path, { force: true });
+  else
+    writeFileSync7(path, render(next, text));
+  return true;
+}
+
+// dist/preview.js
+var CLAUDE_MD_REL = "CLAUDE.md";
+var AGENTS_IMPORT_LINE = "@AGENTS.md";
+var WORDS = {
+  intro: "Halfcycle would set up this folder like this. Nothing has been written.",
+  remove: "an older Halfcycle file this version no longer uses",
+  claudeMdWillAdd: "already holds your own instructions; your first session will add one line to it, pointing to AGENTS.md",
+  claudeMdAlreadyPoints: "already holds your own instructions, including the line pointing to AGENTS.md",
+  ownServerAdd: "lets Claude Code use Halfcycle's tools on this computer without asking each time; kept out of git",
+  ownServerChange: "adds the lines that let Claude Code use Halfcycle's tools without asking; your own lines stay as they are",
+  ownServerLeave: "already lets Claude Code use Halfcycle's tools without asking",
+  ownServerDeclined: "you turned Halfcycle's tools off in this folder; that choice stays",
+  ownServerYours: "a file of yours Halfcycle will not add to; Claude Code will ask before using Halfcycle's tools",
+  signIn: "  This project's sign-in, kept on this computer for you only, in your home folder's .halfcycle folder.",
+  newProject: "  A new project on Halfcycle's service for this folder, made when you sign in.",
+  gitForWindows: "  Git for Windows, which Claude Code needs: setting up will ask before installing it with winget.",
+  firstSession: "Your first session will then write your project's own files as you answer its questions, starting with AGENTS.md and CLAUDE.md, which hold your project's own instructions.",
+  toSetUp: `To set up for real, run: ${ownCommand()}`,
+  planFailed: "halfcycle: setting up this folder would stop on a file that could not be read. Nothing has been written; fix that file, then run the preview again."
+};
+function runPreview(targetRepo, options) {
+  const refusal3 = previewRefusal(targetRepo, options);
+  if (refusal3 !== void 0)
+    return { refusal: refusal3 };
+  let plan;
+  try {
+    plan = planInstall({ targetRepo, env: options.env, home: options.home });
+  } catch {
+    return { refusal: WORDS.planFailed };
+  }
+  if (plan.refusal !== void 0)
+    return { refusal: plan.refusal };
+  return {
+    text: renderPreview(plan, gitBashPath(options.env) === void 0 && options.platform === "win32", claudeMdLine(targetRepo), ownServerRow(targetRepo, plan))
+  };
+}
+function ownServerRow(targetRepo, plan) {
+  const serverEntry = plan.entries.find((entry) => entry.path === MCP_REGISTRATION_REL);
+  const registered = serverEntry !== void 0 && (serverEntry.action === "add" || serverEntry.action === "change") ? true : registersOwnServer(targetRepo);
+  const decided = planOwnServerApproval(targetRepo, registered);
+  switch (decided.outcome) {
+    case "no-server":
+      return void 0;
+    case "approved":
+      if (decided.after === null)
+        return { action: "leave", words: WORDS.ownServerLeave };
+      return decided.before === null ? { action: "add", words: WORDS.ownServerAdd } : { action: "change", words: WORDS.ownServerChange };
+    case "declined":
+      return { action: "leave", words: WORDS.ownServerDeclined };
+    case "tracked":
+    case "unreadable":
+      return { action: "leave", words: WORDS.ownServerYours };
+  }
+}
+function claudeMdLine(targetRepo) {
+  const path = join13(targetRepo, CLAUDE_MD_REL);
+  if (!existsSync9(path))
+    return void 0;
+  let text;
+  try {
+    text = readFileSync12(path, "utf-8");
+  } catch {
+    return WORDS.claudeMdWillAdd;
+  }
+  return text.includes(AGENTS_IMPORT_LINE) ? WORDS.claudeMdAlreadyPoints : WORDS.claudeMdWillAdd;
+}
+function previewRefusal(targetRepo, options) {
+  if (!existsSync9(targetRepo))
+    return folderMissingRefusal(targetRepo);
+  if (!statSync(targetRepo).isDirectory())
+    return folderIsFileRefusal(targetRepo);
+  if (isHalfcycleMonorepo(targetRepo))
+    return monorepoRefusal(targetRepo);
+  if (isHomeFolder(targetRepo))
+    return homeFolderRefusal(targetRepo);
+  try {
+    refuseSystemFolder(targetRepo, options.platform);
+    refuseInsideProject(targetRepo);
+  } catch (err) {
+    if (err instanceof PreCreateRefused)
+      return err.message;
+    throw err;
+  }
+  try {
+    accessSync(targetRepo, constants.W_OK);
+  } catch {
+    return cannotWriteRefusal(targetRepo);
+  }
+  if (existsSync9(join13(targetRepo, PROJECT_IDENTITY_REL)) && readFolderId(targetRepo) === void 0) {
+    return unreadableProjectRefusal(targetRepo);
+  }
+  try {
+    checkSettingsParse(targetRepo);
+  } catch (err) {
+    if (err instanceof PreCreateRefused)
+      return err.message;
+    throw err;
+  }
+  return void 0;
+}
+function wordsOf(entry) {
+  const words = PREVIEW_WORDS[entry.kind];
+  switch (entry.action) {
+    case "add":
+      return words.add;
+    case "change":
+      return words.change;
+    case "remove":
+      return WORDS.remove;
+    case "leave":
+      return entry.yours === true ? words.yours : words.leave;
+  }
+}
+var HEADINGS = [
+  ["add", "Add:"],
+  ["change", "Change:"],
+  ["remove", "Remove:"],
+  ["leave", "Leave alone:"]
+];
+function outsideLine2(outside) {
+  return outside.kind === "sign-in" ? WORDS.signIn : WORDS.newProject;
+}
+function renderPreview(plan, missingGitForWindows, claudeMdWords, ownServer) {
+  const lines = [WORDS.intro];
+  for (const [action, heading] of HEADINGS) {
+    const rows = plan.entries.filter((entry) => entry.action === action);
+    const claudeMdRow = action === "leave" && claudeMdWords !== void 0;
+    const ownServerHere = ownServer !== void 0 && ownServer.action === action;
+    if (rows.length === 0 && !claudeMdRow && !ownServerHere)
+      continue;
+    lines.push("", heading);
+    for (const entry of rows)
+      lines.push(`  ${entry.path} \u2014 ${wordsOf(entry)}`);
+    if (ownServerHere)
+      lines.push(`  ${LOCAL_SETTINGS_REL2} \u2014 ${ownServer.words}`);
+    if (claudeMdRow)
+      lines.push(`  ${CLAUDE_MD_REL} \u2014 ${claudeMdWords}`);
+  }
+  lines.push("", "Outside this folder:");
+  for (const outside of plan.outside)
+    lines.push(outsideLine2(outside));
+  if (missingGitForWindows)
+    lines.push(WORDS.gitForWindows);
+  lines.push("", WORDS.firstSession, "", WORDS.toSetUp);
+  return lines.join("\n");
+}
 
 // dist/doctor.js
-import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync9, lstatSync as lstatSync2, readFileSync as readFileSync12, realpathSync as realpathSync4 } from "node:fs";
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync10, lstatSync as lstatSync2, readFileSync as readFileSync13, realpathSync as realpathSync4, statSync as statSync2 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 var GUARD_RUNNER_REL2 = ".claude/hooks/guard-runner.sh";
 var CONNECTION_VERB = "check-connection";
 var WRAPPER_TIMEOUT_MS = 3e4;
@@ -13777,13 +14106,13 @@ function runDoctor(root, options) {
   };
 }
 function setUpLine(root, upToDate) {
-  if (!existsSync9(join13(root, BUNDLE_PIN_REL))) {
+  if (!existsSync10(join14(root, BUNDLE_PIN_REL))) {
     return {
       state: "no",
       hooksMissing: false,
       line: {
         ok: false,
-        text: `Set up: no. Halfcycle is not set up in this folder. To set it up, run ${HALFCYCLE_COMMAND} here.`
+        text: `Set up: no. Halfcycle is not set up in this folder. To set it up, run ${ownCommand()} here.`
       }
     };
   }
@@ -13791,9 +14120,9 @@ function setUpLine(root, upToDate) {
   const missing = [];
   if (!pinNamesProject(root))
     missing.push("Halfcycle's project record");
-  if (!existsSync9(join13(root, INSTALL_MANIFEST_REL)))
+  if (!existsSync10(join14(root, INSTALL_MANIFEST_REL)))
     missing.push("the install record");
-  if (!existsSync9(join13(root, VENDORED_BIN_REL)))
+  if (!existsSync10(join14(root, VENDORED_BIN_REL)))
     missing.push("Halfcycle's check program");
   if (!mcpNamesServer(root))
     missing.push("Halfcycle's server entry");
@@ -13806,7 +14135,7 @@ function setUpLine(root, upToDate) {
     hooksMissing,
     line: {
       ok: false,
-      text: `Set up: not complete. Missing: ${naturalList(missing)}. To put it back, run ${HALFCYCLE_COMMAND} here; nothing of yours is changed.`
+      text: `Set up: not complete. Missing: ${naturalList(missing)}. To put it back, run ${ownCommand()} here; nothing of yours is changed.`
     }
   };
 }
@@ -13819,14 +14148,14 @@ function pinNamesProject(root) {
   }
 }
 function mcpNamesServer(root) {
-  const parsed = readJson(join13(root, MCP_REGISTRATION_REL));
+  const parsed = readJson(join14(root, MCP_REGISTRATION_REL));
   if (!isObject3(parsed) || !isObject3(parsed["mcpServers"]))
     return false;
   const entry = parsed["mcpServers"][MCP_SERVER_KEY];
   return isObject3(entry) && typeof entry["url"] === "string";
 }
 function settingsRegisterEveryCommand(root) {
-  const parsed = readJson(join13(root, SETTINGS_REL));
+  const parsed = readJson(join14(root, SETTINGS_REL));
   if (!isObject3(parsed) || !isObject3(parsed["hooks"]))
     return false;
   const registered = /* @__PURE__ */ new Set();
@@ -13857,10 +14186,10 @@ function startWrapper(root, options) {
     }
     shell = gitBash;
   }
-  const wrapper = join13(root, GUARD_RUNNER_REL2);
-  if (!existsSync9(wrapper))
+  const wrapper = join14(root, GUARD_RUNNER_REL2);
+  if (!existsSync10(wrapper))
     return failed(repairSentence());
-  const run = spawnSync3(shell, [wrapper, CONNECTION_VERB], {
+  const run = spawnSync2(shell, [wrapper, CONNECTION_VERB], {
     cwd: root,
     env: { ...options.env, CLAUDE_PROJECT_DIR: root },
     encoding: "utf-8",
@@ -13885,7 +14214,7 @@ function startWrapper(root, options) {
 }
 function settingsDisablingHooks(root) {
   for (const rel of [SETTINGS_REL, LOCAL_SETTINGS_REL]) {
-    const parsed = readJson(join13(root, rel));
+    const parsed = readJson(join14(root, rel));
     if (isObject3(parsed) && parsed["disableAllHooks"] === true)
       return rel;
   }
@@ -13915,7 +14244,7 @@ function parseAnswer(stdout) {
 function usageOf(said) {
   if (!Array.isArray(said))
     return [];
-  const usage3 = [];
+  const usage5 = [];
   for (const figure of said) {
     if (!isObject3(figure))
       continue;
@@ -13928,9 +14257,9 @@ function usageOf(said) {
       continue;
     if (typeof resetsAt !== "string" || Number.isNaN(Date.parse(resetsAt)))
       continue;
-    usage3.push({ agent, window, usedPercentage, resetsAt: new Date(resetsAt) });
+    usage5.push({ agent, window, usedPercentage, resetsAt: new Date(resetsAt) });
   }
-  return usage3;
+  return usage5;
 }
 function checksRunningLine(running, hooksMissing) {
   if (running.state === "not-run")
@@ -13947,7 +14276,7 @@ function failed(text) {
   return { state: "failed", line: { ok: false, text } };
 }
 function repairSentence() {
-  return `Checks running: no. Halfcycle's check could not start. To repair it, run ${HALFCYCLE_COMMAND} here.`;
+  return `Checks running: no. Halfcycle's check could not start. To repair it, run ${ownCommand()} here.`;
 }
 function connectionLines(running) {
   if (running.state !== "answered") {
@@ -13975,8 +14304,8 @@ function folderTrustLine(root, options) {
   if (!mcpNamesServer(root))
     return void 0;
   const configFolder = options.env["CLAUDE_CONFIG_DIR"];
-  const stateFile = join13(configFolder !== void 0 && configFolder !== "" ? configFolder : options.home ?? homedir6(), CLAUDE_STATE_FILENAME);
-  const trust = trustOfWorkingFolder(root, stateFile, options.platform, { lstatSync: lstatSync2, readFileSync: readFileSync12, realpathSync: realpathSync4 });
+  const stateFile = join14(configFolder !== void 0 && configFolder !== "" ? configFolder : options.home ?? homedir6(), CLAUDE_STATE_FILENAME);
+  const trust = trustOfWorkingFolder(root, stateFile, options.platform, { lstatSync: lstatSync2, readFileSync: readFileSync13, realpathSync: realpathSync4 });
   return trust === "not-trusted" ? { ok: true, text: `Folder trust: ${FOLDER_NOT_TRUSTED_SENTENCE}` } : void 0;
 }
 function signInCodeLine(root, running, now, options) {
@@ -13986,7 +14315,7 @@ function signInCodeLine(root, running, now, options) {
     return void 0;
   return {
     ok: true,
-    text: `Sign-in code: it ran out before it was confirmed. To get a new one, run ${HALFCYCLE_COMMAND} here.`
+    text: `Sign-in code: it ran out before it was confirmed. To get a new one, run ${ownCommand()} here.`
   };
 }
 var AGENT_NAMES = { "claude-code": "Claude Code", codex: "Codex" };
@@ -14035,9 +14364,9 @@ function installedVersion(root) {
 }
 function versionNoLine(installed, current) {
   if (installed === null) {
-    return `Up to date: no. This folder has no Halfcycle version recorded; the newest is ${current}. To set it up, run ${HALFCYCLE_COMMAND} here.`;
+    return `Up to date: no. This folder has no Halfcycle version recorded; the newest is ${current}. To set it up, run ${ownCommand()} here.`;
   }
-  return `Up to date: no. This folder has Halfcycle ${installed}; the newest is ${current}. To update, run ${HALFCYCLE_COMMAND} here.`;
+  return `Up to date: no. This folder has Halfcycle ${installed}; the newest is ${current}. To update, run ${ownCommand()} here.`;
 }
 var CODEX_EVENT_SNAKE = {
   SessionStart: "session_start",
@@ -14048,13 +14377,26 @@ var CODEX_EVENT_SNAKE = {
   SubagentStop: "subagent_stop",
   SessionEnd: "session_end"
 };
+function codexHomeDir(options) {
+  const codexHome = options.env["CODEX_HOME"];
+  return codexHome !== void 0 && codexHome !== "" ? codexHome : join14(homedir6(), ".codex");
+}
+function isDirectory(path) {
+  try {
+    return statSync2(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
 function codexLine(root, options) {
-  const hooksPath = join13(root, CODEX_HOOKS_REL2);
-  if (!existsSync9(hooksPath))
+  const hooksPath = join14(root, CODEX_HOOKS_REL2);
+  if (!existsSync10(hooksPath))
+    return void 0;
+  if (!isDirectory(codexHomeDir(options)))
     return void 0;
   const positions = codexEntryPositions(hooksPath);
   if (positions === void 0) {
-    return { ok: false, text: `Codex: not complete. To repair it, run ${HALFCYCLE_COMMAND} here.` };
+    return { ok: false, text: `Codex: not complete. To repair it, run ${ownCommand()} here.` };
   }
   return codexApprovalStatus(root, positions, options) === "approved" ? { ok: true, text: "Codex: set up, and its checks are approved." } : {
     ok: false,
@@ -14090,17 +14432,16 @@ function codexEntryPositions(hooksPath) {
   return positions;
 }
 function codexApprovalStatus(root, positions, options) {
-  const codexHome = options.env["CODEX_HOME"];
-  const configPath = join13(codexHome !== void 0 && codexHome !== "" ? codexHome : join13(homedir6(), ".codex"), "config.toml");
+  const configPath = join14(codexHomeDir(options), "config.toml");
   let text;
   try {
-    text = readFileSync12(configPath, "utf-8");
+    text = readFileSync13(configPath, "utf-8");
   } catch {
     return "not-approved";
   }
   let hooksPath;
   try {
-    hooksPath = join13(realpathSync4(root), CODEX_HOOKS_REL2);
+    hooksPath = join14(realpathSync4(root), CODEX_HOOKS_REL2);
   } catch {
     return "not-approved";
   }
@@ -14130,10 +14471,10 @@ function naturalList(items) {
   return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
 }
 function readJson(path) {
-  if (!existsSync9(path))
+  if (!existsSync10(path))
     return void 0;
   try {
-    return JSON.parse(readFileSync12(path, "utf-8"));
+    return JSON.parse(readFileSync13(path, "utf-8"));
   } catch {
     return void 0;
   }
@@ -14143,12 +14484,12 @@ function isObject3(value) {
 }
 
 // dist/claude-version-probe.js
-import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync10, realpathSync as realpathSync5 } from "node:fs";
-import { delimiter as delimiter2, join as join14 } from "node:path";
+import { execFileSync as execFileSync4 } from "node:child_process";
+import { existsSync as existsSync11, realpathSync as realpathSync5 } from "node:fs";
+import { delimiter as delimiter2, join as join15 } from "node:path";
 function execVersionCommand(command, timeoutMs, deps) {
   const platform6 = deps.platform ?? process.platform;
-  const exec = deps.exec ?? execFileSync3;
+  const exec = deps.exec ?? execFileSync4;
   try {
     return platform6 === "win32" ? exec("cmd.exe", ["/d", "/s", "/c", `"${command} --version"`], {
       encoding: "utf-8",
@@ -14188,7 +14529,7 @@ var INSTALL_METHOD_RULES = [
 function probeClaudeCodeInstallMethod(deps = {}) {
   const env = deps.env ?? process.env;
   const platform6 = deps.platform ?? process.platform;
-  const exists = deps.exists ?? existsSync10;
+  const exists = deps.exists ?? existsSync11;
   const realpath = deps.realpath ?? ((file) => {
     try {
       return realpathSync5(file);
@@ -14200,7 +14541,7 @@ function probeClaudeCodeInstallMethod(deps = {}) {
   const dirs = (env["PATH"] ?? "").split(delimiter2).filter((dir) => dir !== "");
   for (const dir of dirs) {
     for (const name of names) {
-      const file = join14(dir, name);
+      const file = join15(dir, name);
       if (!exists(file))
         continue;
       const real = realpath(file);
@@ -14235,8 +14576,8 @@ function codexInstallLine(codex) {
 }
 
 // dist/build-record/write.js
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, rmSync as rmSync6 } from "node:fs";
-import { basename as basename2, join as join15, resolve as resolve3, relative as relative2, isAbsolute as isAbsolute3 } from "node:path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, rmSync as rmSync6 } from "node:fs";
+import { basename as basename2, join as join16, resolve as resolve3, relative as relative2, isAbsolute as isAbsolute3 } from "node:path";
 
 // dist/build-record/render-v2.js
 var HIDDEN = /[\p{Cc}\p{Zl}\p{Zp}\p{Default_Ignorable_Code_Point}]/u;
@@ -14827,7 +15168,7 @@ function renderBuildRecordV2Markdown(record2) {
 }
 
 // dist/build-record/pair-io.js
-import { closeSync, openSync, readFileSync as readFileSync13, renameSync as renameSync2, rmSync as rmSync5, writeSync as writeSync2 } from "node:fs";
+import { closeSync, openSync, readFileSync as readFileSync14, renameSync as renameSync2, rmSync as rmSync5, writeSync as writeSync2 } from "node:fs";
 function createExclusiveOnDisk(path, data) {
   const bytes = typeof data === "string" ? Buffer.from(data, "utf-8") : data;
   const fd = openSync(path, "wx");
@@ -14858,7 +15199,7 @@ function isEexist(err) {
 }
 function readIfPresent(path) {
   try {
-    return readFileSync13(path, "utf-8");
+    return readFileSync14(path, "utf-8");
   } catch {
     return null;
   }
@@ -14890,7 +15231,7 @@ function replaceOne(io, tmp, finalPath, text) {
 }
 
 // dist/build-record/write.js
-var BUILD_RECORD_DIR = join15("docs", "build-records");
+var BUILD_RECORD_DIR = join16("docs", "build-records");
 function assertInsideOutDir(outDir, candidate, identity) {
   const rel = relative2(outDir, resolve3(candidate));
   const isPlainFilename = rel !== "" && rel !== ".." && !isAbsolute3(rel) && rel === basename2(rel);
@@ -14928,8 +15269,8 @@ function writeRecordPair(repoRoot, phase, rawRecord, record2, io = NODE_RECORD_P
   }
   const outDir = resolve3(repoRoot, BUILD_RECORD_DIR);
   const segment = renderPhaseSegment(phase);
-  const jsonPath = join15(outDir, `${segment}.json`);
-  const mdPath = join15(outDir, `${segment}.md`);
+  const jsonPath = join16(outDir, `${segment}.json`);
+  const mdPath = join16(outDir, `${segment}.md`);
   const jsonTmp = `${jsonPath}.tmp`;
   const mdTmp = `${mdPath}.tmp`;
   for (const candidate of [jsonPath, mdPath, jsonTmp, mdTmp]) {
@@ -14943,7 +15284,7 @@ function writeRecordPair(repoRoot, phase, rawRecord, record2, io = NODE_RECORD_P
   }
   const existingJson = readIfPresent(jsonPath);
   if (existingJson === null) {
-    return { kind: "in-the-way", path: existsSync11(jsonPath) ? jsonPath : mdPath };
+    return { kind: "in-the-way", path: existsSync12(jsonPath) ? jsonPath : mdPath };
   }
   if (existingJson === jsonText) {
     replaceOne(io, mdTmp, mdPath, mdText);
@@ -14970,21 +15311,21 @@ function writeRecordPair(repoRoot, phase, rawRecord, record2, io = NODE_RECORD_P
 import { relative as relative5 } from "node:path";
 
 // dist/open-phase.js
-import { readFileSync as readFileSync19 } from "node:fs";
-import { join as join23 } from "node:path";
+import { readFileSync as readFileSync20 } from "node:fs";
+import { join as join24 } from "node:path";
 
 // dist/close-phase.js
-import { execFile, execFileSync as execFileSync5 } from "node:child_process";
-import { readFileSync as readFileSync18 } from "node:fs";
-import { join as join22 } from "node:path";
+import { execFile, execFileSync as execFileSync6 } from "node:child_process";
+import { readFileSync as readFileSync19 } from "node:fs";
+import { join as join23 } from "node:path";
 
 // dist/plan.js
-import { existsSync as existsSync13, readFileSync as readFileSync17 } from "node:fs";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync18 } from "node:fs";
+import { join as join22 } from "node:path";
 
 // dist/draw/write.js
-import { closeSync as closeSync2, lstatSync as lstatSync3, mkdirSync as mkdirSync9, openSync as openSync2, readFileSync as readFileSync14, readSync, realpathSync as realpathSync6, rmSync as rmSync7 } from "node:fs";
-import { dirname as dirname6, isAbsolute as isAbsolute4, join as join16, relative as relative3, resolve as resolve4, sep } from "node:path";
+import { closeSync as closeSync2, lstatSync as lstatSync3, mkdirSync as mkdirSync9, openSync as openSync2, readFileSync as readFileSync15, readSync, realpathSync as realpathSync6, rmSync as rmSync7 } from "node:fs";
+import { dirname as dirname7, isAbsolute as isAbsolute4, join as join17, relative as relative3, resolve as resolve4, sep } from "node:path";
 var DOCS_DIR = "docs";
 var DIAGRAMS_DIR = "diagrams";
 var DIAGRAM_DIR_REL = `${DOCS_DIR}/${DIAGRAMS_DIR}`;
@@ -15040,9 +15381,9 @@ function embedImageLink(base, doc) {
 }
 function diagramPaths(repoRoot, base) {
   const root = resolve4(repoRoot);
-  const dir = join16(root, DOCS_DIR, DIAGRAMS_DIR);
+  const dir = join17(root, DOCS_DIR, DIAGRAMS_DIR);
   const names = fileNames(base);
-  const file = Object.fromEntries(DIAGRAM_FILES.map((which) => [which, join16(dir, names[which])]));
+  const file = Object.fromEntries(DIAGRAM_FILES.map((which) => [which, join17(dir, names[which])]));
   return { repoRoot: root, dir, file };
 }
 function diagramRel(base, which) {
@@ -15077,7 +15418,7 @@ function checkDiagramPlace(paths) {
   }
   let ancestor = paths.dir;
   while (lstatOrNull2(ancestor) === null) {
-    const parent = dirname6(ancestor);
+    const parent = dirname7(ancestor);
     if (parent === ancestor)
       break;
     ancestor = parent;
@@ -15137,7 +15478,7 @@ function readExistingSet(paths) {
     if (!stat.isFile())
       return { ok: false, inTheWay: which, temp: false };
     try {
-      found[which] = readFileSync14(paths.file[which]);
+      found[which] = readFileSync15(paths.file[which]);
     } catch {
       return { ok: false, inTheWay: which, temp: false };
     }
@@ -15315,10 +15656,10 @@ function isMissingRoute(method, status, body) {
 }
 
 // dist/change.js
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 
 // dist/cli-contract.js
-var CLI_VERBS = ["install", "check-drift", "build-record", "open-phase", "close-phase", "system", "draw", "plan", "review", "check-tasks", "check-criteria", "check-report", "ready", "uninstall", "change", "pace", "route", "prove", "preview", "doctor", "restore", "request-shapes", "allow", "size"];
+var CLI_VERBS = ["install", "check-drift", "build-record", "open-phase", "close-phase", "system", "draw", "plan", "review", "check-tasks", "check-criteria", "check-report", "ready", "uninstall", "change", "pace", "route", "prove", "preview", "doctor", "restore", "request-shapes", "allow", "size", "regression", "crew"];
 var CONTRACTS = [
   { verb: "install", required: [], conditional: [] },
   { verb: "check-drift", required: [], conditional: [] },
@@ -15522,7 +15863,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_COMMAND} ${verb} ${quoteForShell(phase)}${flags ? ` ${flags}` : ""}`;
+  return `${ownCommand()} ${verb} ${quoteForShell(phase)}${flags ? ` ${flags}` : ""}`;
 }
 var PLACEHOLDERS = {
   "--verdict": "<clean|defects>",
@@ -15558,13 +15899,13 @@ function placeholderRefusal(verb, tokens) {
 }
 
 // dist/system-report.js
-import { execFileSync as execFileSync4 } from "node:child_process";
-import { readFileSync as readFileSync15 } from "node:fs";
-import { join as join17 } from "node:path";
+import { execFileSync as execFileSync5 } from "node:child_process";
+import { readFileSync as readFileSync16 } from "node:fs";
+import { join as join18 } from "node:path";
 function readDescriptionFile(repoRoot) {
   let text;
   try {
-    text = readFileSync15(join17(repoRoot, SYSTEM_DESCRIPTION_REL), "utf-8");
+    text = readFileSync16(join18(repoRoot, SYSTEM_DESCRIPTION_REL), "utf-8");
   } catch (err) {
     const code = err.code;
     return code === "ENOENT" || code === "ENOTDIR" ? { kind: "missing" } : { kind: "unreadable" };
@@ -15602,7 +15943,7 @@ function problemLines(raw, problems) {
 }
 var listTrackedFiles = (repoRoot) => {
   try {
-    const out = execFileSync4("git", ["-C", repoRoot, "ls-files", "-z"], {
+    const out = execFileSync5("git", ["-C", repoRoot, "ls-files", "-z"], {
       encoding: "utf-8",
       env: gitEnvForNamedRepo(),
       stdio: ["ignore", "pipe", "ignore"],
@@ -15699,7 +16040,7 @@ function readCredentialOrLine(repoRoot, deps, verb) {
   } catch {
     return {
       ok: false,
-      line: `halfcycle ${verb}: this project is not connected to Halfcycle on this machine. Run ${HALFCYCLE_COMMAND} here first, then run this again. Nothing was sent.
+      line: `halfcycle ${verb}: this project is not connected to Halfcycle on this machine. Run ${ownCommand()} here first, then run this again. Nothing was sent.
 `
     };
   }
@@ -15788,8 +16129,8 @@ async function runSystem(repoRoot, deps) {
 }
 
 // dist/build-record/write-change.js
-import { existsSync as existsSync12, mkdirSync as mkdirSync10 } from "node:fs";
-import { basename as basename3, isAbsolute as isAbsolute5, join as join18, relative as relative4, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync10 } from "node:fs";
+import { basename as basename3, isAbsolute as isAbsolute5, join as join19, relative as relative4, resolve as resolve5 } from "node:path";
 
 // dist/build-record/render-change.js
 function counted2(n, one, many) {
@@ -15934,7 +16275,7 @@ function renderChangeRecordMarkdown(record2) {
 }
 
 // dist/build-record/write-change.js
-var CHANGE_RECORD_DIR = join18("docs", "build-records", "changes");
+var CHANGE_RECORD_DIR = join19("docs", "build-records", "changes");
 var InvalidChangeIdError = class extends Error {
   id;
   constructor(id) {
@@ -15954,8 +16295,8 @@ function writeChangeRecordPair(repoRoot, sortingId, rawRecord, record2, io = NOD
   if (!checked.success)
     throw new InvalidChangeIdError(sortingId);
   const outDir = resolve5(repoRoot, CHANGE_RECORD_DIR);
-  const jsonPath = join18(outDir, `${checked.data}.json`);
-  const mdPath = join18(outDir, `${checked.data}.md`);
+  const jsonPath = join19(outDir, `${checked.data}.json`);
+  const mdPath = join19(outDir, `${checked.data}.md`);
   const mdTmp = `${mdPath}.tmp`;
   for (const candidate of [jsonPath, mdPath, mdTmp]) {
     assertInsideChangeDir(outDir, candidate, sortingId);
@@ -15968,7 +16309,7 @@ function writeChangeRecordPair(repoRoot, sortingId, rawRecord, record2, io = NOD
   }
   const existingJson = readIfPresent(jsonPath);
   if (existingJson === null) {
-    return { kind: "in-the-way", path: existsSync12(jsonPath) ? jsonPath : mdPath };
+    return { kind: "in-the-way", path: existsSync13(jsonPath) ? jsonPath : mdPath };
   }
   if (existingJson !== jsonText)
     return { kind: "in-the-way", path: jsonPath };
@@ -15977,9 +16318,9 @@ function writeChangeRecordPair(repoRoot, sortingId, rawRecord, record2, io = NOD
 }
 
 // dist/change.js
-var CHANGE_USAGE = `${HALFCYCLE_COMMAND} change sort --request "<one line>" --touches <path>\u2026 [--contract <from>:<to>]\u2026 [--stored-data] [--standing-rule] [--new-part] [--repo <root>]
-  ${HALFCYCLE_COMMAND} change up <mini|full> (--change <id> | --phase <phase>) [--repo <root>]
-  ${HALFCYCLE_COMMAND} change done <id> [--repo <root>]`;
+var CHANGE_USAGE = `${ownCommand()} change sort --request "<one line>" --touches <path>\u2026 [--contract <from>:<to>]\u2026 [--stored-data] [--standing-rule] [--new-part] [--repo <root>]
+  ${ownCommand()} change up <mini|full> (--change <id> | --phase <phase>) [--repo <root>]
+  ${ownCommand()} change done <id> [--repo <root>]`;
 function usage(line) {
   return { ok: false, line: `${line}
 Usage:
@@ -16176,7 +16517,7 @@ ${nextSayLine(sorted.next.say)}
 `;
 }
 function changeDoneCommand(sortingId) {
-  return `${HALFCYCLE_COMMAND} change done ${quoteForShell(sortingId)}`;
+  return `${ownCommand()} change done ${quoteForShell(sortingId)}`;
 }
 function recordOutcomeLines(record2) {
   switch (record2.outcome) {
@@ -16231,7 +16572,7 @@ function writePairLines(deps, repoRoot, sortingId, found) {
       };
     }
     return {
-      stdout: `[halfcycle] Its record is in ${join19(CHANGE_RECORD_DIR, `${sortingId}.md`)}.
+      stdout: `[halfcycle] Its record is in ${join20(CHANGE_RECORD_DIR, `${sortingId}.md`)}.
 `,
       stderr: "",
       ok: true
@@ -16445,7 +16786,7 @@ async function runChangeDone(repoRoot, sortingId, deps) {
     case "not-configured":
       return {
         stdout: "",
-        stderr: `${p} this project is not connected to Halfcycle on this machine. Run ${HALFCYCLE_COMMAND} here first, then run this again. Nothing was sent.
+        stderr: `${p} this project is not connected to Halfcycle on this machine. Run ${ownCommand()} here first, then run this again. Nothing was sent.
 `,
         exitCode: 1
       };
@@ -16470,24 +16811,24 @@ function runChange(repoRoot, args2, deps) {
 }
 
 // dist/shown-record.js
-import { chmodSync as chmodSync3, mkdirSync as mkdirSync11, readFileSync as readFileSync16, renameSync as renameSync3, unlinkSync, writeFileSync as writeFileSync8 } from "node:fs";
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync11, readFileSync as readFileSync17, renameSync as renameSync3, unlinkSync, writeFileSync as writeFileSync8 } from "node:fs";
 import { platform as platform4 } from "node:os";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 function updateShownRecord(engagementId, update, home) {
   let temp = null;
   try {
     const dir = engagementStateDir(engagementId, home);
-    const path = join20(dir, SHOWN_PLANS_FILENAME);
+    const path = join21(dir, SHOWN_PLANS_FILENAME);
     let current;
     try {
-      current = parseShownRecord(readFileSync16(path, "utf-8"));
+      current = parseShownRecord(readFileSync17(path, "utf-8"));
     } catch {
       current = { entries: [], reviews: [] };
     }
     const next = update(current);
     const body = serialiseShownRecord(next);
     mkdirSync11(dir, { recursive: true, mode: 448 });
-    temp = join20(dir, `.${SHOWN_PLANS_FILENAME}.${process.pid}.tmp`);
+    temp = join21(dir, `.${SHOWN_PLANS_FILENAME}.${process.pid}.tmp`);
     writeFileSync8(temp, body, { mode: 384 });
     if (platform4() !== "win32")
       chmodSync3(temp, 384);
@@ -16505,7 +16846,7 @@ function updateShownRecord(engagementId, update, home) {
 }
 
 // dist/plan.js
-var PLAN_USAGE = `${HALFCYCLE_COMMAND} plan <phase> [--show] [--repo <root>]`;
+var PLAN_USAGE = `${ownCommand()} plan <phase> [--show] [--repo <root>]`;
 var PLAN_DIR_REL = "docs/phases";
 function planFileRel(phase) {
   return `${PLAN_DIR_REL}/${renderPhaseSegment(phase)}.plan.json`;
@@ -16564,7 +16905,7 @@ function readAndCheckPlan(repoRoot, phase, description, verb) {
   const fileRel = planFileRel(phase);
   let text;
   try {
-    text = readFileSync17(join21(repoRoot, fileRel), "utf-8");
+    text = readFileSync18(join22(repoRoot, fileRel), "utf-8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT" || code === "ENOTDIR") {
@@ -16714,19 +17055,19 @@ function notAPhaseNameLine(verb, phase) {
 `;
 }
 function removalOwedLines(verb, parts) {
-  return parts.map((part) => `halfcycle ${verb}: docs/system.json still holds "${part.name}", which phase "${part.phase}"'s review ${part.act}. Take it out, run ${HALFCYCLE_COMMAND} system, then run this again.
+  return parts.map((part) => `halfcycle ${verb}: docs/system.json still holds "${part.name}", which phase "${part.phase}"'s review ${part.act}. Take it out, run ${ownCommand()} system, then run this again.
 `).join("");
 }
 function redrawLine(repoRoot, phase) {
   let exists;
   try {
-    exists = existsSync13(join21(repoRoot, DIAGRAM_DIR_REL, embedImageName(phaseDiagramBase(phase))));
+    exists = existsSync14(join22(repoRoot, DIAGRAM_DIR_REL, embedImageName(phaseDiagramBase(phase))));
   } catch {
     return null;
   }
   if (!exists)
     return null;
-  return `This phase's picture in your docs may show an earlier plan. Draw it again with: ${HALFCYCLE_COMMAND} draw phase ${quoteForShell(phase)}
+  return `This phase's picture in your docs may show an earlier plan. Draw it again with: ${ownCommand()} draw phase ${quoteForShell(phase)}
 `;
 }
 function movedUpLines(movedUp) {
@@ -16746,14 +17087,14 @@ function planStateSentence(state, givenIn) {
       return "The owner sent this plan back. Change it to answer the owner's notes, then run this again.";
   }
 }
-function approvalLine2(phase, number, typedApprovalOffered, pinnedVersion, shown2, engagementId) {
-  const address = systemViewUrl(engagementId, phase);
+function approvalLine2(phase, number, typedApprovalOffered, pinnedVersion, shown2, engagementId, serviceUrl) {
+  const address = systemViewUrl(engagementId, phase, serviceUrl);
   const then = (sentence, viewSentence) => address === void 0 ? sentence : `${sentence} ${viewSentence} ${address}`;
   if (!typedApprovalOffered) {
     return then(TYPED_APPROVAL_OFF_SENTENCE, "The project's owner approves it in the System view:");
   }
   if (!clientMeetsChatApprovalFloor(pinnedVersion)) {
-    return then(CLIENT_UPDATE_SENTENCE, "Or the project's owner approves it in the System view now:");
+    return then(clientUpdateSentence(ownVersion()), "Or the project's owner approves it in the System view now:");
   }
   return then(`To approve it, the project's owner types \`approve ${phase}\` in their own interactive session ${HEADLESS_CANNOT_APPROVE}. Only the owner can.`, "They can also approve it in the System view:");
 }
@@ -16836,13 +17177,13 @@ ${redraw}`;
       exitCode: 1
     };
   }
-  const stdout = outcome.state === "approved" ? listed : listed + `${approvalLine2(shownPhase, outcome.phaseNumber, outcome.typedApprovalOffered, deps.pinnedClientVersion(repoRoot), written.entries, stage.credential.engagementId)}
+  const stdout = outcome.state === "approved" ? listed : listed + `${approvalLine2(shownPhase, outcome.phaseNumber, outcome.typedApprovalOffered, deps.pinnedClientVersion(repoRoot), written.entries, stage.credential.engagementId, stage.credential.serviceUrl)}
 `;
   return { stdout, stderr: warnings, exitCode: 0 };
 }
 
 // dist/review.js
-var REVIEW_USAGE = `${HALFCYCLE_COMMAND} review <phase> (--show | --answer <part> "<answer>") [--repo <root>]`;
+var REVIEW_USAGE = `${ownCommand()} review <phase> (--show | --answer <part> "<answer>") [--repo <root>]`;
 function parseReviewArgs(argv) {
   const positionals = [];
   let repoRoot;
@@ -17061,7 +17402,7 @@ function rv8Line(view) {
   }
   return `halfcycle review: phase "${view.phase}" has no review open. Its review opens when its build is finished and the close step runs.`;
 }
-var RV9_LINE = `halfcycle review: this project is not signed in on this computer. ${HOOK_REMEDY}`;
+var RV9_LINE = `halfcycle review: this project is not signed in on this computer. ${hookRemedy(ownVersion())}`;
 var RV10_LINE = "halfcycle review: Halfcycle could not be reached just now. Check this computer's connection, then run this again.";
 var RV11_LINE = "halfcycle review: the list just shown could not be recorded on this computer, so a typed decision cannot use it. Run this again.";
 function an1Line(name) {
@@ -17230,7 +17571,7 @@ function readHeadCommit(repoRoot) {
   }
   let out;
   try {
-    out = execFileSync5("git", ["-C", repoRoot, "rev-parse", "HEAD"], {
+    out = execFileSync6("git", ["-C", repoRoot, "rev-parse", "HEAD"], {
       encoding: "utf-8",
       env: gitEnvForNamedRepo(),
       stdio: ["ignore", "pipe", "ignore"]
@@ -17241,7 +17582,7 @@ function readHeadCommit(repoRoot) {
       return { read: false, cause: "unreadable", missingGit: true };
     }
     try {
-      execFileSync5("git", ["-C", repoRoot, "rev-parse", "--git-dir"], {
+      execFileSync6("git", ["-C", repoRoot, "rev-parse", "--git-dir"], {
         encoding: "utf-8",
         env: gitEnvForNamedRepo(),
         stdio: ["ignore", "pipe", "ignore"]
@@ -17448,8 +17789,8 @@ function typedReviewHintLine(offered, phase) {
   const lines = accept === null ? "then type one decision per line, as the whole message." : `then type ${accept} as the whole message to accept every built part, or one line per part, such as ${accept}/<part>; the list gives each part's lines.`;
   return `[halfcycle] The owner reviews each part in their own coding agent's session: they say "review what was built" to see the list, ${lines}`;
 }
-function systemViewReviewLine(offered, engagementId, phase) {
-  const address = systemViewUrl(engagementId, phase);
+function systemViewReviewLine(offered, engagementId, phase, serviceUrl) {
+  const address = systemViewUrl(engagementId, phase, serviceUrl);
   if (address === void 0)
     return void 0;
   if (!offered)
@@ -17482,7 +17823,7 @@ function unfinishedStepsLines(phase, steps) {
 function cleanOverFindingsLine(phase, findings) {
   return findings === 1 ? `${REFUSED} the walk's verdict is clean, but 1 defect is recorded against phase "${phase}". Run this again with --verdict defects and a --finding for it. Nothing was sent to the owner.` : `${REFUSED} the walk's verdict is clean, but ${String(findings)} defects are recorded against phase "${phase}". Run this again with --verdict defects and a --finding for each. Nothing was sent to the owner.`;
 }
-function closeStepReport(phase, attempt2, engagementId) {
+function closeStepReport(phase, attempt2, engagementId, serviceUrl) {
   const stdout = [];
   const stderr = [];
   let exitCode = 1;
@@ -17511,7 +17852,7 @@ function closeStepReport(phase, attempt2, engagementId) {
             stdout.push(COULD_NOT_COUNT_LINE);
           stdout.push(typedReviewHintLine(answer.typedReviewOffered, phase));
           {
-            const viewLine = systemViewReviewLine(answer.typedReviewOffered, engagementId, phase);
+            const viewLine = systemViewReviewLine(answer.typedReviewOffered, engagementId, phase, serviceUrl);
             if (viewLine !== void 0)
               stdout.push(viewLine);
           }
@@ -17680,7 +18021,7 @@ var PHASE_MODELS_FILENAME = "phase-models.json";
 var PACING_FOLDER = "pacing";
 function pacingFile(engagementId, name, home) {
   try {
-    return join22(engagementStateDir(engagementId, home), PACING_FOLDER, name);
+    return join23(engagementStateDir(engagementId, home), PACING_FOLDER, name);
   } catch {
     return null;
   }
@@ -17691,7 +18032,7 @@ function readPhaseLimitFile(engagementId, phase, home) {
     return null;
   let text;
   try {
-    text = readFileSync18(path, "utf-8");
+    text = readFileSync19(path, "utf-8");
   } catch (err) {
     return err.code === "ENOENT" ? "missing" : null;
   }
@@ -17732,7 +18073,7 @@ function relayedChoiceLines(engagementId, phase, home) {
   if (path === null)
     return [];
   try {
-    const parsed = relayedChoicesFileSchema.safeParse(JSON.parse(readFileSync18(path, "utf-8")));
+    const parsed = relayedChoicesFileSchema.safeParse(JSON.parse(readFileSync19(path, "utf-8")));
     if (!parsed.success || parsed.data.phase !== phase)
       return [];
     return parsed.data.entries.map((entry) => relayedChoiceLineOf(entry));
@@ -17745,7 +18086,7 @@ function readPhaseModels(engagementId, phase, openedAt, home) {
   if (path === null)
     return null;
   try {
-    const parsed = phaseModelsFileSchema.safeParse(JSON.parse(readFileSync18(path, "utf-8")));
+    const parsed = phaseModelsFileSchema.safeParse(JSON.parse(readFileSync19(path, "utf-8")));
     if (!parsed.success || parsed.data.phase !== phase)
       return null;
     if (openedAt !== null && parsed.data.openedAt !== openedAt)
@@ -17755,8 +18096,8 @@ function readPhaseModels(engagementId, phase, openedAt, home) {
     return null;
   }
 }
-function usageTokensOf(usage3) {
-  return usage3.inputTokens + usage3.outputTokens + usage3.cacheWriteTokens + usage3.cacheReadTokens;
+function usageTokensOf(usage5) {
+  return usage5.inputTokens + usage5.outputTokens + usage5.cacheWriteTokens + usage5.cacheReadTokens;
 }
 function tierFigureLines(work, expected, summary, models, details = false) {
   const lines = [];
@@ -17848,12 +18189,12 @@ function readRepoCredential(repoRoot, env = process.env, home) {
   if (pinned !== null)
     assertEngagementId(pinned);
   const fromStore = pinned === null ? null : readEngagementEnv(pinned, home);
-  const looked = pinned === null ? `${join23(repoRoot, ".halfcycle", "bundle.json")} (which names no engagement)` : engagementEnvPath(pinned, home);
+  const looked = pinned === null ? `${join24(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.`);
+      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 \`${ownBareCommand()}\`; if this repo has no Halfcycle install yet, or this machine has never installed this engagement, run the installer here first.`);
     }
     values[key] = value;
   }
@@ -17865,7 +18206,7 @@ function readRepoCredential(repoRoot, env = process.env, home) {
 }
 function readPinnedEngagementId(repoRoot) {
   try {
-    const pin = JSON.parse(readFileSync19(join23(repoRoot, ".halfcycle", "bundle.json"), "utf-8"));
+    const pin = JSON.parse(readFileSync20(join24(repoRoot, ".halfcycle", "bundle.json"), "utf-8"));
     const id = pin[PIN_ENGAGEMENT_ID_FIELD];
     return typeof id === "string" && id !== "" ? id : null;
   } catch {
@@ -17887,7 +18228,7 @@ function writePhaseStamp(engagementId, phase, home) {
     return { path, reason: err instanceof Error ? err.message : String(err) };
   }
 }
-async function openPhase(credential, phase, entry, home, repoRoot, sortingId, sizeId) {
+async function openPhase(credential, phase, entry, home, repoRoot, sortingId, sizeId, regression) {
   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("; ")}.`);
@@ -17909,6 +18250,9 @@ async function openPhase(credential, phase, entry, home, repoRoot, sortingId, si
   if (phase !== null && sizeId !== void 0) {
     requestBody.sizeId = sizeId;
   }
+  if (phase !== null && regression === true) {
+    requestBody.regression = true;
+  }
   const url = `${credential.serviceUrl}/engagements/${encodeURIComponent(credential.engagementId)}/phase`;
   let res;
   try {
@@ -18038,7 +18382,7 @@ async function obtainBuildRecord(credential, repoRoot, phase, io = NODE_RECORD_P
   };
 }
 function refetchCommand(phase) {
-  return `${HALFCYCLE_COMMAND} build-record ${quoteForShell(phase)}`;
+  return `${ownCommand()} build-record ${quoteForShell(phase)}`;
 }
 
 // dist/phase-work.js
@@ -18073,7 +18417,7 @@ async function readPhaseWork(credential, phase) {
 }
 
 // dist/draw/index.js
-var DRAW_USAGE = `${HALFCYCLE_COMMAND} draw (architecture | phase <phase>) [--repo <root>]`;
+var DRAW_USAGE = `${ownCommand()} draw (architecture | phase <phase>) [--repo <root>]`;
 function parseDrawArgs(argv) {
   const positionals = [];
   let repoRoot;
@@ -18349,9 +18693,9 @@ async function writeDrawOutcome(repoRoot, deps, outcome, target, warnings, canno
 }
 
 // dist/check-tasks.js
-import { readFileSync as readFileSync20 } from "node:fs";
-import { join as join24, resolve as resolve6 } from "node:path";
-var CHECK_TASKS_USAGE = `${HALFCYCLE_COMMAND} check-tasks <phase> [--with-task-list] [--repo <root>]`;
+import { readFileSync as readFileSync21 } from "node:fs";
+import { join as join25, resolve as resolve6 } from "node:path";
+var CHECK_TASKS_USAGE = `${ownCommand()} check-tasks <phase> [--with-task-list] [--repo <root>]`;
 function parseCheckTasksArgs(argv) {
   const positionals = [];
   let repoRoot;
@@ -18391,7 +18735,7 @@ function issuePlace(rel, path) {
 function readJsonFile(repoRoot, rel, parse) {
   let text;
   try {
-    text = readFileSync20(resolve6(repoRoot, rel), "utf-8");
+    text = readFileSync21(resolve6(repoRoot, rel), "utf-8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT" || code === "ENOTDIR")
@@ -18449,7 +18793,7 @@ function readPhasePlanParts(repoRoot, phase, description) {
   const file = planFileRel(phase);
   let text;
   try {
-    text = readFileSync20(join24(repoRoot, file), "utf-8");
+    text = readFileSync21(join25(repoRoot, file), "utf-8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT" || code === "ENOTDIR")
@@ -18482,7 +18826,7 @@ function readPlanSpecFiles(repoRoot, plan) {
     const rel = `${SPEC_FOLDER}/${slug}.md`;
     let text;
     try {
-      text = readFileSync20(join24(repoRoot, rel), "utf-8");
+      text = readFileSync21(join25(repoRoot, rel), "utf-8");
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT" || code === "ENOTDIR") {
@@ -18622,7 +18966,7 @@ async function runCheckTasksSized(repoRoot, phase, withTaskList, deps) {
 }
 
 // dist/check-criteria.js
-var CHECK_CRITERIA_USAGE = `${HALFCYCLE_COMMAND} check-criteria [<record file>] [--repo <root>]`;
+var CHECK_CRITERIA_USAGE = `${ownCommand()} check-criteria [<record file>] [--repo <root>]`;
 function parseCheckCriteriaArgs(argv) {
   const positionals = [];
   let repoRoot;
@@ -18673,8 +19017,8 @@ function runCheckCriteria(repoRoot, file) {
 }
 
 // dist/check-report.js
-import { readFileSync as readFileSync21 } from "node:fs";
-var CHECK_REPORT_USAGE = `${HALFCYCLE_COMMAND} check-report <file | -> --head <sha>`;
+import { readFileSync as readFileSync22 } from "node:fs";
+var CHECK_REPORT_USAGE = `${ownCommand()} check-report <file | -> --head <sha>`;
 function parseCheckReportArgs(argv) {
   const positionals = [];
   let head;
@@ -18709,7 +19053,7 @@ function runCheckReport(source, head, deps = {}) {
   }
   let body;
   try {
-    body = source === "-" ? (deps.readStdin ?? (() => readFileSync21(0, "utf-8")))() : readFileSync21(source, "utf-8");
+    body = source === "-" ? (deps.readStdin ?? (() => readFileSync22(0, "utf-8")))() : readFileSync22(source, "utf-8");
   } catch (err) {
     const code = err.code;
     const what = source === "-" ? "The report could not be read from standard input" : `${source} could not be read`;
@@ -18727,7 +19071,7 @@ function runCheckReport(source, head, deps = {}) {
 }
 
 // dist/ready.js
-var READY_USAGE = `${HALFCYCLE_COMMAND} ready <phase> [--cap <n>] [--repo <root>]`;
+var READY_USAGE = `${ownCommand()} ready <phase> [--cap <n>] [--repo <root>]`;
 var STATES_TEXT = buildTaskStateSchema.options.join(", ");
 var READY_LINES = {
   start: (id, title) => `Ready to start: ${named(id, title)}`,
@@ -18876,8 +19220,8 @@ function runReady(repoRoot, phase, cap) {
 
 // dist/prove.js
 import { spawn as spawn2 } from "node:child_process";
-var PROVE_USAGE = `${HALFCYCLE_COMMAND} prove <phase> <task> --label "<label>" --before -- <test command>
-         ${HALFCYCLE_COMMAND} prove <phase> <task> --label "<label>" --after [-- <test command>]
+var PROVE_USAGE = `${ownCommand()} prove <phase> <task> --label "<label>" --before -- <test command>
+         ${ownCommand()} prove <phase> <task> --label "<label>" --after [-- <test command>]
          (or --change <id> in place of <phase> <task>; add --reason "<why>" to say why) [--repo <root>]`;
 function splitProveInvocation(words) {
   const dash = words.indexOf("--");
@@ -18952,9 +19296,9 @@ function runProveChild(binary, credential, repoRoot, words, deps = {}) {
 }
 
 // dist/uninstall.js
-import { existsSync as existsSync14, lstatSync as lstatSync4, readFileSync as readFileSync22, readdirSync, rmSync as rmSync8, rmdirSync, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync15, lstatSync as lstatSync4, readFileSync as readFileSync23, readdirSync, rmSync as rmSync8, rmdirSync, writeFileSync as writeFileSync9 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { dirname as dirname7, join as join25, relative as relative6, sep as sep2 } from "node:path";
+import { dirname as dirname8, join as join26, relative as relative6, sep as sep2 } from "node:path";
 var REMOVE_CREDENTIAL_FLAG = "--remove-credential";
 function parseUninstallArgs(args2) {
   let removeCredential = false;
@@ -18989,13 +19333,13 @@ function readMergedJson(targetRepo, rule) {
   const { rel } = rule;
   if (symlinkOnPath(targetRepo, rel))
     return { state: "symlink" };
-  const path = join25(targetRepo, rel);
+  const path = join26(targetRepo, rel);
   if (!lexists(path))
     return { state: "absent" };
   let text;
   let value;
   try {
-    text = readFileSync22(path, "utf-8");
+    text = readFileSync23(path, "utf-8");
   } catch {
     text = "";
   }
@@ -19008,29 +19352,29 @@ function readMergedJson(targetRepo, rule) {
     return { state: "object", text, value };
   if (!rule.holdsOurs(text))
     return { state: "not-ours" };
-  throw new Refusal(`${rel} is not a JSON object, so Halfcycle cannot take its own entries out of it and nothing was removed. Fix it or delete it, then run "${HALFCYCLE_COMMAND} uninstall" again.`);
+  throw new Refusal(`${rel} is not a JSON object, so Halfcycle cannot take its own entries out of it and nothing was removed. Fix it or delete it, then run "${ownCommand()} uninstall" again.`);
 }
 function validate(options, rules) {
   const { targetRepo, removeCredential, home } = options;
-  const manifestPath = join25(targetRepo, INSTALL_MANIFEST_REL);
-  const pinPath = join25(targetRepo, BUNDLE_PIN_REL);
+  const manifestPath = join26(targetRepo, INSTALL_MANIFEST_REL);
+  const pinPath = join26(targetRepo, BUNDLE_PIN_REL);
   if (symlinkOnPath(targetRepo, INSTALL_MANIFEST_REL) || symlinkOnPath(targetRepo, BUNDLE_PIN_REL)) {
     throw new Refusal(`.halfcycle, or a file Halfcycle keeps in it, is a symbolic link here, so nothing was followed and nothing was removed.`);
   }
   let manifest = null;
   if (lexists(manifestPath)) {
     try {
-      manifest = parseManifest(readFileSync22(manifestPath, "utf-8"));
+      manifest = parseManifest(readFileSync23(manifestPath, "utf-8"));
     } catch (err) {
       const why = err instanceof UnreadableManifestError ? err.message : "it could not be read";
-      throw new Refusal(`${INSTALL_MANIFEST_REL} cannot be read (${why}), so nothing was removed. Restore it from git, or run "${HALFCYCLE_COMMAND}" once to rewrite it, then run "${HALFCYCLE_COMMAND} uninstall" again.`);
+      throw new Refusal(`${INSTALL_MANIFEST_REL} cannot be read (${why}), so nothing was removed. Restore it from git, or run "${ownCommand()}" once to rewrite it, then run "${ownCommand()} uninstall" again.`);
     }
   }
   let engagementId;
   let pinReadable = true;
   if (lexists(pinPath)) {
     try {
-      const pin = JSON.parse(readFileSync22(pinPath, "utf-8"));
+      const pin = JSON.parse(readFileSync23(pinPath, "utf-8"));
       const id = isPlainObject4(pin) ? pin[PIN_ENGAGEMENT_ID_FIELD] : void 0;
       engagementId = typeof id === "string" && id !== "" ? id : void 0;
     } catch {
@@ -19054,8 +19398,8 @@ function validate(options, rules) {
       throw new Refusal(`the project id in ${BUNDLE_PIN_REL} is not a valid Halfcycle project id, so it cannot name a folder on this machine. Nothing was removed, here or under ~/.halfcycle.`);
     }
     if (engagementId !== void 0) {
-      const expectedParent = join25(home ?? homedir7(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME);
-      if (dirname7(engagementStateDir(engagementId, home)) !== expectedParent) {
+      const expectedParent = join26(home ?? homedir7(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME);
+      if (dirname8(engagementStateDir(engagementId, home)) !== expectedParent) {
         throw new Refusal(`the project id in ${BUNDLE_PIN_REL} does not name a folder under ~/.halfcycle/engagements. Nothing was removed.`);
       }
     }
@@ -19080,7 +19424,7 @@ function mergedFileRules(writeSet) {
 function writeBack(targetRepo, rel, current, next, lists, name) {
   if (next === current)
     return;
-  const path = join25(targetRepo, rel);
+  const path = join26(targetRepo, rel);
   try {
     if (next === null) {
       rmSync8(path);
@@ -19097,7 +19441,7 @@ function statusLineClaimedFromTree(targetRepo, writeSet) {
   try {
     if (symlinkOnPath(targetRepo, SETTINGS_REL))
       return {};
-    const value = JSON.parse(readFileSync22(join25(targetRepo, SETTINGS_REL), "utf-8"));
+    const value = JSON.parse(readFileSync23(join26(targetRepo, SETTINGS_REL), "utf-8"));
     if (!isPlainObject4(value) || !("statusLine" in value))
       return {};
     const hash = canonicalSha256(value["statusLine"]);
@@ -19106,12 +19450,25 @@ function statusLineClaimedFromTree(targetRepo, writeSet) {
     return {};
   }
 }
+function attributionClaimedFromTree(targetRepo, writeSet) {
+  try {
+    if (symlinkOnPath(targetRepo, SETTINGS_REL))
+      return {};
+    const value = JSON.parse(readFileSync23(join26(targetRepo, SETTINGS_REL), "utf-8"));
+    if (!isPlainObject4(value) || !("attribution" in value))
+      return {};
+    const hash = canonicalSha256(value["attribution"]);
+    return writeSet.attributionSha256.has(hash) ? { attributionSha256: hash } : {};
+  } catch {
+    return {};
+  }
+}
 var BEFORE_UNKNOWN_MCP = { created: false, adopted: true, mcpServersCreated: false };
 function noRecord(targetRepo, writeSet) {
   const claim = (rel, header, lines) => {
     let text;
     try {
-      text = symlinkOnPath(targetRepo, rel) ? "" : readFileSync22(join25(targetRepo, rel), "utf-8");
+      text = symlinkOnPath(targetRepo, rel) ? "" : readFileSync23(join26(targetRepo, rel), "utf-8");
     } catch {
       text = "";
     }
@@ -19132,7 +19489,8 @@ function noRecord(targetRepo, writeSet) {
       hooksCreated: false,
       permissionsCreated: false,
       denyCreated: false,
-      ...statusLineClaimedFromTree(targetRepo, writeSet)
+      ...statusLineClaimedFromTree(targetRepo, writeSet),
+      ...attributionClaimedFromTree(targetRepo, writeSet)
     },
     mcp: BEFORE_UNKNOWN_MCP,
     gitignore: claim(GITIGNORE_REL, GITIGNORE_HEADER, writeSet.gitignoreLines),
@@ -19195,6 +19553,10 @@ function unmergeSettings(value, rec, writeSet) {
     delete value["statusLine"];
     changed = true;
   }
+  if (rec.attributionSha256 !== void 0 && writeSet.attributionSha256.has(rec.attributionSha256) && "attribution" in value && canonicalSha256(value["attribution"]) === rec.attributionSha256) {
+    delete value["attribution"];
+    changed = true;
+  }
   if ("schemaBefore" in rec && value["$schema"] === writeSet.settingsSchema) {
     if (rec.schemaBefore === null)
       delete value["$schema"];
@@ -19352,7 +19714,7 @@ function lastOccurrence(text, block) {
 }
 function coveredPathExists(targetRepo, line) {
   const path = line.trim().replace(/^\//, "").replace(/\/$/, "");
-  return path !== "" && lexists(join25(targetRepo, path));
+  return path !== "" && lexists(join26(targetRepo, path));
 }
 function selfBuildMergedFileRules() {
   return {
@@ -19366,7 +19728,7 @@ function removeSelfBuildOwnedFile(targetRepo, rel, lists, name) {
     name(lists.leftAlone, `${rel} (a symbolic link, or inside one \u2014 not followed)`, rel);
     return;
   }
-  const abs = join25(targetRepo, rel);
+  const abs = join26(targetRepo, rel);
   let isFile;
   try {
     isFile = lstatSync4(abs).isFile();
@@ -19390,10 +19752,10 @@ function removeSelfBuildCrewRoster(targetRepo, lists, name) {
     name(lists.leftAlone, `${rel} (a symbolic link, or inside one \u2014 not followed)`, rel);
     return;
   }
-  const abs = join25(targetRepo, rel);
+  const abs = join26(targetRepo, rel);
   let bytes;
   try {
-    bytes = readFileSync22(abs);
+    bytes = readFileSync23(abs);
   } catch {
     return;
   }
@@ -19417,10 +19779,10 @@ function removeSelfBuildCrewProfile(targetRepo, rel, text, lists, name) {
     name(lists.leftAlone, `${rel} (a symbolic link, or inside one \u2014 not followed)`, rel);
     return;
   }
-  const abs = join25(targetRepo, rel);
+  const abs = join26(targetRepo, rel);
   let bytes;
   try {
-    bytes = readFileSync22(abs);
+    bytes = readFileSync23(abs);
   } catch {
     return;
   }
@@ -19442,7 +19804,7 @@ function removeSelfBuildCrewProfile(targetRepo, rel, text, lists, name) {
 function removeSelfBuildEmptyDir(targetRepo, dir, lists, name) {
   if (symlinkOnPath(targetRepo, dir))
     return;
-  const abs = join25(targetRepo, dir);
+  const abs = join26(targetRepo, dir);
   try {
     if (!lstatSync4(abs).isDirectory() || readdirSync(abs).length > 0)
       return;
@@ -19476,7 +19838,7 @@ function uninstallSelfBuild(options) {
     throw err;
   }
   const { targetRepo } = options;
-  const pinExisted = lexists(join25(targetRepo, BUNDLE_PIN_REL));
+  const pinExisted = lexists(join26(targetRepo, BUNDLE_PIN_REL));
   const name = (list2, text, _path) => {
     list2.push(text);
   };
@@ -19556,14 +19918,18 @@ function uninstall(options) {
     adopted: false
   }));
   removeCodexConfigBlock(targetRepo, manifest.codexConfig, deleteCodexWhenEmpty(manifest.codexConfig), result, name);
-  if (holdsLocalAllowRecord(targetRepo)) {
+  const listRemoved = holdsLocalAllowRecord(targetRepo);
+  if (listRemoved) {
     removeLocalAllow(targetRepo);
-    if (existsSync14(join25(targetRepo, LOCAL_SETTINGS_REL2))) {
+    named2.add(LOCAL_ALLOW_RECORD_REL);
+  }
+  const serverRemoved = removeOwnServerApproval(targetRepo);
+  if (listRemoved || serverRemoved) {
+    if (existsSync15(join26(targetRepo, LOCAL_SETTINGS_REL2))) {
       name(result.restored, LOCAL_SETTINGS_REL2, LOCAL_SETTINGS_REL2);
     } else {
       name(result.removed, LOCAL_SETTINGS_REL2, LOCAL_SETTINGS_REL2);
     }
-    named2.add(LOCAL_ALLOW_RECORD_REL);
   }
   const deferred = /* @__PURE__ */ new Set([BUNDLE_PIN_REL, INSTALL_MANIFEST_REL]);
   const recorded = new Map(manifest.files.map((entry) => [entry.path, entry]));
@@ -19601,7 +19967,7 @@ function uninstall(options) {
   const gitattributes = manifest.gitattributes ?? { created: false, appended: [] };
   trimAppendedFile(targetRepo, gitattributes, deleteWhenEmpty(gitattributes.created), gitattributesRules(writeSet), result, name);
   const foundNothing = result.removed.length + result.restored.length + result.kept.length + result.failed.length === 0 && result.keptIgnoreLines.length === 0;
-  if (checked.manifest === null && !lexists(join25(targetRepo, BUNDLE_PIN_REL)) && foundNothing) {
+  if (checked.manifest === null && !lexists(join26(targetRepo, BUNDLE_PIN_REL)) && foundNothing) {
     return { outcome: "not-installed", exitCode: 0, ...result, credential: nothingToSay };
   }
   const credential = handleCredential(options, checked);
@@ -19609,7 +19975,7 @@ function uninstall(options) {
   if (result.failed.length === 0 && !credentialFailed) {
     removeInstalledFile(targetRepo, BUNDLE_PIN_REL, recorded.get(BUNDLE_PIN_REL), writeSet, result, name);
     try {
-      rmSync8(join25(targetRepo, INSTALL_MANIFEST_REL), { force: true });
+      rmSync8(join26(targetRepo, INSTALL_MANIFEST_REL), { force: true });
       named2.add(INSTALL_MANIFEST_REL);
     } catch {
       name(result.failed, INSTALL_MANIFEST_REL, INSTALL_MANIFEST_REL);
@@ -19644,13 +20010,13 @@ function applyMergedJson(targetRepo, rule, file, deleteWhenEmpty, lists, name, e
     return;
   const empty = Object.keys(value).length === 0 && deleteWhenEmpty;
   writeBack(targetRepo, rel, file.text, empty ? null : inLineEndingOf(file.text, serializeJson(value)), lists, name);
-  if (adopted && lexists(join25(targetRepo, rel))) {
+  if (adopted && lexists(join26(targetRepo, rel))) {
     name(lists.leftAlone, `${rel} (Halfcycle's hooks were taken out. There is no record of this file from before the install, so a permission rule or "$schema" Halfcycle added may still be there \u2014 it cannot be told apart from your own)`, rel);
   }
 }
 function removeCodexConfigBlock(targetRepo, record2, deleteWhenEmpty, lists, name) {
   const rel = CODEX_CONFIG_REL2;
-  const path = join25(targetRepo, rel);
+  const path = join26(targetRepo, rel);
   if (symlinkOnPath(targetRepo, rel)) {
     if (lexists(path))
       name(lists.leftAlone, `${rel} (a symbolic link, or inside one \u2014 not followed)`, rel);
@@ -19660,7 +20026,7 @@ function removeCodexConfigBlock(targetRepo, record2, deleteWhenEmpty, lists, nam
   try {
     if (!lstatSync4(path).isFile())
       return;
-    text = readFileSync22(path, "utf-8");
+    text = readFileSync23(path, "utf-8");
   } catch {
     return;
   }
@@ -19695,7 +20061,7 @@ function removeInstalledFile(targetRepo, path, entry, writeSet, lists, name) {
     name(lists.leftAlone, `${path} (a symbolic link, or inside one \u2014 not followed)`, path);
     return;
   }
-  const abs = join25(targetRepo, path);
+  const abs = join26(targetRepo, path);
   let isFile;
   try {
     isFile = lstatSync4(abs).isFile();
@@ -19709,7 +20075,7 @@ function removeInstalledFile(targetRepo, path, entry, writeSet, lists, name) {
   if (!writeSet.ownedDirs.has(path.slice(0, path.lastIndexOf("/")))) {
     let bytes;
     try {
-      bytes = readFileSync22(abs);
+      bytes = readFileSync23(abs);
     } catch {
       name(lists.failed, path, path);
       return;
@@ -19729,7 +20095,7 @@ function removeInstalledFile(targetRepo, path, entry, writeSet, lists, name) {
 function removeEmptyDir(targetRepo, dir, writeSet, lists, name) {
   if (!writeSet.dirs.has(dir) || symlinkOnPath(targetRepo, dir))
     return;
-  const abs = join25(targetRepo, dir);
+  const abs = join26(targetRepo, dir);
   try {
     if (!lstatSync4(abs).isDirectory() || readdirSync(abs).length > 0)
       return;
@@ -19748,10 +20114,10 @@ function trimAppendedFile(targetRepo, rec, deleteWhenEmpty, rules, lists, name)
     name(lists.leftAlone, `${rel} (a symbolic link \u2014 not followed)`, rel);
     return [];
   }
-  const path = join25(targetRepo, rel);
+  const path = join26(targetRepo, rel);
   let before;
   try {
-    before = readFileSync22(path, "utf-8");
+    before = readFileSync23(path, "utf-8");
   } catch {
     return [];
   }
@@ -19795,16 +20161,16 @@ function filesUnder(root, rel) {
   const walk = (dirRel) => {
     let names;
     try {
-      if (!lstatSync4(join25(root, dirRel)).isDirectory())
+      if (!lstatSync4(join26(root, dirRel)).isDirectory())
         return;
-      names = readdirSync(join25(root, dirRel));
+      names = readdirSync(join26(root, dirRel));
     } catch {
       return;
     }
     for (const entry of names.sort()) {
       const childRel = `${dirRel}/${entry}`;
       try {
-        if (lstatSync4(join25(root, childRel)).isDirectory())
+        if (lstatSync4(join26(root, childRel)).isDirectory())
           walk(childRel);
         else
           out.push(childRel);
@@ -19843,13 +20209,13 @@ function renderUninstallReport(result, home) {
   section("Kept, because it changed after Halfcycle wrote it \u2014 delete it yourself if you do not want it:", result.kept);
   section('Kept in .gitignore, because the path each line covers still exists \u2014 without the line, "git add ." would commit it:', result.keptIgnoreLines);
   section("Left alone \u2014 Halfcycle did not write these, or cannot tell that it did:", result.leftAlone);
-  section(`Could not remove \u2014 fix the cause, then run "${HALFCYCLE_COMMAND} uninstall" again to finish:`, result.failed);
+  section(`Could not remove \u2014 fix the cause, then run "${ownCommand()} uninstall" again to finish:`, result.failed);
   const c = result.credential;
   switch (c.kind) {
     case "still-held":
       out.push(`[halfcycle] This machine still holds this project's credential, at ${shownPath(c.dir, home)}.`);
       out.push("  Every checkout and worktree of this project on this machine uses it.");
-      out.push(`  To remove it too:  ${HALFCYCLE_COMMAND} uninstall ${REMOVE_CREDENTIAL_FLAG}`);
+      out.push(`  To remove it too:  ${ownCommand()} uninstall ${REMOVE_CREDENTIAL_FLAG}`);
       break;
     case "invalid-id":
       out.push(`[halfcycle] This machine may still hold a credential for this project, but the project id in ${BUNDLE_PIN_REL} is not valid, so it is not shown as a path.`);
@@ -19857,7 +20223,7 @@ function renderUninstallReport(result, home) {
     case "removed":
       out.push(`[halfcycle] Removed this machine's credential for this project, at ${shownPath(c.dir, home)}.`);
       out.push("  Every other checkout and worktree of this project on this machine used it too. Each stops reaching");
-      out.push(`  Halfcycle until \`${HALFCYCLE_COMMAND}\` is run there again.`);
+      out.push(`  Halfcycle until \`${ownCommand()}\` is run there again.`);
       break;
     case "not-held":
       out.push(`[halfcycle] This machine holds no credential for this project (nothing at ${shownPath(c.dir, home)}).`);
@@ -19866,7 +20232,7 @@ function renderUninstallReport(result, home) {
       out.push(`[halfcycle] No credential was removed: ${BUNDLE_PIN_REL} is missing, so there is no project id to find it by.`);
       break;
     case "failed":
-      out.push(`[halfcycle] Could not remove this machine's credential for this project, at ${shownPath(c.dir, home)}: ${c.reason}. Run "${HALFCYCLE_COMMAND} uninstall ${REMOVE_CREDENTIAL_FLAG}" again to finish.`);
+      out.push(`[halfcycle] Could not remove this machine's credential for this project, at ${shownPath(c.dir, home)}: ${c.reason}. Run "${ownCommand()} uninstall ${REMOVE_CREDENTIAL_FLAG}" again to finish.`);
       break;
     case "nothing-to-say":
       break;
@@ -19876,8 +20242,7 @@ function renderUninstallReport(result, home) {
 }
 
 // dist/banner-facts.js
-import { readFileSync as readFileSync23 } from "node:fs";
-import { basename as basename4, join as join26, resolve as resolve7 } from "node:path";
+import { basename as basename4, resolve as resolve7 } from "node:path";
 var BRAND_URL = "halfcycle.ai";
 var TAGLINE = [
   "Fewer cycles.",
@@ -19888,14 +20253,6 @@ var TAGLINE_NARROW = [
   "The thinking moves earlier.",
   "So does the finish."
 ];
-function bundleVersion() {
-  try {
-    const pkg = JSON.parse(readFileSync23(join26(BUNDLE_ROOT, "package.json"), "utf-8"));
-    return typeof pkg.version === "string" ? pkg.version : void 0;
-  } catch {
-    return void 0;
-  }
-}
 function claudeCodeVersion(deps = {}) {
   return probeClaudeCodeVersion(3e3, deps);
 }
@@ -19984,8 +20341,8 @@ function safeBasename(dir) {
 }
 
 // dist/size.js
-var SIZE_USAGE = `${HALFCYCLE_COMMAND} size sort --description "<one line>" [--existing-code] [--sign-in] [--shared-data] [--paid-services] [--more-than-three-parts] [--repo <root>]
-  ${HALFCYCLE_COMMAND} size up <medium|full> [--repo <root>]`;
+var SIZE_USAGE = `${ownCommand()} size sort --description "<one line>" [--existing-code] [--sign-in] [--shared-data] [--paid-services] [--more-than-three-parts] [--repo <root>]
+  ${ownCommand()} size up <medium|full> [--repo <root>]`;
 function usage2(line) {
   return { ok: false, line: `${line}
 Usage:
@@ -20114,7 +20471,7 @@ async function runSizeSort(repoRoot, args2, deps) {
   } catch {
     return {
       stdout: "",
-      stderr: `halfcycle size: this project is not connected to Halfcycle on this machine. Run ${HALFCYCLE_COMMAND} here first, then run this again. Nothing was sent.
+      stderr: `halfcycle size: this project is not connected to Halfcycle on this machine. Run ${ownCommand()} here first, then run this again. Nothing was sent.
 `,
       exitCode: 1
     };
@@ -20125,7 +20482,7 @@ async function runSizeSort(repoRoot, args2, deps) {
 `, exitCode: 1 };
   const sized = projectSizeSizedSchema.safeParse(answer.raw);
   if (sized.success) {
-    const usageLines2 = (sized.data.usage ?? []).map((line) => `[halfcycle] ${line}
+    const usageLines2 = sizeAnswerPrintedLinesOf(sized.data.usage ?? []).map((line) => `[halfcycle] ${line}
 `).join("");
     return {
       stdout: `[halfcycle] ${sized.data.sentence}
@@ -20162,7 +20519,7 @@ async function runSizeUp(repoRoot, args2, deps) {
   } catch {
     return {
       stdout: "",
-      stderr: `halfcycle size: this project is not connected to Halfcycle on this machine. Run ${HALFCYCLE_COMMAND} here first, then run this again. Nothing was sent.
+      stderr: `halfcycle size: this project is not connected to Halfcycle on this machine. Run ${ownCommand()} here first, then run this again. Nothing was sent.
 `,
       exitCode: 1
     };
@@ -20192,11 +20549,134 @@ function runSize(repoRoot, args2, deps) {
   return args2.form === "sort" ? runSizeSort(repoRoot, args2, deps) : runSizeUp(repoRoot, args2, deps);
 }
 
+// dist/regression.js
+var REGRESSION_USAGE = `${ownCommand()} regression --every <1 to 20> [--repo <root>]`;
+function usage3(line) {
+  return { ok: false, line: `${line}
+Usage:
+  ${REGRESSION_USAGE}
+`, exitCode: 2 };
+}
+function parseRegressionArgs(rest) {
+  let every = null;
+  let repoRoot;
+  for (let i = 0; i < rest.length; i++) {
+    const w = rest[i];
+    if (w === "--every" || w === "--repo") {
+      const v = rest[i + 1];
+      if (v === void 0 || v.trim() === "" || w === "--repo" && v.startsWith("--")) {
+        return usage3(`halfcycle regression: ${w} needs a value after it.`);
+      }
+      if (w === "--every")
+        every = v;
+      else
+        repoRoot = v;
+      i++;
+    } else {
+      return usage3(`halfcycle regression: "${w}" is not something this command takes.`);
+    }
+  }
+  if (every === null)
+    return usage3("halfcycle regression: say how many phases may close between regressions.");
+  const number = /^-?\d+$/.test(every.trim()) ? Number(every) : Number.NaN;
+  const parsed = regressionEveryRequestSchema.safeParse({ every: number });
+  if (!parsed.success) {
+    return { ok: false, line: `${REGRESSION_EVERY_RANGE_REFUSAL}
+`, exitCode: 2 };
+  }
+  return { ok: true, args: { request: parsed.data, ...repoRoot === void 0 ? {} : { repoRoot } } };
+}
+var COULD_NOT_REACH3 = "Halfcycle could not be reached. Nothing was changed; check this machine's connection, then run this again.";
+async function runRegression(repoRoot, args2, deps) {
+  const p = "halfcycle regression:";
+  let credential;
+  try {
+    credential = deps.readCredential(repoRoot);
+  } catch {
+    return {
+      stdout: "",
+      stderr: `${p} this project is not connected to Halfcycle on this machine. Run ${ownCommand()} here first, then run this again. Nothing was sent.
+`,
+      exitCode: 1
+    };
+  }
+  const url = `${credential.serviceUrl}/engagements/${encodeURIComponent(credential.engagementId)}/regression-every`;
+  let status;
+  let raw = null;
+  try {
+    const res = await deps.fetch(url, {
+      method: "PUT",
+      headers: { authorization: `Bearer ${credential.token}`, "content-type": "application/json" },
+      body: JSON.stringify(args2.request)
+    });
+    status = res.status;
+    const text = await res.text();
+    try {
+      raw = JSON.parse(text);
+    } catch {
+      raw = null;
+    }
+  } catch {
+    return { stdout: "", stderr: `${p} ${COULD_NOT_REACH3}
+`, exitCode: 1 };
+  }
+  const answered2 = regressionEveryResponseSchema.safeParse(raw);
+  if (status >= 200 && status < 300 && answered2.success) {
+    const line = answered2.data.line === null ? "" : `[halfcycle] ${answered2.data.line}
+`;
+    return {
+      stdout: `[halfcycle] The number of phases between regressions is now ${answered2.data.every}.
+${line}`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  const wire = wireErrorSchema.safeParse(raw);
+  const said = wire.success ? wire.data.message : `Halfcycle answered ${status}. Nothing was changed; run this again later.`;
+  return { stdout: "", stderr: `${p} ${said}
+`, exitCode: 1 };
+}
+
+// dist/crew.js
+var CREW_USAGE = `${ownCommand()} crew [--repo <root>]`;
+function usage4(line) {
+  return { ok: false, line: `${line}
+Usage:
+  ${CREW_USAGE}
+`, exitCode: 2 };
+}
+function parseCrewArgs(rest) {
+  let repoRoot;
+  for (let i = 0; i < rest.length; i++) {
+    const w = rest[i];
+    if (w === "--repo") {
+      const v = rest[i + 1];
+      if (v === void 0 || v.trim() === "" || v.startsWith("--")) {
+        return usage4("halfcycle crew: --repo needs a value after it.");
+      }
+      repoRoot = v;
+      i++;
+    } else {
+      return usage4(`halfcycle crew: "${w}" is not something this command takes.`);
+    }
+  }
+  return { ok: true, ...repoRoot === void 0 ? {} : { repoRoot } };
+}
+async function runCrew(repoRoot, deps) {
+  const size = await readSizeOnce(repoRoot, deps);
+  const members = crewOfProjectSize(size.kind === "small" ? "small" : void 0);
+  const stdout = members.map((m) => `${m.callsign}  ${m.role}  ${m.tier}
+`).join("");
+  const stderr = size.kind === "failed" ? `halfcycle crew: ${SIZE_READ_FAILED_LINE}
+` : "";
+  return { stdout, stderr, exitCode: 0 };
+}
+
 // dist/pace.js
 import { spawn as spawn3 } from "node:child_process";
 import { readFileSync as readFileSync24 } from "node:fs";
 import { join as join27 } from "node:path";
-var PACE_USAGE = `${HALFCYCLE_COMMAND} pace [--agent claude-code|codex] [--start <phase> [--agents <n>]] [--repo <root>]`;
+var PACE_USAGE = `${ownCommand()} pace [--agent claude-code|codex] [--start <phase> [--agents <n>]] [--repo <root>]`;
 function parsePaceArgs(argv) {
   let repoRoot;
   let phase;
@@ -20302,7 +20782,7 @@ function readPaceLine(stdout) {
     return null;
   }
 }
-var PACE_NOT_CONNECTED_LINE = `halfcycle pace: this project is not signed in on this computer. ${HOOK_REMEDY}`;
+var PACE_NOT_CONNECTED_LINE = `halfcycle pace: this project is not signed in on this computer. ${hookRemedy(ownVersion())}`;
 function notPacedLine(reason) {
   return reason === "not-configured" ? `${PACE_NOT_CONNECTED_LINE}
 ` : "halfcycle pace: Halfcycle could not read this computer's usage records just now. Run this again in a minute.\n";
@@ -20344,7 +20824,7 @@ async function runPace(repoRoot, start, deps, agent = null) {
     if (result.suggestion === void 0)
       return { stdout: "", stderr: notPacedLine("unreadable"), exitCode: 0 };
     const behind = promptScriptBehind((deps.readPromptScript ?? readPromptScript)(repoRoot));
-    return { stdout: `${paceStartLinesOf(result.suggestion, behind).join("\n")}
+    return { stdout: `${paceStartLinesOf(result.suggestion, behind, ownVersion()).join("\n")}
 `, stderr: "", exitCode: 0 };
   }
   const share = result.keepFreePercent ?? KEEP_FREE_DEFAULT;
@@ -20370,7 +20850,7 @@ async function runPace(repoRoot, start, deps, agent = null) {
 // dist/route.js
 import { readFileSync as readFileSync25 } from "node:fs";
 import { join as join28 } from "node:path";
-var ROUTE_USAGE = `${HALFCYCLE_COMMAND} route <phase> <task> [--agent claude-code|codex] [--repo <root>]`;
+var ROUTE_USAGE = `${ownCommand()} route <phase> <task> [--agent claude-code|codex] [--repo <root>]`;
 var ROUTE_WORK_READ_DEADLINE_MS = 5e3;
 function parseRouteArgs(argv) {
   const positionals = [];
@@ -20502,11 +20982,11 @@ async function runRoute(repoRoot, phase, taskId, agent, deps) {
 }
 
 // dist/restore.js
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { spawnSync as spawnSync3 } from "node:child_process";
 import { closeSync as closeSync3, fchmodSync, lstatSync as lstatSync5, mkdirSync as mkdirSync12, openSync as openSync3, readdirSync as readdirSync2, readFileSync as readFileSync26, readlinkSync, realpathSync as realpathSync7, rmSync as rmSync9, symlinkSync, writeSync as writeSync3 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
 import { join as join29, resolve as resolve8 } from "node:path";
-var RESTORE_USAGE = `${HALFCYCLE_COMMAND} restore [<id>]`;
+var RESTORE_USAGE = `${ownCommand()} restore [<id>]`;
 function parseRestoreArgs(rest) {
   if (rest.length > 1)
     return { ok: false };
@@ -20515,7 +20995,7 @@ function parseRestoreArgs(rest) {
     return { ok: false };
   return { ok: true, id: first };
 }
-var LIST_COMMAND = `${HALFCYCLE_COMMAND} restore`;
+var LIST_COMMAND = `${ownCommand()} restore`;
 function runRestore(cwd, id, options = {}) {
   const now = options.now ?? Date.now;
   const top = git2(cwd, ["rev-parse", "--show-toplevel"]);
@@ -20525,7 +21005,7 @@ function runRestore(cwd, id, options = {}) {
   const root = realOrSelf(top.text.trim());
   const engagementId = pinnedEngagement(root);
   if (engagementId === null) {
-    return refused2(`Halfcycle is not set up in this project, so it has saved nothing here. To set it up, run: ${HALFCYCLE_COMMAND}`);
+    return refused2(`Halfcycle is not set up in this project, so it has saved nothing here. To set it up, run: ${ownCommand()}`);
   }
   const folder2 = join29(options.home ?? homedir8(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, SAVED_DIR_NAME);
   const refs = savedRefs(root);
@@ -20752,7 +21232,7 @@ function restoreFromCommit(root, ref, rels, out) {
   }
 }
 function readBlobs(root, objects) {
-  const r = spawnSync4("git", ["cat-file", "--batch"], {
+  const r = spawnSync3("git", ["cat-file", "--batch"], {
     cwd: root,
     env: gitEnvForNamedRepo(),
     input: `${objects.join("\n")}
@@ -20898,7 +21378,7 @@ function markedRepository(dir) {
 }
 function git2(cwd, args2) {
   try {
-    const r = spawnSync4("git", args2, { cwd, encoding: "utf-8", env: gitEnvForNamedRepo(), maxBuffer: 64 * 1024 * 1024 });
+    const r = spawnSync3("git", args2, { cwd, encoding: "utf-8", env: gitEnvForNamedRepo(), maxBuffer: 64 * 1024 * 1024 });
     return r.status === 0 ? { ok: true, text: r.stdout ?? "" } : { ok: false };
   } catch {
     return { ok: false };
@@ -20920,10 +21400,10 @@ function realOrSelf(p) {
 }
 
 // dist/request-shapes-verb.js
-import { chmodSync as chmodSync4, existsSync as existsSync15, mkdirSync as mkdirSync13, readFileSync as readFileSync27, rmSync as rmSync10, writeFileSync as writeFileSync10 } from "node:fs";
+import { chmodSync as chmodSync4, existsSync as existsSync16, mkdirSync as mkdirSync13, readFileSync as readFileSync27, rmSync as rmSync10, writeFileSync as writeFileSync10 } from "node:fs";
 import { homedir as homedir9, platform as platform5 } from "node:os";
 import { join as join30 } from "node:path";
-var REQUEST_SHAPES_USAGE = `${HALFCYCLE_COMMAND} request-shapes on|off|show|clear`;
+var REQUEST_SHAPES_USAGE = `${ownCommand()} request-shapes on|off|show|clear`;
 var REQUEST_SHAPES_FORMS = ["on", "off", "show", "clear"];
 var REQUEST_SHAPES_ON_LINE = "Halfcycle will write down the shape of every request this computer sends to it, never what is in them, until you run request-shapes off.";
 var REQUEST_SHAPES_OFF_LINE = "Halfcycle has stopped writing down requests. What it wrote is still there: run request-shapes show to read it, or request-shapes clear to remove it.";
@@ -20967,7 +21447,7 @@ function formatLine(line) {
 function showLog(logPath2) {
   let text = "";
   try {
-    text = existsSync15(logPath2) ? readFileSync27(logPath2, "utf-8") : "";
+    text = existsSync16(logPath2) ? readFileSync27(logPath2, "utf-8") : "";
   } catch {
     text = "";
   }
@@ -21004,7 +21484,7 @@ function runRequestShapes(form, home = homedir9()) {
       case "show":
         return { stdout: showLog(logPath2), stderr: "", exitCode: 0 };
       case "clear":
-        if (existsSync15(logPath2)) {
+        if (existsSync16(logPath2)) {
           writeFileSync10(logPath2, "", { mode: 384 });
           ownerOnly(logPath2, 384);
         }
@@ -21075,19 +21555,23 @@ function reportCodexVersion(deps = {}) {
 function shortId(id) {
   return id.length > 10 ? `${id.slice(0, 8)}\u2026` : id;
 }
-var USAGE = `  ${HALFCYCLE_COMMAND} [install] [target-repo] [engagement-id] [self-build|client]
+var USAGE = `  ${ownCommand()} [install] [target-repo] [engagement-id] [self-build|client]
          install into target (default: the current directory)
          --yes / -y: use this machine's saved sign-in without being asked
-  ${HALFCYCLE_COMMAND} check-drift <target-repo>
-  ${HALFCYCLE_COMMAND} build-record <phase> [--repo <root>]
+  ${ownCommand()} check-drift <target-repo>
+  ${ownCommand()} build-record <phase> [--repo <root>]
          fetch a closed phase's Build Record and write it into docs/build-records/
-  ${HALFCYCLE_COMMAND} open-phase <phase|--none> --actor "\u2026" (--evidence "\u2026" | --override --reason "\u2026" | --sorting <id> | --size <id>) [--repo <root>]
+  ${ownCommand()} open-phase <phase|--none> --actor "\u2026" (--evidence "\u2026" | --override --reason "\u2026" | --sorting <id> | --size <id>) [--repo <root>]
   ${SIZE_USAGE}
          size a new project at its first sitting, or move its size up
-  ${HALFCYCLE_COMMAND} close-phase <phase> --verdict <clean|defects> --actor "\u2026" [--finding "\u2026"]\u2026 [--details] [--repo <root>]
+  ${REGRESSION_USAGE}
+         set how many phases may close between regression phases
+  ${CREW_USAGE}
+         list the crew this project may use
+  ${ownCommand()} close-phase <phase> --verdict <clean|defects> --actor "\u2026" [--finding "\u2026"]\u2026 [--details] [--repo <root>]
          [--thesis "\u2026"] [--outcome "\u2026"] [--deviation "\u2026"]\u2026
          open the owner's review of the phase; it closes when the owner has decided every part
-  ${HALFCYCLE_COMMAND} system [--repo <root>]
+  ${ownCommand()} system [--repo <root>]
          check docs/system.json, the description of your system, and send it to Halfcycle
   ${DRAW_USAGE}
          draw the architecture picture, or one phase's plan, from docs/system.json into docs/diagrams/
@@ -21113,9 +21597,9 @@ var USAGE = `  ${HALFCYCLE_COMMAND} [install] [target-repo] [engagement-id] [sel
          many may start right now
   ${ROUTE_USAGE}
          say how to start a task of a phase's plan: which crew member, and on which tier
-  ${HALFCYCLE_COMMAND} preview [folder]
+  ${ownCommand()} preview [folder]
          show what setting up this folder would add, change, remove or leave alone; writes nothing
-  ${HALFCYCLE_COMMAND} doctor
+  ${ownCommand()} doctor
          check this folder: set up, signed in, connected, checks running, up to date; says what to do for each one that is not; changes nothing
   ${REQUEST_SHAPES_USAGE}
          write down the shape of every request this computer sends to Halfcycle, never what is in
@@ -21123,11 +21607,11 @@ var USAGE = `  ${HALFCYCLE_COMMAND} [install] [target-repo] [engagement-id] [sel
   ${RESTORE_USAGE}
          list the copies Halfcycle saved before a change it let through, or bring one back; never
          replaces a file or a line of work that exists now
-  ${HALFCYCLE_COMMAND} allow [--remove]
+  ${ownCommand()} allow [--remove]
          let your coding agent work without asking on this computer, for tests, builds, installs, local
          tools, files and local git; pushing, publishing, deploying, deleting and GitHub still ask;
          --remove takes out what this added and keeps everything of yours
-  ${HALFCYCLE_COMMAND} uninstall [${REMOVE_CREDENTIAL_FLAG}]
+  ${ownCommand()} uninstall [${REMOVE_CREDENTIAL_FLAG}]
          take out what the installer added to this project, keeping anything you changed
          ${REMOVE_CREDENTIAL_FLAG}: also remove this machine's credential for the project, which every
          checkout and worktree of that project on this machine shares
@@ -21140,7 +21624,7 @@ var USAGE = `  ${HALFCYCLE_COMMAND} [install] [target-repo] [engagement-id] [sel
 var RETIRED_VERBS = /* @__PURE__ */ new Map([
   ["ci", '"ci" was removed \u2014 CI setup is part of your project, not Halfcycle']
 ]);
-var PROJECT_RESET_LINE = 'To start your own project here, delete the .halfcycle folder and run "npx halfcycle" again.';
+var PROJECT_RESET_LINE = `To start your own project here, delete the .halfcycle folder and run "${ownBareCommand()}" again.`;
 function selfBuildNotOwnerLine(account) {
   return `Halfcycle's own project can only be joined by its owner. This computer is signed in as ${account}. Nothing was written.`;
 }
@@ -21293,7 +21777,7 @@ ${USAGE}`);
   if (cmd === "allow") {
     const extra = rest.filter((word, i) => word !== "--remove" && word !== "--repo" && rest[i - 1] !== "--repo");
     if (extra.length > 0) {
-      process.stderr.write(`halfcycle allow: usage: ${HALFCYCLE_COMMAND} allow [--remove]
+      process.stderr.write(`halfcycle allow: usage: ${ownCommand()} allow [--remove]
 `);
       process.exitCode = 2;
       return;
@@ -21309,13 +21793,13 @@ ${USAGE}`);
   if (installArm) {
     const engagementIdArg = positionals[1];
     const engagementTypeRaw = positionals[2] ?? "client";
-    if (!existsSync16(targetRepo)) {
+    if (!existsSync17(targetRepo)) {
       process.stderr.write(`${folderMissingRefusal(targetRepo)}
 `);
       process.exit(1);
       return;
     }
-    if (!statSync2(targetRepo).isDirectory()) {
+    if (!statSync3(targetRepo).isDirectory()) {
       process.stderr.write(`${folderIsFileRefusal(targetRepo)}
 `);
       process.exit(1);
@@ -21442,7 +21926,11 @@ ${kept}`);
       } else {
         const hadUsableIdBeforeThisRun = readFolderId(targetRepo) !== void 0;
         const projectId = runPreCreateChecks(targetRepo);
-        const created = await createOwnedEngagement(serviceUrl, targetRepo, projectId, { assumeYes, verbose });
+        const created = await createOwnedEngagement(serviceUrl, targetRepo, projectId, {
+          assumeYes,
+          verbose,
+          folderAlreadyHasProject: hadUsableIdBeforeThisRun
+        });
         if (isProjectOwnedElsewhere(created)) {
           process.stderr.write(`halfcycle: ${created.message}
 ${PROJECT_RESET_LINE}
@@ -21485,8 +21973,10 @@ ${PROJECT_RESET_LINE}
         engagementId,
         engagementType: engagementTypeRaw,
         credential,
-        createdByAccountId
+        createdByAccountId,
+        serviceUrl
       });
+      const ownServer = approveOwnServer(targetRepo);
       if (verbose) {
         process.stdout.write(`[halfcycle] Installed v${result.version} into ${targetRepo}
 `);
@@ -21535,18 +22025,18 @@ ${PROJECT_RESET_LINE}
 `);
           }
         } else if (probe.slow === true) {
-          process.stdout.write(`${SLOW_SERVICE_LINE}${DOCTOR_LINE}
+          process.stdout.write(`${SLOW_SERVICE_LINE}${doctorLine(ownVersion())}
 `);
         } else if (probe.credentialRefused) {
           process.stdout.write(`[halfcycle] Method delivery (MCP): ${credential.mcpUrl} \u2014 ${probe.problem}.
-[halfcycle] The address is right, but Halfcycle commands will not work in this project until it accepts this machine's credential. Re-run "npx halfcycle" in this folder; if it says this again, the refusal is on Halfcycle's side, not in this project.
-${DOCTOR_LINE}
+[halfcycle] The address is right, but Halfcycle commands will not work in this project until it accepts this machine's credential. Re-run "${ownBareCommand()}" in this folder; if it says this again, the refusal is on Halfcycle's side, not in this project.
+${doctorLine(ownVersion())}
 `);
         } else {
           const otherAddress = controlOriginConfirmed ? `The other address Halfcycle uses answered fine; this is the only one that did not. ` : `This run could not reach the Halfcycle service at all just now, so this may simply be offline. `;
           process.stdout.write(`[halfcycle] Method delivery (MCP): ${credential.mcpUrl} \u2014 NOT reachable: ${probe.problem}.
 [halfcycle] Halfcycle commands will not work in this project until that address answers. ${otherAddress}Run this installer again once the service is up.
-${DOCTOR_LINE}
+${doctorLine(ownVersion())}
 `);
         }
       }
@@ -21561,7 +22051,7 @@ ${DOCTOR_LINE}
 `);
       }
       if (credential === void 0 && notThisAccountMessage !== void 0) {
-        process.stdout.write(`[halfcycle] ${notThisAccountMessage} Your work carries on exactly as it would without Halfcycle: no edit is evaluated, and nothing you do here is reported as having passed. ${requestAccessSentence(engagementId)} ${identitySwitchRemedy(void 0, isInteractiveRun())}
+        process.stdout.write(`[halfcycle] ${notThisAccountMessage} Your work carries on exactly as it would without Halfcycle: no edit is evaluated, and nothing you do here is reported as having passed. ${requestAccessSentence(engagementId, serviceUrl)} ${identitySwitchRemedy(void 0, isInteractiveRun())}
 `);
       }
       reportClaudeCodeVersion(verbose);
@@ -21608,8 +22098,10 @@ ${DOCTOR_LINE}
       if (credential) {
         process.stdout.write(`[halfcycle] Next: open this folder in Claude Code \u2014 accept the workspace-trust prompt, it is expected \u2014 then say "set up this project" and answer what it asks about your project
 `);
-        process.stdout.write(`[halfcycle] Claude Code will then ask you to approve the new "halfcycle" MCP server. If it is the only one listed, the cursor starts on "Continue without using this MCP server" \u2014 choose "Use this MCP server" instead. If several are listed together, halfcycle is already checked \u2014 leave it that way. Either way, without it Halfcycle will not connect.
+        if (ownServer !== "approved") {
+          process.stdout.write(`[halfcycle] Claude Code will then ask you to approve the new "halfcycle" MCP server. If it is the only one listed, the cursor starts on "Continue without using this MCP server" \u2014 choose "Use this MCP server" instead. If several are listed together, halfcycle is already checked \u2014 leave it that way. Either way, without it Halfcycle will not connect.
 `);
+        }
         const codexLine2 = codexInstallLine(result.codex);
         if (codexLine2 !== void 0)
           process.stdout.write(`${codexLine2}
@@ -21636,7 +22128,7 @@ ${kept}`);
       }
       const fsCode = typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
       if (fsCode !== void 0) {
-        stop(`halfcycle: could not write to ${targetRepo} \u2014 check that you can write to this folder and run "npx halfcycle" again.`);
+        stop(`halfcycle: could not write to ${targetRepo} \u2014 check that you can write to this folder and run "${ownBareCommand()}" again.`);
         return;
       }
       stop(`halfcycle install failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -21973,6 +22465,42 @@ halfcycle build-record: until ${obtained.stampFailure.path} can be written, the
     process.exitCode = run.exitCode;
     return;
   }
+  if (cmd === "regression") {
+    const parsed = parseRegressionArgs(rest);
+    if (!parsed.ok) {
+      process.stderr.write(parsed.line);
+      process.exitCode = parsed.exitCode;
+      return;
+    }
+    const run = await runRegression(parsed.args.repoRoot ?? process.cwd(), parsed.args, {
+      readCredential: (root) => readRepoCredential(root),
+      fetch: (input, init) => fetch(input, init)
+    });
+    if (run.stdout !== "")
+      process.stdout.write(run.stdout);
+    if (run.stderr !== "")
+      process.stderr.write(run.stderr);
+    process.exitCode = run.exitCode;
+    return;
+  }
+  if (cmd === "crew") {
+    const parsed = parseCrewArgs(rest);
+    if (!parsed.ok) {
+      process.stderr.write(parsed.line);
+      process.exitCode = parsed.exitCode;
+      return;
+    }
+    const run = await runCrew(parsed.repoRoot ?? process.cwd(), {
+      readCredential: (root) => readRepoCredential(root),
+      fetch: (input, init) => fetch(input, init)
+    });
+    if (run.stdout !== "")
+      process.stdout.write(run.stdout);
+    if (run.stderr !== "")
+      process.stderr.write(run.stderr);
+    process.exitCode = run.exitCode;
+    return;
+  }
   if (cmd === "size") {
     const parsed = parseSizeArgs(rest);
     if (!parsed.ok) {
@@ -21997,8 +22525,8 @@ halfcycle build-record: until ${obtained.stampFailure.path} can be written, the
     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.
-  ${HALFCYCLE_COMMAND} open-phase <phase> --actor "you" --evidence "<what shows this phase is ready to start>"
-  ${HALFCYCLE_COMMAND} open-phase <phase> --actor "you" --override --reason "${REASON_PLACEHOLDER["open-phase"]}"
+  ${ownCommand()} open-phase <phase> --actor "you" --evidence "<what shows this phase is ready to start>"
+  ${ownCommand()} open-phase <phase> --actor "you" --override --reason "${REASON_PLACEHOLDER["open-phase"]}"
 `);
       process.exit(2);
       return;
@@ -22050,9 +22578,20 @@ halfcycle build-record: until ${obtained.stampFailure.path} can be written, the
     } else {
       entry = { decision: "entry-condition-met", actor, evidence: flagValue(rest, "--evidence") ?? "" };
     }
+    const regressionArg = rest.includes("--regression");
+    if (regressionArg && toProjectScope) {
+      const refusal3 = openPhaseRequestSchema.safeParse({ phase: null, entry, regression: true });
+      if (!refusal3.success) {
+        const said = refusal3.error.issues.map((issue) => issue.message).join("; ");
+        process.stderr.write(`halfcycle open-phase: --regression ${said}. Nothing was sent.
+`);
+        process.exit(2);
+        return;
+      }
+    }
     try {
       const credential = readRepoCredential(repoRoot);
-      const opened = await openPhase(credential, toProjectScope ? null : phaseArg, entry, void 0, repoRoot, sortingArg, sizeArg);
+      const opened = await openPhase(credential, toProjectScope ? null : phaseArg, entry, void 0, repoRoot, sortingArg, sizeArg, regressionArg);
       process.stdout.write(`[halfcycle] ${describeOpen(opened)}
 `);
       const startCommitLine = describeStartCommit(opened.phase, opened.startCommitSent, opened.startCommit);
@@ -22118,8 +22657,8 @@ halfcycle open-phase: until ${opened.stampFailure.path} can be written, guard ev
     const phaseArg = firstPositional(rest);
     if (!phaseArg) {
       process.stderr.write(`halfcycle close-phase: name the phase whose review you are opening.
-  ${HALFCYCLE_COMMAND} close-phase <phase> --verdict clean --actor "you"
-  ${HALFCYCLE_COMMAND} close-phase <phase> --verdict defects --actor "you" --finding "<what is still wrong>"
+  ${ownCommand()} close-phase <phase> --verdict clean --actor "you"
+  ${ownCommand()} close-phase <phase> --verdict defects --actor "you" --finding "<what is still wrong>"
 `);
       process.exit(2);
       return;
@@ -22191,7 +22730,7 @@ halfcycle open-phase: until ${opened.stampFailure.path} can be written, guard ev
         acceptanceOutcome: { verdict: verdict2, findings: findingsDetail.length, findingsDetail },
         stated
       }, () => runObserveChild(runner, credential, repoRoot), repoRoot, () => runTimeChild(runner, credential, repoRoot));
-      const report = closeStepReport(phaseArg, attempt2, credential.engagementId);
+      const report = closeStepReport(phaseArg, attempt2, credential.engagementId, credential.serviceUrl);
       for (const line of report.stdout)
         process.stdout.write(`${line}
 `);
@@ -22329,7 +22868,7 @@ function firstPositional(argv) {
     const arg = argv[i];
     if (arg.startsWith("--")) {
       const next = argv[i + 1];
-      if (next !== void 0 && !next.startsWith("--"))
+      if (arg !== "--regression" && next !== void 0 && !next.startsWith("--"))
         i++;
       continue;
     }