@volter/supercode-orchestrator 0.5.17 → 0.5.19

package/board/dispatch.mjs

@@ -1543,10 +1543,31 @@ export function completeAdoptions(board, fleet, settings, report, lanes = null)
   }
 }
 
+/**
+ * A session on this machine that Teams never published (one outside every synced root: a profile's own directory) is
+ * found through this machine's own doors: its panes, and the native session each pane's process runs. Only a full
+ * address is looked up here; liveness is still verified below as for any other session.
+ */
+function localListing(who) {
+  const m = /^sc:([^:]+):([^:]+):(.+)$/.exec(String(who));
+  if (!m || normalMachine(m[1]) !== localMachine()) return null;
+  const [, , harness, sessionId] = m;
+  const listed = runtimeDoor(null, 'harness.v1.panes.list', {}, { timeout: 60_000 });
+  const panes = (listed.code === 0 ? json(listed.stdout.trim(), []) : []) ?? [];
+  const live = panes.filter((p) => !p.dead && p.pid);
+  if (!live.length) return null;
+  const r = runtimeDoor(null, 'harness.v1.sessions.activity_under', { pids: live.map((p) => p.pid) }, { timeout: 30_000 });
+  const row = (r.code === 0 ? json(r.stdout.trim(), {})?.activities ?? [] : []).find((a) => a.activity?.session_id === sessionId && (a.activity?.harness ?? harness) === harness);
+  // Not found in a pane of this machine: not listed, so a session opened moments ago is looked for again next tick.
+  const pane = row ? live.find((p) => p.pid === row.pid)?.pane ?? null : null;
+  if (!pane) return null;
+  return { address: `sc:${localMachine()}:${harness}:${sessionId}`, machine: localMachine(), harness, session_id: sessionId, pane, name: null };
+}
+
 function adoptSession(board, id, who, { workspace = null, ttl, assignee = null, role = null, fleet = null, lanes = null } = {}) {
   fleet ??= observeFleet();
   if (!fleet.ok) throw new Error(`supercode could not read the fleet: ${fleet.error}`);
-  const found = fleet.sessions.find((s) => s.address === who || s.address.endsWith(`:${who}`) || s.name === who);
+  const found = fleet.sessions.find((s) => s.address === who || s.address.endsWith(`:${who}`) || s.name === who) ?? localListing(who);
   if (!found) throw Object.assign(new Error(`the fleet lists no live session ${who}`), { notListed: true });
   const [, host, harness, sessionId] = found.address.split(':');
   if (!HARNESSES[harness]) throw new Error(`${found.address} is ${harness}; the board keeps and resumes ${Object.keys(HARNESSES).join(' and ')} sessions`);
@@ -1797,9 +1818,17 @@ async function notify(board, fleet, report, entry) {
     try {
       // an event older than the workflow's notice_max_age_seconds is history, not news: it is passed over, never mailed
       const maxAge = Number(entry.params.notice_max_age_seconds) || null;
+      // A backlog (a restart, a recipient that could not be reached) is told as it stands now: of one kind of news about
+      // the card, only the latest (a later adoption_failed, blocked or moved says what the earlier one did); comments
+      // and answers, each its own message, in full. A notice the board already recorded as taken by this address is never sent again.
+      const latest = new Map(events.filter((ev) => !['commented', 'answered'].includes(ev.kind)).map((ev) => [ev.kind, ev.id]));
+      const sentBefore = board.db.prepare("SELECT 1 FROM task_events WHERE task_id = ? AND kind IN ('notice_delivered', 'notice_filed') AND json_extract(payload, '$.source_event') = ? AND json_extract(payload, '$.address') = ? LIMIT 1");
+      const advance = (id) => tx(board, (db) => db.prepare("UPDATE kanban_notify_subs SET last_event_id = ? WHERE task_id = ? AND platform = 'supercode' AND chat_id = ? AND thread_id = ? AND last_event_id < ?").run(id, sub.task_id, sub.chat_id, sub.thread_id ?? '', id));
       for (const ev of events) {
         const p = json(ev.payload, {}) ?? {};
         if (maxAge && now() - Number(ev.created_at) > maxAge) { cursor = ev.id; (report.stale_notices_passed ??= 0); report.stale_notices_passed += 1; continue; }
+        if (latest.has(ev.kind) && latest.get(ev.kind) !== ev.id) { cursor = ev.id; (report.superseded_notices_passed ??= 0); report.superseded_notices_passed += 1; continue; }
+        if (sentBefore.get(sub.task_id, ev.id, sub.chat_id)) { cursor = ev.id; continue; }
         // nobody is told of their own act
         if (p.by && p.by === sub.chat_id) { cursor = ev.id; continue; }
         let text;
@@ -1816,6 +1845,8 @@ async function notify(board, fleet, report, entry) {
           if (!receipt.delivered && !receipt.queued) throw new Error(receipt.reason ?? 'notice was not filed');
           tx(board, (db) => event(db, sub.task_id, receipt.delivered ? 'notice_delivered' : 'notice_filed', { source_event: ev.id, kind: ev.kind, address: sub.chat_id, receipt }));
           report.notified.push([sub.task_id, ev.kind, sub.chat_id]);
+          // the cursor follows each notice sent, so a restart mid-backlog resumes after it
+          advance(ev.id);
         }
         cursor = ev.id;
       }

package/board/workflow.mjs

@@ -396,6 +396,39 @@ function queueTransitionNotice(db, board, entry, task, from, name, payload, befo
   run(db, 'UPDATE task_runs SET metadata = ? WHERE id = ?', JSON.stringify(current), beforeRun.id);
 }
 
+/**
+ * A card's status, read through its workflow. A card carried from a board whose workflow named other statuses (an
+ * imported `ready`) is in none this workflow declares, and no transition leaves it: every verb refused it, the
+ * manager's included. It enters the way a new card does (the workflow's `initial`), recorded on the card, and the verb
+ * then applies from there. No status is named here: the workflow's own start rule decides.
+ */
+function declaredStatus(db, board, entry, task) {
+  const from = statusOf(db, task);
+  if (entry.workflow.statuses[from]) return from;
+  // A name the workflow stores a status as (kanban.db's `archived` for cancelled, Hermes's `blocked`, a `ready` its
+  // stored_as rules write) is that status, never a new card: a stopped card entering at the start would be dispatched
+  // again. Which status is read through the workflow's own rules: each declared status is tried on this card, in the
+  // caller's transaction, and the ones it would be stored as `from` are the candidates. One is the card's status;
+  // none or several say nothing certain, and the verb is refused.
+  const stores = Object.values(entry.workflow.statuses).some((status) => status.stored_as === from) || (entry.workflow.stored_as ?? []).some((rule) => rule.status === from);
+  if (stores) {
+    const stage = (name) => run(db, 'INSERT INTO supercode_cards (task_id, stage) VALUES (?, ?) ON CONFLICT(task_id) DO UPDATE SET stage = excluded.stage', task.id, name);
+    const fits = Object.keys(entry.workflow.statuses).filter((name) => { stage(name); return storedStatus(db, board, entry, task.id).stored === from; });
+    stage(from);
+    if (fits.length !== 1) throw new Error(`${task.id} is ${from}, which the board's workflow does not declare; it stores ${fits.length ? fits.join(' and ') : 'no status of this card'} as ${from}, so which it means is not certain: move it with that status's verb`);
+    setStatus(db, entry.workflow, task.id, fits[0]);
+    record(db, task.id, 'status_adopted', { from, to: fits[0], reason: `${from} is how this board's workflow stores ${fits[0]} for this card` });
+    return fits[0];
+  }
+  const scope = scopeOf(db, board, task, { params: entry.params, event: {}, extra: { lanes: lanesIn(entry) } });
+  const start = entry.workflow.initial?.find((x) => holds(x.guard ?? null, scope));
+  const to = start?.target ? String(templateValue(start.target, scope)) : null;
+  if (!to || !entry.workflow.statuses[to]) throw new Error(`${task.id} is ${from}, which the board's workflow does not declare, and its start rule names no declared status to enter`);
+  setStatus(db, entry.workflow, task.id, to);
+  record(db, task.id, 'status_adopted', { from, to, reason: `${from} is no status of this board's workflow; entered as a new card enters` });
+  return to;
+}
+
 /**
  * Apply event `name` to card `id` in the caller's transaction. `roles` are who sends it (a transition with `by`
  * takes only a sender in one of its roles; `platform` for the dispatcher's own observations). Answers
@@ -407,8 +440,7 @@ export function fire(db, board, entry, id, name, { roles = [], payload = {}, ext
   if (workflow.run && (workflow.run.on?.[name] || Object.values(workflow.run.states ?? {}).some((s) => s.on?.[name]))) return fireRun(db, board, entry, id, name, { roles, payload, extra });
   const task = cardOf(db, id);
   const beforeRun = noticeRun(db, task);
-  const from = statusOf(db, task);
-  if (!workflow.statuses[from]) throw new Error(`${id} is ${from}, which the board's workflow does not declare`);
+  const from = declaredStatus(db, board, entry, task);
   const candidates = transitionsFor(workflow, from, name);
   if (!candidates.length) throw new Error(`${id} is ${from}; ${name.replace(/_/g, '-')} does not apply there`);
   // `sender`: the roles the event was sent with (a validator can ask who is asking)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.17",
+  "version": "0.5.19",
   "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": {