@volter/supercode-orchestrator 0.4.152 → 0.4.154

package/board/ci.mjs

@@ -24,15 +24,19 @@ for (let page = 0; url && page < 10; page += 1) {
   url = /<([^>]+)>;\\s*rel="next"/.exec(r.headers.get('link') ?? '')?.[1] ?? null;
 }
 process.stdout.write(JSON.stringify(out));`;
-let githubToken;
-/** One GitHub REST read (`all`: every page of a list). The token is the environment's, else gh's stored login. */
+let loginToken = null;
+/** One GitHub REST read (`all`: every page of a list). The token is the environment's, else gh's stored login: a failed
+ *  read of the login is not kept, and a login token GitHub refuses (401, rotated or revoked) is read again once. */
 function github(path, all = false) {
-  if (githubToken === undefined) {
-    githubToken = process.env.GH_TOKEN || process.env.GITHUB_TOKEN || null;
-    if (!githubToken) try { githubToken = run('gh', ['auth', 'token']) || null; } catch { githubToken = null; }
-  }
-  const env = githubToken ? { ...process.env, GH_TOKEN: githubToken } : process.env;
-  const result = spawnSync(process.execPath, ['--input-type=module', '-e', GITHUB_READ, path, all ? '1' : '0'], { env, encoding: 'utf8', timeout: 30_000, maxBuffer: 16 * 1024 * 1024 });
+  const fixed = process.env.GH_TOKEN || process.env.GITHUB_TOKEN || null;
+  const read = () => {
+    if (!fixed && !loginToken) try { loginToken = run('gh', ['auth', 'token']) || null; } catch { loginToken = null; }
+    const token = fixed ?? loginToken;
+    const env = token ? { ...process.env, GH_TOKEN: token } : process.env;
+    return spawnSync(process.execPath, ['--input-type=module', '-e', GITHUB_READ, path, all ? '1' : '0'], { env, encoding: 'utf8', timeout: 30_000, maxBuffer: 16 * 1024 * 1024 });
+  };
+  let result = read();
+  if (result.status !== 0 && !fixed && loginToken && /^GitHub 401 /.test(result.stderr ?? '')) { loginToken = null; result = read(); }
   if (result.status !== 0) throw new Error(`GitHub: ${(result.stderr || result.error?.message || 'read failed').trim().slice(-500)}`);
   return JSON.parse(result.stdout);
 }
@@ -122,6 +126,20 @@ function registeredBranches(board, id) {
   return out;
 }
 
+/** Whether `head` is a branch named for card `id`: `wt/<id>` (or `wt/t-…`), alone or with a `-…`/`/…` suffix. */
+export const namedWorkBranch = (id, head) => [`wt/${id}`, `wt/${id.replace(/^t_/, 't-')}`].some((prefix) => head === prefix || head.startsWith(`${prefix}-`) || head.startsWith(`${prefix}/`));
+
+/** The branch names an arc declares as its work: its own and its subtasks' `--branch`, and each branch its latest
+ *  review request covered. With `namedWorkBranch`, these are the branches its PRs are opened from. */
+export function declaredWorkBranches(db, id) {
+  const declared = db.prepare(`SELECT t.branch_name FROM tasks t LEFT JOIN supercode_cards c ON c.task_id=t.id
+    WHERE (t.id=? OR c.subtask_of=?) AND t.status != 'cancelled' AND t.branch_name IS NOT NULL`).all(id, id).map((r) => r.branch_name);
+  const row = db.prepare("SELECT payload FROM task_events WHERE task_id=? AND kind='review_requested' ORDER BY id DESC LIMIT 1").get(id);
+  let reviewed = [];
+  try { reviewed = candidatePullRequests(row && JSON.parse(row.payload)?.ci).map((p) => p.branch); } catch { /* an unreadable payload names none */ }
+  return [...new Set([...declared, ...reviewed].filter(Boolean))];
+}
+
 /** Every opened PR of the arc, each proposed to its repository's default branch: an open PR whose head is the card's
  *  work branch in the card's own repository, a `wt/<card id>` branch in any repository this machine keeps a checkout
  *  of, or a sibling checkout the arc registered (`registeredBranches`). The repository's default branch, declared or
@@ -136,8 +154,7 @@ export function openReviewPullRequests(board, id) {
   const current = task?.branch_name ? null : run('git', ['branch', '--show-current'], own);
   let branch = task?.branch_name ?? (current || null);
   const registered = registeredBranches(board, id);
-  const named = (head) => [`wt/${id}`, `wt/${id.replace(/^t_/, 't-')}`].some((prefix) => head === prefix || head.startsWith(`${prefix}-`) || head.startsWith(`${prefix}/`));
-  const mine = (repository, head) => (repository === ownRepository && head === branch) || named(head)
+  const mine = (repository, head) => (repository === ownRepository && head === branch) || namedWorkBranch(id, head)
     || registered.some((r) => r.repository === repository && r.branch === head);
   const prs = [];
   for (const repository of new Set([ownRepository, ...registered.map((r) => r.repository), ...knownRepositories()])) {

package/board/cli.mjs

@@ -1254,7 +1254,7 @@ async function serve(root, args = {}) {
           for (const [t, why] of r.failed) log(`  ${t} did not start: ${why}`);
           for (const [t, why] of r.unsettled ?? []) log(`  ${t} could not be read: ${why}`);
           for (const [t, s, m] of r.started) log(`  ${t} started ${s} (${m})`);
-          for (const [t, to, why] of r.undelivered) log(`  notice for ${t} to ${to} not delivered: ${why}`);
+          for (const [t, to, why, what] of r.undelivered) log(what === 'close' ? `  close of ${to} for ${t} waits: ${why}` : `  notice for ${t} to ${to} not delivered: ${why}`);
         }
       } catch (error) {
         log(`tick failed: ${error.message}`);

package/board/dispatch.mjs

@@ -428,7 +428,7 @@ function limitsOf(db, board, entry, task, session) {
 
 function stopSession(board, session) {
   if (!session) return;
-  if (boardCopyOf()) throw copyRefusal('closes no session');
+  if (boardCopyOf(board)) throw copyRefusal(board, 'closes no session');
   if (session.surface === 'headless' && pidAlive(session.pid)) {
     // SIGTERM to the worker's process group, then SIGKILL if it is still there after a grace, as Hermes stops its own
     const signal = (sig) => { try { process.kill(-session.pid, sig); } catch { try { process.kill(session.pid, sig); } catch { /* gone */ } } };
@@ -698,7 +698,7 @@ export function closeRequested(board, report, { taskId = null, caller = null } =
           setRunSession(db, row.id, { close_error: error, close_requested: session.close_requested ?? now() });
           if (session.close_error !== error) event(db, row.task_id, 'session_close_failed', { error, retry: true }, row.id);
         });
-        report.undelivered.push([row.task_id, addressOf(session), error]);
+        report.undelivered.push([row.task_id, addressOf(session), error, 'close']);
         continue;
       }
     }
@@ -751,7 +751,7 @@ export function closeRequested(board, report, { taskId = null, caller = null } =
         event(db, row.task_id, 'session_closed', { session_id: session.session_id, pane: session.pane, machine: session.machine }, row.id);
       }
     });
-    if (error) report.undelivered.push([row.task_id, addressOf(session), error]);
+    if (error) report.undelivered.push([row.task_id, addressOf(session), error, 'close']);
     else (report.closed ??= []).push({ task_id: row.task_id, ...session });
   }
 }
@@ -836,7 +836,7 @@ export async function sessionNotice(board, e) {
   let error = null, receipt = null;
   try {
     if (!e.address) throw new Error('lifecycle notice awaits the owned launch session identity');
-    receipt = await send(boardAddress(board.label), board.label, e.address, e.text, effectMessageKey(e));
+    receipt = await send(board, boardAddress(board.label), board.label, e.address, e.text, effectMessageKey(e));
     // A notice filed in the session's mailbox is done: the session reads its mail at its next
     // turn, and a resumed session first. Only a notice no mailbox took is retried.
     if (!receipt.delivered && !receipt.queued) error = receipt.reason ?? 'notice was not filed'; }
@@ -860,7 +860,7 @@ export async function sessionEffect(board, e) {
     let receipt;
     try {
       if (!address) throw new Error('actor session identity unavailable');
-      receipt = await send(boardAddress(board.label), board.label, address, e.text, effectMessageKey(e));
+      receipt = await send(board, boardAddress(board.label), board.label, address, e.text, effectMessageKey(e));
     } catch (error) { receipt = { delivered: false, reason: error.message }; }
     const kind = receipt.delivered ? 'actor_notice_delivered' : receipt.queued ? 'actor_notice_queued' : 'actor_notice_failed';
     tx(board, db => {
@@ -1355,7 +1355,7 @@ function resolveLocalWorkspace(board, task) {
  */
 export function requestAdoption(board, id, who, { workspace = null, assignee = null, role = null } = {}) {
   if (!who) throw new Error('name the session to adopt');
-  if (boardCopyOf()) throw copyRefusal('adopts no session');
+  if (boardCopyOf(board)) throw copyRefusal(board, 'adopts no session');
   tx(board, db => {
     if (!getTask(db, id)) throw new Error(`no card ${id}`);
     event(db, id, 'dispatch_held', { session: who, reason: 'adoption requested', workspace, assignee, role });
@@ -1444,7 +1444,7 @@ function adoptSession(board, id, who, { workspace = null, ttl, assignee = null,
 
 // a notice sent within a transaction's caller that cannot await (the launcher): the same door, synchronously
 function deliverNow(board, to, body, key) {
-  if (boardCopyOf()) throw copyRefusal('sends no notice to sessions');
+  if (boardCopyOf(board)) throw copyRefusal(board, 'sends no notice to sessions');
   const request = { op: 'send', from: boardAddress(board.label), from_name: `${board.label} board`, to, queue: false, id: key, subject: String(body).split('\n')[0].slice(0, 160),
     body: `[Board notice from the ${board.label} board] ${body}\n\n(An automated notice from the board's dispatcher; replies to this address go nowhere.)` };
   const r = sc(['message', 'remote-deliver'], { input: JSON.stringify(request), timeout: 120_000 });
@@ -1453,8 +1453,8 @@ function deliverNow(board, to, body, key) {
   if (!answer.receipt?.delivered) throw new Error(answer.receipt?.reason ?? 'native delivery confirmation pending');
 }
 
-async function send(from, label, to, body, key, { queue = false, ask = false, subject } = {}) {
-  if (boardCopyOf()) throw copyRefusal('sends no mail to sessions or managers');
+async function send(board, from, label, to, body, key, { queue = false, ask = false, subject } = {}) {
+  if (boardCopyOf(board)) throw copyRefusal(board, 'sends no mail to sessions or managers');
   const request = {
     op: 'send', from, from_name: `${label} board`, to, queue, id: key, subject: String(subject ?? String(body).split('\n')[0]).slice(0, 160),
     // a question the board waits on is answered by a reply; a notice is not
@@ -1485,7 +1485,7 @@ export async function sendBoardMessages(board, report, taskId = null) {
     try {
       const task = view(board, db => getTask(db, first.task_id));
       const subject = mail.requester ? `State requests · ${mail.members.length} request(s) · ${task?.title || first.task_id}` : `${task?.title || first.task_id} · ${mail.message_id ? 'Question' : 'Update'}`;
-      const receipt = await send(boardAddress(board.label), board.label, mail.to, mail.text, mail.message_id ?? `board-message-${first.id}`, { ask: Boolean(mail.message_id), subject });
+      const receipt = await send(board, boardAddress(board.label), board.label, mail.to, mail.text, mail.message_id ?? `board-message-${first.id}`, { ask: Boolean(mail.message_id), subject });
       if (!receipt.delivered && !receipt.queued) throw new Error(receipt.reason ?? 'message was not filed');
       tx(board, db => {
         for (const member of mail.members) event(db, member.task_id, 'board_message_sent', { event: member.id, to: mail.to, receipt, ...(mail.message_id ? { message_id: mail.message_id, request_id: member.message_id ?? mail.message_id } : {}) });
@@ -1591,7 +1591,7 @@ async function notify(board, fleet, report, entry) {
         } else text = noticeOf(entry, role, ev.kind, task, p);
         if (text) {
           const body = ['worker', 'dependency'].includes(role) ? identifyNotice(ev, text) : text;
-          const receipt = await send(from, board.label, sub.chat_id, body, `board-${sub.task_id}-${ev.id}-${sub.chat_id.slice(-12)}`, { queue: !working || (!entry.workflow.run && sub.delivery_mode === 'notify'), subject: `${ev.kind.replaceAll('_', ' ')} · run ${ev.run_id ?? 'none'} · event ${ev.id} · ${task?.title || sub.task_id}` });
+          const receipt = await send(board, from, board.label, sub.chat_id, body, `board-${sub.task_id}-${ev.id}-${sub.chat_id.slice(-12)}`, { queue: !working || (!entry.workflow.run && sub.delivery_mode === 'notify'), subject: `${ev.kind.replaceAll('_', ' ')} · run ${ev.run_id ?? 'none'} · event ${ev.id} · ${task?.title || sub.task_id}` });
           // A notice the recipient's mailbox took is filed: the machine delivers it at the session's next turn, so the
           // board does not send it again.
           if (!receipt.delivered && !receipt.queued) throw new Error(receipt.reason ?? 'notice was not filed');
@@ -1793,7 +1793,7 @@ function readMailbox(board, address, report) {
       answer = `${clean.slice(0, 2).join(' ')}: ${(r.status === 0 ? r.stdout : r.stderr || r.stdout).trim().slice(-600) || `exit ${r.status}`}`;
     }
     report.mailed.push([envelope.from, argv?.[0] ?? '?']);
-    report.answers.push(send(address, board.label, envelope.from, answer, `board-answer-${envelope.id}`).catch((error) => { report.undelivered.push(['mail', envelope.from, String(error.message).slice(-200)]); }));
+    report.answers.push(send(board, address, board.label, envelope.from, answer, `board-answer-${envelope.id}`).catch((error) => { report.undelivered.push(['mail', envelope.from, String(error.message).slice(-200)]); }));
   }
 }
 
@@ -1932,7 +1932,7 @@ export async function tick({ root, lanes, settings, only = null, slugs = null, d
     const marker = `${path}.corrupt-seen`;
     if (existsSync(marker) && readFileSync(marker, 'utf8').trim() === fingerprint(path)) { report.error = 'skipped: the board file was corrupt and has not changed since (`supercode workflow repair`)'; out.push(report); continue; }
     // a copy of a home dispatches nothing: its runs, sessions and managers are the original's
-    if (boardCopyOf()) { report.error = `skipped: ${copyRefusal('starts, supervises, adopts and mails nothing').message}`; out.push(report); continue; }
+    if (boardCopyOf({ root })) { report.error = `skipped: ${copyRefusal({ root }, 'starts, supervises, adopts and mails nothing').message}`; out.push(report); continue; }
     let board;
     try {
       board = openBoard(root, slug);

package/board/store.mjs

@@ -144,17 +144,18 @@ export function layOut(db, { fresh }) {
  */
 // A home records where it was made (`.board-origin` at its root). A copy of the home carries that record elsewhere and
 // is a copy: it may be read and written, but it addresses no session and no manager, which are the original's.
-let copyOfHome = null;
-/** The original home's path when the board opened last is a copy of it; null for a home of its own. */
-export const boardCopyOf = () => copyOfHome;
-export const copyRefusal = (what) => new Error(`this board is a copy of the home at ${copyOfHome}; it ${what}, which belong to the original`);
+// Kept per home (the path it was opened by), so a process that opens several homes judges each by its own record.
+const copies = new Map();
+/** The original home's path when the board's home (`board.root`) is a copy of it; null for a home of its own. */
+export const boardCopyOf = (board) => { if (!copies.has(board.root)) noteOrigin(board.root); return copies.get(board.root) ?? null; };
+export const copyRefusal = (board, what) => new Error(`this board is a copy of the home at ${boardCopyOf(board)}; it ${what}, which belong to the original. A home moved here becomes the original once its .board-origin is removed (rm ${join(board.root, '.board-origin')}).`);
 function noteOrigin(root) {
   if (!existsSync(root)) return;
   const here = realpathSync(root), file = join(root, '.board-origin');
   let origin = null;
   try { origin = JSON.parse(readFileSync(file, 'utf8')).root ?? null; } catch { /* none yet */ }
   if (!origin) { writeFileSync(file, `${JSON.stringify({ root: here })}\n`); origin = here; }
-  copyOfHome = origin === here ? null : origin;
+  copies.set(root, origin === here ? null : origin);
 }
 
 export function openBoard(root, slug = DEFAULT_BOARD, { create = false, backing = null, document = null } = {}) {

package/board/workflow.mjs

@@ -11,7 +11,7 @@ import { resolve, relative, isAbsolute } from 'node:path';
 import { randomBytes } from 'node:crypto';
 import { actorOf, appendRunObservation, event as record, json, now } from './store.mjs';
 import { evaluate, holds, render } from './expr.mjs';
-import { completionEvidence, reviewCandidate } from './ci.mjs';
+import { completionEvidence, declaredWorkBranches, namedWorkBranch, reviewCandidate } from './ci.mjs';
 import { isWorkspacePath } from './workspace.mjs';
 import { identifyNotice } from './notices.mjs';
 
@@ -103,17 +103,29 @@ function pattern(p) {
   return text.startsWith('(?i)') ? new RegExp(text.slice(4), 'i') : new RegExp(text);
 }
 
-// the time of the latest commit that names `id` in its message, on any ref of the repository at `path` (a worktree's
-// pushes land on the shared remote-tracking refs), or null (asked only when an expression does). Merge commits are
-// not the card's work: merging its reviewed PR, or main into its branch, is not a newer change to review.
+// the time of the latest commit that names `id` in its message on the card's work in the repository at `path`, or null
+// (asked only when an expression does). Its work is the branches its PRs are opened from (the checkout's own branch,
+// a declared or reviewed one, `wt/<id>…`), local or remote-tracking (a worktree's pushes land on the shared refs),
+// and the default branch they merge into. Another ref naming the card (an evidence branch, a later card's work) is not
+// a change to its reviewed work. Merge commits are not the card's work: merging its reviewed PR, or main into its
+// branch, is not a newer change to review.
 const commitTimes = new Map();
-function observeLastCommit(path, id) {
+function observeLastCommit(path, id, branches = []) {
   if (!path) return null;
   const key = `${path}:${id}`;
   const cached = commitTimes.get(key);
   if (cached && now() - cached.at < 15) return cached.value;
+  const git = (repo, args) => spawnSync('git', ['-C', repo, ...args], { encoding: 'utf8', timeout: 10_000 });
   const readCommit = (repo) => {
-    const r = spawnSync('git', ['-C', repo, 'log', '--all', '--no-merges', '-1', '--format=%ct', '--fixed-strings', `--grep=${id}`], { encoding: 'utf8', timeout: 10_000 });
+    const listed = git(repo, ['for-each-ref', '--format=%(refname)', 'refs/heads', 'refs/remotes']);
+    if (listed.status !== 0) return { repo: false, value: null };
+    const current = git(repo, ['branch', '--show-current']).stdout?.trim();
+    const fallback = git(repo, ['symbolic-ref', '--quiet', 'refs/remotes/origin/HEAD']).stdout?.trim().replace(/^refs\/remotes\/origin\//, '');
+    const names = new Set([...branches, current, fallback].filter(Boolean));
+    const short = (ref) => ref.startsWith('refs/heads/') ? ref.slice(11) : ref.split('/').slice(3).join('/');
+    const refs = listed.stdout.split('\n').filter((ref) => ref && !ref.endsWith('/HEAD') && (names.has(short(ref)) || namedWorkBranch(id, short(ref))));
+    if (!refs.length) return { repo: true, value: null };
+    const r = git(repo, ['log', ...refs, '--no-merges', '-1', '--format=%ct', '--fixed-strings', `--grep=${id}`, '--']);
     const value = Number(r.stdout?.trim());
     return { repo: r.status === 0, value: Number.isFinite(value) && value > 0 ? value : null };
   };
@@ -145,7 +157,7 @@ export function refreshCardInputs(board, id, { commits = false } = {}) {
     const parent=!own && task.subtask_of?board.db.prepare('SELECT workspace_path FROM tasks WHERE id=?').get(task.subtask_of)?.workspace_path:null;
     const path=own??parent??null;
     if(path)commitTimes.delete(`${path}:${id}`);
-    observeLastCommit(path,id);
+    observeLastCommit(path,id,declaredWorkBranches(board.db,id));
   }
 }
 
@@ -179,8 +191,11 @@ function answerTo(id) {
 }
 
 const OPEN_OUTCOME = /^(\s*[-*] )\[ \] (.+)$/;
+const TICKED_OUTCOME = /^\s*[-*] \[[xX]\] .+$/;
+const POINTED_OUTCOME = /^\s*[-*] \[[xX]\] .+: \S.+$/;
 /** Whether `body` is `was` with only outcomes ticked: each changed line is under the Acceptance heading, was `- [ ] X`
- *  and is now `- [x] X` or `- [x] X: <pointer>`; no other line added, removed or changed. */
+ *  and is now `- [x] X` or `- [x] X: <pointer>`, or was `- [x] X` and is now `- [x] X: <pointer>` (the pointer a tick
+ *  needs, added after it); no other line added, removed or changed. */
 function onlyTicks(was, body) {
   if (typeof body !== 'string') return false;
   const before = String(was ?? '').split('\n');
@@ -193,10 +208,13 @@ function onlyTicks(was, body) {
     if (heading) section = heading[1].toLowerCase();
     if (line === after[i]) return true;
     if (section !== 'acceptance') return false;
+    const pointed = (ticked) => after[i].startsWith(`${ticked}: `) && after[i].trim().length > ticked.trim().length + 1;
+    // a ticked outcome that already carries a pointer (as acceptance_complete reads one) is not given another
+    if (TICKED_OUTCOME.test(line)) return !POINTED_OUTCOME.test(line) && pointed(line);
     const open = OPEN_OUTCOME.exec(line);
     if (!open) return false;
     const ticked = `${open[1]}[x] ${open[2]}`;
-    return after[i] === ticked || (after[i].startsWith(`${ticked}: `) && after[i].length > ticked.length + 2);
+    return after[i] === ticked || pointed(ticked);
   });
 }
 
@@ -301,7 +319,8 @@ export function scopeOf(db, board, task, { params, event = {}, extra = {} } = {}
     last_events: Object.fromEntries(all(db, 'SELECT e.kind, e.created_at, e.payload FROM task_events e JOIN (SELECT kind, MAX(id) AS id FROM task_events WHERE task_id = ? GROUP BY kind) l ON l.id = e.id', task.id)
       .map((r) => [r.kind, { created_at: r.created_at, payload: json(r.payload, {}) ?? {} }])),
     comments_since: (t) => all(db, 'SELECT author, body, created_at FROM task_comments WHERE task_id = ? AND created_at >= ?', task.id, t),
-    // the latest commit naming this card, in its workspace's repository (a subtask's: its arc's), as epoch seconds
+    // the latest commit naming this card on its work branches and default branch, in its workspace's repository (a
+    // subtask's: its arc's), as epoch seconds
     last_commit_at: () => {
       const own = task.workspace_kind !== 'scratch' ? task.workspace_path : null;
       const arcWs = !own && task.subtask_of ? one(db, "SELECT workspace_path FROM tasks WHERE id = ? AND workspace_kind != 'scratch'", task.subtask_of)?.workspace_path : null;

package/board/ztrack.mjs

@@ -601,7 +601,10 @@ class ZtrackBoard {
       workspace_kind: workspace?.[1] ?? 'scratch', workspace_path: runtime.workspace_path ?? (/^(\/|~|[A-Za-z]:[\\/])/.test(workspace?.[2] ?? '') ? workspace[2] : null), branch_name: card.branch ?? null };
     const state = { task_id: id, workspace_anchor: workspace?.[2] ?? null, stage: card.status, machine: card.machine ?? null, subtask_of: parent,
       blocked_by: JSON.stringify((card.relations ?? []).map((r) => ({ ...(meta.blocked_by ?? []).find((b) => b.id === nativeId(r.issueId)), id: nativeId(r.issueId), kind: /^[ma]-/.test(r.issueId) ? 'message' : 'card' }))),
-      paused: card.paused ? JSON.stringify(card.paused) : null, archived: meta.archived ? 1 : 0, every: card.every ?? null };
+      // A card whose text says nothing of archiving keeps the store's flag: an entry rendered before subtask lines
+      // carried it (or edited without it) is not an unarchive. Saying `archived: false` of an archived card is.
+      paused: card.paused ? JSON.stringify(card.paused) : null, every: card.every ?? null,
+      archived: (meta.archived ?? card.archived) === undefined ? Number(this.one('SELECT archived FROM main.supercode_cards WHERE task_id = ?', id)?.archived ?? 0) : ((meta.archived ?? card.archived) ? 1 : 0) };
     return { task, state };
   }
 
@@ -737,7 +740,7 @@ class ZtrackBoard {
       card.acceptanceCriteria.push({ sources: json(stored?.sources, undefined) ?? undefined, id: key, status: ['done', 'cancelled'].includes(status) ? 'passed' : 'pending', evidence: [], text: match?.[2] ?? r.title,
         metadata: { id: r.id, status, body: task.body, assignee: r.assignee, machine: s.machine,
           properties: Object.fromEntries(Object.entries(r).filter(([k, v]) => !RUNTIME.has(k) && !CARD_MAIN.has(k) && v != null)),
-          card: { paused: json(s.paused, null) ?? undefined, every: s.every || undefined } }, lines: task.acceptance,
+          card: { paused: json(s.paused, null) ?? undefined, every: s.every || undefined, archived: s.archived ? true : undefined } }, lines: task.acceptance,
         waitingOn: messages[0]?.id,
         blockedBy: blocks.filter((block) => block !== messages[0]).map((block) => {
           const target = keyOf(block.id);

package/board.mjs

@@ -59,7 +59,7 @@ export async function startBoard({ root, orchestration = null, log = () => {}, a
         if (!r.paused) said.delete(`paused:${r.board}`);
         if (!line.endsWith('nothing to do')) log(r.error ? 'warn' : 'info', line);
         for (const [task, why] of r.failed ?? []) log('warn', `board ${r.board}: ${task} did not start: ${why}`);
-        for (const [task, to, why] of r.undelivered ?? []) log('warn', `board ${r.board}: a notice for ${task} to ${to} was not delivered: ${why}`);
+        for (const [task, to, why, what] of r.undelivered ?? []) log('warn', what === 'close' ? `board ${r.board}: the close of ${to} for ${task} waits: ${why}` : `board ${r.board}: a notice for ${task} to ${to} was not delivered: ${why}`);
         const unserved = r.chat_subscriptions && !Object.keys(adapters).length;
         if (unserved && !said.has(`subs:${r.board}`)) { said.add(`subs:${r.board}`); log('warn', `board ${r.board}: ${r.chat_subscriptions} subscription(s) name a chat platform and this daemon hosts no channel adapter to tell them`); }
         if (r.nonspawnable?.length && !said.has(`lane:${r.board}`)) { said.add(`lane:${r.board}`); log('warn', `board ${r.board}: ${r.nonspawnable.length} card(s) name an assignee that is no profile of this home, and wait`); }

package/loop.mjs

@@ -8,7 +8,7 @@ import { mkdirSync, writeFileSync, existsSync, readdirSync, readFileSync, rename
 import { basename, join, dirname } from 'node:path';
 import { step, leaseId } from './reducer.mjs';
 import * as events from './events.mjs';
-import { save, retainWorld, releaseWorld } from './orchestration.mjs';
+import { read, save, retainWorld, releaseWorld } from './orchestration.mjs';
 import { INSTRUCTION_ARGUMENTS, NAME_ARGUMENTS, activationEnv, activationCwd, approvalPolicy, sandboxArguments, limitArguments, materializePersona, materializeSkills, modelArguments, turnCounter, userHomeArguments, userHomePersona } from './activation.mjs';
 import { workerRoute } from './worker-route.mjs';
 import { hermesAccess, hermesApproval, untrustedServerVerdict, hermesToolEnv, memorySnapshot, mirrorSession, mirrorState, recordIncident, sealMirror } from './hermes-cli.mjs';
@@ -60,6 +60,8 @@ export class Orchestrator {
     state.runtime.machine = localMachine(); // a job naming another machine fires there (cron.mjs startFire)
     state.runtime.hostedFires = {};
     this.vault = vault;
+    // each profile's cron/jobs.json as the state was loaded from it: what changes there later was written by another hand
+    this.jobsWritten = this.jobsFiles();
     this.client = client;
     this.adapters = adapters;
     this.clock = clock ?? (() => new Date().toISOString());
@@ -133,8 +135,53 @@ export class Orchestrator {
     return this.webhooks?.port ?? null;
   }
 
+  /** The folder written from state, and each profile's `cron/jobs.json` as that write left it. */
+  async save() {
+    await save(this.state, this.state.root);
+    this.jobsWritten = this.jobsFiles();
+  }
+
+  jobsFiles() {
+    const files = new Map();
+    for (const profile of Object.values(this.state.profiles ?? {})) {
+      if (!profile?.dir) continue;
+      const path = join(profile.dir, 'cron', 'jobs.json');
+      files.set(path, existsSync(path) ? readFileSync(path, 'utf8') : null);
+    }
+    return files;
+  }
+
+  /**
+   * Jobs another writer put in `cron/jobs.json` (Hermes's own `hermes cron create|edit|remove`, which write the file
+   * while this daemon serves the home). Hermes's scheduler reads the file on every tick, so its jobs run whoever wrote
+   * them; here, a file that is no longer what the last save left is read back before the tick, job by job against
+   * that last save: a job the other writer added or changed is taken from the file, one it removed is dropped, and
+   * every other job keeps this daemon's own state, so a change not yet saved here survives the read.
+   */
+  async adoptOutsideJobs() {
+    const now = this.jobsFiles();
+    const changed = [...now].filter(([path, text]) => this.jobsWritten.has(path) && this.jobsWritten.get(path) !== text).map(([path]) => path);
+    if (!changed.length) { this.jobsWritten = now; return; }
+    const fresh = await read(this.state.root);
+    for (const [name, profile] of Object.entries(this.state.profiles ?? {})) {
+      const theirs = fresh.profiles?.[name];
+      if (!theirs || !changed.includes(join(profile.dir, 'cron', 'jobs.json'))) continue;
+      const path = join(profile.dir, 'cron', 'jobs.json');
+      const byId = (text) => { try { return new Map((JSON.parse(text ?? '{}').jobs ?? []).map((job) => [job.id, JSON.stringify(job)])); } catch { return null; } };
+      const before = byId(this.jobsWritten.get(path)), after = byId(now.get(path));
+      if (!before || !after) { profile.jobs = theirs.jobs ?? {}; this.log('info', `profile ${name}: cron/jobs.json changed outside the daemon; its jobs read back whole`); continue; }
+      const touched = [];
+      profile.jobs ??= {};
+      for (const [id, text] of after) if (before.get(id) !== text && theirs.jobs?.[id]) { profile.jobs[id] = theirs.jobs[id]; touched.push(id); }
+      for (const id of before.keys()) if (!after.has(id) && profile.jobs[id]) { delete profile.jobs[id]; touched.push(id); }
+      this.log('info', `profile ${name}: cron/jobs.json changed outside the daemon; jobs read back: ${touched.join(', ') || 'none'}`);
+    }
+    this.jobsWritten = now;
+  }
+
   /** One clock tick: expiry, due cron jobs, obligation retry, breaker windows (§4.3). */
   tick(at = this.clock()) {
+    this.queue = this.queue.then(() => this.adoptOutsideJobs()).catch((error) => this.log('warn', `cron/jobs.json not read back: ${error.message}`));
     return this.dispatch(events.tick(at, cronInactivitySeconds(), cronMaxParallel())).then(
       (result) => { this.tickerHeartbeat(true); return result; },
       (error) => { this.tickerHeartbeat(false); throw error; },
@@ -261,7 +308,7 @@ export class Orchestrator {
         }
         return;
       }
-      case 'save': await save(this.state, this.state.root); return;
+      case 'save': await this.save(); return;
       case 'log': this.log(effect.level, effect.message); return;
       default: this.log('warn', `unknown effect ${effect.type}`);
     }
@@ -703,7 +750,7 @@ export class Orchestrator {
       o.state = 'failed';
       o.last_error = `no adapter for ${o.target.platform}`;
       this.recordDelivery(profile, o, o.last_error);
-      await save(this.state, this.state.root);
+      await this.save();
       return;
     }
     const entry = (rt.adapters[o.target.platform] ??= { state: 'up', breaker: { failures: 0 } });
@@ -732,7 +779,7 @@ export class Orchestrator {
       }
       if (o.attempts >= MAX_ATTEMPTS) { o.state = 'failed'; this.recordDelivery(profile, o, error.message); }
     }
-    await save(this.state, this.state.root);
+    await this.save();
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.4.152",
+  "version": "0.4.154",
   "type": "module",
   "description": "The orchestrator runtime over the Volter Harness ontology: one typed operational model whose folder is its serialization, read and written through the harness orchestration doors (docs/ORCHESTRATOR-IR.md)",
   "exports": {