@openchambery/web 2.1.7-beta.9 → 2.1.8-beta.2

package/server/lib/config-sync/routes.js

@@ -2,7 +2,7 @@ import { createConfigSyncReceiver } from './receiver.js';
 
 /**
  * Register HTTP config-sync receive/download routes for direct (and later relay) hosts.
- * Auth is the global `/api` UI/client-token gate. Selected kinds (including auth)
+ * Auth is the global `/api` UI/client-token gate. Selected kinds (including credentials)
  * sync when present in the plan — no extra credential grant checks.
  *
  * @param {import('express').Express} app
@@ -70,11 +70,32 @@ export const registerConfigSyncRoutes = (app, deps = {}) => {
     }
   });
 
+  app.get('/api/openchamber/config-sync/magpie/inventory', async (_req, res) => {
+    try { res.json({ magpie: await receiver.magpieInventory() }); }
+    catch (error) { sendError(res, error); }
+  });
+
+  app.put('/api/openchamber/config-sync/magpie', async (req, res) => {
+    try { res.json(await receiver.importMagpie(req)); }
+    catch (error) { sendError(res, error); }
+  });
+
+  app.get('/api/openchamber/config-sync/credentials/inventory', async (_req, res) => {
+    try { res.json({ providerCredentials: await receiver.credentialInventory() }); }
+    catch (error) { sendError(res, error); }
+  });
+
+  app.put('/api/openchamber/config-sync/credentials', async (req, res) => {
+    try { res.json(await receiver.importCredentials(req)); }
+    catch (error) { sendError(res, error); }
+  });
+
   app.get('/api/openchamber/config-sync/download/:kind', async (req, res) => {
     try {
       const kind = String(req.params.kind || '').trim();
       const buffer = await receiver.download({ kind });
-      res.setHeader('Content-Type', 'application/gzip');
+      res.setHeader('Content-Type', kind === 'credentials' || kind === 'magpie' ? 'application/octet-stream' : 'application/gzip');
+      res.setHeader('Cache-Control', 'no-store');
       res.setHeader('Content-Length', String(buffer.byteLength));
       res.send(buffer);
     } catch (error) {

package/server/lib/config-sync/routes.test.js

@@ -27,7 +27,7 @@ afterEach(async () => {
   }
 });
 
-const createApp = async () => {
+const createApp = async (credentials, magpie) => {
   const home = await makeTempDir();
   const configDir = path.join(home, '.config', 'opencode');
   await fsp.mkdir(configDir, { recursive: true });
@@ -36,6 +36,8 @@ const createApp = async () => {
 
   const receiver = createConfigSyncReceiver({
     homedir: () => home,
+    ...(credentials ? { credentials } : {}),
+    ...(magpie ? { magpie } : {}),
   });
 
   const app = express();
@@ -44,6 +46,62 @@ const createApp = async () => {
 };
 
 describe('config-sync HTTP routes', () => {
+  it('discovers Magpie without import and requires a selected transfer before finalizing', async () => {
+    const payload = Buffer.from('fixture-magpie-payload');
+    const received = [];
+    const { app } = await createApp(undefined, {
+      inventory: async () => ({ available: true, installed: false }),
+      download: async () => payload,
+      import: async (buffer) => { received.push(buffer); return { ok: true }; },
+    });
+    const probe = await request(app).post('/api/openchamber/config-sync/probe').send({ plan: {} });
+    expect(probe.body.inventory.magpie).toEqual({ available: true, installed: false });
+    expect(received).toEqual([]);
+    const download = await request(app).get('/api/openchamber/config-sync/download/magpie').expect(200);
+    expect(download.headers['cache-control']).toBe('no-store');
+    expect(download.body).toEqual(payload);
+    await request(app).put('/api/openchamber/config-sync/magpie')
+      .set('Content-Type', 'application/octet-stream').send(payload).expect(200);
+    const plan = { files: [], directories: [], deletes: [], magpie: { bytes: 0 } };
+    await request(app).post('/api/openchamber/config-sync/prepare').send({ plan, syncRunId: 'magpie-run' }).expect(200);
+    await request(app).post('/api/openchamber/config-sync/finalize').send({ syncRunId: 'magpie-run' }).expect(500);
+    await request(app).put('/api/openchamber/config-sync/put/magpie?syncRunId=magpie-run')
+      .set('Content-Type', 'application/octet-stream').send(payload).expect(200);
+    await request(app).post('/api/openchamber/config-sync/finalize').send({ syncRunId: 'magpie-run' }).expect(200);
+    expect(received).toEqual([payload, payload]);
+  });
+
+  it('transfers credential bytes through HTTP without putting values in inventory or filesystem backups', async () => {
+    const payload = Buffer.from(JSON.stringify({ format: 'opencode-credentials-v1', entries: [{ fixture: 'private-value' }] }));
+    const received = [];
+    const { app, home } = await createApp({
+      inventory: async () => ({ bytes: payload.length }),
+      download: async () => payload,
+      import: async (buffer) => { received.push(buffer); return { ok: true }; },
+    });
+    const plan = { direction: 'push', files: [], directories: [], deletes: [], providerCredentials: { bytes: payload.length } };
+    const inventory = await request(app).get('/api/openchamber/config-sync/credentials/inventory');
+    expect(inventory.body).toEqual({ providerCredentials: { bytes: payload.length } });
+    const download = await request(app).get('/api/openchamber/config-sync/download/credentials');
+    expect(download.headers['cache-control']).toBe('no-store');
+    expect(download.body).toEqual(payload);
+    await request(app).post('/api/openchamber/config-sync/prepare').send({ plan, syncRunId: 'credential-run' }).expect(200);
+    await request(app).post('/api/openchamber/config-sync/finalize').send({ syncRunId: 'credential-run' }).expect(500);
+    await request(app).put('/api/openchamber/config-sync/put/credentials?syncRunId=credential-run')
+      .set('Content-Type', 'application/octet-stream').send(download.body).expect(200);
+    await request(app).post('/api/openchamber/config-sync/finalize').send({ syncRunId: 'credential-run' }).expect(200);
+    await request(app).put('/api/openchamber/config-sync/credentials')
+      .set('Content-Type', 'application/octet-stream').send(payload).expect(200);
+    expect(received).toEqual([payload, payload]);
+    await expect(fsp.stat(path.join(home, '.openchamber.sync-backup-auth'))).rejects.toThrow();
+    await expect(fsp.stat(path.join(home, '.local', 'share', 'opencode', 'auth.json'))).rejects.toThrow();
+    await request(app).post('/api/openchamber/config-sync/prepare')
+      .send({ plan: { ...plan, providerCredentials: null }, syncRunId: 'unselected' }).expect(200);
+    await request(app).put('/api/openchamber/config-sync/put/credentials?syncRunId=unselected')
+      .set('Content-Type', 'application/octet-stream').send(payload).expect(500);
+    expect(received).toHaveLength(2);
+  });
+
   it.each(['http-config', 'http-agents', 'local-pack', 'ssh-config', 'ssh-agents'])(
     '%s archive excludes inventory-skipped files, including inside followed symlinks',
     async (transport) => {
@@ -91,7 +149,7 @@ describe('config-sync HTTP routes', () => {
       directories: [],
       deletes: ['config.json', 'opencode.json'],
       agentsRoot: null,
-      authFile: null,
+      providerCredentials: null,
       totalBytes: 3,
     };
 
@@ -124,7 +182,7 @@ describe('config-sync HTTP routes', () => {
       directories: [],
       deletes: [],
       agentsRoot: null,
-      authFile: null,
+      providerCredentials: null,
       totalBytes: 2,
     };
     const first = await request(app).post('/api/openchamber/config-sync/prepare').send({ plan, syncRunId: 'run-a' });
@@ -143,7 +201,7 @@ describe('config-sync HTTP routes', () => {
       directories: [],
       deletes: [],
       agentsRoot: null,
-      authFile: null,
+      providerCredentials: null,
       totalBytes: 0,
     };
     await request(app).post('/api/openchamber/config-sync/prepare').send({ plan, syncRunId: 'run-stream' });
@@ -151,7 +209,7 @@ describe('config-sync HTTP routes', () => {
     // Tiny invalid tar still proves chunk aggregation reached extract.
     await expect(receiver.put({
       syncRunId: 'run-stream',
-      kind: 'auth',
+      kind: 'config',
       stream: Readable.from([Buffer.from('aa'), Buffer.from('bb')]),
     })).rejects.toThrow(/tar|failed|Local tar extract/i);
 

package/server/lib/config-sync/scripts.js

@@ -3,8 +3,6 @@ import path from 'node:path';
 import {
   OPENCODE_AGENTS_ROOT_PROBE_MARKER,
   OPENCODE_AGENTS_SYNC_BACKUP_DIR,
-  OPENCODE_AUTH_FILE_PROBE_MARKER,
-  OPENCODE_AUTH_SYNC_BACKUP_DIR,
   OPENCODE_CONFIG_SYNC_ALLOWLIST,
   OPENCODE_CONFIG_SYNC_BACKUP_DIR,
   OPENCODE_CONFIG_SYNC_BACKUP_GENERATIONS,
@@ -60,7 +58,7 @@ const generationalBackupSetupLines = ({ backupVar, runVar, quotedRunId, generati
  * {@link OPENCODE_CONFIG_SYNC_BACKUP_GENERATIONS} are pruned; prepare no longer
  * `rm -rf`s the entire backup root at start.
  *
- * @param {{ files: { path: string }[], directories: { path: string }[], deletes: string[], agentsRoot?: { fileCount: number, bytes: number } | null, authFile?: { bytes: number } | null }} plan
+ * @param {{ files: { path: string }[], directories: { path: string }[], deletes: string[], agentsRoot?: { fileCount: number, bytes: number } | null }} plan
  * @param {{ syncRunId: string, generations?: number }} options
  * @returns {string}
  */
