@volter/supercode-orchestrator 0.5.205 → 0.5.207

package/board/workflow.mjs

@@ -5,6 +5,7 @@
 // the engine's primitives (the rows Hermes's tables hold); the I/O an action asks for (stopping a worker, closing a
 // pane, sending a session a message, cleaning a workspace) is answered as effects the caller runs after commit.
 import { current } from './call.mjs';
+import { detachedCard, detachedSession } from './custody.mjs';
 import { notRuntime } from './owner-files.mjs';
 import { machineCall } from './doors.mjs';
 import { execFile } from 'node:child_process';
@@ -17,9 +18,24 @@ import { releaseAllSideSessions } from './side-sessions.mjs';
 import { evaluate, holds, render, needsSources } from './expr.mjs';
 import { completionEvidence, declaredWorkBranches, namedWorkBranch, reviewCandidate } from './ci.mjs';
 import { cardCommitsOn, isLocalWorkspace, isWorkspacePath } from './workspace.mjs';
-import { identifyNotice } from './notices.mjs';
+import { cardNumber, identifyNotice, numbered } from './notices.mjs';
 
 const loaded = new Map();
+// the owner's read door holds the workflow the owner reads (owner-door.mjs), told when it is read again
+const workflowWatchers = new Set();
+const hold = (root, entry) => {
+  const again = loaded.get(root)?.orchestration !== entry.orchestration;
+  loaded.set(root, entry);
+  if (again) for (const watcher of workflowWatchers) watcher(root, entry);
+};
+/** `watcher(root, entry)` is told each workflow this process holds, now and whenever one is read again; answers its stop. */
+export function watchWorkflows(watcher) {
+  workflowWatchers.add(watcher);
+  for (const [root, entry] of loaded) watcher(root, entry);
+  return () => workflowWatchers.delete(watcher);
+}
+/** Hold the workflow another thread of this process read for `root` (the owner's, on its read door). */
+export function holdWorkflow(root, entry) { loaded.set(root, { ...entry, root }); }
 const homes = new Map(); // root → Promise<orchestration>: the home as the IR reads it, held until it changes
 
 /**
@@ -49,15 +65,15 @@ export async function loadWorkflow(root) {
     entry = workflowEntry(orchestration);
     entry.root = root;
     entry.orchestration = orchestration;
-    loaded.set(root, entry);
+    hold(root, entry);
   }
   current().workflows.set(root, entry);
   return entry;
 }
 
 // What the board's view of a home is decoded from: the workflow, each profile's config, credentials and the agent
-// layer, and which profiles there are. A session store or a run log changing is no change to it.
-const DECODED = /^(?:(?:profiles\/[^/]+\/)?(?:config\.yaml|\.env|agents\.json)|workflow\.yaml|profiles(?:\/[^/]+)?)$/;
+// layer, persona, and which profiles there are. A session store or a run log changing is no change to it.
+const DECODED = /^(?:(?:profiles\/[^/]+\/)?(?:config\.yaml|\.env|agents\.json|AGENTS\.md)|workflow\.yaml|profiles(?:\/[^/]+)?)$/;
 
 /**
  * Follow the home's own files, so the held view is read again on its next use after one it is decoded from changes:
@@ -75,7 +91,7 @@ export function followHome(root, { onChange = () => {}, onLost = () => {} } = {}
   const linked = new Map(); // target folder → watcher
   const followLinks = () => {
     const targets = new Map();
-    const decoded = ['workflow.yaml', 'config.yaml', '.env', 'agents.json'];
+    const decoded = ['workflow.yaml', 'config.yaml', '.env', 'agents.json', 'AGENTS.md'];
     const watchIn = (folder, name) => { if (!targets.has(folder)) targets.set(folder, new Set()); targets.get(folder).add(name); };
     let realRoot = root;
     try { realRoot = realpathSync(root); } catch { /* the home's own watch reports it */ }
