@tablation/crew 0.79.8 → 0.79.10

package/dist/cli.js

@@ -4326,7 +4326,7 @@ function reconcileHeldWorktrees(state, repo, log, stillRefused) {
   }
 }
 function openShipAttention(state, nowMs = Date.now()) {
-  const stale = staleRelease(state.releaseHeartbeat().at(), nowMs);
+  const stale = state.releaseInProgress() ? null : staleRelease(state.releaseHeartbeat().at(), nowMs);
   const stored = state.shipAttention().previous();
   return stale ? [...stored, stale] : stored;
 }
@@ -5465,7 +5465,7 @@ var HandoffTranscriptTracker = class {
 };
 
 // src/pending-handoff.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, readdirSync as readdirSync5, readFileSync as readFileSync13, rmSync as rmSync8, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, readdirSync as readdirSync6, readFileSync as readFileSync13, rmSync as rmSync8, writeFileSync as writeFileSync9 } from "fs";
 import { join as join16 } from "path";
 
 // src/ticket-branch.ts
@@ -5476,7 +5476,7 @@ import { hostname } from "os";
 import { TablationClient } from "@tablation/client";
 
 // src/state.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync12, mkdirSync as mkdirSync7, rmSync as rmSync7, statSync as statSync4 } from "fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync12, mkdirSync as mkdirSync7, rmSync as rmSync7, statSync as statSync4, readdirSync as readdirSync5 } from "fs";
 import { join as join13 } from "path";
 var EPOCH = "1970-01-01T00:00:00.000Z";
 var State = class _State {
@@ -5605,6 +5605,35 @@ var State = class _State {
       }
     };
   }