@@ -134,19 +132,6 @@ export const buildRemoteSyncPrepareScript = (plan, options) => {
     lines.push('rm -rf -- "$HOME/.agents"');
   }
 
-  if (plan?.authFile) {
-    lines.push(`AUTH_BK="$HOME/${OPENCODE_AUTH_SYNC_BACKUP_DIR}"`);
-    lines.push(...generationalBackupSetupLines({
-      backupVar: 'AUTH_BK',
-      runVar: 'AUTH_RUN_BK',
-      quotedRunId,
-      generations,
-    }));
-    lines.push('if [ -e "$HOME/.local/share/opencode/auth.json" ]; then');
-    lines.push('  cp -a "$HOME/.local/share/opencode/auth.json" "$AUTH_RUN_BK/auth.json"');
-    lines.push('fi');
-  }
-
   lines.push("printf 'SYNC_READY\\n'");
   return lines.join('\n');
 };
@@ -164,9 +149,6 @@ export const buildRemoteSyncProbeScript = (uniqueProbePaths) => {
   lines.push(
     `[ -e "$HOME/.agents" ] && printf '%s\\n' ${shellQuote(OPENCODE_AGENTS_ROOT_PROBE_MARKER)}`,
   );
-  lines.push(
-    `[ -e "$HOME/.local/share/opencode/auth.json" ] && printf '%s\\n' ${shellQuote(OPENCODE_AUTH_FILE_PROBE_MARKER)}`,
-  );
   lines.push('exit 0');
   return lines.join('\n');
 };