@@ -143,7 +159,7 @@ export function workflowFor(root) {
 /** Use `entry` for `root` (a caller that read the IR itself). */
 export function useWorkflow(root, entry) {
   entry.root = root;
-  loaded.set(root, entry);
+  hold(root, entry);
   current().workflows.set(root, entry);
   return entry;
 }
@@ -170,6 +186,11 @@ export function completionOwnerOf(db, id) {
   return creatorOf(db, id);
 }
 
+/** A card's explicitly named review profile, retained in its own history. */
+export function reviewerOf(db, id) {
+  return json(one(db, "SELECT payload FROM task_events WHERE task_id=? AND kind IN ('created','reviewer_set') ORDER BY id DESC LIMIT 1", id)?.payload, {})?.reviewer ?? null;
+}
+
 export function latestReview(db, id) {
   const row = one(db, "SELECT id,started_at,metadata FROM task_runs WHERE task_id=? AND json_extract(metadata,'$.supercode.role')='reviewer' ORDER BY id DESC LIMIT 1", id);
   if (!row) return null;
@@ -363,7 +384,8 @@ export function runWorkingSeconds(row, at = now()) {
   return Math.max(0, end - Number(row.started_at ?? end) - Number(json(row.metadata,{})?.supercode?.stopped_seconds??0));
 }
 
-function timeOf(db, task) {
+/** Elapsed role totals need no review candidate or workflow guard scope. */
+export function timeOf(db, task) {
   const t = now();
   const out = { coding: 0, reviewing: 0, auditing: 0, triaging: 0 };
   const key = { implementer: 'coding', reviewer: 'reviewing', auditor: 'auditing', triager: 'triaging' };
@@ -394,6 +416,14 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {}, lazy
   const lastRun = once(() => one(db, 'SELECT * FROM task_runs WHERE task_id = ? AND ended_at IS NOT NULL ORDER BY ended_at DESC, id DESC LIMIT 1', task.id));
   const lastCompleted = once(() => one(db, "SELECT * FROM task_runs WHERE task_id = ? AND outcome = 'completed' ORDER BY ended_at DESC LIMIT 1", task.id));
   const asked = once(() => json(one(db, "SELECT payload FROM task_events WHERE task_id = ? AND kind = 'review_requested' ORDER BY id DESC LIMIT 1", task.id)?.payload, {}) ?? {});
+  const entry = current().workflows.get(board.root) ?? loaded.get(board.root);
+  // Read the coding role, never the latest run of any role: after a review or a
+  // reassignment that run may belong to a different harness than the coder's.
+  const coding = once(() => one(db, "SELECT id,profile,metadata FROM task_runs WHERE task_id=? AND json_extract(metadata,'$.supercode.role')='implementer' ORDER BY id DESC LIMIT 1", task.id));
+  const codingSession = once(() => json(coding()?.metadata, {})?.supercode ?? {});
+  const codingProfile = once(() => coding()?.profile ?? asked().implementer ?? task.assignee);
+  const coderProfile = once(() => entry?.profiles?.[codingProfile()]);
+  const configuredCoder = once(() => coderProfile()?.worker);
   const changes = once(() => json(one(db, "SELECT payload FROM task_events WHERE task_id = ? AND kind = 'changes_requested' ORDER BY id DESC LIMIT 1", task.id)?.payload, {}) ?? {});
   const interruption = once(() => json(one(db, `SELECT payload FROM task_events WHERE task_id = ? AND kind IN ('blocked', 'block_loop_detected', 'dependency_wait', 'gave_up',
     'unblocked', 'changes_requested', 'review_reopened', 'status', 'reclaimed', 'stale', 'timed_out', 'crashed', 'spawn_failed', 'rate_limited', 'session_lost')
@@ -415,6 +445,7 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {}, lazy
     status,
     blocked_by: blocks,
     paused: json(state.paused, null),
+    detached: json(state.detached, null),
     archived: Boolean(state.archived),
     every: state.every ?? null,
     next_run_at: state.next_run_at ?? null,
@@ -436,6 +467,15 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {}, lazy
     get counters() { return { failures: Number(task.consecutive_failures || 0), block_recurrences: Number(task.block_recurrences || 0), goal_turns: Number(session().goal_turns || 0) }; },
     goal_mode: Boolean(task.goal_mode),
     get implementer() { return asked().implementer ?? task.assignee; },
+    get implementer_harness() { return codingSession().harness ?? configuredCoder()?.harness ?? null; },
+    get implementer_model() { return codingSession().model ?? (codingProfile() === task.assignee ? task.model_override : asked().implementer_model) ??
+      configuredCoder()?.model ?? coderProfile()?.residue?.config?.model?.default ?? null; },
+    get implementer_run() { return coding() ? { id: coding().id, profile: coding().profile, harness: codingSession().harness ?? null,
+      model: codingSession().model ?? null, machine: codingSession().machine ?? null } : null; },
+    get implementer_machine() { return Object.hasOwn(asked(), 'implementer_machine') ? asked().implementer_machine : task.machine ?? null; },
+    get implementer_model_override() { return Object.hasOwn(asked(), 'implementer_model_override') ? asked().implementer_model_override : task.model_override ?? null; },
+    get implementer_provider_override() { return Object.hasOwn(asked(), 'implementer_provider_override') ? asked().implementer_provider_override : task.provider_override ?? null; },
+    get reviewer() { return reviewerOf(db, task.id); },
     get last_reviewer() { return changes().reviewer ?? null; },
     get arc() { return task.subtask_of ? one(db, `SELECT t.id, ${related}, t.title, t.body, t.assignee FROM tasks t LEFT JOIN supercode_cards c ON c.task_id = t.id WHERE t.id = ?`, task.subtask_of) ?? null : null; },
     // the cards filed as its subtasks (`create --subtask-of`), in the order they were filed
@@ -485,13 +525,7 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {}, lazy
     Object.defineProperty(card, key, { get: read, enumerable: true, configurable: true });
     if (!lazy) read();
   }
-  const derived = loaded.get(board.root)?.workflow?.derived ?? {};
-  for (const [key, expr] of Object.entries(derived)) {
-    // Preflight neither evaluates nor exposes a derived source value from a stale/missing observation.
-    const value = deferSources && needsSources(expr, derived) ? undefined : evaluate(expr, { card, event, params, now: now() });
-    Object.defineProperty(card, key, { value, writable: true, enumerable: true, configurable: true });
-  }
-  return {
+  const scope = {
     card,
     requester: actorOf(),
     event,
@@ -499,8 +533,15 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {}, lazy
     now: now(),
     board: board.label ?? board.slug,
     matches: (text, p) => (text === null || text === undefined ? false : pattern(p).test(String(text))),
+    lanes: entry ? lanesIn(entry) : {},
+    profile_harnesses: Object.fromEntries(Object.entries(entry?.profiles ?? {}).filter(([, profile]) => profile?.worker?.harness)
+      .map(([name, profile]) => [name, profile.worker.harness])),
     ...extra,
   };
+  // Derived facts see the same names as transitions, including the home's
+  // lanes. The pinned entry remains the basis if the home reloads mid-call.
+  for (const [key, expr] of Object.entries(entry?.workflow?.derived ?? {})) card[key] = deferSources && needsSources(expr, entry.workflow.derived) ? undefined : evaluate(expr, scope);
+  return scope;
 }
 
 // ------------------------------------------------------------------ events
@@ -528,13 +569,19 @@ function noticeRun(db, task) {
     : all(db, 'SELECT id, metadata FROM task_runs WHERE task_id = ? ORDER BY id DESC', task.id).find((r) => json(r.metadata, {})?.supercode?.session_id) ?? null;
 }
 
-function queueTransitionNotice(db, board, entry, task, from, name, payload, beforeRun, effects) {
+function queueTransitionNotice(db, board, entry, task, from, name, payload, beforeRun, effects, noticeSession = null) {
   const after = cardOf(db, task.id), to = statusOf(db, after);
+  // A verified adoption starts a new run before binding its session. Its notice
+  // belongs to that new run and verified identity, never the last ended session
+  // that noticeRun found before the transition.
+  const targetRun = noticeSession && after.current_run_id
+    ? one(db, 'SELECT id, metadata FROM task_runs WHERE id = ?', after.current_run_id) : beforeRun;
   const state = (t, status) => JSON.stringify([status, t.current_run_id, t.paused, t.archived, t.blocked_by]);
   const beforeState = json(beforeRun?.metadata, {})?.supercode?.state;
   const afterState = beforeRun && json(one(db, 'SELECT metadata FROM task_runs WHERE id=?', beforeRun.id)?.metadata, {})?.supercode?.state;
-  if (!beforeRun || (state(task, from) === state(after, to) && beforeState === afterState) || effects.some((e) => e.kind === 'session_notice' && e.runId === beforeRun.id)) return;
-  const session = json(beforeRun.metadata, {})?.supercode;
+  if (!targetRun || (state(task, from) === state(after, to) && beforeState === afterState) || effects.some((e) => e.kind === 'session_notice' && e.runId === targetRun.id)) return;
+  const session = noticeSession ?? json(targetRun.metadata, {})?.supercode;
+  if (detachedSession(db, session)) return;
   const address = session?.address ?? (session?.session_id && session.machine ? `sc:${session.machine}:${session.harness ?? 'claude-code'}:${session.session_id}` : null);
   if (!address && !session?.launch_key && !session?.pane) return;
   // The session that made this change learns it from its own command's answer; a notice about
@@ -542,16 +589,19 @@ function queueTransitionNotice(db, board, entry, task, from, name, payload, befo
   // confirmed is not told either: its next run resumes it with the card's state in its prompt.
   if (address && address === actorOf()) return;
   if (session?.close_confirmed_at) return;
-  const scope = scopeOf(db, board, after, { params: entry.params, event: { ...payload, verb: name, from, to }, extra: { run: { id: beforeRun.id } } });
-  const body = render(entry.workflow.notify?.worker?.run_changed ?? '{{card.id}}: {{event.verb}} changed run {{run.id}} ({{event.from}} → {{event.to}}). Stop work under the previous run; follow the board’s current state. {{event.reason ?? ""}}', scope);
+  const scope = scopeOf(db, board, after, { params: entry.params, event: { ...payload, verb: name, from, to }, extra: { run: { id: targetRun.id } } });
+  const defaultNotice = noticeSession
+    ? '{{card.id}}: verified adoption started run {{run.id}} ({{event.from}} → {{event.to}}). Follow the board’s current state before continuing.'
+    : '{{card.id}}: {{event.verb}} changed run {{run.id}} ({{event.from}} → {{event.to}}). Stop work under the previous run; follow the board’s current state. {{event.reason ?? ""}}';
+  const body = numbered(cardNumber(db, task.id), render(entry.workflow.notify?.worker?.run_changed ?? defaultNotice, scope));
   const source = one(db, 'SELECT MAX(id) AS id FROM task_events WHERE task_id = ?', task.id)?.id;
-  const text = identifyNotice({ id: source, kind: name, run_id: beforeRun.id, created_at: now() }, body);
-  const effect = { kind: 'session_notice', id: task.id, runId: beforeRun.id, address, text, sourceEvent: source, verb: name, messageKey: `board-run-notice-${randomBytes(16).toString('hex')}` };
+  const text = identifyNotice({ id: source, kind: name, run_id: targetRun.id, created_at: now() }, body);
+  const effect = { kind: 'session_notice', id: task.id, runId: targetRun.id, address, text, sourceEvent: source, verb: name, messageKey: `board-run-notice-${randomBytes(16).toString('hex')}` };
   const inserted = run(db, 'INSERT INTO supercode_effects (effect) VALUES (?)', JSON.stringify(effect));
   effects.push({ ...effect, durableId: Number(inserted.lastInsertRowid) });
-  const current = json(one(db, 'SELECT metadata FROM task_runs WHERE id = ?', beforeRun.id)?.metadata, {}) ?? {};
+  const current = json(one(db, 'SELECT metadata FROM task_runs WHERE id = ?', targetRun.id)?.metadata, {}) ?? {};
   current.supercode = { ...current.supercode, lifecycle_notice_pending: Number(inserted.lastInsertRowid) };
-  run(db, 'UPDATE task_runs SET metadata = ? WHERE id = ?', JSON.stringify(current), beforeRun.id);
+  run(db, 'UPDATE task_runs SET metadata = ? WHERE id = ?', JSON.stringify(current), targetRun.id);
 }
 
 /**
@@ -644,7 +694,7 @@ export function validateEvent(db, board, entry, id, name, { roles = [], payload
   return { task, from, taken, scope, beforeRun: localOnly ? null : noticeRun(db, task) };
 }
 
-export function fire(db, board, entry, id, name, { roles = [], payload = {}, extra = {} } = {}) {
+export function fire(db, board, entry, id, name, { roles = [], payload = {}, extra = {}, noticeSession = null } = {}) {
   const checked = validateEvent(db, board, entry, id, name, { roles, payload, extra });
   if (!checked) return fireRun(db, board, entry, id, name, { roles, payload, extra });
   const { task, from, taken, scope, beforeRun } = checked;
@@ -658,8 +708,10 @@ export function fire(db, board, entry, id, name, { roles = [], payload = {}, ext
   const ended = task.current_run_id && one(db, 'SELECT ended_at FROM task_runs WHERE id = ?', task.current_run_id)?.ended_at != null ? task.current_run_id : null;
   if ((scope.card.dispatch_hold || ended) && roles.some(role => ['manager','creator'].includes(role)) &&
       (['resume','reclaim','replace_session','reopen','reopen_review'].includes(name) || (name === 'set' && ['assignee','machine','model'].includes(payload.field))))
-    record(db,id,'dispatch_released',{reason:`explicit ${name}`,incident:scope.card.last_events.run_incident?.payload?.run ?? null,...(ended ? { ended_run: ended } : {})});
-  queueTransitionNotice(db, board, entry, task, from, name, payload, beforeRun, effects);
+    record(db,id,'dispatch_released',{reason:`explicit ${name}`,incident:scope.card.last_events.run_incident?.payload?.run ?? null,...(ended ? { ended_run: ended } : {}),
+      ...(ended && name === 'set' && payload.field === 'assignee' && (payload.value ?? null) !== (task.assignee ?? null)
+        ? { reassigned_from: task.assignee ?? null, reassigned_to: payload.value ?? null, abandon_waiting_input: true } : {})});
+  queueTransitionNotice(db, board, entry, task, from, name, payload, beforeRun, effects, noticeSession);
   return { from, to: statusOf(db, cardOf(db, id)), moved: to !== from, effects };
 }
 
@@ -690,7 +742,7 @@ function cardOf(db, id) {
   const row = one(db, 'SELECT * FROM tasks WHERE id = ?', id);
   if (!row) throw new Error(`no card ${id}`);
   const ours = one(db, 'SELECT * FROM supercode_cards WHERE task_id = ?', id);
-  return { ...row, blocked_by: json(ours?.blocked_by, []) ?? [], paused: json(ours?.paused, null), archived: Boolean(ours?.archived), skills: json(row.skills, []) ?? [], machine: ours?.machine ?? null, subtask_of: ours?.subtask_of ?? null };
+  return { ...row, blocked_by: json(ours?.blocked_by, []) ?? [], paused: json(ours?.paused, null), detached: json(ours?.detached, null), archived: Boolean(ours?.archived), skills: json(row.skills, []) ?? [], machine: ours?.machine ?? null, subtask_of: ours?.subtask_of ?? null };
 }
 
 // one transition: the old status's exit actions, the move, the transition's actions, the new status's entry actions
@@ -724,6 +776,7 @@ export function setStatus(db, workflow, id, status) {
 /** Take every `always` transition that holds, from wherever the card is, until none does. */
 export function settle(db, board, entry, id, effects = []) {
   const { workflow, params } = entry;
+  if (detachedCard(db, id)) return effects;
   settleRelations(db, board, entry, id, effects);
   for (let hops = 0; hops < 16; hops += 1) {
     const task = cardOf(db, id);
@@ -772,12 +825,14 @@ function dueAfter(db, workflow, task, status, scope) {
 
 /**
  * Where a new card starts: the first `initial` transition that holds (`event` is the create's own words), its status
- * set and its actions run (a goal card by the workflow's default, for one). Answers the status.
+ * set and its actions run (a goal card by the workflow's default, for one). Answers the status. A validator that fails
+ * refuses the create, as it refuses any other event (a home that keeps its root unassigned says so here).
  */
 export function startNew(db, board, entry, task, event) {
   const scope = scopeOf(db, board, task, { params: entry.params, event, extra: { lanes: lanesIn(entry) } });
   const t = entry.workflow.initial.find((x) => holds(x.guard ?? null, scope));
   if (!t?.target) throw new Error('the workflow says nowhere for a new card to start');
+  for (const v of t.validate ?? []) if (!holds(v.expr, scope)) throw new Error(render(v.message, scope));
   const status = String(templateValue(t.target, scope));
   if (!entry.workflow.statuses[status]) throw new Error(`the workflow starts a new card in ${status}, which it does not declare`);
   setStatus(db, entry.workflow, task.id, status);
@@ -813,7 +868,9 @@ const FORMAT = {
   blocked: ({ e, after, source }) => ({ reason: e.reason ?? null, on: e.on ?? null, waiting_on: e.waiting_on ?? null, recurrences: Number(after.block_recurrences || 0), source_status: source }),
   block_loop_detected: ({ e, after, source, params }) => ({ reason: e.reason ?? null, kind: e.kind ?? null, recurrences: Number(after.block_recurrences || 0), limit: params.block_recurrence_limit, source_status: source }),
   dependency_wait: ({ e, source }) => ({ reason: e.reason ?? null, on: e.on ?? null, source_status: source }),
-  review_requested: ({ e, before, after }) => ({ summary: firstLine(e.summary), ci: e.ci ?? null, pr: e.ci?.pr ?? null, commit: e.ci?.commit ?? null, implementer: before.assignee, reviewer: after.assignee !== before.assignee ? after.assignee : (e.reviewer ?? null) }),
+  review_requested: ({ e, before, after }) => ({ summary: firstLine(e.summary), ci: e.ci ?? null, pr: e.ci?.pr ?? null, commit: e.ci?.commit ?? null,
+    implementer: before.assignee, implementer_machine: before.machine ?? null, implementer_model: before.implementer_model ?? null,
+    implementer_model_override: before.model_override ?? null, implementer_provider_override: before.provider_override ?? null, reviewer: after.assignee }),
   // the reviewer is the lane that reviewed (the card's assignee while in review), unless the verdict names one
   changes_requested: ({ e, before, after }) => ({ reason: e.reason ?? null, reviewer: e.reviewer ?? before.assignee ?? null, implementer: after.assignee }),
   review_reopened: ({ after, to }) => ({ status: to, implementer: after.assignee }),
@@ -922,9 +979,15 @@ const ACTIONS = {
     } else record(ctx.db, on ?? ctx.id, kind, payload && Object.keys(payload).length ? payload : null, on ? null : ctx.runId);
   },
   assign(ctx, { field, value }) {
+    if (field === 'reviewer') {
+      if (value != null && (typeof value !== 'string' || !ctx.entry.profiles?.[value]?.worker?.harness)) throw new Error('A card reviewer names a runnable profile in this home.');
+      record(ctx.db, ctx.id, 'reviewer_set', { reviewer: value ?? null }, ctx.runId);
+      return;
+    }
     if (field === 'machine') {
       const task = one(ctx.db, 'SELECT t.current_run_id,t.workspace_kind,c.workspace_anchor,c.machine FROM tasks t JOIN supercode_cards c ON c.task_id=t.id WHERE t.id=?', ctx.id);
       if (task.current_run_id) throw new Error('End the current run before moving its card.');
+      if ((value ?? null) === task.machine) return;
       if (task.workspace_kind !== 'scratch' && (!task.workspace_anchor || isWorkspacePath(task.workspace_anchor))) throw new Error('declare the repository and branch with workflow specify --workspace before moving a legacy path card');
       if ((value ?? null) !== task.machine) run(ctx.db, 'UPDATE tasks SET workspace_path=NULL WHERE id=?', ctx.id);
       cardField(ctx, 'machine', value ?? null);
@@ -984,6 +1047,7 @@ const ACTIONS = {
     run(ctx.db, 'UPDATE tasks SET current_run_id = NULL, claim_lock = NULL, claim_expires = NULL, worker_pid = NULL WHERE id = ?', ctx.id);
   },
   claim(ctx, role, scope) {
+    if (detachedCard(ctx.db, ctx.id)) throw new Error('a detached card must receive a verified adoption before starting another run');
     const task = cardOf(ctx.db, ctx.id);
     const t = now();
     const ttl = Number(ctx.entry.params.claim_ttl_seconds) || 900;
@@ -1124,7 +1188,7 @@ const ACTIONS = {
   send_to_actor(ctx, text) {
     const effect = { kind: 'send_to_actor', id: ctx.id, runId: ctx.runId, text, messageKey: `board-actor-${randomBytes(16).toString('hex')}` };
     const inserted = run(ctx.db, 'INSERT INTO supercode_effects (effect) VALUES (?)', JSON.stringify(effect));
-    effect.text = identifyNotice({ id: `notice-${inserted.lastInsertRowid}`, kind: 'actor_notice', run_id: ctx.runId, created_at: now() }, text);
+    effect.text = identifyNotice({ id: `notice-${inserted.lastInsertRowid}`, kind: 'actor_notice', run_id: ctx.runId, created_at: now() }, numbered(cardNumber(ctx.db, ctx.id), text));
     run(ctx.db, 'UPDATE supercode_effects SET effect=? WHERE id=?', JSON.stringify(effect), Number(inserted.lastInsertRowid));
     ctx.effects.push({ ...effect, durableId: Number(inserted.lastInsertRowid) });
   },
@@ -1139,7 +1203,7 @@ export function retireSupersededRuns(db, id, runId, session) {
       OR (? IS NOT NULL AND json_extract(metadata, '$.supercode.pane') = ?))`,
     runId, session.machine ?? null, session.session_id ?? null, session.session_id ?? null, session.pane ?? null, session.pane ?? null)) {
     const whole = json(old.metadata, {}) ?? {}, s = whole.supercode;
-    if (!s || s.machine !== session.machine || !((session.session_id && s.session_id === session.session_id) || (session.pane && s.pane === session.pane))) continue;
+    if (!s || detachedSession(db, s) || s.machine !== session.machine || !((session.session_id && s.session_id === session.session_id) || (session.pane && s.pane === session.pane))) continue;
     if (old.task_id !== id && one(db, 'SELECT 1 FROM tasks WHERE current_run_id = ?', old.id)) throw new Error(`session is still owned by active run ${old.id} of ${old.task_id}`);
     if (s.pane && s.pane === session.pane) whole.supercode = { ...s, close_transferred_to: runId, close_requested: null };
     run(db, "UPDATE task_runs SET status='superseded', outcome='superseded', ended_at=?, claim_lock=NULL, claim_expires=NULL, worker_pid=NULL, metadata=? WHERE id=?", now(), JSON.stringify(whole), old.id);
@@ -1159,6 +1223,7 @@ export function requestSessionClose(db, id, { runId = null, slot = null, through
     if ((runId != null && row.id !== runId) || (through != null && row.id > through)) continue;
     const whole = json(row.metadata, {}) ?? {};
     const session = whole.supercode;
+    if (detachedSession(db, session)) continue;
     if ((!session?.pane && !session?.launch_key && !(session?.surface === 'native' && session.session_id)) || session.close_transferred_to || session.close_confirmed_at || (slot != null && (session.slot ?? 'worker') !== slot)) continue;
     if (session.close_requested && !session.closed_at) continue;
     whole.supercode = { ...session, close_requested: session.close_requested ?? now() };