@tablation/crew 0.46.1 → 0.47.0

package/dist/cli.js

@@ -2256,6 +2256,7 @@ function parseResolved(raw, m, where) {
     holds: holds2,
     contract: raw.contract ?? void 0,
     ...typeof raw.releaseSeat === "string" && raw.releaseSeat ? { releaseSeat: raw.releaseSeat } : {},
+    ...typeof raw.releaseAgentId === "string" && raw.releaseAgentId ? { releaseAgentId: raw.releaseAgentId } : {},
     ...Object.keys(agentPersonas).length > 0 ? { agentPersonas } : {},
     ...Object.keys(agentSkills).length > 0 ? { agentSkills } : {}
   };
@@ -7548,6 +7549,8 @@ function needsBaselineBackfill(model, row) {
 function isPromptGateRejection(e) {
   return e instanceof TablationApiError && e.status === 422;
 }
+var RELEASE_AGENT_NAME = "Release agent";
+var RELEASE_AGENT_PROMPT = "Principal for the crew release phase (merge, deploy, release comments). It runs no model; this row only gives those tracker writes an agent identity.";
 async function syncPersonas(route, opts) {
   if (!route.resolved) {
     throw new AgentsSyncError(`route "${route.route}" has no resolved ids \u2014 run \`crew connect\` first`);
@@ -7679,7 +7682,24 @@ async function syncPersonas(route, opts) {
     }
   }
   const crewLinks = opts.dryRun ? [] : await linkCrewSeats(route, client2, agentsModel.id, agentPersonas, opts.userAgent);
-  return { outcomes, agentPersonas, crewLinks };
+  const releaseAgentId = opts.dryRun ? route.resolved.releaseAgentId : await linkReleaseSeat(route, client2, agentsModel, opts.userAgent);
+  return { outcomes, agentPersonas, crewLinks, ...releaseAgentId ? { releaseAgentId } : {} };
+}
+async function linkReleaseSeat(route, client2, agentsModel, userAgent) {
+  const seatId = route.resolved.releaseSeat;
+  if (!seatId) return void 0;
+  const rows = await client2.records.list(agentsModel.id, { limit: 200 });
+  const agentId = rows.find((r) => r.name === RELEASE_AGENT_NAME)?.id ?? (await client2.records.create(agentsModel.id, {
+    name: RELEASE_AGENT_NAME,
+    prompt: RELEASE_AGENT_PROMPT,
+    ...promptSourceFields(agentsModel, RELEASE_AGENT_PROMPT)
+  })).id;
+  const crewModelId = route.resolved.models.crew;
+  const crewModel = await client2.dataModels.get(crewModelId);
+  const columnName = await ensureCrewAgentField(route, client2, crewModel, agentsModel.id, userAgent);
+  const seatRow = await client2.records.get(crewModelId, seatId);
+  if (seatRow[CREW_AGENT_COLUMN] !== agentId) await client2.records.update(crewModelId, seatId, { [columnName]: agentId });
+  return agentId;
 }
 async function linkCrewSeats(route, client2, agentsModelId, agentPersonas, userAgent) {
   const seats2 = route.resolved.seats;
@@ -10870,6 +10890,18 @@ function slugFor(route, agentId) {
 function seatAgentId(route, role) {
   return route.resolved?.agentPersonas?.[role]?.agentId;
 }
+async function resolveReleaseKey(route, getStore = getSessionStore2) {
+  const ship = (reason) => ({ kind: "ship", apiKey: resolveApiKey(route), reason });
+  const agentId = route.resolved?.releaseAgentId;
+  if (!agentId) return ship("release seat has no linked Agents row (run `crew agents sync`)");
+  try {
+    const session = await getStore().get(hostFromUrl2(route.baseUrl), slugFor(route, agentId));
+    if (session?.apiKey) return { kind: "agent", apiKey: session.apiKey, agentId };
+    return ship("no agent key stored for the release seat (run `crew agents sync`)");
+  } catch {
+    return ship("OS keychain unavailable");
+  }
+}
 async function resolveSeatKey(route, role, getStore = getSessionStore2) {
   const ship = (reason) => ({ kind: "ship", apiKey: resolveApiKey(route), reason });
   if (!SEAT_KEY_ROLES.includes(role)) return ship(`${role} always writes as the ship`);
@@ -10888,12 +10920,15 @@ async function mintMissingSeatKeys(route, o) {
   if (!route.resolved) return out;
   const resolved = route.resolved;
   const doFetch = o.fetchImpl ?? fetch;
-  const seated = SEAT_KEY_ROLES.filter((r) => resolved.seats[r]);
+  const targets = [
+    ...SEAT_KEY_ROLES.filter((r) => resolved.seats[r]).map((role) => ({ role, agentId: seatAgentId(route, role) })),
+    ...resolved.releaseSeat ? [{ role: "release", agentId: resolved.releaseAgentId }] : []
+  ];
   let store;
   try {
     store = (o.getStore ?? getSessionStore2)();
   } catch (e) {
-    return seated.map((role) => ({
+    return targets.map(({ role }) => ({
       role,
       action: "failed",
       detail: `OS keychain unavailable: ${e.message}`
@@ -10901,8 +10936,7 @@ async function mintMissingSeatKeys(route, o) {
   }
   const host = hostFromUrl2(route.baseUrl);
   const base = route.baseUrl.replace(/\/+$/, "");
-  for (const role of seated) {
-    const agentId = seatAgentId(route, role);
+  for (const { role, agentId } of targets) {
     if (!agentId) {
       out.push({ role, action: "no_agent" });
       continue;
@@ -13277,7 +13311,9 @@ ${changed2.map((c) => `  - ${c}
         return { scope, tests: "skipped", outcome: "skipped", detail: note };
       }
       if (!dryRun && !c.enabled) return { scope, tests: "skipped", outcome: "skipped", detail: "route not enabled" };
-      const tracker = new Tracker(c, cfg.ship);
+      const releaseIdentity = await resolveReleaseKey(c);
+      if (releaseIdentity.kind === "ship") remit.warn(`release writes as the ship, not its own agent: ${releaseIdentity.reason}`, { step: "release" });
+      const tracker = new Tracker(c, cfg.ship, { apiKey: releaseIdentity.apiKey });
       if (!dryRun) {
         const force2 = command === "deploy" || flag("force");
         let seen = precheckTickets.get(c.route);
@@ -14237,12 +14273,14 @@ ${changed2.map((c) => `  - ${c}
         const raw = existsSync24(resolvedPath) ? JSON.parse(readFileSync18(resolvedPath, "utf8")) : {};
         raw.agentPersonas = personaResult.agentPersonas;
         raw.agentSkills = skillResult.agentSkills;
+        if (personaResult.releaseAgentId) raw.releaseAgentId = personaResult.releaseAgentId;
         mkdirSync13(dirOf(resolvedPath), { recursive: true });
         writeFileSync14(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
       }
       if (!dryRun) {
         target.resolved.agentPersonas = personaResult.agentPersonas;
+        if (personaResult.releaseAgentId) target.resolved.releaseAgentId = personaResult.releaseAgentId;
       }
       for (const o of await mintMissingSeatKeys(target, { userAgent: cfg.ship.userAgent, dryRun, shipName: cfg.ship.name })) {
         process.stdout.write(`${describeMintOutcome(o)}
@@ -14708,7 +14746,8 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           // role as "diverged by definition" on the next sync even though
           // nothing about its prompt actually changed.
           ...previous?.agentPersonas ? { agentPersonas: previous.agentPersonas } : {},
-          ...previous?.agentSkills ? { agentSkills: previous.agentSkills } : {}
+          ...previous?.agentSkills ? { agentSkills: previous.agentSkills } : {},
+          ...previous?.releaseAgentId ? { releaseAgentId: previous.releaseAgentId } : {}
         };
         if (dryRun) {
           process.stderr.write(`(dry run) would write resolved ids to ${resolvedPath}
@@ -15613,6 +15652,13 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
         const id = await resolveSeatKey(route, role);
         process.stdout.write(
           `seat identity:    ${role} writes as ${id.kind === "agent" ? `its own agent (${id.agentId})` : `the ship (${id.reason})`}
+`
+        );
+      }
+      if (route.resolved?.releaseSeat) {
+        const id = await resolveReleaseKey(route);
+        process.stdout.write(
+          `seat identity:    release writes as ${id.kind === "agent" ? `its own agent (${id.agentId})` : `the ship (${id.reason})`}
 `
         );
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.46.1",
+  "version": "0.47.0",
   "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",