@volter/supercode-orchestrator 0.4.151 → 0.4.153

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);
 }
@@ -40,7 +44,7 @@ const repositoryOf = (url) => new URL(url).pathname.split('/').slice(1, 3).join(
 const numberOf = (url) => Number(new URL(url).pathname.split('/')[4]);
 /** A PR as the board reads it (gh's field names). */
 const pullRequest = (repository, p) => ({ url: p.html_url, number: p.number, state: p.merged_at ? 'MERGED' : String(p.state).toUpperCase(), headRefOid: p.head.sha,
-  headRefName: p.head.ref, baseRefName: p.base.ref, isCrossRepository: p.head.repo?.full_name?.toLowerCase() !== repository.toLowerCase(), isDraft: Boolean(p.draft) });
+  headRefName: p.head.ref, baseRefName: p.base.ref, defaultBranch: p.base.repo?.default_branch ?? null, isCrossRepository: p.head.repo?.full_name?.toLowerCase() !== repository.toLowerCase(), isDraft: Boolean(p.draft) });
 const readPullRequest = (url) => pullRequest(repositoryOf(url), github(`/repos/${repositoryOf(url)}/pulls/${numberOf(url)}`));
 
 const observations = new Map();
@@ -122,18 +126,22 @@ function registeredBranches(board, id) {
   return out;
 }
 
-/** Every opened PR of the arc: each open PR whose head is the card's branch or a `wt/<card id>` branch, in the
- *  card's own repository and in every repository this machine keeps a checkout of, and each open PR on a sibling
- *  checkout the arc registered (`registeredBranches`). One review covers them all; the caller decides the transition. */
+/** 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
+ *  checked out (or no branch), is not a work branch: such a card's PRs are only its `wt/<card>` and registered ones, and with none it
+ *  answers `{ waits }` saying so. One review covers them all; the caller decides the transition. */
 export function openReviewPullRequests(board, id) {
   const own = repositoryWorkspace(board, id);
   if (!own) return null;
   const task = board.db.prepare('SELECT branch_name FROM tasks WHERE id=?').get(id);
-  const branch = task?.branch_name ?? run('git', ['branch', '--show-current'], own);
   const ownRepository = originOf(own);
   if (!ownRepository) return null;
+  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 mine = (repository, head) => head === branch || [`wt/${id}`, `wt/${id.replace(/^t_/, 't-')}`].some((prefix) => head === prefix || head.startsWith(`${prefix}-`) || head.startsWith(`${prefix}/`))
+  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)
     || registered.some((r) => r.repository === repository && r.branch === head);
   const prs = [];
   for (const repository of new Set([ownRepository, ...registered.map((r) => r.repository), ...knownRepositories()])) {
@@ -147,10 +155,15 @@ export function openReviewPullRequests(board, id) {
       if (pullRequestLists.size >= 64) pullRequestLists.delete(pullRequestLists.keys().next().value);
       pullRequestLists.set(repository, list);
     }
-    // a draft is not handed over yet: its review starts when it is marked ready
-    for (const pr of list.items) if (!pr.isCrossRepository && !pr.isDraft && mine(repository, pr.headRefName)) prs.push({ url: pr.url, head: pr.headRefOid });
+    // The repository's default branch is not a work branch, declared or checked out (a card working in a `dir` on main).
+    if (repository === ownRepository && branch) {
+      const defaultBranch = list.items.find((pr) => pr.defaultBranch)?.defaultBranch ?? (() => { try { return run('git', ['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'], own).replace(/^origin\//, ''); } catch { return null; } })();
+      if (branch === defaultBranch) branch = null;
+    }
+    // a draft is not handed over yet: its review starts when it is marked ready; a PR to another base (main→prod) is a release, not the arc's work
+    for (const pr of list.items) if (!pr.isCrossRepository && !pr.isDraft && pr.baseRefName === pr.defaultBranch && mine(repository, pr.headRefName)) prs.push({ url: pr.url, head: pr.headRefOid });
   }
-  if (!prs.length) return null;
+  if (!prs.length) return branch ? null : { waits: `the card has no work branch (${task?.branch_name ? `it declares ${task.branch_name}, its repository's default` : current ? `its checkout ${own} is on ${current}, its repository's default` : `its checkout ${own} is on no branch`}): give it one with --branch, or open its PR from a wt/${id} branch` };
   return { pr: prs.map((p) => p.url), pr_head: prs.map((p) => p.head), branch };
 }
 

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)]); }));
   }
 }
 
@@ -1880,6 +1880,7 @@ async function activatePullRequestReviews(board, entry, report, effects, { only
       // The arc's open PRs ask for one review only while some head has no verdict: after changes are
       // requested the next run is the implementer's, until a new head is pushed.
       if (!payload) { report.queued.push([id, 'review waits: no open PR on its branch, a wt/<card> branch or a registered checkout']); continue; }
+      if (payload.waits) { report.queued.push([id, `review waits: ${payload.waits}`]); payload = null; continue; }
       if (!reviewDue(board, id, payload.pr.map((url, index) => ({ url, head: payload.pr_head[index] })))) {
         report.queued.push([id, `review waits: every open PR head (${payload.pr.join(', ')}) has a verdict or predates the last one; push a commit that answers it`]);
         continue;
@@ -1931,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

@@ -179,8 +179,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 +196,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);
   });
 }
 

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.151",
+  "version": "0.4.153",
   "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": {