@@ -228,14 +210,9 @@ export const buildRemoteSyncInventoryScript = () => {
   lines.push("  ABYTES=\"$(find \"$HOME/.agents\" -type f ! -path '*/node_modules/*' ! -path '*/.venv-asc/*' ! -name '*.backup' -exec wc -c {} + 2>/dev/null | awk 'END{print $1+0}')\"");
   lines.push('  AGENTS="{\\"fileCount\\":$ACOUNT,\\"bytes\\":$ABYTES}"');
   lines.push('fi');
-  lines.push('AUTH="null"');
-  lines.push('if [ -f "$HOME/.local/share/opencode/auth.json" ]; then');
-  lines.push('  AUBYTES="$(wc -c < "$HOME/.local/share/opencode/auth.json" | tr -d \' \')"');
-  lines.push('  AUTH="{\\"bytes\\":$AUBYTES}"');
-  lines.push('fi');
   lines.push('FILES="${FILES%,}"');
   lines.push('DIRS="${DIRS%,}"');
-  lines.push('printf \'SYNC_INVENTORY={"files":[%s],"directories":[%s],"agentsRoot":%s,"authFile":%s}\\n\' "$FILES" "$DIRS" "$AGENTS" "$AUTH"');
+  lines.push('printf \'SYNC_INVENTORY={"files":[%s],"directories":[%s],"agentsRoot":%s}\\n\' "$FILES" "$DIRS" "$AGENTS"');
   lines.push('exit 0');
   return lines.join('\n');
 };
@@ -265,9 +242,4 @@ export const buildRemoteAgentsTarScript = () => [
   `cd "$HOME" && tar ${OPENCODE_CONFIG_SYNC_TAR_EXCLUDES.map(shellQuote).join(' ')} -h -czf - .agents`,
 ].join('\n');
 
