halfcycle 0.3.11 → 0.3.12

package/dist/bin.js

@@ -413,6 +413,7 @@ var LOOPBACK_RESULT = {
   APPROVED: "approved",
   DECLINED: "declined"
 };
+var DASHBOARD_URL = "https://app.halfcycle.ai";
 function loopbackVerificationUrl(verificationUrl, target) {
   let url;
   try {
@@ -425,6 +426,16 @@ function loopbackVerificationUrl(verificationUrl, target) {
   return url.toString();
 }
 
+// ../events/dist/account-identity.js
+import { z as z7 } from "zod";
+var accountIdentitySchema = z7.object({
+  accountId: z7.string().min(1),
+  email: z7.string().min(1).optional()
+}).strict();
+function safeParseAccountIdentity(payload) {
+  return accountIdentitySchema.safeParse(payload);
+}
+
 // dist/engagement-credential.js
 import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { platform as platform2 } from "node:os";
@@ -1323,12 +1334,24 @@ ${header}
     return "failed";
   }
 }
-function writeBundlePin(targetRepoRoot, version, engagementId, engagementType, writtenPaths) {
+function previousAccountId(targetRepoRoot, engagementId) {
+  try {
+    const existing = readBundlePin(targetRepoRoot);
+    if (existing === null || existing.engagementId !== engagementId)
+      return void 0;
+    return existing.accountId;
+  } catch {
+    return void 0;
+  }
+}
+function writeBundlePin(targetRepoRoot, version, engagementId, engagementType, accountId, writtenPaths) {
+  const carried = accountId ?? previousAccountId(targetRepoRoot, engagementId);
   const pin = {
     version,
     engagementId,
     engagementType,
-    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...carried !== void 0 && carried.trim() !== "" ? { accountId: carried } : {}
   };
   const pinPath = join5(targetRepoRoot, ".halfcycle", "bundle.json");
   writeAllowlisted(pinPath, targetRepoRoot, JSON.stringify(pin, null, 2) + "\n", writtenPaths);
@@ -1483,7 +1506,7 @@ function migrateLegacyEnvLocal(targetRepo, stored) {
   }
 }
 async function install(options) {
-  const { targetRepo, engagementId, engagementType, credential, home } = options;
+  const { targetRepo, engagementId, engagementType, credential, home, accountId } = options;
   if (!existsSync3(targetRepo)) {
     throw new Error(`[bundle install] Target repo does not exist: ${targetRepo}`);
   }
@@ -1572,7 +1595,7 @@ async function install(options) {
     case "absent":
       break;
   }
-  writeBundlePin(targetRepo, manifest.version, engagementId, engagementType, report.writtenPaths);
+  writeBundlePin(targetRepo, manifest.version, engagementId, engagementType, accountId, report.writtenPaths);
   writeCrewRoster(targetRepo, report);
   const scanResult = runBootstrapScan(targetRepo);
   return {
@@ -1598,126 +1621,6 @@ function controlOriginNote(resolved) {
   return resolved.source === "environment" ? `${resolved.origin} (from HALFCYCLE_SERVICE_URL)` : `${resolved.origin} (the Halfcycle plane)`;
 }
 
-// dist/create-engagement.js
-var CreateEngagementRefused = class extends Error {
-  status;
-  serverMessage;
-  errorCode;
-  constructor(status, serverMessage, errorCode, message) {
-    super(message);
-    this.status = status;
-    this.serverMessage = serverMessage;
-    this.errorCode = errorCode;
-    this.name = "CreateEngagementRefused";
-  }
-  /**
-   * Is this a refusal of the CALLER's credential — the arm signing in again can fix?
-   *
-   * `PublicStartDisabled` is excluded even though it is a 403, and that exclusion is
-   * the whole reason this is a method rather than a status comparison at the call
-   * site: the flag gates the DEPLOYMENT, identically for every caller, so no
-   * credential and no sign-in changes the answer. Treating it as an auth refusal
-   * would send a developer through a browser handoff to arrive at the same 403.
-   *
-   * **THIS IS THE CREATE ROUTE'S DERIVATION AND THE JOIN CALLER MUST NOT USE IT
-   * (T-24).** On the join route a 403 has two causes that share a status AND a
-   * discriminant (`error: 'Forbidden'`), so nothing on this object can tell them
-   * apart: the credential may be a live engagement token carrying no account, or the
-   * engagement id may not resolve. Signing in again cannot fix the second, and
-   * treating it as though it could would discard a good credential, walk the
-   * developer through a browser, and arrive at the identical 403 — a remedy that
-   * loops. `bin.ts`'s join path therefore retries on `401` ALONE, at the call site,
-   * where the reason can be written down. See `joinPinnedEngagement` there.
-   */
-  get authRefused() {
-    if (this.errorCode === "PublicStartDisabled")
-      return false;
-    return this.status === 401 || this.status === 403;
-  }
-};
-function planeRefusal(detail) {
-  let body;
-  try {
-    body = JSON.parse(detail);
-  } catch {
-    return void 0;
-  }
-  if (typeof body !== "object" || body === null)
-    return void 0;
-  const candidate = body;
-  if (typeof candidate.message !== "string" || candidate.message.trim() === "")
-    return void 0;
-  const hasDiscriminant = typeof candidate.error === "string" || typeof candidate.statusCode === "number" || typeof candidate.status === "string";
-  if (!hasDiscriminant)
-    return void 0;
-  return {
-    message: candidate.message,
-    error: typeof candidate.error === "string" ? candidate.error : void 0
-  };
-}
-var CONTROL_ORIGIN_HINT = `This CLI talks to ${DEFAULT_CONTROL_ORIGIN}; it must be the CONTROL origin \u2014 the one that serves /engagements and /board/enter-codes. The MCP server runs at a different address, and the platform supplies that one itself; you configure neither.`;
-async function createEngagement(baseUrl, name, credential) {
-  return requestEngagementValues(`${baseUrl.replace(/\/+$/, "")}/engagements`, name ? { name } : {}, credential, { action: "Create-engagement", nothingHappened: "No engagement was created", route: "POST /engagements" });
-}
-async function joinEngagement(baseUrl, engagementId, credential) {
-  return requestEngagementValues(`${baseUrl.replace(/\/+$/, "")}/engagements/${encodeURIComponent(engagementId)}/join`, {}, credential, {
-    action: "Join-engagement",
-    nothingHappened: "No credential was minted",
-    route: "POST /engagements/:engagementId/join"
-  });
-}
-async function requestEngagementValues(url, requestBody, credential, shape) {
-  const bearer = credential?.trim();
-  let res;
-  try {
-    res = await fetch(url, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        ...bearer ? { authorization: `Bearer ${bearer}` } : {}
-      },
-      body: JSON.stringify(requestBody)
-    });
-  } catch (err) {
-    throw new Error(`[bundle install] Could not reach the Halfcycle control plane at ${url}: ${err instanceof Error ? err.message : String(err)}. ${shape.nothingHappened}. ` + CONTROL_ORIGIN_HINT);
-  }
-  if (!res.ok) {
-    const detail = await res.text().catch(() => "");
-    const refusal = res.status === 404 ? void 0 : planeRefusal(detail);
-    if (refusal) {
-      throw new CreateEngagementRefused(res.status, refusal.message, refusal.error, `[bundle install] ${shape.action} failed: ${url} returned ${res.status}. ${refusal.message} ${shape.nothingHappened}.`);
-    }
-    const wrongOrigin = res.status === 404 ? `That address answered, but it does not serve ${shape.route} \u2014 so it is not the control plane. ` : "";
-    throw new Error(`[bundle install] ${shape.action} failed: ${url} returned ${res.status}. ${wrongOrigin}${detail ? `Response: ${detail.slice(0, 300)}. ` : ""}${shape.nothingHappened}. ` + CONTROL_ORIGIN_HINT);
-  }
-  const body = await res.json().catch(() => null);
-  if (!body || typeof body.engagementId !== "string" || typeof body.sessionToken !== "string") {
-    throw new Error(`[bundle install] ${shape.action} response from ${url} did not carry {engagementId, sessionToken}. ${shape.nothingHappened}. ` + CONTROL_ORIGIN_HINT);
-  }
-  for (const [field, value] of [
-    ["engagementId", body.engagementId],
-    ["sessionToken", body.sessionToken]
-  ]) {
-    if (value.trim() === "") {
-      throw new Error(`[bundle install] The Halfcycle plane at ${url} answered with a blank ${field} (the field is present but empty). An install cannot proceed on it: it would be written into this engagement's credential store, read back as a configured value, and every guard evaluation would fail against it for the life of the engagement. ${shape.nothingHappened} and nothing was written. ` + CONTROL_ORIGIN_HINT);
-    }
-  }
-  if (typeof body.mcpUrl !== "string" || body.mcpUrl.trim() === "") {
-    throw new Error(`[bundle install] The Halfcycle plane at ${url} created an engagement but did not say where its MCP server lives (no mcpUrl on the response). Without that address the install would write an MCP registration pointing nowhere, so nothing was written. Either that plane is older than this installer, or ${url} is not a Halfcycle control plane.`);
-  }
-  if (typeof body.guardUrl !== "string" || body.guardUrl.trim() === "") {
-    throw new Error(`[bundle install] The Halfcycle plane at ${url} created an engagement but did not say where its guard service lives (no guardUrl on the response). Without that address the install would wire a guard hook that evaluates nothing, so nothing was written. Either that plane is older than this installer, or ${url} is not a Halfcycle control plane.`);
-  }
-  const controlTelemetryUrl = typeof body.controlTelemetryUrl === "string" && body.controlTelemetryUrl.trim() !== "" ? body.controlTelemetryUrl.trim().replace(/\/+$/, "") : void 0;
-  return {
-    engagementId: body.engagementId,
-    sessionToken: body.sessionToken,
-    mcpUrl: body.mcpUrl.trim().replace(/\/+$/, ""),
-    guardUrl: body.guardUrl.trim().replace(/\/+$/, ""),
-    ...controlTelemetryUrl !== void 0 ? { controlTelemetryUrl } : {}
-  };
-}
-
 // dist/device-signin.js
 import { spawn } from "node:child_process";
 import { platform as platform3 } from "node:os";
@@ -1728,8 +1631,10 @@ import { randomBytes, timingSafeEqual } from "node:crypto";
 var LOOPBACK_PORT_ENV = "HALFCYCLE_LOOPBACK_PORT";
 var DEFAULT_STILL_WAITING_MS = 15e3;
 function completionPage(result) {
-  const headline = result === LOOPBACK_RESULT.APPROVED ? "Signed in. You can close this tab and return to your terminal." : "Sign-in declined. Nothing was created. You can close this tab.";
-  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Halfcycle</title></head><body style="font:16px/1.5 system-ui;padding:3rem"><p>${headline}</p></body></html>`;
+  const approved = result === LOOPBACK_RESULT.APPROVED;
+  const headline = 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 successLink = approved ? `<p><a href="${DASHBOARD_URL}" style="color:#c8a24b">Go to your projects</a></p>` : "";
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Halfcycle</title></head><body style="margin:0;min-height:100vh;display:flex;align-items:center;justify-content:center;background:#0a0a0a;color:#fafafa;font:16px/1.6 -apple-system,BlinkMacSystemFont,'Segoe UI',Helvetica,Arial,sans-serif"><div style="max-width:26rem;padding:2rem;text-align:center"><p>${headline}</p>${successLink}</div></body></html>`;
 }
 function isLoopbackPeer(remoteAddress) {
   if (remoteAddress === void 0)
@@ -1800,14 +1705,14 @@ async function bindLoopback(env = process.env) {
     else
       pending = callback;
   }));