+  /**
+   * Whether a release is running right now: any `.release-<scope>.lock` in the
+   * state directory naming a live process (the locks `releasePhase` takes per
+   * scope). A lock naming a dead pid is ignored, as `acquire` ignores it.
+   */
+  releaseInProgress() {
+    let names;
+    try {
+      names = readdirSync5(this.dir);
+    } catch {
+      return false;
+    }
+    for (const n of names) {
+      if (!/^\.release-.+\.lock$/.test(n)) continue;
+      let pid = 0;
+      try {
+        pid = Number.parseInt(readFileSync12(this.path(n), "utf8").trim(), 10);
+      } catch {
+        continue;
+      }
+      if (!Number.isFinite(pid) || pid <= 0) continue;
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch {
+      }
+    }
+    return false;
+  }
   /**
    * Like `acquire`, but for a resource with `max` interchangeable slots
    * rather than one exclusive holder — this machine's overall concurrency
@@ -7519,7 +7548,7 @@ function listPendingHandoffs(stateDir, route) {
   const dir = pendingDirFor(stateDir);
   if (!existsSync15(dir)) return [];
   const out = [];
-  for (const f of readdirSync5(dir).filter((n) => n.endsWith(".json")).sort()) {
+  for (const f of readdirSync6(dir).filter((n) => n.endsWith(".json")).sort()) {
     try {
       const rec = JSON.parse(readFileSync13(join16(dir, f), "utf8"));
       if (rec.version === 1 && rec.ticketRecordId && (!route || rec.route === route)) out.push(rec);
@@ -7639,7 +7668,7 @@ function expandSkillMarkers(text, lookup, opts = {}) {
 }
 
 // src/skills.ts
-import { readFileSync as readFileSync15, readdirSync as readdirSync6, existsSync as existsSync17 } from "fs";
+import { readFileSync as readFileSync15, readdirSync as readdirSync7, existsSync as existsSync17 } from "fs";
 import { join as join18 } from "path";
 import { parse as parseYaml } from "yaml";
 import { TablationClient as TablationClient3, StaleWriteError as StaleWriteError3, TablationApiError as TablationApiError2 } from "@tablation/client";
@@ -8138,7 +8167,7 @@ function parseSkillFile(path) {
 function listLocalSkills(promptsDir) {
   const dir = join18(promptsDir, "skills");
   if (!existsSync17(dir)) return [];
-  return readdirSync6(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join18(dir, f)));
+  return readdirSync7(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join18(dir, f)));
 }
 async function syncSkills(route, opts) {
   if (!route.resolved) {
@@ -9650,6 +9679,35 @@ function rememberSession(stateDir, host, workspaceSlug) {
   } catch {
   }
 }
+function forgetWorkspace(stateDir, host, workspaceSlug) {
+  try {
+    const all = readPointers(stateDir);
+    const left = (all[host] ?? []).filter((w) => w !== workspaceSlug);
+    const { [host]: _old, ...rest } = all;
+    const next = left.length ? { ...rest, [host]: left } : rest;
+    if (Object.keys(next).length) writePointers(stateDir, next);
+    else rmSync10(lastSessionFile(stateDir), { force: true });
+  } catch {
+  }
+}
+async function adoptSessionAddress(o) {
+  if (o.from === o.to) return false;
+  try {
+    const stored = await o.store.get(o.host, o.from);
+    if (!stored?.apiKey) return false;
+    if (!(await o.store.get(o.host, o.to))?.apiKey) await o.store.set(o.host, o.to, stored);
+    await o.store.clear(o.host, o.from);
+  } catch {
+    return false;
+  }
+  forgetWorkspace(o.stateDir, o.host, o.from);
+  rememberSession(o.stateDir, o.host, o.to);
+  return true;
+}
+function rememberedAddressFor(stateDir, host, workspace) {
+  if (workspace.includes(":")) return workspace;
+  return (readPointers(stateDir)[host] ?? []).find((w) => w.endsWith(`:${workspace}`)) ?? workspace;
+}
 async function resumableSessions(o) {
   const out = [];
   for (const workspace of readPointers(o.stateDir)[o.host] ?? []) {
@@ -9696,7 +9754,7 @@ async function signOutSessions(o) {
 }
 
 // src/reset.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync19, readdirSync as readdirSync7, rmSync as rmSync11, statSync as statSync6, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync19, readdirSync as readdirSync8, rmSync as rmSync11, statSync as statSync6, writeFileSync as writeFileSync13 } from "fs";
 import { dirname as dirname9, join as join22 } from "path";
 import { hostFromUrl as hostFromUrl3 } from "@tablation/client";
 function clonedCheckoutsFile(stateDir) {
@@ -9791,7 +9849,7 @@ function removeState(stateDir, dryRun) {
   const out = [];
   const targets = [join22(stateDir, "resolved"), join22(stateDir, "keys"), clonedCheckoutsFile(stateDir), join22(stateDir, "connect-session.json"), join22(stateDir, "reload-requested"), join22(stateDir, "daemon.started")];
   try {
-    for (const name of readdirSync7(stateDir)) {
+    for (const name of readdirSync8(stateDir)) {
       if (name.startsWith(".") && statSync6(join22(stateDir, name)).isFile()) targets.push(join22(stateDir, name));
     }
   } catch {
@@ -15477,7 +15535,7 @@ function schedulerInstalled(plan, exists, crontab) {
 }
 
 // src/worktree-sweep.ts
-import { existsSync as existsSync27, readFileSync as readFileSync25, readdirSync as readdirSync8 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync25, readdirSync as readdirSync9 } from "fs";
 import { basename as basename11, dirname as dirname18, join as join30, resolve as resolve4 } from "path";
 function planWorktreeSweep(target, tickets, contract) {
   const terminal = new Set(contract.statuses.resolved.filter((s) => s !== contract.statuses.verified));
@@ -15537,7 +15595,7 @@ function siblingWorktreeDirs(target) {
   const registered = new Set(worktrees(target.dir).map((w) => resolve4(w.path)));
   let names;
   try {
-    names = readdirSync8(parent);
+    names = readdirSync9(parent);
   } catch {
     return [];
   }
@@ -15753,14 +15811,14 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 }
 
 // src/stream-sweep.ts
-import { existsSync as existsSync28, readdirSync as readdirSync9, rmSync as rmSync13, statSync as statSync8 } from "fs";
+import { existsSync as existsSync28, readdirSync as readdirSync10, rmSync as rmSync13, statSync as statSync8 } from "fs";
 import { join as join31 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
   const dir = join31(stateDir, "streams");
   if (!existsSync28(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync9(dir).map((name) => join31(dir, name)).filter((path) => {
+  return readdirSync10(dir).map((name) => join31(dir, name)).filter((path) => {
     try {
       return statSync8(path).mtimeMs < cutoff;
     } catch {
@@ -15788,7 +15846,7 @@ function applyStreamSweep(paths, dryRun, log) {
 function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
   if (!existsSync28(stateDir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync9(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join31(stateDir, name)).filter((path) => {
+  return readdirSync10(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join31(stateDir, name)).filter((path) => {
     try {
       return statSync8(path).mtimeMs < cutoff;
     } catch {
@@ -15798,7 +15856,7 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { realpathSync as realpathSync3, readFileSync as readFileSync31, existsSync as existsSync34, mkdirSync as mkdirSync22, writeFileSync as writeFileSync23, rmSync as rmSync15, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync10, readdirSync as readdirSync14 } from "fs";
+import { realpathSync as realpathSync3, readFileSync as readFileSync31, existsSync as existsSync34, mkdirSync as mkdirSync22, writeFileSync as writeFileSync23, rmSync as rmSync15, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync10, readdirSync as readdirSync15 } from "fs";
 import { createInterface } from "readline/promises";
 import { dirname as dirOf, resolve as resolvePath } from "path";
 
@@ -16055,7 +16113,7 @@ function syncAllPassengerCheckouts(cfg) {
 
 // src/tunnel.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync30, mkdirSync as mkdirSync19, readFileSync as readFileSync27, writeFileSync as writeFileSync20, unlinkSync as unlinkSync3, readdirSync as readdirSync10 } from "fs";
+import { existsSync as existsSync30, mkdirSync as mkdirSync19, readFileSync as readFileSync27, writeFileSync as writeFileSync20, unlinkSync as unlinkSync3, readdirSync as readdirSync11 } from "fs";
 import { randomInt } from "crypto";
 import { join as join33 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
@@ -16237,7 +16295,7 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
 function readAllPersistedWorkspaceIds(stateDir) {
   const dir = join33(stateDir, "passengers");
   if (!existsSync30(dir)) return [];
-  return readdirSync10(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
+  return readdirSync11(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
 // src/mcp-endpoint-registry.ts
@@ -16357,7 +16415,7 @@ async function unregisterEndpoint(workspaceId, info, d) {
 import { createServer as createHttpServer } from "http";
 import { spawn as spawn6 } from "child_process";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync31, mkdirSync as mkdirSync20, readFileSync as readFileSync28, writeFileSync as writeFileSync21, unlinkSync as unlinkSync4, readdirSync as readdirSync11 } from "fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync20, readFileSync as readFileSync28, writeFileSync as writeFileSync21, unlinkSync as unlinkSync4, readdirSync as readdirSync12 } from "fs";
 import { join as join34 } from "path";
 
 // src/secret-compare.ts
@@ -16484,7 +16542,7 @@ function readAllPersistedSyncWorkspaceIds(stateDir) {
   const dir = join34(stateDir, "passengers");
   if (!existsSync31(dir)) return [];
   const suffix = "-sync.json";
-  return readdirSync11(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
+  return readdirSync12(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
 }
 function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
   const alive = deps.isPidAlive ?? isPidAlive;
@@ -16570,11 +16628,11 @@ function describeCause(err) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync33, mkdirSync as mkdirSync21, readFileSync as readFileSync30, readdirSync as readdirSync13, rmSync as rmSync14, statSync as statSync9, writeFileSync as writeFileSync22 } from "fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync21, readFileSync as readFileSync30, readdirSync as readdirSync14, rmSync as rmSync14, statSync as statSync9, writeFileSync as writeFileSync22 } from "fs";
 import { join as join36 } from "path";
 
 // src/interrupted.ts
-import { existsSync as existsSync32, readdirSync as readdirSync12, readFileSync as readFileSync29 } from "fs";
+import { existsSync as existsSync32, readdirSync as readdirSync13, readFileSync as readFileSync29 } from "fs";
 import { join as join35 } from "path";
 var INTERRUPTED_MARKER = calloutHeader("NOTE", "Interrupted");
 function interruptedComment(b) {
@@ -16606,7 +16664,7 @@ function orphanedStreams(o) {
   if (!existsSync32(dir)) return [];
   const ownerAlive = o.isOwnerAlive ?? pidAlive;
   const out = [];
-  for (const name of readdirSync12(dir)) {
+  for (const name of readdirSync13(dir)) {
     if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
     const streamPath = join35(dir, name);
     if (runFinished(streamPath)) continue;
@@ -16727,7 +16785,7 @@ function latestMtime(path) {
   if (stat.isFile()) return stat.mtimeMs;
   if (!stat.isDirectory()) return 0;
   let latest = stat.mtimeMs;
-  for (const entry of readdirSync13(path, { withFileTypes: true })) {
+  for (const entry of readdirSync14(path, { withFileTypes: true })) {
     latest = Math.max(latest, latestMtime(join36(path, entry.name)));
   }
   return latest;
@@ -17502,6 +17560,7 @@ if (command === "passenger-sync-daemon") {
   }, releaseRefused = function() {
     const why = state.releaseSkipReason();
     if (!why) return false;
+    if (!dryRun) state.releaseHeartbeat().touch();
     emit.emit(`${why} \u2014 release skipped`, { step: "release" });
     return true;
   }, doctorMachineId = function(stateDir) {
@@ -19252,7 +19311,7 @@ ${changed2.map((c) => `  - ${c}
           if (!existsSync34(dir)) throw new ReposError(`${dir} does not exist on disk`);
           const files = { exists: (r) => existsSync34(resolvePath(dir, r)), list: (r) => {
             try {
-              return readdirSync14(resolvePath(dir, r));
+              return readdirSync15(resolvePath(dir, r));
             } catch {
               return [];
             }
@@ -19449,7 +19508,7 @@ ${changed2.map((c) => `  - ${c}
 ` : `${human}
 `);
           const plan2 = planRepoClone({ text, base, route: routeName, name: addName, resolved: resolvedRemotes, dir: value("dir"), isCheckout });
-          if (existsSync34(plan2.target) && (existsSync34(`${plan2.target}/.git`) || readdirSync14(plan2.target).length > 0)) {
+          if (existsSync34(plan2.target) && (existsSync34(`${plan2.target}/.git`) || readdirSync15(plan2.target).length > 0)) {
             throw new ReposError(
               existsSync34(`${plan2.target}/.git`) ? `${plan2.target} is already a checkout \u2014 attach it with \`crew repos add ${routeName} ${plan2.name} ${plan2.target}\`` : `${plan2.target} exists and is not empty \u2014 pass --dir to clone somewhere else`
             );
@@ -19680,12 +19739,22 @@ ${reconstruction.prompt}
         store = void 0;
       }
       let keychainBacked = false;
+      let sessionAddress;
       if (!apiKey && workspace && store) {
         try {
-          const existing = await store.get(hostFromUrl4(baseUrl), workspace);
+          let existing = await store.get(hostFromUrl4(baseUrl), workspace);
+          let found = workspace;
+          if (!existing?.apiKey) {
+            const full = rememberedAddressFor(cfg.ship.stateDir, hostFromUrl4(baseUrl), workspace);
+            if (full !== workspace) {
+              existing = await store.get(hostFromUrl4(baseUrl), full);
+              found = full;
+            }
+          }
           if (existing?.apiKey) {
             apiKey = existing.apiKey;
             keychainBacked = true;
+            sessionAddress = found;
             process.stderr.write(`Reusing the existing keychain session for ${hostFromUrl4(baseUrl)}/${workspace}.
 `);
           }
@@ -19719,6 +19788,7 @@ ${reconstruction.prompt}
           apiKey = resumed.apiKey;
           workspace = resumed.workspace;
           keychainBacked = true;
+          sessionAddress = resumed.workspace;
           signInSource = "keychain";
           process.stderr.write(`Reusing the existing keychain session for ${hostFromUrl4(baseUrl)}/${workspace}.
 `);
@@ -19773,13 +19843,6 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         );
         apiKey = result.apiKey.key;
         mintedFromDevice = true;
-        signedInEmitted = true;
-        connectEvents.emit("signed_in", `signed in as ${result.identity.email}`, {
-          identity: { id: result.identity.id, email: result.identity.email },
-          workspaces: [{ slug: result.workspace.slug, name: result.workspace.name }],
-          session: "device",
-          host: hostFromUrl4(baseUrl)
-        });
         const deviceWorkspace = "path" in result.workspace && typeof result.workspace.path === "string" ? result.workspace.path : result.workspace.slug;
         if (!workspace) workspace = deviceWorkspace;
         if (store) {
@@ -19791,6 +19854,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
               createdAt: result.apiKey.createdAt
             });
             keychainBacked = true;
+            sessionAddress = deviceWorkspace;
             rememberSession(cfg.ship.stateDir, hostFromUrl4(baseUrl), deviceWorkspace);
             process.stderr.write(
               `API key stored in the OS keychain for ${hostFromUrl4(baseUrl)}/${deviceWorkspace}.
@@ -19834,9 +19898,18 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       };
       const runConnect = async (ws, proj) => {
         let found = await discover({ ...authOpts, workspace: ws, project: proj, area: value("area"), ship, dryRun, interactive: canAsk || connectEvents.json });
+        if (store && keychainBacked && sessionAddress && sessionAddress !== found.workspaceSlug) {
+          if (await adoptSessionAddress({
+            store,
+            stateDir: cfg.ship.stateDir,
+            host: hostFromUrl4(baseUrl),
+            from: sessionAddress,
+            to: found.workspaceSlug
+          })) sessionAddress = found.workspaceSlug;
+        }
         if (!signedInEmitted && found.meId) {
           signedInEmitted = true;
-          connectEvents.emit("signed_in", `key belongs to ${found.meEmail ?? found.meId}`, {
+          connectEvents.emit("signed_in", mintedFromDevice ? `signed in as ${found.meEmail ?? found.meId}` : `key belongs to ${found.meEmail ?? found.meId}`, {
             identity: { id: found.meId, email: found.meEmail, name: found.meName },
             workspaces: [{ slug: found.workspaceSlug, name: found.workspaceName, role: found.role }],
             session: signInSource,
@@ -20987,7 +21060,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       }
       const projectId = route.resolved.areaId ?? resolveRepoProject(await tracker.projectRows(), value("project"));
       const fresh = !existsSync34(join37(dir, ".git"));
-      if (existsSync34(dir) && fresh && readdirSync14(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
+      if (existsSync34(dir) && fresh && readdirSync15(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
       if (dryRun) {
         say("dry-run", { dir, newCheckout: fresh, repoRow: row?.id ?? null }, `would ${fresh ? "create" : "reuse"} ${dir}${row ? "" : ", create the Repos row"}, and file one ${tracker.contract.statuses.approved} ticket`);
         break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.79.8",
+  "version": "0.79.10",
   "description": "A standing team of headless agents that picks work off a Tablation board, does it on a machine you control, and reports back.",
   "type": "module",
   "license": "MIT",