-export const buildRemoteAuthTarScript = () => [
-  'set -e',
-  'cd "$HOME/.local/share/opencode" && tar -h -czf - auth.json',
-].join('\n');
-
 export { shellQuote };

package/server/lib/config-sync/selections.js

@@ -6,13 +6,14 @@ import { OPENCODE_CONFIG_SYNC_ALLOWLIST } from './constants.js';
  *   singleFiles: boolean[],
  *   directories: boolean[],
  *   agentsRoot: boolean,
- *   authFile: boolean,
+ *   providerCredentials: boolean,
+ *   magpie?: boolean,
  * }} SyncSelections
  */
 
 /**
- * Default: everything selected except authFile (credentials stay opt-in).
- * @param {{ includeAuthFile?: boolean }} [options]
+ * Default: everything selected except providerCredentials (credentials stay opt-in).
+ * @param {{ includeProviderCredentials?: boolean }} [options]
  * @returns {SyncSelections}
  */
 export const buildDefaultSyncSelections = (options = {}) => ({
@@ -20,13 +21,14 @@ export const buildDefaultSyncSelections = (options = {}) => ({
   singleFiles: OPENCODE_CONFIG_SYNC_ALLOWLIST.singleFiles.map(() => true),
   directories: OPENCODE_CONFIG_SYNC_ALLOWLIST.directories.map(() => true),
   agentsRoot: true,
-  authFile: options.includeAuthFile === true,
+  providerCredentials: options.includeProviderCredentials === true,
+  magpie: false,
 });
 
 /**
  * Normalize a partial selections object against the allowlist shape.
  * @param {Partial<SyncSelections> | null | undefined} raw
- * @param {{ includeAuthFile?: boolean }} [options]
+ * @param {{ includeProviderCredentials?: boolean }} [options]
  * @returns {SyncSelections}
  */
 export const normalizeSyncSelections = (raw, options = {}) => {
@@ -48,7 +50,8 @@ export const normalizeSyncSelections = (raw, options = {}) => {
     singleFiles,
     directories,
     agentsRoot: raw.agentsRoot !== false,
-    authFile: raw.authFile === true,
+    providerCredentials: raw.providerCredentials === true,
+    magpie: raw.magpie === true,
   };
 };
 
@@ -59,7 +62,7 @@ export const normalizeSyncSelections = (raw, options = {}) => {
  * @param {SyncSelections} selections
  */
 export const filterPlanBySelections = (plan, selections) => {
-  const selected = normalizeSyncSelections(selections, { includeAuthFile: selections?.authFile === true });
+  const selected = normalizeSyncSelections(selections, { includeProviderCredentials: selections?.providerCredentials === true });
   const selectedFileNames = new Set();
   const selectedDeleteNames = new Set();
 
@@ -91,13 +94,13 @@ export const filterPlanBySelections = (plan, selections) => {
   const directories = (Array.isArray(plan?.directories) ? plan.directories : []).filter((entry) => selectedDirNames.has(entry.path));
   const deletes = (Array.isArray(plan?.deletes) ? plan.deletes : []).filter((name) => selectedDeleteNames.has(name) || selectedDirLegacy.has(name));
   const agentsRoot = selected.agentsRoot ? (plan?.agentsRoot ?? null) : null;
-  const authFile = selected.authFile ? (plan?.authFile ?? null) : null;
+  const providerCredentials = selected.providerCredentials ? (plan?.providerCredentials ?? null) : null;
 
   let totalBytes = 0;
   for (const entry of files) totalBytes += Number(entry.bytes) || 0;
   for (const entry of directories) totalBytes += Number(entry.bytes) || 0;
   if (agentsRoot) totalBytes += Number(agentsRoot.bytes) || 0;
-  if (authFile) totalBytes += Number(authFile.bytes) || 0;
+  if (providerCredentials) totalBytes += Number(providerCredentials.bytes) || 0;
 
   return {
     ...plan,
@@ -105,7 +108,8 @@ export const filterPlanBySelections = (plan, selections) => {
     directories,
     deletes,
     agentsRoot,
-    authFile,
+    providerCredentials,
+    magpie: selected.magpie && plan?.magpieAvailable ? { bytes: 0 } : null,
     totalBytes,
     selections: selected,
   };

package/server/lib/notifications/DOCUMENTATION.md

@@ -13,6 +13,11 @@ Android notification-only subscriptions send the App locale in `Accept-Language`
 - `packages/web/server/lib/notifications/apns-runtime.js`: native iOS APNs device-token persistence + delivery, plus a separate Live Activity token store and `end` send path. Two modes: **relay** (default — sign + POST tokens + generic text to the isolated Push Relay in `packages/relay-server/src/push/`, which holds the project APNs key) and **direct** (fallback — sign ES256 JWT with Node crypto + HTTP/2, when `OPENCHAMBER_PUSH_RELAY_DISABLED=true`). Unless `OPENCHAMBER_PUSH_RELAY_URL` is set, the Host maps the effective Relay `wss`/`ws` URL to the same host as `https`/`http` `/v1/push/send`. Before each relay send, the runtime checks an in-memory registration success cache (keyed by current register URL + token + platform) and only POSTs `/v1/push/register-token` for cache misses; only successfully bound tokens are sent. Switching Relay/Push URL clears that cache so persisted tokens re-bind to the new origin on the next send or `reRegisterAllTokens()`. Each server has an auto-generated ECDSA P-256 keypair (`getOrCreateRelayKeypair`, persisted in settings); it binds tokens on the relay (`/v1/push/register-token`) and signs every relay request, so the relay only delivers to tokens bound to that server. APNs is the iOS app's sole notification channel (no local notifications) and is NOT gated on UI visibility — iOS suppresses the foreground banner instead. APNs push carries only generic text (scenario title + session name) — see `APNS.md`. Android uses the separate native notification stream described above. Live Activity tokens are persisted beside alert tokens in the same file (`version` 2, `liveActivityTokensBySession`) without mixing the two token types; v1 files remain readable. Live Activity relay bind/send uses `/v1/push/register-live-activity-token`, `/v1/push/unregister-live-activity-token`, and `/v1/push/live-activity`.
 - `packages/web/server/lib/notifications/emitter-runtime.js`: desktop/stdout + UI SSE notification emission runtime.
 - `packages/web/server/lib/notifications/runtime.js`: trigger runtime for OpenCode event-driven notification fanout.
+- Assistant-owned scheduled results first enter the assistant's read-only result
+  review. They bypass generic scheduled-task fanout: a spoken review uses the
+  existing contact notification path, while an explicit silent review sends
+  nothing. Unowned tasks retain `notifyOnScheduledTasks` and the manual-run gate.
+  Result handoff/recovery belongs to `scheduled-tasks`, not this notification module.
 - `family-completion-gate.js` (with a TypeScript declaration): dependency-free, runtime-local completion barrier shared by Host fanout and the VS Code webview. The Host supplies authoritative HTTP reads; VS Code supplies official SDK reads.
 - `packages/web/server/lib/notifications/live-activity-refresh-runtime.js`: periodic Live Activity snapshot refresh (default 30s, `OPENCHAMBER_LIVE_ACTIVITY_REFRESH_INTERVAL_MS` overrides, `0` disables). Each tick snapshots the authoritative session states once, recomputes every persisted Live Activity token's snapshot, and pushes updates only for real changes — busy→retry transitions, newly visible top-level sessions, idle completions the event path missed, and stale-row recovery. Entries whose recomputed snapshot is unchanged never send (APNs budgets Live Activity updates per hour). Rows for sessions without authoritative server state are preserved as-is; server-side-only sub-states (`permission`/`input`/`tool`) keep their last value while the session stays busy. When no row is working anymore the refresh sends `end` and clears accepted tokens.
 - `packages/web/server/lib/notifications/template-runtime.js`: notification template variables and session text/title enrichment runtime. Zen-model helpers are retained as compatibility stubs only.

package/server/lib/opencode/DOCUMENTATION.md

@@ -73,11 +73,12 @@ This module provides OpenCode server integration utilities for the web server ru
 
 ## Public exports (auth.js)
 - `configureOpenCodeCredentials(resolveClient)`: host composition injects a call-time SDK client resolver; `null` detaches it. Web/Electron share server wiring; VS Code wires its manager in extension activation. Mobile clients use their host.
+- `currentClient()`: trusted host-only client resolver used by config-sync to retain full V2 credential account records instead of the active-account quota projection.
 - `openCodeCredentialSource({ buildOpenCodeUrl, getOpenCodeAuthHeaders })`: resolves the current endpoint/auth at each read rather than capturing a previous runtime.
 - `readOpenCodeCredentials()`: async SDK `credential.list()` read of the running service; validates entries and projects only active accounts into the quota/TTS credential shape. OAuth `metadata.accountID` becomes `accountId`. No local `auth.json`, local environment, or local provider-config fallback; external service environment-only keys are not exposed by the credential API.
 - `getProviderAuth(providerId)`: async selected stored credential or authoritative `null`; network/auth/schema failures reject with a sanitized error, never empty success.
 - `removeProviderAuth(providerId)`: deletes every stored account for that integration through SDK `credential.remove`, preserving unrelated integrations. Partial failure rejects explicitly; retry lists remaining accounts. Auth-only disconnect requires no process restart.
-- Credential values remain host-only. `credential-boundary.js` blocks raw credential list/creation responses (GET/HEAD/POST `/api/credential`, including encoded/trailing-slash forms) in Web proxy and VS Code bridge because v2 replies contain keys. Provider-source responses expose only existence; errors never include upstream credential bodies/headers. Explicit legacy config-sync file transfer is not a current-service credential source or login operation.
+- Credential values remain host-only outside explicitly selected instance sync. `credential-boundary.js` blocks raw credential list/creation responses (GET/HEAD/POST `/api/credential`, including encoded/trailing-slash forms) in Web proxy and VS Code bridge because v2 replies contain keys. Provider-source responses expose only existence; errors never include upstream credential bodies/headers. The authenticated config-sync routes own explicit V2 credential transfer; previews and run logs contain only metadata.
 
 ## Public exports (shared.js)
 - `OPENCODE_CONFIG_DIR`, `AGENT_DIR`, `COMMAND_DIR`, `SKILL_DIR`, `CONFIG_FILE`, `CUSTOM_CONFIG_FILE`: Path constants.

package/server/lib/opencode/auth.d.ts

@@ -4,6 +4,7 @@ export type ProviderCredential =
   | { type: 'api'; key: string }
   | { type: 'oauth'; access: string; refresh: string; expires: number; accountId?: string; enterpriseUrl?: string };
 export function configureOpenCodeCredentials(resolveClient: (() => OpenCodeClient) | null): void;
+export function currentClient(): OpenCodeClient;
 export function openCodeCredentialSource(deps: {
   buildOpenCodeUrl: (path: string, prefix?: string) => string;
   getOpenCodeAuthHeaders: () => Record<string, string>;

package/server/lib/opencode/auth.js

@@ -49,7 +49,7 @@ async function listCredentials(client) {
   }
 }
 
-function currentClient() {
+export function currentClient() {
   if (!getClient) throw credentialError();
   try { return getClient(); } catch { throw credentialError(); }
 }

package/server/lib/opencode/feature-routes-runtime.js

@@ -337,6 +337,7 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       onSystemSessionPersisted,
       upsertScheduledTask: (projectID, task) => projectConfigRuntime.upsertScheduledTask(projectID, task),
       syncScheduledTaskProject: (projectID) => scheduledTasksRuntime.syncProject(projectID),
+      setTaskResultHandler: (handler) => scheduledTasksRuntime.setTaskResultHandler(handler),
       refreshAllowedRoots: refreshAssistantAllowedRoots,
       globalEventHub: globalMessageStreamHub,
       onRevisionTip: (tip) => broadcastAssistantRevisionTip({

package/server/lib/scheduled-tasks/DOCUMENTATION.md

@@ -10,6 +10,31 @@ Server-owned scheduled task runtime and routes for OpenChamber-only automation.
 - This module is OpenChamber feature logic; it is intentionally separate from OpenCode proxy/runtime internals.
 - Prompt and goal execution preserve hash-prefixed text literally; no snippet discovery or expansion occurs before dispatch.
 
+## Assistant result handoff
+
+`setTaskResultHandler(handler)` installs the Host's assistant result consumer and
+returns its cleanup function. The feature-route composition wires it to the
+assistant service. A handler returns `true` once associated contacts have reviewed
+the result (including explicit silence); `false` retains ordinary scheduled-task
+notification delivery. The scheduler releases its execution slot independently
+of assistant inference. Handler failures keep the result pending.
+
+Run history stores the original execution prompt privately alongside a
+`result_pending` marker. The same terminal history update makes the result
+eligible for delivery, including an in-flight run reconciled after restart.
+`listPendingResults` uses bounded keyset pages of 20; the existing five-second
+recovery pass retries handoffs with at most four in flight per runtime. A failing
+page does not prevent the cursor from reaching later results. `acknowledgeResult`
+clears only the delivery marker, never the execution result. Execution failure,
+history-persistence failure, and assistant delivery failure remain distinct.
+
+The additive migration leaves already-terminal old history acknowledged, avoiding
+an upgrade notification backlog. Old running records enroll when they really
+settle. Public history DTOs expose neither the prompt nor internal delivery state.
+Assistant receipts deduplicate completed reviews, including silent ones; this is
+a retryable handoff, not an exactly-once guarantee for model requests or device
+pushes during crashes/concurrent Hosts. Result review is read-only.
+
 ## Built-in new-session skill
 
 `session-skill.js` intercepts new `POST /api/session` admissions on a Host using

package/server/lib/scheduled-tasks/run-history-store.js

@@ -113,6 +113,12 @@ export const createScheduledTaskRunHistoryStore = ({ dbPath, clock = () => Date.
   if (!hasSlotAt) {
     db.exec('ALTER TABLE scheduled_task_run ADD COLUMN slot_at INTEGER');
   }
+  db.transaction(() => {
+    const columns = new Set(db.prepare("SELECT name FROM pragma_table_info('scheduled_task_run')").all().map((row) => row.name));
+    if (!columns.has('result_pending')) db.exec('ALTER TABLE scheduled_task_run ADD COLUMN result_pending INTEGER NOT NULL DEFAULT 0');
+    if (!columns.has('execution_prompt')) db.exec('ALTER TABLE scheduled_task_run ADD COLUMN execution_prompt TEXT');
+    db.exec("CREATE INDEX IF NOT EXISTS scheduled_task_run_pending_result ON scheduled_task_run(started_at DESC, run_id DESC) WHERE result_pending=1 AND status IN ('success','error')");
+  })();
   db.exec(`
     CREATE UNIQUE INDEX IF NOT EXISTS scheduled_task_run_scheduled_slot
       ON scheduled_task_run (project_id, task_id, slot_at)
@@ -161,9 +167,9 @@ export const createScheduledTaskRunHistoryStore = ({ dbPath, clock = () => Date.
       db.prepare(`
         INSERT INTO scheduled_task_run (
           run_id, project_id, task_id, task_name, trigger, status,
-          session_id, directory, error, started_at, finished_at, duration_ms, slot_at
-        ) VALUES (?, ?, ?, ?, ?, 'running', NULL, ?, NULL, ?, NULL, NULL, ?)
-      `).run(id, projectId, taskId, taskName, trigger, directory, startedAt, slotAt);
+          session_id, directory, error, started_at, finished_at, duration_ms, slot_at, result_pending, execution_prompt
+        ) VALUES (?, ?, ?, ?, ?, 'running', NULL, ?, NULL, ?, NULL, NULL, ?, 1, ?)
+      `).run(id, projectId, taskId, taskName, trigger, directory, startedAt, slotAt, typeof record.prompt === 'string' ? record.prompt : null);
     } catch (error) {
       if (slotAt !== null && SQLITE_UNIQUE_CODES.has(error?.code)) {
         const claimed = new Error('scheduled slot already claimed');
@@ -220,6 +226,7 @@ export const createScheduledTaskRunHistoryStore = ({ dbPath, clock = () => Date.
     const updated = db.prepare(`
       UPDATE scheduled_task_run
       SET status = ?,
+          result_pending = CASE WHEN status='running' THEN 1 ELSE result_pending END,
           session_id = ?,
           error = ?,
           finished_at = ?,
@@ -231,7 +238,7 @@ export const createScheduledTaskRunHistoryStore = ({ dbPath, clock = () => Date.
     return rowToDto(db.prepare('SELECT * FROM scheduled_task_run WHERE run_id = ?').get(id));
   };
 
-  const listRuns = ({ before, limit, projectID, taskID, projectId, taskId } = {}, runningOnly = false) => {
+  const listRuns = ({ before, limit, projectID, taskID, projectId, taskId } = {}, runningOnly = false, pendingOnly = false) => {
     assertOpen();
     const cursor = decodeCursor(before);
     const resolvedLimit = (() => {
@@ -249,6 +256,7 @@ export const createScheduledTaskRunHistoryStore = ({ dbPath, clock = () => Date.
     if (runningOnly) {
       filters.push("status = 'running'");
     }
+    if (pendingOnly) filters.push("result_pending=1 AND status IN ('success','error')");
     const params = [];
     const resolvedProjectID = asNonEmptyString(projectID ?? projectId);
     const resolvedTaskID = asNonEmptyString(taskID ?? taskId);
@@ -278,7 +286,7 @@ export const createScheduledTaskRunHistoryStore = ({ dbPath, clock = () => Date.
     const hasMore = rows.length > resolvedLimit;
     const last = pageRows[pageRows.length - 1];
     return {
-      runs: pageRows.map(rowToDto),
+      runs: pageRows.map((row) => pendingOnly ? { ...rowToDto(row), prompt: row.execution_prompt } : rowToDto(row)),
       nextCursor: hasMore && last
         ? encodeCursor({ startedAt: last.started_at, runID: last.run_id })
         : null,
@@ -300,6 +308,11 @@ export const createScheduledTaskRunHistoryStore = ({ dbPath, clock = () => Date.
     finishRun,
     listRuns,
     listRunningRuns: (options) => listRuns(options, true),
+    listPendingResults: (options) => listRuns(options, false, true),
+    acknowledgeResult: (runID) => {
+      assertOpen();
+      db.prepare("UPDATE scheduled_task_run SET result_pending=0 WHERE run_id=? AND status IN ('success','error')").run(runID);
+    },
     close,
   };
 };

package/server/lib/scheduled-tasks/run-history-store.test.js

@@ -33,6 +33,57 @@ const startSample = (store, overrides = {}) => store.startRun({
 });
 
 describe('scheduled task run history store', () => {
+  it('keeps terminal result handoffs durable, with the execution prompt private and running runs excluded', () => {
+    const dbPath = createTempDbPath();
+    let store = createScheduledTaskRunHistoryStore({ dbPath });
+    try {
+      store.startRun({ id: 'report', projectId: 'p', taskId: 't', prompt: 'Deliver research findings' });
+      expect(store.listPendingResults().runs).toEqual([]);
+      store.finishRun('report', { status: 'success' });
+      expect(store.listRuns().runs[0]).not.toHaveProperty('prompt');
+      store.close();
+      store = createScheduledTaskRunHistoryStore({ dbPath });
+      expect(store.listPendingResults().runs).toEqual([expect.objectContaining({ id: 'report', prompt: 'Deliver research findings' })]);
+      store.acknowledgeResult('report');
+      store.close();
+      store = createScheduledTaskRunHistoryStore({ dbPath });
+      expect(store.listPendingResults().runs).toEqual([]);
+    } finally { store.close(); }
+  });
+
+  it('migrates old history without replaying completed runs and enrolls recovered in-flight work', () => {
+    const dbPath = createTempDbPath();
+    const first = createScheduledTaskRunHistoryStore({ dbPath });
+    startSample(first, { id: 'old-complete' });
+    first.finishRun('old-complete', { status: 'success' });
+    startSample(first, { id: 'old-running' });
+    first.close();
+    const Database = require('better-sqlite3');
+    const db = new Database(dbPath);
+    db.exec('DROP INDEX scheduled_task_run_pending_result; ALTER TABLE scheduled_task_run DROP COLUMN result_pending; ALTER TABLE scheduled_task_run DROP COLUMN execution_prompt');
+    db.close();
+    const store = createScheduledTaskRunHistoryStore({ dbPath });
+    try {
+      expect(store.listPendingResults().runs).toEqual([]);
+      store.finishRun('old-running', { status: 'error', error: 'actual failure' });
+      expect(store.listPendingResults().runs).toEqual([expect.objectContaining({ id: 'old-running', status: 'error', prompt: null })]);
+    } finally { store.close(); }
+  });
+
+  it('does not publish a result when the terminal history write rolls back', () => {
+    const dbPath = createTempDbPath();
+    const store = createScheduledTaskRunHistoryStore({ dbPath });
+    startSample(store, { id: 'failed-write' });
+    const Database = require('better-sqlite3');
+    const db = new Database(dbPath);
+    db.exec("CREATE TRIGGER reject_finish BEFORE UPDATE OF status ON scheduled_task_run BEGIN SELECT RAISE(ABORT, 'disk write failed'); END");
+    try {
+      expect(() => store.finishRun('failed-write', { status: 'success' })).toThrow('disk write failed');
+      expect(store.listRuns().runs[0].status).toBe('running');
+      expect(store.listPendingResults().runs).toEqual([]);
+    } finally { db.close(); store.close(); }
+  });
+
   it('lists runs newest-first and supports stable keyset pagination', () => {
     let now = 1_000;
     const store = createScheduledTaskRunHistoryStore({