mixdog 1.2.5 → 1.3.0

package/src/runtime/shared/llm/usage-ledger-rollup.mjs

@@ -292,20 +292,27 @@ function mergeLegacyDays(db, { days, hourly, hourlyDay, fromDay, toDay }) {
  * Compaction requests run under their own provider session id but are
  * recorded under the source session, so this is the whole conversation
  * across compactions. The same route choice as a rollup applies: a gateway
- * summary never doubles a detail record.
+ * summary never doubles a detail record. `ownerIds` adds every session
+ * recorded as run for one of them (a Lead's agents, theirs in turn).
  */
-export function readSessionUsage(db, sessionIds) {
+export function readSessionUsage(db, sessionIds, ownerIds = []) {
   const total = empty();
   const rows = db
     .prepare(`
-            WITH mine AS (
+            WITH RECURSIVE owned(id) AS (
+                SELECT o.session FROM usage_session_owners o JOIN usage_sessions s ON s.id=o.owner
+                WHERE s.value IN (SELECT value FROM json_each(?))
+                UNION
+                SELECT o.session FROM usage_session_owners o JOIN owned ON o.owner=owned.id
+            ), mine AS (
                 SELECT day,route,COUNT(*) AS turns,SUM(input) AS input,SUM(output) AS output,
                     SUM(cache_read) AS cache_read,SUM(cache_write) AS cache_write,
                     SUM(cost_usd) AS cost_usd,SUM(duration_ms) AS duration_ms,
                     SUM(CASE WHEN duration_ms>0 AND output>0 THEN output ELSE 0 END) AS speed_output,
                     SUM(CASE WHEN duration_ms>0 AND output>0 THEN duration_ms ELSE 0 END) AS speed_ms
                 FROM usage_events WHERE session IN (
-                    SELECT id FROM usage_sessions WHERE value IN (SELECT value FROM json_each(?)))
+                    SELECT id FROM usage_sessions WHERE value IN (SELECT value FROM json_each(?))
+                    UNION SELECT id FROM owned)
                 GROUP BY day,route
             ), attributed AS (
                 SELECT printf('%04d-%02d-%02d',m.day/10000,(m.day/100)%100,m.day%100) AS day,
@@ -320,7 +327,7 @@ export function readSessionUsage(db, sessionIds) {
             )
             SELECT a.* FROM attributed a JOIN (${best}) b USING(day,provider,model,rank)
         `)
-    .all(JSON.stringify(sessionIds), '0000-01-01', '9999-12-31');
+    .all(JSON.stringify(ownerIds), JSON.stringify(sessionIds), '0000-01-01', '9999-12-31');
   let speedOutput = 0;
   let speedMs = 0;
   for (const row of rows) {

package/src/runtime/shared/llm/usage-ledger-worker.mjs

@@ -60,7 +60,7 @@ function recordBatch(ledger, rows) {
 const operations = {
   rollup: ({ path, options }) => read(path, (db) => rollupUsage(db, options)),
   rollupDelta: ({ path, options, known, now }) => read(path, (db) => rollupDelta(db, options, known, now)),
-  sessionUsage: ({ path, sessionIds }) => read(path, (db) => readSessionUsage(db, sessionIds)),
+  sessionUsage: ({ path, sessionIds, ownerIds }) => read(path, (db) => readSessionUsage(db, sessionIds, ownerIds)),
   record: ({ path, rows }) => write(path, (ledger) => recordBatch(ledger, rows)),
   recordQuota: ({ path, samples }) => write(path, (ledger) => ledger.recordQuota(samples)),
   quotaHistory: ({ path, options }) => read(path, (db) => readQuotaHistory(db, options)),

package/src/runtime/shared/llm/usage-ledger.mjs

@@ -78,6 +78,13 @@ const COMPACT_SCHEMA = `
     -- One session's lifetime totals (the /context footer) read that session's
     -- records only instead of scanning every record ever written.
     CREATE INDEX IF NOT EXISTS usage_events_session ON usage_events(session);
+    -- The session each session ran for (an agent's Lead), so a Lead's agents
+    -- stay countable after their own session records are gone.
+    CREATE TABLE IF NOT EXISTS usage_session_owners (
+        session INTEGER PRIMARY KEY REFERENCES usage_sessions(id),
+        owner INTEGER NOT NULL REFERENCES usage_sessions(id)
+    );
+    CREATE INDEX IF NOT EXISTS usage_session_owners_owner ON usage_session_owners(owner);
 `;
 
 // Preserve the old read surface. Only storage changes: every field, including
@@ -109,6 +116,7 @@ function compactEventWriter(db) {
   const insertSession = db.prepare('INSERT OR IGNORE INTO usage_sessions(value) VALUES (?)');
   const findSession = db.prepare('SELECT id FROM usage_sessions WHERE value=?');
   const insert = db.prepare('INSERT INTO usage_events VALUES (?,?,?,?,?,?,?,?,?,?,?)');
+  const insertOwner = db.prepare('INSERT OR IGNORE INTO usage_session_owners VALUES (?,?)');
   return (row) => {
     for (const key of ['id', 'provider', 'model', 'kind', 'source_type', 'cost_source', 'origin', 'session_id']) {
       if (row[key] == null) throw new Error(`Usage requires ${key}`);
@@ -133,6 +141,11 @@ function compactEventWriter(db) {
     const route = findRoute.get(signature).id;
     insertSession.run(String(row.session_id));
     const session = findSession.get(String(row.session_id)).id;
+    const owner = row.owner_session_id ? String(row.owner_session_id) : '';
+    if (owner && owner !== String(row.session_id)) {
+      insertSession.run(owner);
+      insertOwner.run(session, findSession.get(owner).id);
+    }
     insert.run(
       id,
       row.ts,
@@ -201,7 +214,6 @@ function migrateUsageLedger(db, path) {
 
 export function usageRouteKind(provider) {
   if (provider === 'mixdog-local') return 'local';
-  if (provider === 'opencode-go') return 'quota-api';
   return provider.endsWith('-oauth') ? 'oauth' : 'api';
 }
 
@@ -273,6 +285,7 @@ export function makeUsageRecord(args) {
     model,
     kind,
     sessionId: ['no-session', '(none)'].includes(args.sessionId) ? '' : text(args.sessionId),
+    ...(args.ownerSessionId ? { ownerSessionId: text(args.ownerSessionId) } : {}),
     sourceType: text(args.sourceType),
     input: priced.input,
     output: num(args.outputTokens),
@@ -453,6 +466,7 @@ export class UsageLedger {
           !this.insert({
             ...row,
             session_id: row.sessionId,
+            owner_session_id: row.ownerSessionId,
             source_type: row.sourceType,
             cache_read: row.cacheRead,
             cache_write: row.cacheWrite,
@@ -558,10 +572,11 @@ export class UsageLedger {
     return this.workerRequest('quotaWindows', { options });
   }
 
-  /** Every request one session made under any of its ids, compactions included, read on the ledger worker. */
-  sessionUsageAsync(sessionIds) {
-    if (this.path === ':memory:') return Promise.resolve().then(() => readSessionUsage(this.db, sessionIds));
-    return this.workerRequest('sessionUsage', { sessionIds });
+  /** Every request one session made under any of its ids, compactions included, read on the ledger worker.
+   *  `ownerIds` adds every session recorded as run for them, transitively. */
+  sessionUsageAsync(sessionIds, ownerIds = []) {
+    if (this.path === ':memory:') return Promise.resolve().then(() => readSessionUsage(this.db, sessionIds, ownerIds));
+    return this.workerRequest('sessionUsage', { sessionIds, ownerIds });
   }
 
   preserveLegacyDays(days) {

package/src/runtime/shared/memory-snapshot.mjs

@@ -22,8 +22,12 @@ const PERIODIC_ATTRIBUTION_FREE_BYTES = 2 * 1024 * 1024 * 1024;
 let periodicTimer = null;
 let lastPressureSnapshotAt = 0;
 
+// Opt-in diagnostics (MIXDOG_MEMORY_SNAPSHOT=1): every sample starts a
+// PowerShell process on Windows (two for a full snapshot, requested exactly
+// when the host is under memory pressure), from every process that loads
+// this module. A normal install never pays for that.
 function enabled() {
-  return process.env.MIXDOG_MEMORY_SNAPSHOT !== '0';
+  return process.env.MIXDOG_MEMORY_SNAPSHOT === '1';
 }
 
 function snapshotPaths() {

package/src/runtime/shared/notify-trace.mjs

@@ -1,4 +1,6 @@
-// Lightweight always-on completion-notification trace. The display path for
+// Opt-in (MIXDOG_NOTIFY_TRACE=1) completion-notification trace: off by
+// default, so a normal install writes no line per delivery decision (it kept
+// a multi-MB log growing in every data dir). The display path for
 // background completions is event-time only and has repeatedly failed silently
 // in the field (2026-08-17: bench shell output never rendered while the model
 // queue twin worked every time). One append-only line per decision point keeps
@@ -36,7 +38,12 @@ function tracePath() {
   return join(traceDir, 'notify-trace.log');
 }
 
+function notifyTraceEnabled() {
+  return process.env.MIXDOG_NOTIFY_TRACE === '1';
+}
+
 export function notifyTrace(stage, fields = {}) {
+  if (!notifyTraceEnabled()) return;
   try {
     const parts = [`[${new Date().toISOString()}]`, `pid=${process.pid}`, stage];
     for (const [key, value] of Object.entries(fields)) {

package/src/runtime/shared/plain-preview.d.mts

@@ -0,0 +1 @@
+export function plainPreviewText(text: unknown): string;

package/src/runtime/shared/plain-preview.mjs

@@ -0,0 +1,28 @@
+// A messenger preview line reads as plain text, as KakaoTalk shows it: the
+// markdown a reply was written in (bold, headings, list markers, quotes,
+// code fences and spans, links, images) is dropped, its words kept.
+
+/** `text` without markdown syntax, whitespace folded to single spaces. */
+export function plainPreviewText(text) {
+  // HTML comments never show in markdown (a greeting's suggestions ride one).
+  return String(text ?? '')
+    .replace(/<!--[\s\S]*?(?:-->|$)/g, ' ')
+    .replace(/^[ \t]*(`{3,}|~{3,})[^\n]*$/gm, ' ')
+    .replace(/!\[([^\]]*)\]\([^)]*\)/g, '$1')
+    .replace(/\[([^\]]+)\]\([^)]*\)/g, '$1')
+    .replace(/^[ \t]{0,3}#{1,6}[ \t]+/gm, '')
+    .replace(/^[ \t]*>[ \t]?/gm, '')
+    .replace(/^[ \t]*(?:[-*+]|\d+[.)])[ \t]+(?:\[[ xX]\][ \t]+)?/gm, '')
+    .replace(/^[ \t]*(?:[-*_][ \t]*){3,}$/gm, ' ')
+    .replace(/(\*\*|__)(?=\S)([\s\S]*?\S)\1/g, '$2')
+    .replace(/(^|[^\w*])\*(?=\S)([^*\n]*?\S)\*(?!\w)/g, '$1$2')
+    .replace(/(^|[^\w_])_(?=\S)([^_\n]*?\S)_(?!\w)/g, '$1$2')
+    .replace(/~~(?=\S)([\s\S]*?\S)~~/g, '$1')
+    .replace(/`+([^`\n]*)`+/g, '$1')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, PREVIEW_CAP);
+}
+
+/** A safety cap only: the row clamps the shown text to two lines. */
+const PREVIEW_CAP = 200;

package/src/runtime/shared/pristine-execution-contract.json

@@ -88,6 +88,11 @@
       "credentialFile": "antigravity-oauth.json",
       "credentialPathEnv": "ANTIGRAVITY_OAUTH_CREDENTIALS_PATH",
       "modelCatalogFile": "antigravity-oauth-models.json"
+    },
+    "opencode-go-oauth": {
+      "credentialFile": "opencode-go-oauth.json",
+      "credentialPathEnv": "OPENCODE_GO_OAUTH_CREDENTIALS_PATH",
+      "modelCatalogFile": "opencode-go-oauth-models.json"
     }
   },
   "apiKeyProviders": {
@@ -96,7 +101,6 @@
     "gemini": "GEMINI_API_KEY",
     "deepseek": "DEEPSEEK_API_KEY",
     "xai": "XAI_API_KEY",
-    "opencode-go": "OPENCODE_API_KEY",
     "openrouter": "OPENROUTER_API_KEY"
   },
   "personalStateCounters": [

package/src/runtime/shared/process-runner-worker.mjs

@@ -0,0 +1,7 @@
+// Worker-thread body for process-runner.mjs: helper children (process-table
+// enumeration, tree kills) are spawned on this thread, never on the host
+// event loop (run-child.mjs).
+import { runChild } from './run-child.mjs';
+import { serveWorkerRequests } from './worker-requests.mjs';
+
+serveWorkerRequests(runChild);

package/src/runtime/shared/process-runner.mjs

@@ -0,0 +1,38 @@
+// Run short helper processes from one shared worker thread, so their
+// synchronous native process creation never stalls the host event loop. A
+// daemon profile under heavy agent load measured single PowerShell spawns
+// blocking the daemon's loop for up to 7 s each. Separate from the git
+// runner's worker: a slow helper start never queues a git child behind it.
+import { SHARE_ENV } from 'node:worker_threads';
+import { runChild } from './run-child.mjs';
+import { createWorkerRequestClient } from './worker-requests.mjs';
+
+// Created on first use. A bundled copy of this module (the desktop service's
+// CommonJS bundle) has no module URL and no worker file beside it: there the
+// child is started on the calling thread, exactly as before.
+let requestProcess = null;
+function processClient() {
+  if (requestProcess !== null) return requestProcess;
+  try {
+    // SHARE_ENV: children inherit the live process environment, exactly as a
+    // spawn from this thread would.
+    requestProcess = createWorkerRequestClient(new URL('./process-runner-worker.mjs', import.meta.url), {
+      env: SHARE_ENV,
+    });
+  } catch {
+    requestProcess = false;
+  }
+  return requestProcess;
+}
+
+/**
+ * Resolves to { code, stdout, stderr } (a non-zero exit is the caller's to
+ * judge). Rejects with code ETIMEDOUT after timeoutMs (the child is killed;
+ * 0 sets no deadline),
+ * EMAXBUFFER once stdout+stderr exceed maxBytes, or the spawn error itself.
+ */
+export function runProcessOffThread(command, args, { cwd, input = '', env = null, timeoutMs, maxBytes }) {
+  const request = processClient();
+  const payload = { command, args, cwd, input, env, timeoutMs, maxBytes };
+  return request ? request(payload) : runChild(payload);
+}

package/src/runtime/shared/provider-accounts.mjs

@@ -13,6 +13,7 @@ export const ACCOUNT_PROVIDERS = Object.freeze([
   'mimo-oauth',
   'cursor-oauth',
   'antigravity-oauth',
+  'opencode-go-oauth',
 ]);
 const MAX_ACCOUNTS = 20;
 // `dataDir` defaults to this process's data dir; an isolated runtime passes
@@ -79,7 +80,7 @@ function normalizeLabels(pool) {
 // only; `limit` keeps the selected account until it reaches a limit and then
 // moves to the account with the most headroom; `headroom` starts every new
 // session on the account with the most headroom and keeps it for that session.
-export const ACCOUNT_POLICIES = Object.freeze(['manual', 'limit', 'headroom']);
+const ACCOUNT_POLICIES = Object.freeze(['manual', 'limit', 'headroom']);
 
 // `auto` predates `policy` and is still written beside it, so a build that
 // knows only `auto` reads the same switching on/off. Whenever the two

package/src/runtime/shared/provider-api-key.mjs

@@ -13,7 +13,6 @@ export const AGENT_PROVIDER_ENV = Object.freeze({
   gemini: 'GEMINI_API_KEY',
   deepseek: 'DEEPSEEK_API_KEY',
   xai: 'XAI_API_KEY',
-  'opencode-go': 'OPENCODE_API_KEY',
   openrouter: 'OPENROUTER_API_KEY',
 });
 

package/src/runtime/shared/read-row-numbers.mjs

@@ -88,7 +88,7 @@ export function readSourceWindow(text) {
       rows.push({ number, content: row[2] });
       continue;
     }
-    const metadata = /^\[lines (\d+)-(\d+) of (\d+)(?:; pass offset:\d+ to continue)?\]$/.exec(line);
+    const metadata = /^\[lines (\d+)-(\d+) of (\d+)(?:; offset:\d+ for more)?\]$/.exec(line);
     if (!metadata || footer) return null;
     footer = metadata;
     totalLines = Number(metadata[3]);

package/src/runtime/shared/resource-admission.mjs

@@ -1,4 +1,4 @@
-import { freemem, totalmem } from 'node:os';
+import { availableParallelism, freemem, totalmem } from 'node:os';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { requestMemoryPressureSnapshot } from './memory-snapshot.mjs';
 import { nonNegativeInt, positiveInt } from './numbers.mjs';
@@ -6,12 +6,20 @@ import { nonNegativeInt, positiveInt } from './numbers.mjs';
 const MB = 1024 * 1024;
 
 // The unified daemon queues bursts instead of starting an unbounded number of
-// agent/provider/shell tasks in one process. Environment overrides remain
-// available for larger hosts; memory thresholds are diagnostic only.
+// agent/provider tasks in one process. Shell commands start immediately: their
+// only bound is maxShells (64) live foreground commands, a runaway guard
+// rather than a CPU budget; the OS shares the cores. Environment overrides remain available; memory thresholds
+// are diagnostic only.
+// Agent leases are held only while an agent runs tools (they yield during
+// provider I/O) and their tool work is mostly child-process I/O, so two per
+// core keeps the host busy: 30-agent stress on 20 cores halved wall time at
+// 40 versus 8 with no event-loop or memory cost. 8 is the floor for small
+// hosts. maxHighLoad now bounds agents only and defaults to the same.
+const AGENT_LIMIT = Math.max(8, 2 * availableParallelism());
 const RESOURCE_ADMISSION_DEFAULTS = Object.freeze({
-  maxAgents: 8,
-  maxShells: 8,
-  maxHighLoad: 12,
+  maxAgents: AGENT_LIMIT,
+  maxShells: 64,
+  maxHighLoad: AGENT_LIMIT,
   maxQueue: 1024,
   minFreeMemoryMb: 0,
   maxRssMb: 0,
@@ -79,12 +87,15 @@ class ResourceAdmissionQueueFullError extends ResourcePressureError {
  * shells. Running work is never revoked: pressure only rejects a new request or
  * keeps a concurrency-blocked request in the bounded FIFO queue.
  *
- * A shell lease covers only the foreground part of a command: promotion to a
- * background job releases it (lib/shell-run-background/promote-job.mjs), so
- * background jobs count toward neither maxShells nor the maxHighLoad budget
- * shared with agents, and are not capped at all: they are mostly idle
- * servers/watchers at below-normal OS priority whose memory lives in their own
- * processes. Session/runtime close stops them (shell-jobs shutdownShellJobs).
+ * Shell leases are their own pool of maxShells: they are not part of the
+ * maxHighLoad budget, do not suspend the calling agent's lease, and never wait
+ * behind queued agent work, so a command starts at once unless maxShells
+ * commands are already running. A shell lease covers only the foreground part
+ * of a command: promotion to a background job releases it
+ * (lib/shell-run-background/promote-job.mjs), so background jobs are not
+ * capped at all: they are mostly idle servers/watchers at below-normal OS
+ * priority whose memory lives in their own processes. Session/runtime close
+ * stops them (shell-jobs shutdownShellJobs).
  */
 export class ResourceAdmissionController {
   constructor({ limits = {}, metrics = defaultMetrics, now = Date.now, env = process.env } = {}) {
@@ -98,6 +109,20 @@ export class ResourceAdmissionController {
     // Live leases for saturation diagnostics only (labels/ages in snapshot()).
     this.activeLeases = new Set();
     this.context = new AsyncLocalStorage();
+    // Admission waits by pool: first acquisition (agent/shell) and the
+    // reacquisition after a yielded provider call (restore). Shows whether
+    // the agent cap actually delays work.
+    this.waitStats = {};
+  }
+
+  _recordWait(pool, waitedMs) {
+    this.waitStats[pool] ??= { admitted: 0, waited: 0, totalWaitMs: 0, maxWaitMs: 0 };
+    const stats = this.waitStats[pool];
+    stats.admitted += 1;
+    if (waitedMs <= 0) return;
+    stats.waited += 1;
+    stats.totalWaitMs += waitedMs;
+    stats.maxWaitMs = Math.max(stats.maxWaitMs, waitedMs);
   }
 
   _recordMemoryPressure(kind) {
@@ -129,9 +154,14 @@ export class ResourceAdmissionController {
   }
 
   _canStart(kind) {
-    const total = this.active.agent + this.active.shell;
-    const kindLimit = kind === 'shell' ? this.limits.maxShells : this.limits.maxAgents;
-    return total < this.limits.maxHighLoad && this.active[kind] < kindLimit;
+    if (kind === 'shell') return this.active.shell < this.limits.maxShells;
+    return this.active.agent < this.limits.maxHighLoad && this.active.agent < this.limits.maxAgents;
+  }
+
+  // Shell and agent waiters never delay each other's new requests.
+  _queuedInPool(lane) {
+    const shell = lane === 'shell';
+    return this.queue.some((item) => (item.kind === 'shell') === shell);
   }
 
   _adjustOwnerCount(kind, ownerKey, delta) {
@@ -240,6 +270,7 @@ export class ResourceAdmissionController {
       },
     };
     this.activeLeases.add(lease);
+    this._recordWait(kind, lease.queuedMs);
     return lease;
   }
 
@@ -294,8 +325,9 @@ export class ResourceAdmissionController {
     this._recordMemoryPressure(lane);
     const ambientParent = this.context.getStore();
     const detachedDependency = dependency === 'detached' && ambientParent?.controller === this;
-    const parent = detachedDependency ? null : this._suspendParent(ambientParent);
-    if (detachedDependency && (!this._canStart(lane) || this.queue.length > 0)) {
+    // A shell runs beside its agent instead of taking the agent's slot.
+    const parent = detachedDependency || lane === 'shell' ? null : this._suspendParent(ambientParent);
+    if (detachedDependency && (!this._canStart(lane) || this._queuedInPool(lane))) {
       const error = new ResourcePressureError(
         `detached nested ${lane} work has no admission capacity; retry after running work completes`,
         { kind: lane }
@@ -303,7 +335,7 @@ export class ResourceAdmissionController {
       error.code = 'ERESOURCEDEPENDENCY';
       return Promise.reject(error);
     }
-    if (this._canStart(lane) && this.queue.length === 0) {
+    if (this._canStart(lane) && !this._queuedInPool(lane)) {
       const lease = this._lease(lane, null, parent, owner, taskPriority);
       lease.label = label;
       lease.signal = signal;
@@ -439,6 +471,7 @@ export class ResourceAdmissionController {
       if (item.restore) {
         item.parent.restorePending = null;
         item.parent.counted = true;
+        this._recordWait(`${item.kind}Restore`, Math.max(0, this.now() - item.queuedAt));
         this.active[item.kind] += 1;
         this._adjustOwnerCount(item.kind, item.ownerKey, 1);
         item.resolve();
@@ -461,6 +494,15 @@ export class ResourceAdmissionController {
         shell: this.activeByOwner.shell.size,
       },
       queued: this.queue.length,
+      waitStats: Object.fromEntries(
+        Object.entries(this.waitStats).map(([pool, stats]) => [
+          pool,
+          {
+            ...stats,
+            averageQueuedMs: stats.waited > 0 ? Math.round(stats.totalWaitMs / stats.waited) : 0,
+          },
+        ])
+      ),
       limits: {
         ...this.limits,
         maxAgents: wireLimit(this.limits.maxAgents),

package/src/runtime/shared/routine-limits.d.mts

@@ -0,0 +1,11 @@
+export declare const ROUTINE_LIMITS: Readonly<{
+  backoffBaseMs: number;
+  pauseAfterFailures: number;
+  homeQueueLimit: number;
+}>;
+
+export declare function routineBackoffRemaining(
+  state: { consecutiveFailures?: unknown; lastFailedAt?: unknown } | null | undefined,
+  now?: number,
+  limits?: typeof ROUTINE_LIMITS
+): number;

package/src/runtime/shared/routine-limits.mjs

@@ -0,0 +1,21 @@
+// Safeguards of owned routines (schedules and webhook endpoints, see
+// session-runtime/owned-automation-run.mjs): after a failure the next
+// unattended fire waits `backoffBaseMs * 2^(n-1)` (n consecutive failures)
+// and the routine switches itself off at `pauseAfterFailures`; a home thread
+// holds at most `homeQueueLimit` routine turns waiting (and as many queued
+// rows posted from outside its turns). Runs themselves are
+// unlimited: no concurrency cap and no deadline.
+export const ROUTINE_LIMITS = Object.freeze({
+  backoffBaseMs: 60_000,
+  pauseAfterFailures: 5,
+  homeQueueLimit: 200,
+});
+
+/** How long (ms) an unattended fire still waits after the routine's
+ *  `consecutiveFailures`, the latest at `lastFailedAt`; 0 when it may run. */
+export function routineBackoffRemaining(state, now = Date.now(), limits = ROUTINE_LIMITS) {
+  const failures = Number(state?.consecutiveFailures) || 0;
+  const at = state?.lastFailedAt ? new Date(state.lastFailedAt).getTime() : Number.NaN;
+  if (failures < 1 || !Number.isFinite(at)) return 0;
+  return Math.max(0, at + limits.backoffBaseMs * 2 ** (failures - 1) - now);
+}

package/src/runtime/shared/routine-trigger.d.mts

@@ -0,0 +1,10 @@
+export interface RoutineTrigger {
+  kind: 'schedule' | 'webhook';
+  name: string;
+  event?: string;
+}
+
+export declare function routineTriggerHeader(input: { kind: string; name: string; project?: string }): string;
+export declare function stripRoutineTriggerHeader(text: unknown): string;
+export declare function normalizeRoutineTrigger(value: unknown): RoutineTrigger | null;
+export declare function routineTriggerField(value: unknown): { routineTrigger?: RoutineTrigger };

package/src/runtime/shared/routine-trigger.mjs

@@ -0,0 +1,44 @@
+// A routine fire delivered into its bot's home thread as a turn
+// (session-runtime/routine-home-turn.mjs): the model-visible header line that
+// opens the turn's prompt, and the `routineTrigger` marker its user row
+// carries (live, persisted in meta.transcript, restored) so a chat paints it
+// as a routine marker instead of a user bubble.
+
+const HEADER_PREFIX = '[Routine trigger]';
+const KINDS = new Set(['schedule', 'webhook']);
+
+/** The first line of a routine turn's prompt: which routine fired and how to
+ *  treat the turn. Only the turn's content carries it, never the system
+ *  prompt, so the thread's prompt cache is untouched. */
+export function routineTriggerHeader({ kind, name, project = '' }) {
+  const what = kind === 'webhook' ? 'webhook' : 'schedule';
+  return [
+    `${HEADER_PREFIX} Your ${what} "${String(name)}" fired.`,
+    'Carry out its instructions below now, yourself or by delegating; nobody is watching this turn, so approvals wait for the user.',
+    'Reply in this chat with the result.',
+    ...(project ? [`Project folder: ${project}`] : []),
+  ].join(' ');
+}
+
+/** `text` without the header line a routine turn opens with. */
+export function stripRoutineTriggerHeader(text) {
+  const value = String(text ?? '');
+  if (!value.startsWith(HEADER_PREFIX)) return value;
+  const end = value.indexOf('\n');
+  return end < 0 ? '' : value.slice(end + 1).replace(/^\n+/, '');
+}
+
+/** A well-formed `{ kind, name, event? }` marker, or null. */
+export function normalizeRoutineTrigger(value) {
+  if (!value || typeof value !== 'object') return null;
+  const name = typeof value.name === 'string' ? value.name.trim().slice(0, 200) : '';
+  if (!name || !KINDS.has(value.kind)) return null;
+  const event = typeof value.event === 'string' ? value.event.trim().slice(0, 200) : '';
+  return { kind: value.kind, name, ...(event ? { event } : {}) };
+}
+
+/** The `routineTrigger` field of a transcript row (absent when none). */
+export function routineTriggerField(value) {
+  const trigger = normalizeRoutineTrigger(value?.routineTrigger);
+  return trigger ? { routineTrigger: trigger } : {};
+}

package/src/runtime/shared/run-child.mjs

@@ -0,0 +1,84 @@
+// One child process run to completion, its output collected — the body of
+// the off-thread runners (git-runner-worker.mjs, process-runner-worker.mjs).
+// Starting a child process is a synchronous native call (CreateProcess on
+// Windows, amplified by on-access scanning and seconds long under load), so
+// those workers spawn here instead of on the host event loop.
+// Resolves to { code, stdout, stderr }; rejects with code ETIMEDOUT after
+// timeoutMs (the child is killed), EMAXBUFFER once stdout+stderr exceed
+// maxBytes, or the spawn error itself.
+import { spawn } from 'node:child_process';
+
+export function runChild({ command, args, cwd, input, env, timeoutMs, maxBytes, stdoutEncoding = 'utf8' }) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const hasInput = (typeof input === 'string' || ArrayBuffer.isView(input)) && input.length > 0;
+    const child = spawn(command, args, {
+      cwd,
+      ...(env ? { env } : {}),
+      windowsHide: true,
+      stdio: [hasInput ? 'pipe' : 'ignore', 'pipe', 'pipe'],
+    });
+    const stdout = [];
+    const stderr = [];
+    let outputBytes = 0;
+    let stdinError = null;
+    let settled = false;
+    const finish = (error, result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (error) rejectPromise(error);
+      else resolvePromise(result);
+    };
+    // timeoutMs 0: no deadline (the caller's own work bounds the child).
+    const timer =
+      timeoutMs > 0
+        ? setTimeout(() => {
+            const error = new Error(`${command} ${args.join(' ')} timed out after ${timeoutMs}ms`);
+            error.code = 'ETIMEDOUT';
+            try {
+              child.kill();
+            } catch {}
+            finish(error);
+          }, timeoutMs)
+        : null;
+    const collect = (chunks, chunk) => {
+      const next = Buffer.from(chunk);
+      outputBytes += next.length;
+      if (outputBytes > maxBytes) {
+        const error = new Error(`${command} ${args.join(' ')} exceeded ${maxBytes} output bytes`);
+        error.code = 'EMAXBUFFER';
+        try {
+          child.kill();
+        } catch {}
+        finish(error);
+        return;
+      }
+      chunks.push(next);
+    };
+    child.stdout.on('data', (chunk) => collect(stdout, chunk));
+    child.stderr.on('data', (chunk) => collect(stderr, chunk));
+    child.once('error', (error) => finish(error));
+    child.once('close', (code) => {
+      const result = {
+        code: Number(code ?? 1),
+        // 'base64' keeps non-UTF-8 bytes (a replayable patch) intact across the thread hop.
+        stdout: Buffer.concat(stdout).toString(stdoutEncoding === 'base64' ? 'base64' : 'utf8'),
+        stderr: Buffer.concat(stderr).toString('utf8'),
+      };
+      // A failed stdin write only matters when the child otherwise reported success.
+      if (stdinError && result.code === 0) {
+        finish(stdinError);
+        return;
+      }
+      finish(null, result);
+    });
+    if (child.stdin) {
+      // A short-lived child can close before stdin is flushed. Keep that
+      // transport race inside this promise instead of an unhandled EPIPE.
+      child.stdin.on('error', (error) => {
+        stdinError = error;
+      });
+      child.stdin.end(input);
+    }
+  });
+}

package/src/runtime/shared/schedule-model-ref.mjs

@@ -1,13 +1,12 @@
-// schedule.model wire format shared by the channels-worker scheduler and the
-// engine-side run-now dispatch: either a config.presets id/name (legacy) or a
-// direct "provider/model[@effort][+fast][+noauto][?parameter=value]" route string
-// written by the desktop schedule editor (`+noauto`: Auto effort off for the
-// route; absent means on). Slash-form values become direct route
-// objects, which agent-dispatch consumes without a presets lookup.
-// The optional route fields an automation run carries, from a preset, a
-// maintenance slot or a parsed route ref. One shape so schedule and webhook
-// runs cannot drift when a field is added. modelParameters is copied so a
-// stored preset can never be mutated through the run.
+// Model route-ref wire format (task sessions, provider model caches): either a
+// config.presets id/name (legacy) or a direct
+// "provider/model[@effort][+fast][+noauto][?parameter=value]" route string
+// (`+noauto`: Auto effort off for the route; absent means on). Slash-form
+// values become direct route objects, which agent-dispatch consumes without a
+// presets lookup.
+// The optional route fields a run carries, from a preset, a maintenance slot
+// or a parsed route ref. modelParameters is copied so a stored preset can
+// never be mutated through the run.
 export function modelRouteFields(slot = {}) {
   return {
     provider: slot.provider,