@volter/supercode-orchestrator 0.4.95 → 0.4.97

package/board/cli.mjs

@@ -236,7 +236,8 @@ export async function runWorkflow(argv) {
   const ids = (first = rest) => [...first, ...(args.ids ?? [])];
 
   // a caller that is a card's own session (its harness names it; the board recorded which session it launched)
-  const sid = callerSession();
+  const listing = ['list','ls'].includes(verb);
+  const sid = listing && !args.mine ? null : callerSession();
   // what this command records is the calling session's act (its address, as its subscriptions name it)
   if (sid) setActor(`sc:${localMachine()}:${sid === process.env.CODEX_THREAD_ID ? 'codex' : 'claude-code'}:${sid}`);
   if (sid && !READS.has(verb) && boardExists(root, slug)) {
@@ -244,7 +245,7 @@ export async function runWorkflow(argv) {
   }
   // the board's workflow (the IR's): what each verb does, and who may send it, is its
   // every verb reads the board through its workflow (a list settles cards too), so every verb loads it
-  if (verb !== 'help') await loadWorkflow(root).catch((error) => { if (verb !== 'init' && verb !== 'boards') throw error; });
+  if (verb !== 'help' && !listing) await loadWorkflow(root).catch((error) => { if (verb !== 'init' && verb !== 'boards') throw error; });
   engine.setCaller((db, cardId) => rolesFor(db, cardId, sid, workflowFor(root).params));
   // a verb with no session behind it (a person at the CLI, the board file's sync) is the manager's, as its roles are
   if (!sid && verb !== 'help') { try { setActor([].concat(workflowFor(root).params?.managers ?? [])[0] ?? null); } catch { /* no workflow */ } }

package/board/rows.mjs

@@ -57,6 +57,21 @@ export class RuntimeRows {
       return {name,key,value:row,source:{name,key,row}};
     });
   }
