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

package/server/lib/opencode/plugins.test.js

@@ -52,6 +52,9 @@ describe('opencode plugins data layer', () => {
     expect(plugins.parsePluginRaw('foo@1.0.0')).toEqual({ spec: 'foo@1.0.0' });
     expect(plugins.parsePluginRaw(['foo', { a: 1 }])).toEqual({ spec: 'foo', options: { a: 1 } });
     expect(plugins.parsePluginRaw(['foo', {}])).toEqual({ spec: 'foo', options: {} });
+    expect(plugins.parsePluginRaw({ package: 'foo', options: { a: 1 } })).toEqual({ spec: 'foo', options: { a: 1 } });
+    expect(plugins.parsePluginRaw({ package: 'foo' })).toEqual({ spec: 'foo' });
+    expect(() => plugins.parsePluginRaw({ package: 'foo', options: [] })).toThrow('Plugin spec');
     expect(() => plugins.parsePluginRaw(123)).toThrow('Plugin spec');
   });
 
@@ -59,7 +62,7 @@ describe('opencode plugins data layer', () => {
     expect(plugins.serializePluginEntry({ spec: 'foo' })).toBe('foo');
     expect(plugins.serializePluginEntry({ spec: 'foo', options: undefined })).toBe('foo');
     expect(plugins.serializePluginEntry({ spec: 'foo', options: {} })).toBe('foo');
-    expect(plugins.serializePluginEntry({ spec: 'foo', options: { a: 1 } })).toEqual(['foo', { a: 1 }]);
+    expect(plugins.serializePluginEntry({ spec: 'foo', options: { a: 1 } })).toEqual({ package: 'foo', options: { a: 1 } });
   });
 
   test('rejects invalid specs and file names', () => {
@@ -71,11 +74,11 @@ describe('opencode plugins data layer', () => {
     expect(() => plugins.writePluginDirFile({ fileName: 'foo.txt', content: '', scope: 'project' }, projectDir)).toThrow('Plugin file name');
   });
 
-  test('creates string and tuple entries with duplicate rejection', () => {
+  test('creates V2 string and object entries with duplicate rejection', () => {
     plugins.createPluginEntry({ spec: 'plain-plugin', scope: 'user' }, projectDir);
     plugins.createPluginEntry({ spec: 'tuple-plugin', options: { apiKey: 'x' }, scope: 'user' }, projectDir);
 
-    expect(readJson(userConfigPath).plugin).toEqual(['plain-plugin', ['tuple-plugin', { apiKey: 'x' }]]);
+    expect(readJson(userConfigPath).plugins).toEqual(['plain-plugin', { package: 'tuple-plugin', options: { apiKey: 'x' } }]);
     expect(() => plugins.createPluginEntry({ spec: 'plain-plugin', scope: 'user' }, projectDir)).toThrow('already exists');
     expect(thrownBy(() => plugins.createPluginEntry({ spec: 'plain-plugin', scope: 'user' }, projectDir))).toHaveProperty('code', 'ENTRY_EXISTS');
   });
@@ -84,8 +87,8 @@ describe('opencode plugins data layer', () => {
     plugins.createPluginEntry({ spec: 'user-plugin', scope: 'user' }, projectDir);
     plugins.createPluginEntry({ spec: 'project-plugin', scope: 'project' }, projectDir);
 
-    expect(readJson(userConfigPath).plugin).toEqual(['user-plugin']);
-    expect(readJson(path.join(projectDir, '.opencode', 'opencode.json')).plugin).toEqual(['project-plugin']);
+    expect(readJson(userConfigPath).plugins).toEqual(['user-plugin']);
+    expect(readJson(path.join(projectDir, '.opencode', 'opencode.json')).plugins).toEqual(['project-plugin']);
   });
 
   test('re-resolves custom config env between calls', () => {
@@ -100,20 +103,62 @@ describe('opencode plugins data layer', () => {
     plugins.createPluginEntry({ spec: 'second-plugin', scope: 'user' }, projectDir);
     plugins.writePluginDirFile({ fileName: 'second.js', content: 'two', scope: 'user' }, projectDir);
 
-    expect(readJson(firstConfigPath).plugin).toEqual(['first-plugin']);
-    expect(readJson(secondConfigPath).plugin).toEqual(['second-plugin']);
+    expect(readJson(firstConfigPath).plugins).toEqual(['first-plugin']);
+    expect(readJson(secondConfigPath).plugins).toEqual(['second-plugin']);
     expect(fs.existsSync(path.join(path.dirname(firstConfigPath), 'plugins', 'first.js'))).toBe(true);
     expect(fs.existsSync(path.join(path.dirname(secondConfigPath), 'plugins', 'second.js'))).toBe(true);
   });
 
-  test('updates entries in place and transitions between string and tuple', () => {
+  test('migrates legacy entries in place and transitions between string and object', () => {
     writeJson(userConfigPath, { plugin: ['first', ['second', { a: 1 }], 'third'] });
 
     plugins.updatePluginEntry(plugins.encodePluginId('config', 'user:second'), { spec: 'second-new', options: {} }, projectDir);
-    expect(readJson(userConfigPath).plugin).toEqual(['first', 'second-new', 'third']);
+    expect(readJson(userConfigPath)).toEqual({ plugins: ['first', 'second-new', 'third'] });
 
     plugins.updatePluginEntry(plugins.encodePluginId('config', 'user:first'), { spec: 'first-new', options: { b: 2 } }, projectDir);
-    expect(readJson(userConfigPath).plugin).toEqual([['first-new', { b: 2 }], 'second-new', 'third']);
+    expect(readJson(userConfigPath).plugins).toEqual([{ package: 'first-new', options: { b: 2 } }, 'second-new', 'third']);
+  });
+
+  test('converts untouched legacy options on save and preserves unrelated JSONC', () => {
+    fs.writeFileSync(userConfigPath, '// retained comment\n' + JSON.stringify({ model: 'example/model', plugin: [['old', { nested: { enabled: false } }]] }));
+    plugins.createPluginEntry({ spec: 'new', scope: 'user' }, projectDir);
+    const text = fs.readFileSync(userConfigPath, 'utf8');
+    expect(text).toContain('// retained comment');
+    expect(plugins.listPluginEntries(projectDir).map(({ spec, options }) => ({ spec, options }))).toEqual([
+      { spec: 'old', options: { nested: { enabled: false } } }, { spec: 'new', options: undefined },
+    ]);
+    expect(text).toContain('"plugins"');
+    expect(text).not.toContain('"plugin"');
+    expect(text).toContain('example/model');
+  });
+
+  test('prefers native plugins over legacy entries including an empty native array', () => {
+    writeJson(userConfigPath, { plugin: ['shadowed'], plugins: [{ package: 'native', options: { enabled: false } }] });
+    expect(plugins.listPluginEntries(projectDir).map((entry) => entry.spec)).toEqual(['native']);
+    expect(() => plugins.createPluginEntry({ spec: 'native' }, projectDir)).toThrow('already exists');
+    plugins.deletePluginEntry(plugins.encodePluginId('config', 'user:native'), projectDir);
+    expect(readJson(userConfigPath)).toEqual({});
+    writeJson(userConfigPath, { plugin: ['shadowed'], plugins: [] });
+    expect(plugins.listPluginEntries(projectDir)).toEqual([]);
+    plugins.createPluginEntry({ spec: 'new' }, projectDir);
+    expect(readJson(userConfigPath)).toEqual({ plugins: ['new'] });
+  });
+
+  test('malformed legacy data and failed atomic writes leave original config intact', () => {
+    writeJson(userConfigPath, { plugin: [['bad', null]], model: 'example/model' });
+    const malformed = fs.readFileSync(userConfigPath, 'utf8');
+    expect(() => plugins.createPluginEntry({ spec: 'new' }, projectDir)).toThrow('Plugin spec');
+    expect(fs.readFileSync(userConfigPath, 'utf8')).toBe(malformed);
+
+    writeJson(userConfigPath, { plugin: [['old', { enabled: false }]] });
+    const original = fs.readFileSync(userConfigPath, 'utf8');
+    const rename = vi.spyOn(fs, 'renameSync').mockImplementation(() => { throw new Error('write failed'); });
+    try {
+      expect(() => plugins.createPluginEntry({ spec: 'new' }, projectDir)).toThrow('write failed');
+      expect(fs.readFileSync(userConfigPath, 'utf8')).toBe(original);
+    } finally {
+      rename.mockRestore();
+    }
   });
 
   test('deletes entries and prunes empty plugin key', () => {

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({

package/server/lib/scheduled-tasks/runtime.js

@@ -1327,7 +1327,53 @@ export const createScheduledTasksRuntime = (deps) => {
         runID,
         error: safeErrorMessage(error),
       });
-      return { error };
+      return { persistenceError: error };
+    }
+  };
+
+  let taskResultHandler = null;
+  let resultRecoveryCursor;
+  let resultRecoveryFlight = false;
+  const deliveringResults = new Set();
+  const deliverTaskResult = async (run) => {
+    if (deliveringResults.has(run.id) || deliveringResults.size >= 4) return;
+    deliveringResults.add(run.id);
+    const handler = taskResultHandler;
+    try {
+      const handled = handler ? await handler(run) : false;
+      if (handler !== taskResultHandler) return;
+      if (!handled) {
+        await notifyTaskRun?.({
+          projectID: run.projectId, taskID: run.taskId, taskName: run.taskName,
+          status: run.status, reason: run.trigger,
+          ...(run.sessionId ? { sessionId: run.sessionId } : {}),
+          ...(run.error ? { errorMessage: run.error } : {}),
+        });
+      }
+      runHistoryStore?.acknowledgeResult?.(run.id);
+    } catch (error) {
+      logger.warn?.('[ScheduledTasks] result delivery failed', { runID: run.id, error: safeErrorMessage(error) });
+    } finally {
+      deliveringResults.delete(run.id);
+    }
+  };
+  const recoverTaskResults = async () => {
+    if (resultRecoveryFlight || !taskResultHandler || typeof runHistoryStore?.listPendingResults !== 'function') return;
+    resultRecoveryFlight = true;
+    try {
+      const page = runHistoryStore.listPendingResults({ before: resultRecoveryCursor, limit: 20 });
+      resultRecoveryCursor = page.nextCursor || undefined;
+      let index = 0;
+      await Promise.all(Array.from({ length: Math.min(4, page.runs.length) }, async () => {
+        while (index < page.runs.length && taskResultHandler) {
+          const run = page.runs[index++];
+          await deliverTaskResult(run);
+        }
+      }));
+    } catch (error) {
+      logger.warn?.('[ScheduledTasks] result recovery failed', { error: safeErrorMessage(error) });
+    } finally {
+      resultRecoveryFlight = false;
     }
   };
 
@@ -1375,6 +1421,7 @@ export const createScheduledTasksRuntime = (deps) => {
             trigger: reason === 'manual' ? 'manual' : 'scheduled',
             directory: projectPath,
             startedAt: runStartedAt,
+            prompt: task.execution?.prompt,
             ...(resolvedSlotAt !== undefined ? { slotAt: resolvedSlotAt } : {}),
           });
         } catch (error) {
@@ -1587,9 +1634,9 @@ export const createScheduledTasksRuntime = (deps) => {
         ...(sessionID ? { sessionId: sessionID } : {}),
         ...(status === 'error' ? { error: errorMessage || 'Unknown error' } : {}),
       });
-      if (historyFinalize?.error) {
+      if (historyFinalize?.persistenceError) {
         status = 'error';
-        errorMessage = errorMessage || safeErrorMessage(historyFinalize.error);
+        errorMessage = errorMessage || safeErrorMessage(historyFinalize.persistenceError);
       }
 
       try {
@@ -1606,15 +1653,21 @@ export const createScheduledTasksRuntime = (deps) => {
       // Notification fanout for scheduled (non-manual) runs; the notification
       // runtime owns every delivery gate (settings toggle, channels).
       try {
-        await notifyTaskRun?.({
-          projectID,
-          taskID,
-          taskName,
-          status,
-          reason,
-          ...(sessionID ? { sessionId: sessionID } : {}),
-          ...(status === 'error' ? { errorMessage } : {}),
-        });
+        if (taskResultHandler && historyFinalize && !historyFinalize.persistenceError) {
+          // Reviewing a result is independent of the scheduler's execution slot.
+          void deliverTaskResult({ ...historyFinalize, prompt: task.execution?.prompt });
+        } else {
+          await notifyTaskRun?.({
+            projectID,
+            taskID,
+            taskName,
+            status,
+            reason,
+            ...(sessionID ? { sessionId: sessionID } : {}),
+            ...(status === 'error' ? { errorMessage } : {}),
+          });
+          if (!historyFinalize?.persistenceError && runID) runHistoryStore?.acknowledgeResult?.(runID);
+        }
       } catch (error) {
         logger.warn?.('[ScheduledTasks] task-run notification failed', {
           projectID,
@@ -1813,6 +1866,7 @@ export const createScheduledTasksRuntime = (deps) => {
     if (controller.signal.aborted) return;
     await recoverTaskStates(controller);
     if (controller.signal.aborted) return;
+    void recoverTaskResults();
     historyRecoveryTimer = setTimeout(() => {
       void recoverRunHistory(controller, nextCursor || undefined);
     }, 5_000);
@@ -1994,5 +2048,9 @@ export const createScheduledTasksRuntime = (deps) => {
     runNow,
     getStatus,
     observeSessionEvent,
+    setTaskResultHandler: (handler) => {
+      taskResultHandler = handler;
+      return () => { if (taskResultHandler === handler) taskResultHandler = null; };
+    },
   };
 };

package/server/lib/scheduled-tasks/runtime.test.js

@@ -5,6 +5,8 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { createAssistantsService } from '../assistants/service.js';
+import { runContactTurn as reviewTaskResult } from '../assistants/harness.js';
 
 vi.mock('../opencode/v2-client.js', () => ({
   makeOpenCodeV2Client: vi.fn(),
@@ -318,6 +320,135 @@ describe('scheduled-tasks history recovery', () => {
   });
 });
 
+describe('scheduled task result handoff', () => {
+  it.each(['report', 'silent', 'failure'])('connects a real scheduled run to the owner contact with %s delivery', async (mode) => {
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'scheduled-contact-'));
+    const store = createScheduledTaskRunHistoryStore({ dbPath: path.join(directory, 'runs.sqlite') });
+    let task = { ...scheduledTask, execution: { ...scheduledTask.execution, prompt: mode === 'report' ? 'Research and send a summary' : 'Do background work; no success report needed' } };
+    let releaseWorker;
+    const workerResult = new Promise((resolve) => { releaseWorker = resolve; });
+    const messageList = vi.fn(() => workerResult);
+    const client = {
+      session: {
+        create: vi.fn(async () => ({ id: 'worker' })),
+        prompt: vi.fn(async () => ({ id: 'inbox', type: 'user' })),
+        active: vi.fn(async () => ({})),
+      },
+      message: { list: messageList },
+      provider: { list: async () => ({ data: [] }) },
+      model: { list: async () => ({ data: [] }) },
+    };
+    makeOpenCodeV2Client.mockReturnValue(client);
+    const listProjects = async () => [{ id: 'project-1', path: directory }];
+    const projectConfigRuntime = {
+      listScheduledTasks: async () => [task],
+      upsertScheduledTask: async (_project, input) => ({ task: { ...task, ...input, id: 'task-1' } }),
+      updateScheduledTaskState: async (_project, _id, state) => {
+        task = { ...task, state: { ...task.state, ...state } };
+        return { task };
+      },
+    };
+    const notifyTaskRun = vi.fn();
+    const onContactTurnComplete = vi.fn();
+    const reviews = vi.fn(async (input) => {
+      expect(input.userText).toContain(task.execution.prompt);
+      if (mode === 'failure') expect(input.userText).toContain('upstream failed');
+      else expect(input.userText).toContain('Actual research findings');
+      return reviewTaskResult({ ...input, createChatCompletion: async () => ({ text: mode === 'silent'
+        ? '```openchamber-final\n{"status":"silent","text":""}\n```'
+        : mode === 'failure' ? '任务执行失败，需要检查服务。' : '资料汇总：有两项值得关注的更新。' }) });
+    });
+    const runtime = createRuntime(null, {
+      projectConfigRuntime, listProjects, runHistoryStore: store, notifyTaskRun,
+      waitForOpenCodeReady: async () => {},
+    });
+    const service = createAssistantsService({
+      dbPath: path.join(directory, 'assistants.sqlite'), dataDir: directory,
+      getAllowedRoots: () => [directory], listProjects, clientFactory: () => client,
+      buildOpenCodeUrl: () => 'http://127.0.0.1:4096', getOpenCodeAuthHeaders: () => ({}),
+      upsertScheduledTask: projectConfigRuntime.upsertScheduledTask,
+      syncScheduledTaskProject: (id) => runtime.syncProject(id),
+      onContactTurnComplete,
+      runContactTurn: async (input) => {
+        if (input.readOnly) return reviews(input);
+        await input.tools.find((tool) => tool.name === 'schedule_task').execute('schedule', {
+          name: 'Task', prompt: task.execution.prompt, time: '23:59', timezone: 'UTC',
+        });
+        return { bubbles: ['已安排'] };
+      },
+    });
+    const detach = runtime.setTaskResultHandler((run) => service.reportScheduledTaskResult(run));
+    try {
+      service.setEnabled({ enabled: true, expectedRevision: service.snapshot().revision });
+      const owner = service.createAssistant({ name: 'Research', providerID: 'openai', modelID: 'gpt-4.1' });
+      const sent = await service.send(owner.id, { messageID: 'schedule', parts: [{ type: 'text', text: 'Create the recurring task' }] });
+      await service.whenContactTurnSettled(sent.messageID);
+      onContactTurnComplete.mockClear();
+      const run = runtime.runNow('project-1', 'task-1');
+      await vi.waitFor(() => expect(messageList).toHaveBeenCalled());
+      expect(reviews).not.toHaveBeenCalled();
+      releaseWorker({ data: [{ id: 'result', type: 'assistant', text: 'Actual research findings', time: { created: 1, completed: 2 }, finish: 'stop', ...(mode === 'failure' ? { error: { name: 'ProviderError', message: 'upstream failed' } } : {}) }] });
+      const result = await run;
+      expect(result.status).toBe(mode === 'failure' ? 'error' : 'success');
+      await vi.waitFor(() => expect(store.listPendingResults().runs).toEqual([]));
+      expect(reviews).toHaveBeenCalledOnce();
+      expect(notifyTaskRun).not.toHaveBeenCalled();
+      expect(onContactTurnComplete).toHaveBeenCalledTimes(mode === 'silent' ? 0 : 1);
+      expect(service.snapshot().assistants[0].working).toBe(false);
+    } finally {
+      detach(); runtime.stop(); service.close(); store.close();
+      fs.rmSync(directory, { recursive: true, force: true });
+    }
+  });
+
+  it('recovers durable results after restart and isolates a failed handoff from other runs', async () => {
+    vi.useFakeTimers();
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'scheduled-result-recovery-'));
+    const dbPath = path.join(directory, 'runs.sqlite');
+    let store = createScheduledTaskRunHistoryStore({ dbPath });
+    const retryIDs = Array.from({ length: 4 }, (_, index) => `z-retry-${index}`);
+    const healthyIDs = Array.from({ length: 21 }, (_, index) => `healthy-${index}`);
+    for (const id of [...retryIDs, ...healthyIDs, 'unowned']) {
+      store.startRun({ id, projectId: 'project-1', taskId: 'task-1', prompt: 'Original instruction' });
+      store.finishRun(id, { status: 'success' });
+    }
+    store.close();
+    store = createScheduledTaskRunHistoryStore({ dbPath });
+    let broken = true;
+    let active = 0;
+    let peak = 0;
+    const handler = vi.fn(async (run) => {
+      expect(run.prompt).toBe('Original instruction');
+      active += 1;
+      peak = Math.max(peak, active);
+      try {
+        await Promise.resolve();
+        if (retryIDs.includes(run.id) && broken) throw new Error('temporary handoff failure');
+        return run.id !== 'unowned';
+      } finally { active -= 1; }
+    });
+    const notifyTaskRun = vi.fn();
+    const runtime = createRuntime(vi.fn(async () => ({ task: scheduledTask })), { runHistoryStore: store, notifyTaskRun });
+    const detach = runtime.setTaskResultHandler(handler);
+    try {
+      await runtime.start();
+      await vi.advanceTimersByTimeAsync(0);
+      await vi.advanceTimersByTimeAsync(5000);
+      expect(store.listPendingResults().runs.map((run) => run.id).sort()).toEqual(retryIDs);
+      expect(notifyTaskRun).toHaveBeenCalledOnce();
+      broken = false;
+      await vi.advanceTimersByTimeAsync(5000);
+      expect(store.listPendingResults().runs).toEqual([]);
+      for (const id of healthyIDs) expect(handler.mock.calls.filter(([run]) => run.id === id)).toHaveLength(1);
+      expect(peak).toBeLessThanOrEqual(4);
+    } finally {
+      detach(); runtime.stop(); store.close();
+      fs.rmSync(directory, { recursive: true, force: true });
+      vi.useRealTimers();
+    }
+  });
+});
+
 describe('scheduled-tasks runtime helpers', () => {
   it('computes next daily run in timezone', () => {
     const nowUtc = Date.UTC(2025, 0, 1, 8, 0, 0);

package/server/lib/session-folders/DOCUMENTATION.md

@@ -0,0 +1,20 @@
+# Session folders and order
+
+Folder membership/collapse retains `/api/session-folders` and
+`sessions-directories.json`. Session ordering uses `/api/session-folders/order`
+and `session-order.json` independently so an older folder client cannot erase it.
+
+GET returns `{ revision, sessionOrderByScope, sessionOrderActivityByScope }`.
+POST replaces one scope using `{ scopeKey, order, activity, onlyIfAbsent? }`.
+Directory paths identify ordinary lists; `__pinned__` identifies global pins.
+Writes serialize per Host, merge other scopes, atomically rename the new file,
+then broadcast `openchamber:session-order-changed` through the product SSE stream.
+Last committed drag wins within a scope; independent scopes never replace each
+other. A failed write leaves the previous file and emits no success event.
+Missing files mean an empty initial catalog; malformed/unreadable files fail.
+
+`onlyIfAbsent` imports pre-existing local ranks without overwriting a scope
+already saved by another device. It does not bump revision or emit a tip when
+the scope already exists. Local caches are startup continuity, not authority.
+Clients fetch first and refetch on tips/reconnect/foreground through the shared
+runtime HTTP/SSE transport (direct and Relay use identical routes).

package/server/lib/session-folders/order-routes.js

@@ -0,0 +1,69 @@
+const emptySnapshot = () => ({ revision: 0, sessionOrderByScope: {}, sessionOrderActivityByScope: {} });
+
+export function registerSessionOrderRoutes(app, { fsPromises: fs, path, openchamberDataDir, broadcastOpenChamberEvent }) {
+  const file = path.join(openchamberDataDir, 'session-order.json');
+  let writes = Promise.resolve();
+  const read = async () => {
+    try {
+      const snapshot = JSON.parse(await fs.readFile(file, 'utf8'));
+      if (!Number.isSafeInteger(snapshot?.revision) || snapshot.revision < 0
+        || !snapshot.sessionOrderByScope || typeof snapshot.sessionOrderByScope !== 'object' || Array.isArray(snapshot.sessionOrderByScope)
+        || !snapshot.sessionOrderActivityByScope || typeof snapshot.sessionOrderActivityByScope !== 'object' || Array.isArray(snapshot.sessionOrderActivityByScope)) {
+        throw new Error('Invalid session order file');
+      }
+      return snapshot;
+    } catch (error) {
+      if (error.code === 'ENOENT') return emptySnapshot();
+      throw error;
+    }
+  };
+  app.get('/api/session-folders/order', async (_req, res) => {
+    try {
+      await writes;
+      res.json(await read());
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+  app.post('/api/session-folders/order', async (req, res) => {
+    const { scopeKey, order, activity, onlyIfAbsent } = req.body ?? {};
+    if (typeof scopeKey !== 'string' || !scopeKey.trim() || scopeKey.length > 4096
+      || !Array.isArray(order) || order.length > 10000
+      || !order.every((id) => typeof id === 'string' && id.length > 0 && id.length < 512)
+      || !activity || typeof activity !== 'object' || Array.isArray(activity)
+      || Object.keys(activity).length > 10000
+      || !Object.values(activity).every((value) => typeof value === 'number' && Number.isFinite(value))
+      || (onlyIfAbsent !== undefined && typeof onlyIfAbsent !== 'boolean')) {
+      return res.status(400).json({ error: 'Invalid session order' });
+    }
+    const write = writes.then(async () => {
+      const current = await read();
+      if (onlyIfAbsent && Object.hasOwn(current.sessionOrderByScope, scopeKey)) return current;
+      const next = {
+        revision: current.revision + 1,
+        sessionOrderByScope: { ...current.sessionOrderByScope, [scopeKey]: [...new Set(order)] },
+        sessionOrderActivityByScope: { ...current.sessionOrderActivityByScope, [scopeKey]: activity },
+      };
+      await fs.mkdir(openchamberDataDir, { recursive: true });
+      const tmp = `${file}.tmp-${process.pid}-${next.revision}`;
+      try {
+        await fs.writeFile(tmp, JSON.stringify(next), 'utf8');
+        await fs.rename(tmp, file);
+      } catch (error) {
+        await fs.unlink(tmp).catch(() => {});
+        throw error;
+      }
+      broadcastOpenChamberEvent?.({
+        type: 'openchamber:session-order-changed',
+        properties: { occurredAt: Date.now() },
+      });
+      return next;
+    });
+    writes = write.then(() => {}, () => {});
+    try {
+      res.json(await write);
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+}

package/server/lib/session-folders/routes.js

@@ -1,6 +1,9 @@
+import { registerSessionOrderRoutes } from './order-routes.js';
+
 const MAX_BODY_BYTES = 4 * 1024 * 1024;
 
 export const registerSessionFoldersRoutes = (app, dependencies) => {
+  registerSessionOrderRoutes(app, dependencies);
   const {
     fsPromises,
     path,