@volter/supercode-teams 0.3.3 → 0.3.4

package/bin/workspace/args.mjs

@@ -5,6 +5,8 @@ const BOOLEANS = new Set([
 ]);
 
 const VALUES = new Set([
+  // calendar (bin/workspace/calendar.mjs)
+  'kind', 'title', 'at', 'card', 'reason', 'number', 'start', 'end', 'holder', 'requester', 'thread', 'guarantee', 'from', 'draws', 'notify', 'threshold',
   'context', 'server', 'team', 'credential-ref', 'data-dir', 'listen',
   'public-origin', 'init-team', 'as', 'user', 'repo', 'harness', 'machine',
   'source', 'cursor', 'limit', 'tail', 'before', 'after', 'revision', 'role',

package/bin/workspace/calendar.mjs

@@ -0,0 +1,126 @@
+// `supercode calendar` (company RFC 0023 decisions 12-19): the calendar's verbs over the team's calendar door and the
+// calendar pack. People and agents record what only they know (a holder's window, a fixed date, the manager's call);
+// the projection, the risks and the calibration are computed from the board's own record, never stated by an agent.
+//
+//   calendar list                                   fixed events, windows, calls; the IR's recurring jobs read live
+//   calendar event add --kind deadline|delivery --title T --at ISO [--card ID] [--reason R]
+//   calendar window add --number N --start ISO --end ISO --holder H --requester R --thread ID --guarantee TEXT
+//   calendar call --card ID --from ISO --to ISO --reason R    the manager's call beside the base rate
+//   calendar projection --root HOME [--draws N]     each open card's forecast; a changed one is kept as a revision
+//   calendar risk --root HOME --notify MANAGER      mails the manager once per crossing of a date's threshold
+//   calendar calibration --root HOME                the base rate and the manager's calls graded against outcomes
+import { execFileSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { usage, requireArgs } from './args.mjs';
+
+async function pack() {
+  try { return await import('@volter/supercode-calendar'); } catch { /* not installed */ }
+  try { return await import(new URL('../../../calendar/index.mjs', import.meta.url).href); } catch { /* not beside it */ }
+  usage('calendar needs the calendar pack (@volter/supercode-calendar)');
+}
+
+const supercode = () => process.env.SUPERCODE_BIN ?? 'supercode';
+const at = (value, name) => { const t = Date.parse(String(value ?? '')); if (!Number.isFinite(t)) usage(`--${name} is an ISO date and time`); return t; };
+
+function readBoard(root) {
+  if (!root) usage('--root names the board\'s home');
+  const text = execFileSync(supercode(), ['workflow', 'load', '--from', 'hermes', '--json', String(root)], { encoding: 'utf8', maxBuffer: 512 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'] });
+  const board = Object.values(JSON.parse(text).workflow.boards)[0];
+  return { tasks: Object.entries(board.tasks).map(([id, task]) => ({ id, ...task })), dependencies: board.dependencies ?? [] };
+}
+
+async function objects(client, path, kind, revisions = false) {
+  const query = new URLSearchParams({ ...(kind ? { kind } : {}), ...(revisions ? { revisions: 'true' } : {}) });
+  return (await client.request('GET', path(`/calendar/objects?${query}`))).data.items;
+}
+// A write is keyed by the object's uid, so a rate-limited one is retried after the wait the server names: a board with
+// many open cards writes as many forecasts on its first projection.
+async function put(client, path, kind, object) {
+  for (let attempt = 0; ; attempt++) {
+    try { return await client.request('PUT', path(`/calendar/objects/${encodeURIComponent(object.uid)}`), { body: { kind, object } }); } catch (error) {
+      if (error.code !== 'rate_limited' || attempt >= 30) throw error;
+      const seconds = Number(error.details?.retry_after_seconds ?? error.retry_after_seconds ?? 1);
+      await new Promise((resolve) => setTimeout(resolve, Math.max(1, seconds) * 1000));
+    }
+  }
+}
+
+/** Fixed events linked to cards, as the projection reads them. */
+const datedCards = (items) => items.filter((item) => item.object['volter:card'] && (item.kind === 'deadline' || item.kind === 'delivery')).map((item) => ({ card: item.object['volter:card'], at: Date.parse(item.object.start), kind: item.kind }));
+
+export async function calendarCommand(sub, { flags, rest, output, client, context, teamPath }) {
+  const path = (suffix) => teamPath(context, suffix);
+  const calendar = await pack();
+  if (sub === 'list') {
+    requireArgs(rest, 0, 0, 'calendar list');
+    const items = await objects(client, path);
+    let jobs = [];
+    // Recurring jobs are the IR's, read where they live and never copied (decision 7).
+    try { jobs = JSON.parse(execFileSync(supercode(), ['jobs', 'list', '--json', ...(flags.harness ? ['--harness', String(flags.harness)] : [])], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] })); } catch { /* no jobs here */ }
+    return output({ version: 1, data: { objects: items, recurring: (Array.isArray(jobs) ? jobs : jobs.jobs ?? []).map((job) => ({ id: job.id ?? job.name, schedule: job.schedule ?? job.schedule_display, next: job.next_run_at ?? job.nextRunAt ?? null })) } });
+  }
+  if (sub === 'event') {
+    if (rest[0] !== 'add') usage('calendar event add --kind deadline|delivery --title T --at ISO [--card ID]');
+    if (!['deadline', 'delivery'].includes(flags.kind)) usage('--kind is deadline (never moves) or delivery (moves only on the owner\'s word)');
+    if (!flags.title) usage('--title is required');
+    const object = calendar.fixedEvent({ uid: `event-${randomUUID()}`, kind: flags.kind, title: String(flags.title), at: at(flags.at, 'at'), card: flags.card ?? null, reason: flags.reason ?? null });
+    return output(await put(client, path, flags.kind, object));
+  }
+  if (sub === 'window') {
+    if (rest[0] !== 'add') usage('calendar window add --number N --start ISO --end ISO --holder H --requester R --thread ID --guarantee TEXT');
+    for (const key of ['number', 'holder', 'requester', 'thread', 'guarantee']) if (!flags[key]) usage(`--${key} is required`);
+    const object = calendar.windowEvent({ uid: `window-${String(flags.holder)}-${Number(flags.number)}`, number: Number(flags.number), start: at(flags.start, 'start'), end: at(flags.end, 'end'), holder: String(flags.holder), requester: String(flags.requester), thread: String(flags.thread), guarantee: String(flags.guarantee) });
+    return output(await put(client, path, 'window', object));
+  }
+  if (sub === 'call') {
+    requireArgs(rest, 0, 0, 'calendar call --card ID --from ISO --to ISO --reason R');
+    if (!flags.card || !flags.reason) usage('--card and --reason are required');
+    const forecast = (await objects(client, path, 'forecast')).find((item) => item.object['volter:card'] === flags.card);
+    const object = calendar.callTask({ uid: `call-${flags.card}`, card: String(flags.card), from: at(flags.from, 'from'), to: at(flags.to, 'to'), reason: String(flags.reason), baseRate: forecast ? { p50: forecast.object['volter:p50'], p85: forecast.object['volter:p85'] } : null });
+    return output(await put(client, path, 'call', object));
+  }
+  if (sub === 'projection' || sub === 'risk') {
+    const board = readBoard(flags.root);
+    const priors = calendar.boardPriors(board.tasks);
+    const events = datedCards(await objects(client, path));
+    const projection = calendar.project({ ...board, priors, events, draws: flags.draws ? Number(flags.draws) : 2000 });
+    if (sub === 'projection') {
+      // A card's forecast is kept as a revision when it moved (decision 16: no change, no entry).
+      const kept = new Map((await objects(client, path, 'forecast')).map((item) => [item.object['volter:card'], item.object]));
+      let revised = 0;
+      for (const card of projection.cards) {
+        const before = kept.get(card.id);
+        const hours = (iso) => Math.round(Date.parse(iso) / 3_600_000);
+        if (before && hours(before['volter:p85']) === Math.round(card.p85 / 3_600_000) && hours(before['volter:p50']) === Math.round(card.p50 / 3_600_000)) continue;
+        // Why it moved, from the card's own record: a review asking for changes, a move of lane, else the base rate.
+        const cause = !before ? 'first forecast'
+          : card.changes > (before['volter:changes'] ?? 0) ? `a review asked for changes (round ${card.changes})`
+          : before['volter:lane'] && before['volter:lane'] !== card.lane ? `moved to ${card.lane}`
+          : 'the base rate moved';
+        await put(client, path, 'forecast', calendar.forecastTask({ uid: `forecast-${card.id}`, card: card.id, p50: card.p50, p85: card.p85, due: card.due ?? null, chanceByDue: card.chanceByDue ?? null, cause, lane: card.lane, changes: card.changes }));
+        revised += 1;
+      }
+      return output({ version: 1, data: { revised, priors: { coding: { median: priors.coding.median, p85: priors.coding.p85, n: priors.coding.n }, rework: { median: priors.rework.median, p85: priors.rework.p85, n: priors.rework.n }, reviewWait: { median: priors.reviewWait.median, n: priors.reviewWait.n }, reviewRounds: priors.reviewRounds.counts },
+        cards: projection.cards.map((card) => ({ id: card.id, title: card.title, lane: card.lane, forecast: calendar.sentence(card.chanceByDue ?? 0.85, card.p50, card.due ?? card.p85), p50: new Date(card.p50).toISOString(), p85: new Date(card.p85).toISOString(), ...(card.due ? { due: new Date(card.due).toISOString(), chanceByDue: card.chanceByDue } : {}) })) } });
+    }
+    if (!flags.notify) usage('--notify names the manager the calendar mails');
+    const found = calendar.risks(projection, { threshold: flags.threshold ? Number(flags.threshold) : 0.85 });
+    const notices = new Set((await objects(client, path, 'notice')).map((item) => item.object.uid));
+    const sent = [];
+    for (const risk of found) {
+      const uid = `notice-${risk.id}-${risk.due}`;
+      if (notices.has(uid)) continue;
+      const body = `${risk.title} (${risk.id}) is at risk for ${new Date(risk.due).toISOString().slice(0, 16)}Z: ${calendar.sentence(risk.chance, risk.p85, risk.due)} (${risk.reason}). The calendar's base rate; your call is yours.`;
+      execFileSync(supercode(), ['message', 'send', String(flags.notify), body, '--subject', `At risk: ${risk.id}`], { stdio: ['ignore', 'pipe', 'pipe'] });
+      await put(client, path, 'notice', { '@type': 'Event', uid, title: `Mailed ${flags.notify} about ${risk.id}`, start: new Date().toISOString(), duration: 'PT0S', 'volter:kind': 'notice', 'volter:card': risk.id });
+      sent.push(risk.id);
+    }
+    return output({ version: 1, data: { risks: found.map((risk) => ({ ...risk, due: new Date(risk.due).toISOString(), p85: new Date(risk.p85).toISOString() })), mailed: sent } });
+  }
+  if (sub === 'calibration') {
+    const board = readBoard(flags.root);
+    const revisions = (await objects(client, path, undefined, true)).filter((item) => item.kind === 'forecast' || item.kind === 'call').map((item) => ({ card: item.object['volter:card'], ...(item.kind === 'forecast' ? { p85: Date.parse(item.object['volter:p85']) } : { callTo: Date.parse(item.object.due) }) }));
+    return output({ version: 1, data: calendar.calibration(revisions, board.tasks) });
+  }
+  usage('calendar list | event add | window add | call | projection | risk | calibration');
+}

package/bin/workspace.mjs

@@ -14,6 +14,7 @@ import { makeToken } from '@volter/teams/server/auth';
 import { moveWorkspace } from '../workspace-move.mjs';
 import { TeamsConnector, readSyncStatus } from '../connector/index.mjs';
 import { syncStatusLines } from './workspace/sync-status.mjs';
+import { calendarCommand } from './workspace/calendar.mjs';
 import { CONTINUATION_FIDELITY, CONTINUATION_HARNESSES } from '../connector/native-continuation.mjs';
 import { MachineEvents } from '../machine-events.mjs';
 import { openLocalMachine, nodeRpc } from '../client.mjs';
@@ -70,7 +71,7 @@ export async function workspaceMain(argv = process.argv.slice(2), env = process.
         if(identity&&!flags.context&&!env.SUPERCODE_AGENT_CONTEXT)env={...env,SUPERCODE_AGENT_CONTEXT:identity.context,SUPERCODE_AGENT_ID:identity.agent,SUPERCODE_AGENT_ASSIGNMENTS:JSON.stringify(identity.assignments)};
       }catch(error){
         // Only absence of an older/offline daemon permits the ordinary plain-session context.
-        if(!['ENOENT','ECONNREFUSED',-32601].includes(error.code))throw error;
+        if(!['ENOENT','ECONNREFUSED','machine_offline',-32601].includes(error.code))throw error;
       }finally{channel?.close();}
     }
   }
@@ -105,6 +106,7 @@ export async function workspaceMain(argv = process.argv.slice(2), env = process.
   if (verb === 'identities') return identityRecordCommand(sub,command);
   if (verb === 'apps' || verb === 'app-installations') return appsCommand(verb,sub,{...command,output:value=>output(flags.json?value:redactAppSecrets(value))});
   if (verb === 'sessions') return sessionsCommand(sub, command);
+  if (verb === 'calendar') return calendarCommand(sub, { ...command, teamPath });
   if (verb === 'members') return membersCommand(sub, command);
   if (verb === 'groups') return groupsCommand(sub, command);
   if (verb === 'sources') return sourcesCommand(sub, command);
@@ -481,6 +483,7 @@ async function sessionsCommand(sub, command) {
   if (sub === 'follow') { only(flags, ['json', 'help', 'context', 'tail', 'after']); requireArgs(rest, 1, 1, 'sessions follow REF'); return stream(session.follow({ tail: positiveInteger(flags.tail, 100, 'tail'), ...optional(flags, ['after']) }), flags.json); }
   if (sub === 'attach') return attachSession(session, command);
   if (sub === 'export') return exportSession(session, command);
+  if (sub === 'trace') return traceSession(session, command);
   if (sub === 'continue') return continueSession(session, command);
   if (sub === 'url') { only(flags, ['json', 'help', 'context']); requireArgs(rest, 1, 1, 'sessions url REF'); const descriptor = await session.descriptor(); return output({ version: 1, context: scope(context), data: { url: `${context.origin}/teams/${context.team_id}/sessions/${descriptor.data.id}` } }); }
   // A session view (RH2 ADR 0008): its owner lets a workplace Room's Conversation read this session with the tokens that
@@ -544,6 +547,47 @@ async function exportSession(session, { flags, rest, output, client, context })
   } catch (error) { destination.abort(); throw error; }
 }
 
+/** The trace pack (company RFC 0023 decision 17), outside core: installed, or beside this package in the repository. */
+async function tracePack() {
+  try { return await import('@volter/supercode-trace'); } catch { /* not installed */ }
+  try { return await import(new URL('../../trace/trace.mjs', import.meta.url).href); } catch { /* not beside it */ }
+  unsupported('sessions trace needs the trace pack (@volter/supercode-trace)');
+}
+
+/** `sessions trace REF`: the session's captured record, exported byte-lossless through the export door, read as its trace. */
+async function traceSession(session, { flags, rest, output, client, context }) {
+  only(flags, ['json', 'help', 'context', 'since', 'until', 'timeout']);
+  requireArgs(rest, 1, 1, 'sessions trace REF [--since ISO] [--until ISO]');
+  const pack = await tracePack();
+  const descriptor = (await session.descriptor()).data;
+  const format = descriptor.harness;
+  if (format !== 'claude-code' && format !== 'codex') unsupported(`trace reads Claude Code and Codex sessions; this one is ${format}`);
+  const window = { ...(flags.since ? { since: String(flags.since) } : {}), ...(flags.until ? { until: String(flags.until) } : {}) };
+  const print = (trace) => flags.json ? output({ version: 1, context: scope(context), data: { session: descriptor.id, revision: descriptor.revision, ...trace } }) : process.stdout.write(pack.formatTrace(trace));
+  // A session with no exportable record (known only from telemetry) is read from its stored evidence.
+  const fromEvidence = async () => {
+    const items = []; let after = 0;
+    // Read until the door says it is done: a page may hold none of this session's records and still not be the last.
+    for (;;) { const page = (await client.request('GET', `${session.path}/evidence?after=${after}&limit=5000`)).data; items.push(...page.items); if (page.done || page.next_after === after) break; after = page.next_after; }
+    if (!items.length) return null;
+    return pack.traceTelemetry(items, format, window);
+  };
+  let operation = null;
+  try {
+    const started = await session.export({ format, fidelity: 'byte_lossless', revision: descriptor.revision });
+    operation = await waitForOperation(client, context, started.data, flags.timeout ? duration(flags.timeout) : undefined);
+  } catch (error) { operation = { state: 'failed', error }; }
+  const result = operation.result;
+  if (operation.state !== 'succeeded' || result?.kind !== 'export' || result.source_revision !== descriptor.revision) {
+    const trace = await fromEvidence();
+    if (trace) return print(trace);
+    throw new Error(`the session's record could not be exported losslessly (${operation.error?.message ?? operation.state}) and it has no stored telemetry; read its native file on its own machine with supercode-trace FILE`);
+  }
+  const primary = result.files.find(file => file.role === 'primary');
+  const text = new TextDecoder().decode(await downloadArtifact(client, context, result.source_session_id, primary));
+  return print(pack.traceText(text, { harness: format, ...window }));
+}
+
 async function continueSession(session, { flags, rest, output, client, context, team, home, env, dependencies }) {
   only(flags, ['json', 'help', 'context', 'plan', 'on', 'harness', 'cwd', 'root', 'fidelity', 'dry_run', 'timeout', 'workspace_from']);
   requireArgs(rest, 1, 1, 'sessions continue REF (--plan ID | --on local|MACHINE --harness ID --cwd PATH [--workspace-from MACHINE:PATH])');
@@ -1268,7 +1312,8 @@ function printHelp() {
   sources create|list|status|pause|revoke|credentials|config
   machines list|roots|access|authorize-continuation|subscribe|unsubscribe|events
   sync add|list|show|pause|resume|remove
-  sessions list|search|show|follow|access|rename|delete|url|attach|export|continue|bind|unbind
+  sessions list|search|show|follow|access|rename|delete|url|attach|export|trace|continue|bind|unbind
+  calendar list|event add|window add|call|projection|risk|calibration
 Use --help with a command for its required arguments and options.
 `);
 }

package/machine.mjs

@@ -24,6 +24,7 @@
 // grants before acting. There is no inbound port and no address book.
 //
 // It decides nothing on anyone's behalf. Every act is logged.
+import { ProcessTree } from './process-tree.mjs';
 import { spawn, spawnSync } from 'node:child_process';
 import { EventEmitter } from 'node:events';
 import { appendFileSync, readFileSync, writeFileSync, writeSync, statSync, readdirSync, mkdirSync, renameSync, rmSync, existsSync, openSync, readSync, closeSync, accessSync, constants } from 'node:fs';
@@ -231,6 +232,13 @@ export class TeamsMachine extends MachineCore {
       this.terminalMailWork = this.#drainTerminalMail().catch(error => this.emit('mail-watch-stderr', `terminal mailbox: ${error.message}`)).finally(() => { this.terminalMailWork = null; });
     }, 1000);
     this.terminalMailTimer.unref?.();
+    // What actually runs under each hosted pane, for the trace pack (process-tree.mjs): one read every five seconds.
+    this.processTree = new ProcessTree({ root: join(this.home, 'processes'), panes: async () => (await this.attentionEvidence()).map(({ session }) => ({ pane: session.contextKey, rootPid: session.rootPid })) });
+    this.processTimer = setInterval(() => {
+      if (this.processWork) return;
+      this.processWork = this.processTree.sample().catch(error => this.emit('mail-watch-stderr', `process tree: ${error.message}`)).finally(() => { this.processWork = null; });
+    }, 5000);
+    this.processTimer.unref?.();
     this.inputInFlight = new Set(); // one input transaction per pane
     this.inputRepairsPath = join(this.home, 'input-repairs.json');
     this.inputRepairs = readJson(this.inputRepairsPath, {});
@@ -299,6 +307,7 @@ export class TeamsMachine extends MachineCore {
   async beforeClose() {
     this.#stopHealth();
     clearInterval(this.terminalMailTimer); await this.terminalMailWork;
+    clearInterval(this.processTimer); await this.processWork;
     clearInterval(this.inputRepairTimer);this.inputRepairTimer=null;
     await this.inputRepairWork;
     clearInterval(this.endWatch); this.endWatch = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",
@@ -59,12 +59,14 @@
   "scripts": {},
   "dependencies": {
     "@homebridge/node-pty-prebuilt-multiarch": "^0.14.1",
+    "@volter/identity": "^0.4.1",
+    "@volter/supercode-calendar": "^0.1.0",
     "@volter/supercode-frontend": "^0.2.2",
     "@volter/supercode-harness-sdk": "^0.3.43",
     "@volter/supercode-health": "^0.1.0",
     "@volter/supercode-terminal": "^0.2.54",
-    "@volter/identity": "^0.4.1",
-    "@volter/teams": "0.2.1",
+    "@volter/supercode-trace": "^0.1.0",
+    "@volter/teams": "0.2.2",
     "@xterm/addon-serialize": "^0.14.0",
     "@xterm/headless": "^6.0.0",
     "protobufjs": "8.8.0",

package/process-tree.mjs

@@ -0,0 +1,71 @@
+// A HOSTED SESSION'S PROCESS TREE (company RFC 0023 decision 17, Experiment 5). A transcript keeps only the text of the
+// commands an agent ran; what actually ran is the processes under its pane. This daemon hosts the pane, so it records
+// them: every few seconds one `ps` read, and for each pane each descendant of its harness process that started or ended
+// since the last read, with its program identity (the binary, or for an interpreter the package owning its script:
+// `node:wrangler`, `bun:@volter/world-runtime`) and its subcommand by position. The trace pack names shell time by what
+// ran from this record. Exit codes are not visible to a sampler (a process's end is the read it was last seen in), and
+// processes shorter than one interval may be missed; both are said here, not guessed at.
+import { execFile } from 'node:child_process';
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+
+const INTERPRETERS = new Set(['node', 'bun', 'deno', 'python', 'python3', 'ruby', 'tsx']);
+const SHELLS = new Set(['sh', 'bash', 'zsh', 'fish', 'login']);
+
+function ps() {
+  return new Promise((resolve) => execFile('ps', ['-axo', 'pid=,ppid=,lstart=,command='], { maxBuffer: 16 * 1024 * 1024, timeout: 10_000 }, (error, stdout) => resolve(error ? '' : stdout)));
+}
+
+/** The package that owns a script, by the nearest package.json above it; cached by folder. */
+const owners = new Map();
+function packageOf(path) {
+  let folder = dirname(path);
+  for (let i = 0; i < 12 && folder !== dirname(folder); i++, folder = dirname(folder)) {
+    if (owners.has(folder)) return owners.get(folder);
+    const manifest = join(folder, 'package.json');
+    if (existsSync(manifest)) { let name = null; try { name = JSON.parse(readFileSync(manifest, 'utf8')).name ?? null; } catch { /* unreadable */ } owners.set(folder, name); return name; }
+  }
+  return null;
+}
+
+/** A process's program identity and its subcommand, from its argv. */
+export function identityOf(command) {
+  const argv = command.trim().split(/\s+/);
+  const binary = basename(argv[0] ?? '');
+  if (INTERPRETERS.has(binary)) {
+    const script = argv.slice(1).find((arg) => !arg.startsWith('-'));
+    const owner = script && script.includes('/') ? packageOf(script) : null;
+    const name = owner ?? (script ? basename(script).replace(/\.(m?[jt]s|py)$/, '') : binary);
+    const rest = argv.slice(argv.indexOf(script ?? '') + 1).filter((arg) => !arg.startsWith('-'));
+    return { program: `${binary}:${name}`, sub: rest[0] ?? null };
+  }
+  return { program: binary, sub: argv.slice(1).find((arg) => !arg.startsWith('-')) ?? null };
+}
+
+export class ProcessTree {
+  /** `panes()` answers the hosted panes as `{ pane, rootPid }`; records go under `root`. */
+  constructor({ root, panes }) { this.root = root; this.panes = panes; this.seen = new Map(); }
+
+  async sample(now = Date.now()) {
+    const panes = (await this.panes()).filter((row) => Number.isInteger(row.rootPid));
+    if (!panes.length) return;
+    const rows = (await ps()).split('\n').map((line) => /^\s*(\d+)\s+(\d+)\s+(\w{3} \w{3}\s+\d+ [\d:]+ \d{4})\s+(.*)$/.exec(line)).filter(Boolean)
+      .map((m) => ({ pid: Number(m[1]), ppid: Number(m[2]), started: Date.parse(m[3]), command: m[4] }));
+    const children = new Map();
+    for (const row of rows) children.set(row.ppid, [...(children.get(row.ppid) ?? []), row]);
+    mkdirSync(this.root, { recursive: true });
+    for (const { pane, rootPid } of panes) {
+      const live = new Map();
+      const walk = (pid) => { for (const child of children.get(pid) ?? []) { live.set(child.pid, child); walk(child.pid); } };
+      walk(rootPid);
+      // A shell is the command's carrier, not what ran: walked through, never recorded.
+      const recorded = new Map([...live].filter(([, row]) => !SHELLS.has(basename(row.command.split(/\s+/)[0] ?? '').replace(/^-/, ''))));
+      const before = this.seen.get(pane) ?? new Map();
+      const file = join(this.root, `${String(pane).replace(/[^\w.-]/g, '_')}.jsonl`);
+      const write = (record) => appendFileSync(file, `${JSON.stringify(record)}\n`);
+      for (const [pid, row] of recorded) if (!before.has(pid)) write({ event: 'start', pane, rootPid, pid, ppid: row.ppid, at: Number.isFinite(row.started) ? row.started : now, ...identityOf(row.command) });
+      for (const pid of before.keys()) if (!recorded.has(pid)) write({ event: 'end', pane, pid, at: now });
+      this.seen.set(pane, recorded);
+    }
+  }
+}

package/server/calendar-route.mjs

@@ -0,0 +1,39 @@
+// THE CALENDAR'S DOOR (company RFC 0023 decisions 18-19). A team member reads the calendar's objects and writes one: a
+// fixed event, a resource window its holder grants, the manager's call on a card, a forecast revision. Objects are
+// JSCalendar (an `Event` or a `Task`, with Volter's own fields under `volter:`); each write is a new revision of its
+// `uid`, and a read returns each object's latest revision unless `revisions=true`. Nothing here decides anything: the
+// calendar pack computes, people and agents act.
+const KINDS = new Set(['deadline', 'delivery', 'window', 'call', 'forecast', 'notice']);
+
+export async function calendarRoute({ api, req, res, auth, url, uid, requestId, parseJson, fail, send, result }) {
+  if (!['user', 'service'].includes(auth.kind)) fail(403, 'forbidden', 'credential cannot use the calendar');
+  if (req.method === 'GET' && uid === undefined) {
+    const kind = url.searchParams.get('kind'), all = url.searchParams.get('revisions') === 'true', since = Number(url.searchParams.get('since') ?? 0);
+    if (kind !== null && !KINDS.has(kind)) fail(400, 'invalid_request', 'kind is deadline, delivery, window, call, forecast or notice');
+    const rows = all
+      ? await api.store.query('SELECT uid,revision,kind,object_json,written_by,written_at,deleted FROM calendar_objects WHERE team_id=? AND (? IS NULL OR kind=?) AND written_at>=? ORDER BY written_at, uid, revision', [auth.team_id, kind, kind, since])
+      : await api.store.query('SELECT c.uid,c.revision,c.kind,c.object_json,c.written_by,c.written_at,c.deleted FROM calendar_objects c WHERE c.team_id=? AND (? IS NULL OR c.kind=?) AND c.revision=(SELECT MAX(revision) FROM calendar_objects l WHERE l.team_id=c.team_id AND l.uid=c.uid) AND c.deleted=0 ORDER BY c.written_at', [auth.team_id, kind, kind]);
+    return send(res, 200, result(api, auth, { items: rows.map(row => ({ uid: row.uid, revision: row.revision, kind: row.kind, written_by: row.written_by, written_at: row.written_at, deleted: row.deleted === 1, object: JSON.parse(row.object_json) })) }), requestId);
+  }
+  if (uid === undefined || !/^[\w.:-]{1,200}$/.test(uid)) fail(404, 'not_found', 'not found');
+  const latest = await api.store.one('SELECT MAX(revision) revision FROM calendar_objects WHERE team_id=? AND uid=?', [auth.team_id, uid]);
+  const now = api.clock.nowMs();
+  // The next revision is taken in the write itself, so two writers never share one.
+  const write = async (kind, text, deleted) => {
+    await api.store.exec('INSERT INTO calendar_objects(team_id,uid,revision,kind,object_json,written_by,written_at,deleted) SELECT ?,?,COALESCE(MAX(revision),0)+1,?,?,?,?,? FROM calendar_objects WHERE team_id=? AND uid=?', [auth.team_id, uid, kind, text, auth.principal_id, now, deleted, auth.team_id, uid]);
+    return Number((await api.store.one('SELECT MAX(revision) revision FROM calendar_objects WHERE team_id=? AND uid=?', [auth.team_id, uid])).revision);
+  };
+  if (req.method === 'DELETE') {
+    if (!latest?.revision) fail(404, 'not_found', 'not found');
+    const prior = await api.store.one('SELECT kind,object_json FROM calendar_objects WHERE team_id=? AND uid=? AND revision=?', [auth.team_id, uid, latest.revision]);
+    return send(res, 200, result(api, auth, { uid, revision: await write(prior.kind, prior.object_json, 1), deleted: true }), requestId);
+  }
+  if (req.method !== 'PUT') fail(405, 'method_not_allowed', 'method not allowed');
+  const body = await parseJson(req);
+  const object = body?.object, kind = body?.kind;
+  if (!KINDS.has(kind)) fail(400, 'invalid_request', 'kind is deadline, delivery, window, call, forecast or notice');
+  if (!object || typeof object !== 'object' || !['Event', 'Task'].includes(object['@type']) || object.uid !== uid) fail(400, 'invalid_request', 'object is a JSCalendar Event or Task whose uid is the path');
+  const text = JSON.stringify(object);
+  if (text.length > 64_000) fail(413, 'too_large', 'a calendar object is at most 64 KB');
+  send(res, 200, result(api, auth, { uid, revision: await write(kind, text, 0), kind, written_at: now }), requestId);
+}

package/server/evidence-route.mjs

@@ -0,0 +1,42 @@
+// A SESSION'S TELEMETRY, READ BACK (company RFC 0023 decision 17). Teams stores every OTLP record a source sends in
+// `evidence` and projects only prompts and responses into messages; the rest (each API request's duration, first-token
+// time and tokens, each tool result's name and duration) is what a telemetry-only session's trace is read from. This
+// door returns the session's log evidence, decoded per harness by the same decoder ingestion used, oldest first. Read
+// access is the session's own: whoever may read its descriptor reads its evidence.
+import { decodeLogEvidence } from './otlp/decoders/index.mjs';
+
+const attributes = (value) => value?.attributes ?? [];
+const value = (any) => any == null ? null : any.stringValue ?? any.intValue ?? any.doubleValue ?? any.boolValue ?? null;
+
+export async function sessionEvidenceRoute({ api, res, auth, sessionId, url, requestId, send, result }) {
+  const session = await api.store.authorizedSession({ teamId: auth.team_id, principalId: auth.principal_id, credentialId: auth.credential_id, ref: sessionId, now: api.clock.nowMs(), bound: auth.bound });
+  const after = Number(url.searchParams.get('after') ?? 0), limit = Math.min(Math.max(Number(url.searchParams.get('limit') ?? 2000), 1), 5000);
+  const origins = await api.store.query('SELECT source_id,harness,native_id FROM origins WHERE team_id=? AND session_id=? AND deleted_at IS NULL', [auth.team_id, session.id]);
+  const items = [];
+  let cursor = after, done = origins.length === 0;
+  // Every origin's rows in one pass, in the order they arrived: a source (one machine's OTLP stream) carries many
+  // sessions, so its rows are narrowed to this session's own id in the query and checked again after decoding. The scan
+  // goes on until a page holds `limit` of this session's records or nothing is left (`done`), never stopping at a page
+  // of other sessions' records.
+  const where = origins.map(() => "(source_id=? AND raw_json LIKE ? ESCAPE '\\')").join(' OR ');
+  const bound = origins.flatMap((origin) => [origin.source_id, `%${String(origin.native_id).replace(/[%_\\]/g, (c) => `\\${c}`)}%`]);
+  const byKey = new Map(origins.map((origin) => [origin.source_id, origin]));
+  while (!done && items.length < limit) {
+    const rows = await api.store.query(`SELECT rowid AS position,id,source_id,raw_json,received_at FROM evidence WHERE team_id=? AND signal='logs' AND rowid>? AND (${where}) ORDER BY rowid LIMIT ?`, [auth.team_id, cursor, ...bound, limit]);
+    if (rows.length < limit) done = true;
+    for (const row of rows) {
+      cursor = Math.max(cursor, Number(row.position));
+      const origin = byKey.get(row.source_id);
+      const raw = JSON.parse(row.raw_json);
+      if (!origin || raw.evidenceKind !== 'log_record') continue;
+      const decoded = decodeLogEvidence({ record: raw.record, resourceAttributes: attributes(raw.resource), scopeAttributes: attributes(raw.scope), receivedAt: raw.receivedAt });
+      // The decoder names a harness only on the events it projects (prompts, responses); the session's id is on each.
+      if (decoded?.native_session_id !== origin.native_id || (decoded.harness && decoded.harness !== origin.harness)) continue;
+      const fields = Object.fromEntries(attributes(raw.record).map((entry) => [entry.key, value(entry.value)]));
+      const nanos = raw.record?.timeUnixNano ?? raw.record?.observedTimeUnixNano;
+      items.push({ id: row.id, at: nanos ? Math.floor(Number(BigInt(nanos) / 1_000_000n)) : decoded.recorded_at ?? row.received_at, harness: origin.harness, event: fields['event.name'] ?? value(raw.record?.body) ?? null, fields });
+    }
+  }
+  items.sort((a, b) => a.at - b.at);
+  send(res, 200, result(api, auth, { session_id: session.id, items, next_after: cursor, done }), requestId);
+}

package/server/harness-routes.mjs

@@ -21,6 +21,8 @@ import { deliverSessionRoomNotice, sessionDeliveryResolution } from '@volter/tea
 import { renderSourceCollectorConfig } from './otlp/collector-config.mjs';
 import { attachmentActionRoute, createAttachment, liveGrantRoute, machineEffectRoute } from './effects.mjs';
 import { exportSessionRoute, operationRoute } from './exports.mjs';
+import { sessionEvidenceRoute } from './evidence-route.mjs';
+import { calendarRoute } from './calendar-route.mjs';
 import { attachmentStreamRoute, attachmentFramesRoute, closeMachineAttachmentRoute, detachAttachmentRoute } from './attachment-relay.mjs';
 import { continuationRoute, remoteContinuationArtifactRoute, remoteContinuationRoute } from './continuations.mjs';
 import { fail, parseJson, result, send, guardedMutation, requireRevision, checkRate, grants, syncRuleJson, authGuards } from '@volter/teams/server/http';
@@ -94,6 +96,8 @@ async function team({ api, req, res, auth, url, path, sub, requestId }) {
   if(req.method==='GET'&&(m=/^\/sessions\/([^/]+)$/.exec(sub))){await sessionDescriptor(api,res,auth,sessionRef(m[1]),requestId);return true;}
   if((req.method==='PATCH'||req.method==='DELETE')&&(m=/^\/sessions\/([^/]+)$/.exec(sub))){await mutateSession(api,req,res,auth,sessionRef(m[1]),requestId);return true;}
   if(req.method==='GET'&&(m=/^\/sessions\/([^/]+)\/messages$/.exec(sub))){await readSession(api,res,auth,sessionRef(m[1]),url,requestId);return true;}
+  if((m=/^\/calendar\/objects(?:\/([^/]+))?$/.exec(sub))){await calendarRoute({api,req,res,auth,url,uid:m[1]===undefined?undefined:decodeURIComponent(m[1]),requestId,parseJson,fail,send,result});return true;}
+  if(req.method==='GET'&&(m=/^\/sessions\/([^/]+)\/evidence$/.exec(sub))){await sessionEvidenceRoute({api,res,auth,sessionId:sessionRef(m[1]),url,requestId,send,result});return true;}
   if(req.method==='GET'&&(m=/^\/sessions\/([^/]+)\/artifacts\/([^/]+)$/.exec(sub))){await readArtifact(api,req,res,auth,sessionRef(m[1]),m[2],requestId);return true;}
   if(req.method==='POST'&&(m=/^\/sessions\/([^/]+)\/exports$/.exec(sub))){await exportSessionRoute({api,req,res,auth,sessionId:sessionRef(m[1]),requestId,parseJson,exact,fail,send,result,guardedMutation});return true;}
   if(req.method==='POST'&&(m=/^\/sessions\/([^/]+)\/continuations$/.exec(sub))){await continuationRoute({api,req,res,auth,sessionId:sessionRef(m[1]),requestId,parseJson,exact,fail,send,result,guardedMutation});return true;}