+  mirror(changes, revision) {
+    const previous=Number(this.db.prepare("SELECT value FROM state WHERE key='read_revision'").get()?.value??-1);
+    for(const name of ['tasks','supercode_cards']) {
+      const table=this.tables.get(name); if(!table)return;
+      this.db.exec(table.sql.replace(/^CREATE TABLE (?:IF NOT EXISTS )?(?:"[^"]+"|\w+)/,`CREATE TABLE IF NOT EXISTS ${quote('read_'+name)}`));
+    }
+    const rows=previous===revision-1?changes.filter(c=>['tasks','supercode_cards'].includes(c.source.name)).map(c=>c.source):this.db.prepare("SELECT name,key,value FROM runtime_rows WHERE name IN ('@task_cache','@card_cache')").all().map(r=>({name:r.name==='@task_cache'?'tasks':'supercode_cards',key:JSON.stringify([r.key]),row:json(r.value,null)}));
+    for(const {name,key,row} of rows) {
+      const table=this.tables.get(name), target=quote('read_'+name);
+      if(!row) {this.db.prepare(`DELETE FROM ${target} WHERE ${table.keys.map(k=>`${quote(k)} IS ?`).join(' AND ')}`).run(...JSON.parse(key));continue;}
+      const keys=Object.keys(row);
+      this.db.prepare(`INSERT OR REPLACE INTO ${target} (${keys.map(quote)}) VALUES (${keys.map(()=>'?')})`).run(...keys.map(k=>row[k]??null));
+    }
+    this.db.prepare("INSERT INTO state VALUES('read_revision',?) ON CONFLICT(key) DO UPDATE SET value=excluded.value").run(String(revision));
+  }
   write(changes) {
     this.db.exec(`CREATE TABLE IF NOT EXISTS runtime_schema(name TEXT PRIMARY KEY,sql TEXT NOT NULL); CREATE TABLE IF NOT EXISTS runtime_rows(name TEXT,key TEXT,value TEXT,revision INTEGER NOT NULL,PRIMARY KEY(name,key)); CREATE INDEX IF NOT EXISTS runtime_rows_revision ON runtime_rows(revision); CREATE INDEX IF NOT EXISTS runtime_rows_task ON runtime_rows(name,json_extract(value,'$.task_id'),json_extract(value,'$.id')); CREATE INDEX IF NOT EXISTS runtime_rows_id ON runtime_rows(name,json_extract(value,'$.id'))`);
     const revision=Number(this.db.prepare("SELECT value FROM state WHERE key='rows_revision'").get()?.value??0)+1;
@@ -77,6 +92,7 @@ export class RuntimeRows {
     }
     for(const {name,sql} of this.tables.values())if(!OMIT.has(name))this.db.prepare('INSERT OR IGNORE INTO runtime_schema VALUES(?,?)').run(name,sql);
     this.db.prepare("INSERT INTO state VALUES('rows_revision',?) ON CONFLICT(key) DO UPDATE SET value=excluded.value").run(String(revision));
+    this.mirror(changes,revision);
     this.revision=revision;
   }
 }

package/board/workflow.mjs

@@ -113,7 +113,7 @@ function lastCommitAt(path, id) { return path ? commitTimes.get(`${path}:${id}`)
 export function refreshCardInputs(board, id, { commits = false } = {}) {
   const task=board.db.prepare('SELECT t.*,c.subtask_of FROM tasks t LEFT JOIN supercode_cards c ON c.task_id=t.id WHERE t.id=?').get(id);
   if (!task)return;
-  if (commits) {
+  if (commits && !task.subtask_of) {
     const own=task.workspace_kind!=='scratch'?task.workspace_path:null;
     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;

package/board/ztrack.mjs

@@ -109,6 +109,7 @@ class ZtrackBoard {
 
   transaction(fn) {
     if (this.cachedReader) this.invalidate();
+    this.readOnly(()=>{ if(this.runtime.prepare('PRAGMA journal_mode').get().journal_mode!=='wal')this.runtime.exec('PRAGMA journal_mode=WAL'); });
     for (;;) {
       try { this.runtime.exec('BEGIN'); }
       catch (error) { if (!/busy|locked/i.test(error.message)) throw error; continue; }
@@ -126,12 +127,12 @@ class ZtrackBoard {
         const result = fn(this.db);
         const changes = this.rows.changes(this.mem, { all: !this.rows.normalized() });
         const canonical = (row, omitted) => row && Object.fromEntries(Object.entries(row).filter(([key])=>!omitted.has(key)));
-        const cardDirty = this.seed || changes.some(({source})=>{
+        const documentChanges = changes.filter(({source})=>{
           if(source.name==='tasks')return JSON.stringify(canonical(source.row,new Set([...RUNTIME,'status'])))!==JSON.stringify(canonical(this.rows.cachedTasks[JSON.parse(source.key)[0]],new Set([...RUNTIME,'status'])));
           if(source.name==='supercode_cards')return JSON.stringify(canonical(source.row,new Set(['since','after_fired','next_run_at'])))!==JSON.stringify(canonical(this.rows.cachedCards[JSON.parse(source.key)[0]],new Set(['since','after_fired','next_run_at'])));
-          return source.name==='task_links';
+          return false;
         });
-        const documents = cardDirty ? this.documents() : {open:this.text, archived:this.archiveText};
+        const documents = this.seed || documentChanges.length ? this.documents(this.seed ? null : documentChanges) : {open:this.text, archived:this.archiveText};
         const files = [{ path: this.path, before: hash(this.text), base: this.text, text: documents.open }, { path: this.archive, before: hash(this.archiveText), base: this.archiveText, text: documents.archived }];
         const snapshot = this.snapshot(documents);
         this.computing = false;
@@ -219,12 +220,21 @@ class ZtrackBoard {
     this.mem.prepare(`INSERT OR REPLACE INTO ${quote(table)} (${keys.map(quote).join(',')}) VALUES (${keys.map(() => '?').join(',')})`).run(...keys.map((k) => row[k] ?? null));
   }
   openCachedReader(saved) {
+    const native = this.get('read_revision',-1)===this.get('rows_revision',0);
+    if(this.cachedReader && native!==this.nativeReader)this.invalidate();
     if (!this.cachedReader) {
       this.mem?.close(); this.mem=new DatabaseSync(':memory:'); this.init(this.mem,{fresh:true});
       for(const row of this.runtime.prepare('SELECT name,sql FROM runtime_schema').all())this.mem.exec(row.sql.replace('CREATE TABLE ','CREATE TABLE IF NOT EXISTS '));
       this.mem.prepare('ATTACH DATABASE ? AS source').run(this.runtimePath);
       const tables=this.mem.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all();
       for(const {name} of tables) {
+        if (native && name==='tasks') {
+          const fields=this.mem.prepare('PRAGMA main.table_info(tasks)').all().map(({name:column})=>column==='status'?'COALESCE(c.stage,t.status) AS status':`t.${quote(column)}`);
+          this.mem.exec(`CREATE TEMP VIEW tasks AS SELECT ${fields.join(',')} FROM source.read_tasks t LEFT JOIN source.read_supercode_cards c ON c.task_id=t.id`);
+          continue;
+        }
+        if(native && name==='supercode_cards') {this.mem.exec('CREATE TEMP VIEW supercode_cards AS SELECT * FROM source.read_supercode_cards');continue;}
+        if(native && name==='task_links') {this.mem.exec("CREATE TEMP VIEW task_links AS SELECT json_extract(b.value,'$.id') parent_id,r.task_id child_id FROM source.read_supercode_cards r,json_each(r.blocked_by) b WHERE json_extract(b.value,'$.kind')='card'");continue;}
         if(name==='task_links') {
           this.mem.exec(`CREATE TEMP VIEW task_links AS SELECT json_extract(b.value,'$.id') parent_id,r.key child_id FROM source.runtime_rows r,json_each(json_extract(r.value,'$.blocked_by')) b WHERE r.name='@card_cache' AND json_extract(b.value,'$.kind')='card'`);
           continue;
@@ -236,7 +246,7 @@ class ZtrackBoard {
         this.mem.exec(`CREATE TEMP VIEW ${quote(name)} AS SELECT ${fields.join(',')} FROM source.runtime_rows r${join} WHERE r.name='${recordName}' AND r.value IS NOT NULL`);
       }
       this.mem.exec('PRAGMA query_only=ON');
-      this.cachedReader=true;
+      this.cachedReader=true;this.nativeReader=native;
     }
     this.saved=saved; this.errors.clear();
     for(const [id,reason] of saved.errors??[])this.errors.set(id,reason);
@@ -275,12 +285,13 @@ class ZtrackBoard {
     this.rows.watch(this.mem);
     this.mem.exec('DELETE FROM tasks; DELETE FROM supercode_cards; DELETE FROM task_links');
     this.errors.clear(); this.preserve.clear();
-    const records = [];
+    const records = []; this.documentRecords=new Map();
     for (const [text,path] of [[this.text,this.path],[this.archiveText,this.archive]]) {
       const result = this.codec.inspectBoardDocument(text,path);
       const kept = new Set(result.errors.map(e=>e.id));
       for(const error of result.errors)this.errors.set(nativeId(error.id),error.reason);
       for(const record of result.records) {
+        this.documentRecords.set(nativeId(record.id),{record,path});
         try { records.push(this.preset.KanbanRootSchema.parse(this.preset.parseKanban([record])).issues[0]); }
         catch(error) { this.errors.set(nativeId(record.id),error.message); kept.add(record.id); }
       }
@@ -380,10 +391,11 @@ class ZtrackBoard {
   committer() {
     return 'document-editor';
   }
-  documents() {
-    const rows = this.mem.prepare('SELECT * FROM tasks ORDER BY created_at, id').all();
+  documents(changes=null) {
+    const allRows = this.mem.prepare('SELECT * FROM tasks ORDER BY created_at, id').all();
     const states = new Map(this.mem.prepare('SELECT * FROM supercode_cards').all().map((c) => [c.task_id, c]));
-    const byId = new Map(rows.map((r) => [r.id, r]));
+    const affected=changes?new Set(changes.map(({source})=>{const id=JSON.parse(source.key)[0];return states.get(id)?.subtask_of??this.rows.cachedCards[id]?.subtask_of??id;})):null;
+    const rows=affected?allRows.filter(row=>affected.has(states.get(row.id)?.subtask_of??row.id)):allRows;
     const cards = new Map();
     for (const row of rows.filter((r) => !states.get(r.id)?.subtask_of && !this.errors.has(r.id))) {
       const c = states.get(row.id) ?? {};
@@ -420,12 +432,15 @@ class ZtrackBoard {
         blockedBy: json(c.blocked_by, []).map((b) => ({ issue: b.id })) });
     }
     const open = [], archived = [];
+    if(affected)for(const [id,{record,path}] of this.documentRecords??[])if(!affected.has(id)&&!this.errors.has(id))(path===this.path?open:archived).push(record);
     for (const [id, card] of cards) {
       const serialized = this.preset.serializeKanbanCard(card);
       const record = { id: card.id, title: card.title, status: card.status, ...(card.assignee ? { assignee: card.assignee } : {}), body: serialized.body };
       (states.get(id)?.archived || ['done', 'cancelled'].includes(card.status) ? archived : open).push(record);
     }
-    return { open: this.codec.renderBoardDocument(this.text, open, this.path, [...(this.preserve.get(this.path)??[])]), archived: this.codec.renderBoardDocument(this.archiveText, archived, this.archive, [...(this.preserve.get(this.archive)??[])]) };
+    const original=this.documentRecords;
+    const changedPath=path=>!affected||[...affected].some(id=>original?.get(id)?.path===path||cards.has(id)&&((states.get(id)?.archived||['done','cancelled'].includes(cards.get(id).status))?this.archive:this.path)===path);
+    return { open: !changedPath(this.path)?this.text:this.codec.renderBoardDocument(this.text, open, this.path, [...(this.preserve.get(this.path)??[])]), archived: !changedPath(this.archive)?this.archiveText:this.codec.renderBoardDocument(this.archiveText, archived, this.archive, [...(this.preserve.get(this.archive)??[])]) };
   }
   snapshot(documents) {
     return { documentHashes:{open:hash(documents.open),archived:hash(documents.archived)}, errors:[...this.errors], fingerprints: this.fingerprints(), taskIds: Object.fromEntries([...this.taskKeys].map(([id, key]) => [key, id])) };

package/package.json

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