-  const bindProblem = await new Promise((resolve2) => {
+  const bindProblem = await new Promise((resolve3) => {
     const onError = (err) => {
-      resolve2(`${err.code ?? "bind failed"} on ${LOOPBACK_REDIRECT_HOST}:${wanted.port}`);
+      resolve3(`${err.code ?? "bind failed"} on ${LOOPBACK_REDIRECT_HOST}:${wanted.port}`);
     };
     server.once("error", onError);
     server.listen({ host: LOOPBACK_REDIRECT_HOST, port: wanted.port }, () => {
       server.removeListener("error", onError);
-      resolve2(null);
+      resolve3(null);
     });
   });
   if (bindProblem !== null) {
@@ -1823,9 +1728,9 @@ async function bindLoopback(env = process.env) {
     bound: true,
     target: { port: address.port, state },
     boundAddress: address.address,
-    waitForCallback: ({ timeoutMs, onStillWaiting, stillWaitingMs = DEFAULT_STILL_WAITING_MS }) => new Promise((resolve2) => {
+    waitForCallback: ({ timeoutMs, onStillWaiting, stillWaitingMs = DEFAULT_STILL_WAITING_MS }) => new Promise((resolve3) => {
       if (pending !== null) {
-        resolve2(pending);
+        resolve3(pending);
         return;
       }
       const startedAt = Date.now();
@@ -1835,7 +1740,7 @@ async function bindLoopback(env = process.env) {
           clearInterval(ticker);
         clearTimeout(timer);
         deliver = null;
-        resolve2(value);
+        resolve3(value);
       };
       const timer = setTimeout(() => finish(null), Math.max(0, timeoutMs));
       deliver = finish;
@@ -1844,9 +1749,9 @@ async function bindLoopback(env = process.env) {
   };
 }
 function closeServer(server) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     server.closeAllConnections();
-    server.close(() => resolve2());
+    server.close(() => resolve3());
   });
 }
 
@@ -1868,7 +1773,7 @@ function defaultWrite(text) {
   process.stdout.write(text);
 }
 function defaultSleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function browserOpenCommand(os, url) {
   if (os === "darwin")
@@ -1894,12 +1799,12 @@ async function openBrowser(url, env = process.env) {
     return { opened: false, reason: "the sign-in address is not an http(s) URL this CLI will open" };
   }
   const { command, args: args2 } = browserOpenCommand(platform3(), url);
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     let child;
     try {
       child = spawn(command, args2, { stdio: "ignore", env });
     } catch (err) {
-      resolve2({
+      resolve3({
         opened: false,
         reason: `${command} could not be run (${err instanceof Error ? err.message : String(err)})`
       });
@@ -1911,7 +1816,7 @@ async function openBrowser(url, env = process.env) {
         return;
       settled = true;
       clearTimeout(timer);
-      resolve2(attempt);
+      resolve3(attempt);
     };
     const timer = setTimeout(() => {
       child.unref();
@@ -2131,6 +2036,134 @@ async function deviceCodeSignIn(serviceUrl, started, env, deps) {
   };
 }
 
+// dist/create-engagement.js
+var CreateEngagementRefused = class extends Error {
+  status;
+  serverMessage;
+  errorCode;
+  constructor(status, serverMessage, errorCode, message) {
+    super(message);
+    this.status = status;
+    this.serverMessage = serverMessage;
+    this.errorCode = errorCode;
+    this.name = "CreateEngagementRefused";
+  }
+  /**
+   * Is this a refusal of the CALLER's credential — the arm signing in again can fix?
+   *
+   * `PublicStartDisabled` is excluded even though it is a 403, and that exclusion is
+   * the whole reason this is a method rather than a status comparison at the call
+   * site: the flag gates the DEPLOYMENT, identically for every caller, so no
+   * credential and no sign-in changes the answer. Treating it as an auth refusal
+   * would send a developer through a browser handoff to arrive at the same 403.
+   *
+   * **THIS IS THE CREATE ROUTE'S DERIVATION AND THE JOIN CALLER MUST NOT USE IT
+   * (T-24).** On the join route a 403 has two causes that share a status AND a
+   * discriminant (`error: 'Forbidden'`), so nothing on this object can tell them
+   * apart: the credential may be a live engagement token carrying no account, or the
+   * engagement id may not resolve. Signing in again cannot fix the second, and
+   * treating it as though it could would discard a good credential, walk the
+   * developer through a browser, and arrive at the identical 403 — a remedy that
+   * loops. `bin.ts`'s join path therefore retries on `401` ALONE, at the call site,
+   * where the reason can be written down. See `joinPinnedEngagement` there.
+   */
+  get authRefused() {
+    if (this.errorCode === "PublicStartDisabled")
+      return false;
+    return this.status === 401 || this.status === 403;
+  }
+};
+function planeRefusal(detail) {
+  let body;
+  try {
+    body = JSON.parse(detail);
+  } catch {
+    return void 0;
+  }
+  if (typeof body !== "object" || body === null)
+    return void 0;
+  const candidate = body;
+  if (typeof candidate.message !== "string" || candidate.message.trim() === "")
+    return void 0;
+  const hasDiscriminant = typeof candidate.error === "string" || typeof candidate.statusCode === "number" || typeof candidate.status === "string";
+  if (!hasDiscriminant)
+    return void 0;
+  return {
+    message: candidate.message,
+    error: typeof candidate.error === "string" ? candidate.error : void 0
+  };
+}
+var CONTROL_ORIGIN_HINT = `This CLI talks to ${DEFAULT_CONTROL_ORIGIN}; it must be the CONTROL origin \u2014 the one that serves /engagements and /board/enter-codes. The MCP server runs at a different address, and the platform supplies that one itself; you configure neither.`;
+async function createEngagement(baseUrl, name, credential, derivedName) {
+  return requestEngagementValues(
+    `${baseUrl.replace(/\/+$/, "")}/engagements`,
+    // A stated name wins over a guess, and the body carries at most one of them —
+    // the plane applies the same ordering, so the two cannot disagree about which
+    // one a row was named from.
+    name ? { name } : derivedName ? { derivedName } : {},
+    credential,
+    { action: "Create-engagement", nothingHappened: "No engagement was created", route: "POST /engagements" }
+  );
+}
+async function joinEngagement(baseUrl, engagementId, credential) {
+  return requestEngagementValues(`${baseUrl.replace(/\/+$/, "")}/engagements/${encodeURIComponent(engagementId)}/join`, {}, credential, {
+    action: "Join-engagement",
+    nothingHappened: "No credential was minted",
+    route: "POST /engagements/:engagementId/join"
+  });
+}
+async function requestEngagementValues(url, requestBody, credential, shape) {
+  const bearer = credential?.trim();
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...bearer ? { authorization: `Bearer ${bearer}` } : {}
+      },
+      body: JSON.stringify(requestBody)
+    });
+  } catch (err) {
+    throw new Error(`[bundle install] Could not reach the Halfcycle control plane at ${url}: ${err instanceof Error ? err.message : String(err)}. ${shape.nothingHappened}. ` + CONTROL_ORIGIN_HINT);
+  }
+  if (!res.ok) {
+    const detail = await res.text().catch(() => "");
+    const refusal = res.status === 404 ? void 0 : planeRefusal(detail);
+    if (refusal) {
+      throw new CreateEngagementRefused(res.status, refusal.message, refusal.error, `[bundle install] ${shape.action} failed: ${url} returned ${res.status}. ${refusal.message} ${shape.nothingHappened}.`);
+    }
+    const wrongOrigin = res.status === 404 ? `That address answered, but it does not serve ${shape.route} \u2014 so it is not the control plane. ` : "";
+    throw new Error(`[bundle install] ${shape.action} failed: ${url} returned ${res.status}. ${wrongOrigin}${detail ? `Response: ${detail.slice(0, 300)}. ` : ""}${shape.nothingHappened}. ` + CONTROL_ORIGIN_HINT);
+  }
+  const body = await res.json().catch(() => null);
+  if (!body || typeof body.engagementId !== "string" || typeof body.sessionToken !== "string") {
+    throw new Error(`[bundle install] ${shape.action} response from ${url} did not carry {engagementId, sessionToken}. ${shape.nothingHappened}. ` + CONTROL_ORIGIN_HINT);
+  }
+  for (const [field, value] of [
+    ["engagementId", body.engagementId],
+    ["sessionToken", body.sessionToken]
+  ]) {
+    if (value.trim() === "") {
+      throw new Error(`[bundle install] The Halfcycle plane at ${url} answered with a blank ${field} (the field is present but empty). An install cannot proceed on it: it would be written into this engagement's credential store, read back as a configured value, and every guard evaluation would fail against it for the life of the engagement. ${shape.nothingHappened} and nothing was written. ` + CONTROL_ORIGIN_HINT);
+    }
+  }
+  if (typeof body.mcpUrl !== "string" || body.mcpUrl.trim() === "") {
+    throw new Error(`[bundle install] The Halfcycle plane at ${url} created an engagement but did not say where its MCP server lives (no mcpUrl on the response). Without that address the install would write an MCP registration pointing nowhere, so nothing was written. Either that plane is older than this installer, or ${url} is not a Halfcycle control plane.`);
+  }
+  if (typeof body.guardUrl !== "string" || body.guardUrl.trim() === "") {
+    throw new Error(`[bundle install] The Halfcycle plane at ${url} created an engagement but did not say where its guard service lives (no guardUrl on the response). Without that address the install would wire a guard hook that evaluates nothing, so nothing was written. Either that plane is older than this installer, or ${url} is not a Halfcycle control plane.`);
+  }
+  const controlTelemetryUrl = typeof body.controlTelemetryUrl === "string" && body.controlTelemetryUrl.trim() !== "" ? body.controlTelemetryUrl.trim().replace(/\/+$/, "") : void 0;
+  return {
+    engagementId: body.engagementId,
+    sessionToken: body.sessionToken,
+    mcpUrl: body.mcpUrl.trim().replace(/\/+$/, ""),
+    guardUrl: body.guardUrl.trim().replace(/\/+$/, ""),
+    ...controlTelemetryUrl !== void 0 ? { controlTelemetryUrl } : {}
+  };
+}
+
 // dist/resolve-credential.js
 async function obtainCredential(serviceUrl, opts = {}) {
   const env = opts.env ?? process.env;
@@ -2139,8 +2172,16 @@ async function obtainCredential(serviceUrl, opts = {}) {
     return { credential: fromEnv, source: "environment" };
   const stored = readStoredCredential(serviceUrl, opts.home);
   if (stored) {
-    return { credential: stored.credential, source: "stored", accountId: stored.accountId };
+    return {
+      credential: stored.credential,
+      source: "stored",
+      accountId: stored.accountId,
+      signedInAt: stored.signedInAt
+    };
   }
+  return signInAndStore(serviceUrl, opts);
+}
+async function signInAndStore(serviceUrl, opts) {
   const signedIn = await signIn(serviceUrl, opts);
   writeStoredCredential(serviceUrl, {
     accountId: signedIn.accountId,
@@ -2153,21 +2194,15 @@ async function obtainCredential(serviceUrl, opts = {}) {
     accountId: signedIn.accountId
   };
 }
+async function switchAccount(serviceUrl, opts = {}) {
+  forgetStoredCredential(serviceUrl, opts.home);
+  return signInAndStore(serviceUrl, opts);
+}
 async function replaceRefusedCredential(serviceUrl, refused, opts = {}) {
   if (refused.source !== "stored")
     return null;
   forgetStoredCredential(serviceUrl, opts.home);
-  const signedIn = await signIn(serviceUrl, opts);
-  writeStoredCredential(serviceUrl, {
-    accountId: signedIn.accountId,
-    credential: signedIn.credential,
-    expiresAt: signedIn.expiresAt
-  }, opts.home);
-  return {
-    credential: signedIn.credential,
-    source: "browser-handoff",
-    accountId: signedIn.accountId
-  };
+  return signInAndStore(serviceUrl, opts);
 }
 function refusedCredentialRemedy(source) {
   switch (source) {
@@ -2180,6 +2215,238 @@ function refusedCredentialRemedy(source) {
   }
 }
 
+// dist/confirm-identity.js
+import { createInterface } from "node:readline/promises";
+var IDENTITY_TIMEOUT_MS = 5e3;
+var IDENTITY_DECLINED = "identity-declined";
+async function describeAccount(serviceUrl, credential, fetchImpl = fetch) {
+  const url = `${serviceUrl.replace(/\/+$/, "")}/account`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), IDENTITY_TIMEOUT_MS);
+  try {
+    const res = await fetchImpl(url, {
+      headers: { authorization: `Bearer ${credential}` },
+      signal: controller.signal
+    });
+    if (!res.ok)
+      return void 0;
+    const parsed = safeParseAccountIdentity(await res.json());
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function accountLabel(identity, storedAccountId) {
+  const accountId = identity?.accountId ?? storedAccountId;
+  if (identity?.email !== void 0 && identity.email.trim() !== "") {
+    return accountId !== void 0 ? `${identity.email} (account ${accountId})` : identity.email;
+  }
+  if (accountId !== void 0)
+    return `account ${accountId} (no email on record for it)`;
+  return "the account this credential belongs to, which this plane did not name";
+}
+function onlyDate(iso) {
+  if (iso === void 0)
+    return void 0;
+  const match = /^(\d{4}-\d{2}-\d{2})/.exec(iso);
+  return match?.[1] ?? iso;
+}
+function actClause(act) {
+  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}`;
+}
+async function defaultAsk(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await rl.question(question);
+  } finally {
+    rl.close();
+    process.stdin.pause();
+  }
+}
+function readDecision(answer) {
+  const said = answer.trim().toLowerCase();
+  if (said === "y" || said === "yes")
+    return "proceed";
+  if (said === "s" || said === "switch")
+    return "switch-account";
+  return "stop";
+}
+function actingAs(credential, identity) {
+  const accountId = identity?.accountId ?? credential.accountId;
+  return accountId === void 0 ? credential : { ...credential, accountId };
+}
+function armScript(credential, act, label, home) {
+  switch (credential.source) {
+    case "browser-handoff":
+      return {
+        preamble: `[halfcycle] Signed in as ${label}. This install will ${actClause(act)}.
+`,
+        asks: false,
+        noTerminalNote: "",
+        switchOpening: "",
+        stopRemedy: "",
+        afterSwitch: ""
+      };
+    case "environment":
+      return {
+        preamble: `[halfcycle] HALFCYCLE_TOKEN is set in this environment, and this install will use it.
+[halfcycle]   Account: ${label}
+[halfcycle]   About to ${actClause(act)}
+[halfcycle] A variable exported by a shell profile is not a choice about this run \u2014 if that is not your account, the project will belong to it and not to you.
+`,
+        asks: true,
+        // Deliberately nothing. This is the arm's DESIGNED case — a run with no browser
+        // and no human — the preamble has already named the account and the variable,
+        // and a line about having nobody to ask would print on every CI job forever.
+        noTerminalNote: "",
+        switchOpening: `[halfcycle] Signing you in through your browser \u2014 this install will use that account instead.
+`,
+        stopRemedy: `Stopped before anything was created \u2014 nothing was created and nothing was written. HALFCYCLE_TOKEN in this environment is the credential for ${label}, and it takes precedence over any saved sign-in \u2014 so unset it, or set it to your own account's credential, before running this again.`,
+        // The switch is real for THIS run (the new credential is what gets used) and it
+        // does not persist: `obtainCredential` reads the variable first, so the next run
+        // is the same variable again. Said here rather than discovered tomorrow.
+        afterSwitch: `[halfcycle] HALFCYCLE_TOKEN is still set in this environment and still wins over a saved sign-in \u2014 unset it, or the next run will use it again.
+`
+      };
+    case "stored": {
+      const savedOn = onlyDate(credential.signedInAt);
+      return {
+        preamble: `[halfcycle] This machine already has a Halfcycle sign-in saved, and this install will use it.
+[halfcycle]   Account: ${label}
+` + (savedOn !== void 0 ? `[halfcycle]   Saved on this machine: ${savedOn}
+` : "") + `[halfcycle]   About to ${actClause(act)}
+[halfcycle] If that is not your account, the project will belong to it and not to you \u2014 you would not see the project in your own Halfcycle.
+`,
+        asks: true,
+        // Not a question nobody will read — a record of what happened, the two ways to
+        // make the next run act as somebody else (both executable from exactly the state
+        // this is printed in), and where to look for the answer once this output is gone.
+        noTerminalNote: `[halfcycle] Nothing here to ask at (no terminal), so this is continuing as that account.
+[halfcycle] To run as a different one, set HALFCYCLE_TOKEN for that account, or remove ${accountStorePath(home)} and run this again with a terminal to sign in.
+[halfcycle] When this install finishes, which account it used is recorded in .halfcycle/bundle.json, so it can be checked after this output is gone.
+`,
+        switchOpening: `[halfcycle] Forgetting this machine's saved sign-in and signing you in through your browser.
+`,
+        stopRemedy: `Stopped before anything was created \u2014 nothing was created and nothing was written. This machine's saved sign-in is for ${label}. Run this again and answer "s" to sign in as a different account, or remove ${accountStorePath(home)} to be asked for a sign-in next time.`,
+        afterSwitch: ""
+      };
+    }
+  }
+}
+async function confirmActingIdentity(serviceUrl, credential, act, deps = {}) {
+  const write = deps.write ?? ((text) => process.stdout.write(text));
+  const identity = await describeAccount(serviceUrl, credential.credential, deps.fetchImpl);
+  const label = accountLabel(identity, credential.accountId);
+  const acting = actingAs(credential, identity);
+  const script = armScript(credential, act, label, deps.home);
+  write(script.preamble);
+  if (!script.asks)
+    return acting;
+  if (deps.assumeYes === true) {
+    write(`[halfcycle] Continuing as that account without asking, because --yes was given.
+`);
+    return acting;
+  }
+  const interactive = deps.interactive ?? (process.stdin.isTTY === true && !isNonInteractive(deps.env));
+  if (!interactive) {
+    if (script.noTerminalNote !== "")
+      write(script.noTerminalNote);
+    return acting;
+  }
+  const ask = deps.ask ?? defaultAsk;
+  const decision = readDecision(await ask(`[halfcycle] Continue as that account?  [y] yes   [s] sign in as someone else   [anything else] stop: `));
+  if (decision === "proceed")
+    return acting;
+  if (decision === "switch-account") {
+    write(script.switchOpening);
+    const replacement = await switchAccount(serviceUrl, deps);
+    const replacementIdentity = await describeAccount(serviceUrl, replacement.credential, deps.fetchImpl);
+    write(`[halfcycle] Signed in as ${accountLabel(replacementIdentity, replacement.accountId)}. This install will ${actClause(act)}.
+`);
+    if (script.afterSwitch !== "")
+      write(script.afterSwitch);
+    return actingAs(replacement, replacementIdentity);
+  }
+  throw new SignInRefused(IDENTITY_DECLINED, script.stopRemedy);
+}
+
+// dist/project-name.js
+import { basename, resolve } from "node:path";
+var MAX_DERIVED_NAME_LEN = 100;
+var EMPTY_SEGMENTS = /* @__PURE__ */ new Set(["", ".", "..", "/", "\\"]);
+function repositoryNameFromRemote(remote) {
+  const trimmed = remote.trim();
+  if (trimmed.length === 0)
+    return void 0;
+  const withoutTrailingSlash = trimmed.replace(/\/+$/, "");
+  const lastSeparator = Math.max(withoutTrailingSlash.lastIndexOf("/"), withoutTrailingSlash.lastIndexOf(":"));
+  const segment = withoutTrailingSlash.slice(lastSeparator + 1);
+  const name = segment.replace(/\.git$/i, "").trim();
+  return name.length > 0 ? name : void 0;
+}
+function deriveProjectName(targetRepoRoot) {
+  const remote = readRemote(targetRepoRoot);
+  const fromRemote = remote ? repositoryNameFromRemote(remote) : void 0;
+  const candidate = fromRemote ?? basename(resolve(targetRepoRoot));
+  const name = candidate.trim();
+  if (EMPTY_SEGMENTS.has(name))
+    return void 0;
+  return name.slice(0, MAX_DERIVED_NAME_LEN);
+}
+
+// dist/own-engagement.js
+async function createOwnedEngagement(serviceUrl, targetRepo, deps = {}) {
+  let credential = await confirmActingIdentity(serviceUrl, await obtainCredential(serviceUrl, deps), { kind: "create", targetRepo }, deps);
+  for (; ; ) {
+    try {
+      return {
+        ...await createEngagement(serviceUrl, void 0, credential.credential, deriveProjectName(targetRepo)),
+        actingAccountId: credential.accountId
+      };
+    } catch (err) {
+      if (!(err instanceof CreateEngagementRefused) || !err.authRefused)
+        throw err;
+      const replacement = await replaceRefusedCredential(serviceUrl, credential, deps);
+      if (replacement === null) {
+        throw new SignInRefused(`create-${err.status}`, `${err.serverMessage} ${refusedCredentialRemedy(credential.source)} No engagement was created.`);
+      }
+      process.stdout.write(`[halfcycle] Your saved Halfcycle sign-in was refused \u2014 signing you in again.
+`);
+      credential = replacement;
+    }
+  }
+}
+var JOIN_REFUSED_LOCAL_REMEDY = "No credential was minted and nothing was written. This repository is pinned to that engagement by .halfcycle/bundle.json \u2014 check that the id in it is the one you meant. To start a NEW engagement here instead, remove that file and re-run.";
+async function joinPinnedEngagement(serviceUrl, engagementId, targetRepo, deps = {}) {
+  let credential = await confirmActingIdentity(serviceUrl, await obtainCredential(serviceUrl, deps), { kind: "join", targetRepo, engagementId }, deps);
+  for (; ; ) {
+    try {
+      return {
+        ...await joinEngagement(serviceUrl, engagementId, credential.credential),
+        actingAccountId: credential.accountId
+      };
+    } catch (err) {
+      if (!(err instanceof CreateEngagementRefused))
+        throw err;
+      if (err.status === 403) {
+        throw new SignInRefused(`join-${err.status}`, `${err.serverMessage} ${JOIN_REFUSED_LOCAL_REMEDY}`);
+      }
+      if (err.status !== 401) {
+        throw err;
+      }
+      const replacement = await replaceRefusedCredential(serviceUrl, credential, deps);
+      if (replacement === null) {
+        throw new SignInRefused(`join-${err.status}`, `${err.serverMessage} ${refusedCredentialRemedy(credential.source)} No credential was minted and nothing was written.`);
+      }
+      process.stdout.write(`[halfcycle] Your saved Halfcycle sign-in was refused \u2014 signing you in again.
+`);
+      credential = replacement;
+    }
+  }
+}
+
 // dist/mint-board-code.js
 async function mintBoardEnterCode(baseUrl, sessionToken) {
   const url = `${baseUrl.replace(/\/+$/, "")}/board/enter-codes`;
@@ -2512,14 +2779,14 @@ function renderBuildRecordMarkdown(record2) {
 
 // dist/build-record/write.js
 import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join7, resolve, relative as relative2, isAbsolute } from "node:path";
+import { join as join7, resolve as resolve2, relative as relative2, isAbsolute } from "node:path";
 var BUILD_RECORD_DIR = join7("docs", "build-records");
 function serialiseRecordJson(record2) {
   return JSON.stringify(record2, null, 2) + "\n";
 }
 function writeBuildRecord(repoRoot, record2) {
-  const outDir = resolve(repoRoot, BUILD_RECORD_DIR);
-  const expected = resolve(repoRoot, BUILD_RECORD_DIR);
+  const outDir = resolve2(repoRoot, BUILD_RECORD_DIR);
+  const expected = resolve2(repoRoot, BUILD_RECORD_DIR);
   const rel = relative2(expected, outDir);
   if (rel !== "" || isAbsolute(rel)) {
     throw new Error(`[build-record] refusing to write outside ${BUILD_RECORD_DIR}`);
@@ -2793,7 +3060,10 @@ var PLACEHOLDERS = {
 };
 
 // dist/bin.js
-var args = process.argv.slice(2);
+var ASSUME_YES_FLAGS = /* @__PURE__ */ new Set(["--yes", "-y"]);
+var rawArgs = process.argv.slice(2);
+var assumeYes = rawArgs.some((a) => ASSUME_YES_FLAGS.has(a));
+var args = rawArgs.filter((a) => !ASSUME_YES_FLAGS.has(a));
 var MIN_HEADERS_HELPER_VERSION = "2.1.118";
 var MIN_HEADER_ROTATION_VERSION = "2.1.193";
 function compareVersions(a, b) {
@@ -2832,6 +3102,7 @@ function reportClaudeCodeVersion() {
 }
 var USAGE = `  halfcycle [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 check-drift <target-repo>
   halfcycle build-record <phase-id> [--repo <root>]
   halfcycle open-phase <phase|--none> --actor "\u2026" (--evidence "\u2026" | --override --reason "\u2026") [--repo <root>]
@@ -2845,49 +3116,6 @@ function isHalfcycleMonorepo(dir) {
     return false;
   }
 }
-async function createOwnedEngagement(serviceUrl) {
-  let credential = await obtainCredential(serviceUrl);
-  for (; ; ) {
-    try {
-      return await createEngagement(serviceUrl, void 0, credential.credential);
-    } catch (err) {
-      if (!(err instanceof CreateEngagementRefused) || !err.authRefused)
-        throw err;
-      const replacement = await replaceRefusedCredential(serviceUrl, credential);
-      if (replacement === null) {
-        throw new SignInRefused(`create-${err.status}`, `${err.serverMessage} ${refusedCredentialRemedy(credential.source)} No engagement was created.`);
-      }
-      process.stdout.write(`[halfcycle] Your saved Halfcycle sign-in was refused \u2014 signing you in again.
-`);
-      credential = replacement;
-    }
-  }
-}
-var JOIN_REFUSED_LOCAL_REMEDY = "No credential was minted and nothing was written. This repository is pinned to that engagement by .halfcycle/bundle.json \u2014 check that the id in it is the one you meant. To start a NEW engagement here instead, remove that file and re-run.";
-async function joinPinnedEngagement(serviceUrl, engagementId) {
-  let credential = await obtainCredential(serviceUrl);
-  for (; ; ) {
-    try {
-      return await joinEngagement(serviceUrl, engagementId, credential.credential);
-    } catch (err) {
-      if (!(err instanceof CreateEngagementRefused))
-        throw err;
-      if (err.status === 403) {
-        throw new SignInRefused(`join-${err.status}`, `${err.serverMessage} ${JOIN_REFUSED_LOCAL_REMEDY}`);
-      }
-      if (err.status !== 401) {
-        throw err;
-      }
-      const replacement = await replaceRefusedCredential(serviceUrl, credential);
-      if (replacement === null) {
-        throw new SignInRefused(`join-${err.status}`, `${err.serverMessage} ${refusedCredentialRemedy(credential.source)} No credential was minted and nothing was written.`);
-      }
-      process.stdout.write(`[halfcycle] Your saved Halfcycle sign-in was refused \u2014 signing you in again.
-`);
-      credential = replacement;
-    }
-  }
-}
 async function main() {
   const [cmd, ...rest] = args;
   if (cmd === "--help" || cmd === "-h" || cmd === "help") {
@@ -2930,6 +3158,7 @@ ${USAGE}`);
       const reusable = pinned !== null && pinned.engagementId === requestedId ? pinned.credential : void 0;
       let engagementId;
       let credential;
+      let actingAccountId;
       if (reusable !== void 0 && pinned !== null) {
         engagementId = pinned.engagementId;
         credential = reusable;
@@ -2943,8 +3172,9 @@ ${USAGE}`);
 `);
         }
       } else if (requestedId !== void 0) {
-        const joined = await joinPinnedEngagement(serviceUrl, requestedId);
+        const joined = await joinPinnedEngagement(serviceUrl, requestedId, targetRepo, { assumeYes });
         engagementId = joined.engagementId;
+        actingAccountId = joined.actingAccountId;
         credential = {
           serviceUrl,
           token: joined.sessionToken,
@@ -2958,8 +3188,9 @@ ${USAGE}`);
         process.stdout.write(`[halfcycle] Joined engagement ${joined.engagementId} \u2014 this credential is yours. Everyone else's keeps working; nobody was signed out and nothing was pasted.
 `);
       } else {
-        const created = await createOwnedEngagement(serviceUrl);
+        const created = await createOwnedEngagement(serviceUrl, targetRepo, { assumeYes });
         engagementId = created.engagementId;
+        actingAccountId = created.actingAccountId;
         credential = {
           serviceUrl,
           token: created.sessionToken,
@@ -2980,7 +3211,8 @@ ${USAGE}`);
         targetRepo,
         engagementId,
         engagementType: engagementTypeRaw,
-        credential
+        credential,
+        accountId: actingAccountId
       });
       process.stdout.write(`[halfcycle] Installed v${result.version} into ${targetRepo}
 `);