@vantran-se/openchamber-web 2.1.1 → 2.2.0

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

@@ -350,6 +350,54 @@ describe('scheduled-tasks runtime prompt dispatch', () => {
     expect(dispatch[2].body).toMatchObject({ text: 'Review open issues' });
     expect(dispatch[2].body.resume).toBeUndefined();
   });
+
+  it('points a run that fails after creating its session at that session', async () => {
+    vi.stubGlobal('fetch', vi.fn(async (input, init = {}) => {
+      const { pathname } = new URL(String(input));
+      if (init.method === 'POST' && pathname.endsWith('/prompt')) {
+        return new Response(JSON.stringify({ error: 'provider down' }), { status: 500 });
+      }
+      const data = pathname === '/api/session' ? { id: 'ses_failed' } : pathname === '/api/command' ? [] : {};
+      return new Response(JSON.stringify({ location: { directory: '/repo' }, data }), { status: 200, headers: { 'content-type': 'application/json' } });
+    }));
+    const task = {
+      id: 'task-1',
+      name: 'Nightly',
+      enabled: true,
+      schedule: { kind: 'daily', times: ['03:00'], timezone: 'UTC' },
+      execution: { prompt: 'Review open issues', providerID: 'openai', modelID: 'gpt-5' },
+      state: { createdAt: 1, updatedAt: 1, lastSessionId: 'ses_previous' },
+    };
+    const patches = [];
+    const runtime = createScheduledTasksRuntime({
+      projectConfigRuntime: {
+        listScheduledTasks: async () => [task],
+        reconcileLoopTasks: async () => [task],
+        updateScheduledTaskState: async (_projectID, _taskID, patch) => {
+          patches.push(patch);
+          return { task, updated: true };
+        },
+        updateScheduledTaskStateIf: async () => ({ task, updated: true }),
+      },
+      listProjects: async () => [{ id: 'proj', path: '/repo' }],
+      buildOpenCodeUrl: () => 'http://127.0.0.1:1/',
+      getOpenCodeAuthHeaders: () => ({}),
+      waitForOpenCodeReady: async () => {},
+      logger: { info: () => {}, warn: () => {}, error: () => {} },
+    });
+    await runtime.start();
+    const result = await runtime.runNow('proj', 'task-1');
+    runtime.stop();
+
+    expect(result.ok).toBe(false);
+    // The start clears the previous run's session, creation records this one,
+    // and the failure keeps it.
+    const startIndex = patches.findIndex((patch) => patch.lastStatus === 'running');
+    expect(Object.hasOwn(patches[startIndex], 'lastSessionId')).toBe(true);
+    expect(patches[startIndex].lastSessionId).toBeUndefined();
+    expect(patches[startIndex + 1]).toEqual({ lastSessionId: 'ses_failed' });
+    expect(patches.at(-1)).toMatchObject({ lastStatus: 'error', lastSessionId: 'ses_failed' });
+  });
 });
 
 describe('scheduled-tasks runtime chats scope', () => {

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

@@ -1,13 +1,13 @@
+import { asNonEmptyString } from '../shared/guards.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { OpenChamberControlError } from '../openchamber-control/error.js';
-import { loopFingerprint, parseLoopDefinition, setLoopFileEnabled } from './loops.js';
+import { discoverLoopFiles, loopFingerprint, parseLoopDefinition, setLoopFileEnabled } from './loops.js';
 
-const asNonEmptyString = (value) => {
-  if (typeof value !== 'string') return null;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-};
+// Same scope rule the scheduler applies: a file under the project's own
+// `.agents/loops` is a repository loop, even where it is also the user folder.
+const isRepositoryLoop = (projectPath, loopFile) => discoverLoopFiles(projectPath)
+  .some((entry) => entry.scope === 'project' && entry.filePath === loopFile);
 
 export const createScheduledTaskService = (dependencies) => {
   const {
@@ -111,6 +111,10 @@ export const createScheduledTaskService = (dependencies) => {
       throw new OpenChamberControlError('task payload is required', 400);
     }
     let upserted;
+    const previous = taskInput.id ? (await projectConfigRuntime.listScheduledTasks(id)).find((task) => task.id === taskInput.id) : null;
+    if (taskInput.targetSessionId && (taskInput.enabled !== false || previous?.targetSessionId !== taskInput.targetSessionId)) {
+      await scheduledTasksRuntime.validateTarget(id, taskInput.targetSessionId);
+    }
     try {
       upserted = await projectConfigRuntime.upsertScheduledTask(id, taskInput);
     } catch (error) {
@@ -118,6 +122,9 @@ export const createScheduledTaskService = (dependencies) => {
       const invalid = message.toLowerCase().includes('required') || message.toLowerCase().includes('invalid');
       throw new OpenChamberControlError(message, invalid ? 400 : 500);
     }
+    if (previous?.targetSessionId && ((previous.enabled && upserted.task.enabled === false) || previous.targetSessionId !== upserted.task.targetSessionId)) {
+      await scheduledTasksRuntime.cancelWaitingPrompt(id, taskInput.id);
+    }
     await scheduledTasksRuntime.syncProject(id);
     const tasks = await projectConfigRuntime.listScheduledTasks(id);
     return {
@@ -146,6 +153,7 @@ export const createScheduledTaskService = (dependencies) => {
     }
     const result = await projectConfigRuntime.deleteScheduledTask(id, normalizedTaskID);
     if (!result.deleted) throw new OpenChamberControlError('Task not found', 404);
+    await scheduledTasksRuntime.cancelWaitingPrompt?.(id, normalizedTaskID);
     await scheduledTasksRuntime.syncProject(id);
     return projectConfigRuntime.listScheduledTasks(id);
   };
@@ -156,11 +164,11 @@ export const createScheduledTaskService = (dependencies) => {
     if (!normalizedTaskID) throw new OpenChamberControlError('taskId is required', 400);
     const result = await scheduledTasksRuntime.runNow(id, normalizedTaskID);
     if (result.running || result.queued) {
-      throw new OpenChamberControlError(result.error || 'Task already running', 409);
+      throw new OpenChamberControlError(result.error || 'Task already running', 409, { busy: result.queued ? 'queued' : 'running' });
     }
     if (result.skipped) throw new OpenChamberControlError('Task not found or disabled', 404);
     if (!result.ok) {
-      throw new OpenChamberControlError(result.error || 'Task run failed', 500, { task: result.task });
+      throw new OpenChamberControlError(result.error || 'Task run failed', result.statusCode || 500, { task: result.task });
     }
     const response = {
       task: result.task,
@@ -173,12 +181,26 @@ export const createScheduledTaskService = (dependencies) => {
     return response;
   };
 
+  // The agent tool and the CLI. A loop task follows its file, so it changes
+  // the way the Scheduled tasks checkbox does. A repository loop is the
+  // exception for enabling: that is the user's own decision on this machine,
+  // made in Scheduled tasks, never by an agent or a script on their behalf.
   const setEnabled = async (projectID, taskID, enabled) => {
-    const tasks = await list(projectID);
+    const project = await findProjectByID(projectID);
+    const tasks = await scheduledTasksRuntime.syncProject(project.id);
     const task = tasks.find((entry) => entry?.id === taskID);
     if (!task) throw new OpenChamberControlError('Task not found', 404);
-    const result = await upsert(projectID, { ...task, enabled });
-    return result.task;
+    if (!task.loopFile) {
+      const result = await upsert(project.id, { ...task, enabled });
+      return result.task;
+    }
+    // Nothing to change: the loop file, which may be tracked in the
+    // repository, and the approval stay untouched.
+    if (enabled === task.enabled) return task;
+    if (enabled && isRepositoryLoop(project.path, task.loopFile)) {
+      throw new OpenChamberControlError(`"${task.name}" comes from this repository. Enable it in Scheduled tasks.`, 409);
+    }
+    return setLoopEnabled(project.id, task.id, enabled);
   };
 
   const status = async () => {

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

@@ -1,10 +1,12 @@
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import os from 'os';
 import path from 'path';
-import { mkdtemp, readFile, rm, writeFile } from 'fs/promises';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'fs/promises';
 import { createScheduledTaskService } from './service.js';
 import { registerScheduledTaskRoutes } from './routes.js';
 import { CHATS_SCOPE_PUBLIC_ID, createChatsScope } from './chats-scope.js';
+import { createScheduledTasksRuntime } from './runtime.js';
+import { createProjectConfigRuntime } from '../projects/project-config.js';
 
 const createService = (overrides = {}) => {
   const projectConfigRuntime = {
@@ -349,3 +351,127 @@ Run the digest.
     }
   });
 });
+
+// The agent tool and the CLI enable and disable through setEnabled; these run
+// it against the real project config and scheduler, as the server does.
+describe('scheduled-task service setEnabled on loop tasks', () => {
+  const loopFileContent = (name, enabled, prompt = `Run ${name}.`) => `---
+name: ${name}
+schedule: "0 9 * * *"
+enabled: ${enabled}
+model: openai/gpt-5
+---
+${prompt}
+`;
+
+  let tempRoot;
+  let repoPath;
+  let repoLoop;
+  let userLoop;
+  let service;
+  let projectConfigRuntime;
+  const savedHome = { HOME: process.env.HOME, USERPROFILE: process.env.USERPROFILE };
+
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(path.join(os.tmpdir(), 'oc-loop-set-enabled-'));
+    // User-scope loops live under the home directory.
+    const home = path.join(tempRoot, 'home');
+    process.env.HOME = home;
+    process.env.USERPROFILE = home;
+    repoPath = path.join(tempRoot, 'repo');
+    await mkdir(path.join(repoPath, '.agents', 'loops'), { recursive: true });
+    await mkdir(path.join(home, '.agents', 'loops'), { recursive: true });
+    repoLoop = path.join(repoPath, '.agents', 'loops', 'repo.md');
+    userLoop = path.join(home, '.agents', 'loops', 'mine.md');
+    await writeFile(repoLoop, loopFileContent('repo-loop', true), 'utf8');
+    await writeFile(userLoop, loopFileContent('my-loop', false), 'utf8');
+
+    projectConfigRuntime = createProjectConfigRuntime({
+      fsPromises: await import('fs/promises'),
+      path,
+      projectsDirPath: path.join(tempRoot, 'config'),
+      createTaskID: () => 'task-fixed-id',
+    });
+    const listProjects = async () => [{ id: 'proj', path: repoPath }];
+    const scheduledTasksRuntime = createScheduledTasksRuntime({
+      buildOpenCodeUrl: () => 'http://localhost',
+      getOpenCodeAuthHeaders: () => ({}),
+      waitForOpenCodeReady: async () => {},
+      projectConfigRuntime,
+      listProjects,
+    });
+    service = createScheduledTaskService({
+      readSettingsFromDiskMigrated: async () => ({ projects: await listProjects() }),
+      sanitizeProjects: (projects) => projects,
+      projectConfigRuntime,
+      scheduledTasksRuntime,
+    });
+  });
+
+  afterEach(async () => {
+    for (const [key, value] of Object.entries(savedHome)) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+    await rm(tempRoot, { recursive: true, force: true });
+  });
+
+  const stored = async (taskID) => (await projectConfigRuntime.listScheduledTasks('proj')).find((task) => task.id === taskID);
+  const listed = async (taskID) => (await service.list('proj')).find((task) => task.id === taskID);
+
+  it('refuses to enable a repository loop and changes nothing', async () => {
+    expect(await listed('loop:project:repo-loop')).toMatchObject({ enabled: false, loopApproval: 'required' });
+
+    await expect(service.setEnabled('proj', 'loop:project:repo-loop', true)).rejects.toMatchObject({
+      statusCode: 409,
+      message: '"repo-loop" comes from this repository. Enable it in Scheduled tasks.',
+    });
+
+    expect((await stored('loop:project:repo-loop')).enabled).toBe(false);
+    expect(await readFile(repoLoop, 'utf8')).toBe(loopFileContent('repo-loop', true));
+    expect(await listed('loop:project:repo-loop')).toMatchObject({ enabled: false, loopApproval: 'required' });
+  });
+
+  it('leaves a held-back repository loop file alone when asked to disable it', async () => {
+    await expect(service.setEnabled('proj', 'loop:project:repo-loop', false)).resolves.toMatchObject({ enabled: false });
+
+    expect(await readFile(repoLoop, 'utf8')).toBe(loopFileContent('repo-loop', true));
+    expect(await listed('loop:project:repo-loop')).toMatchObject({ enabled: false, loopApproval: 'required' });
+  });
+
+  it('disables a repository loop the user enabled, and it stays disabled', async () => {
+    await service.setLoopEnabled('proj', 'loop:project:repo-loop', true);
+    const enabled = await listed('loop:project:repo-loop');
+    expect(enabled.enabled).toBe(true);
+    expect(enabled.loopApproval).toBeUndefined();
+
+    await expect(service.setEnabled('proj', 'loop:project:repo-loop', false)).resolves.toMatchObject({ enabled: false });
+
+    const disabled = await listed('loop:project:repo-loop');
+    expect(disabled.enabled).toBe(false);
+    // Paused by the user: nothing to explain on the card.
+    expect(disabled.loopApproval).toBeUndefined();
+    expect(await readFile(repoLoop, 'utf8')).toContain('enabled: false');
+    // And the agent cannot turn it back on.
+    await expect(service.setEnabled('proj', 'loop:project:repo-loop', true)).rejects.toMatchObject({ statusCode: 409 });
+  });
+
+  it('says a repository loop changed since the user enabled it', async () => {
+    await service.setLoopEnabled('proj', 'loop:project:repo-loop', true);
+    await writeFile(repoLoop, loopFileContent('repo-loop', true, 'Run something else.'), 'utf8');
+
+    expect(await listed('loop:project:repo-loop')).toMatchObject({ enabled: false, loopApproval: 'outdated' });
+    expect((await stored('loop:project:repo-loop')).loopApproval).toBeUndefined();
+    await expect(service.setEnabled('proj', 'loop:project:repo-loop', true)).rejects.toMatchObject({ statusCode: 409 });
+  });
+
+  it('enables and disables a loop from the user folder', async () => {
+    await expect(service.setEnabled('proj', 'loop:user:my-loop', true)).resolves.toMatchObject({ enabled: true });
+    expect((await stored('loop:user:my-loop')).enabled).toBe(true);
+    expect(await readFile(userLoop, 'utf8')).toContain('enabled: true');
+
+    await expect(service.setEnabled('proj', 'loop:user:my-loop', false)).resolves.toMatchObject({ enabled: false });
+    expect((await stored('loop:user:my-loop')).enabled).toBe(false);
+    expect(await readFile(userLoop, 'utf8')).toContain('enabled: false');
+  });
+});

package/server/lib/scheduled-tasks/session-defaults.js

@@ -0,0 +1,27 @@
+/**
+ * The model, thinking level and agent a new session starts with, as Settings
+ * and the project define them: the project's own default first, then the
+ * global one. A thinking level travels with the model it was set next to.
+ * Anything unset is null, and OpenCode then applies its own default.
+ */
+const splitModel = (value) => {
+  const text = typeof value === 'string' ? value.trim() : '';
+  const slash = text.indexOf('/');
+  if (slash <= 0 || slash === text.length - 1) return null;
+  return { providerID: text.slice(0, slash), modelID: text.slice(slash + 1) };
+};
+
+const text = (value) => (typeof value === 'string' && value.trim() ? value.trim() : null);
+
+export const resolveSessionDefaults = ({ settings, project }) => {
+  const projectModel = splitModel(project?.defaultModel);
+  const globalModel = splitModel(settings?.defaultModel);
+  const model = projectModel ?? globalModel;
+  const variant = projectModel ? text(project?.defaultVariant) : globalModel ? text(settings?.defaultVariant) : null;
+  return {
+    providerID: model?.providerID ?? null,
+    modelID: model?.modelID ?? null,
+    variant,
+    agent: text(project?.defaultAgent) ?? text(settings?.defaultAgent),
+  };
+};

package/server/lib/scheduled-tasks/session-defaults.test.js

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+
+import { resolveSessionDefaults } from './session-defaults.js';
+
+describe('resolveSessionDefaults', () => {
+  it('prefers the project default, then the global one, keeping each variant with its model', () => {
+    const settings = { defaultModel: 'anthropic/claude-sonnet-5', defaultVariant: 'high', defaultAgent: 'build' };
+    expect(resolveSessionDefaults({ settings, project: { defaultModel: 'openai/gpt-6', defaultAgent: 'plan' } }))
+      .toEqual({ providerID: 'openai', modelID: 'gpt-6', variant: null, agent: 'plan' });
+    expect(resolveSessionDefaults({ settings, project: {} }))
+      .toEqual({ providerID: 'anthropic', modelID: 'claude-sonnet-5', variant: 'high', agent: 'build' });
+  });
+
+  it('leaves everything to OpenCode when nothing is set', () => {
+    expect(resolveSessionDefaults({ settings: {}, project: null }))
+      .toEqual({ providerID: null, modelID: null, variant: null, agent: null });
+    expect(resolveSessionDefaults({ settings: { defaultModel: 'no-slash' }, project: null }).modelID).toBeNull();
+  });
+});

package/server/lib/session-assist/context.js

@@ -111,6 +111,7 @@ function readMessage(message) {
     id: message.id,
     role,
     created: Number.isFinite(message.time?.created) ? message.time.created : null,
+    completed: Number.isFinite(message.time?.completed) ? message.time.completed : null,
     transparent: isTransparent(message),
     // v2 has no `parentID` on a message: a turn is the run of messages between
     // one user message and the assistant reply that follows it, which is what

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

@@ -1,6 +1,6 @@
-const MAX_BODY_BYTES = 4 * 1024 * 1024;
+import { isRecord as isObjectRecord } from '../shared/guards.js';
 
-const isObjectRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+const MAX_BODY_BYTES = 4 * 1024 * 1024;
 
 const hasValidFolderShape = (folder) => (
   isObjectRecord(folder)

package/server/lib/session-goal/objectives.js

@@ -24,7 +24,7 @@ const goalsDir = () => path.join(
 
 const objectiveFilePath = (sessionId) => path.join(goalsDir(), `${sessionId}.md`);
 
-export const isValidObjectiveKey = (sessionId) =>
+const isValidObjectiveKey = (sessionId) =>
   typeof sessionId === 'string' && SESSION_ID_PATTERN.test(sessionId);
 
 const clampContent = (content) => String(content ?? '').trim().slice(0, GOAL_OBJECTIVE_CHAR_LIMIT);

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

@@ -13,9 +13,9 @@
 
 import express from 'express';
 
-const parseJsonBody = express.json({ limit: '1mb' });
+import { isRecord } from '../shared/guards.js';
 
-const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+const parseJsonBody = express.json({ limit: '1mb' });
 
 const asNonEmptyString = (value) => (
   typeof value === 'string' && value.trim().length > 0 ? value.trim() : ''

package/server/lib/session-knowledge/runtime.js

@@ -14,6 +14,7 @@
  * it survives compaction: the tab goes on believing the agent still has context
  * that has just been summarised away.
  */
+import { isRecord } from '../shared/guards.js';
 
 const KNOWLEDGE_METADATA_KEY = 'knowledge_context_delivered';
 const PINS_METADATA_KEY = 'project_context_pins';
@@ -21,8 +22,6 @@ const PINS_METADATA_KEY = 'project_context_pins';
 /** Total budget for the assembled block; anything past it is cut, loudly. */
 const KNOWLEDGE_MAX_LENGTH = 8000;
 
-const isRecord = (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value));
-
 const truncate = (value, budget) => (
   value.length <= budget ? value : `${value.slice(0, Math.max(0, budget - 1))}…`
 );

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

@@ -4,8 +4,11 @@
 
 Keeps sessions where real work is going on in one block at the top of the
 sidebar until the user marks them done. Jev moves a session in when work
-starts in it; the user alone closes it. The same turn-end Jev call tells
-session assist whether the Small Model is worth waking.
+starts in it; the user alone closes it. While a session is in work, Jev also
+says after a turn whether the work looks done. Independently of work, the
+same call says whether the turn handed over changes worth a look (the
+composer then offers an AI review or a walkthrough). The same turn-end Jev call tells session assist whether the
+Small Model is worth waking.
 
 ## Files
 
@@ -25,6 +28,10 @@ session assist whether the Small Model is worth waking.
 - `doneAt` once the user closed it
 - `suggestDoneAt` while Jev thinks the last turn closed the work out
 
+`metadata.openchamber.reviewOffer`: `{ at }` while Jev thinks the last turn
+handed over changes the user could look over. It lives outside `work` so it
+needs neither the In work block nor a session in work.
+
 The UI parser is `packages/ui/src/lib/sessionWorkMetadata.ts`; the user's own
 Track / Done go through the generic metadata route
 (`setSessionWorkState` in `packages/ui/src/sync/session-actions.ts`), which
@@ -32,7 +39,6 @@ also exists in VS Code.
 
 ## Invariants
 
-- Jev only evaluates sessions adopted by OpenChamber (`metadata.openchamber.adopted === true`). Sessions seen only through the shared local OpenCode service remain TUI-owned; viewing one does not send its content to Jev. Creating a session or sending into it from an OpenChamber surface persists adoption first.
 - Jev only opens. Nothing here ever writes `done`.
 - Jev reopens a closed session only for a request sent after the user closed
   it (`openByJevPatch` compares the request's `time.created` with `doneAt`).
@@ -40,13 +46,14 @@ also exists in VS Code.
   store's per-session write queue, so a user's Done written a moment earlier
   is seen and kept.
 - A turn-end check is bound to its turn: every turn start and new user
-  message advances a per-session counter, and the done hint is written only if
+  message advances a per-session counter, and a hint is written only if
   the counter is unchanged when the write runs (decided inside the store's
   queue). A late Jev answer about a turn the user already moved past writes
   nothing.
-- The done hint is current while `suggestDoneAt >= session.time.idle` (the
-  assist's freshness rule). This runtime also deletes a hint it wrote when the
-  next turn starts; the rule covers hints written by another process.
+- A turn writes at most one hint: looks done wins over the review offer.
+- A hint is current while its time `>= session.time.idle` (the assist's
+  freshness rule). This runtime also deletes a hint it wrote when the next
+  turn starts; the rule covers hints written by another process.
 - Only top-level, unarchived project sessions that are not review sessions
   (`openchamber.kind === 'review'`) are asked about. Managed Chats (under the
   `chatRoots` the server passes in) are plain conversations and never in work.
@@ -66,8 +73,10 @@ also exists in VS Code.
   message id is asked about once.
 - A turn ended: session assist calls `evaluateTurnEnd` before it arms its quiet
   window. One call carries only the questions that apply: the open questions
-  while not in work, `wrap_up` while in work, `recap` / `next_step` for the
-  assist fields the user has on. No applicable question, no call.
+  while not in work, `wrap_up` while in work, `review_ready` while the review offer is on, `recap` / `next_step` for the assist fields
+  the user has on. No applicable question, no call.
+- Jev reads the request's first 1500 characters, the answer's first and last
+  500, and three earlier turns cut as routing cuts them.
 
 ## Measurement
 
@@ -82,27 +91,43 @@ across 106 work sessions, 22 of them followed by more edits, and caught 53 of
 81 shipping steps. At 0.85 the same wording hinted 70 times (18) and missed a
 closing turn whose answer asked the user for a last check (0.82); the earlier
 request-only wording at 0.85 hinted 60 times (16) and caught 33.
+Growing the answer excerpt from 300+300 to 500+500 left `wrap_up` where it
+was (80 hints, 22 followed by edits; 53 of 77 shipping steps).
+`review_ready >= 0.7` was set on the 156 sessions and checked on the 190,
+against whether the turn ran an edit tool (Jev sees no tools): with looks
+done winning it hinted after 271 of 362 edit turns and after 14 of 823 turns
+without edits. The lab is `julia-lab/jev-work` (`run-review.mjs`,
+`score-held.mjs`) under `~/projects/openchamber-extensions`.
 `recap` stayed high (0.86–0.96) after a closing "thanks"/"commit" that followed
 real work, because it reads the same three turns the recap does. Do not change
 the wording or thresholds without re-running this measurement.
 
 ## Settings
 
-`sessionWorkEnabled` (the block and the actions, default on) and
-`sessionWorkAutoOpen` (Jev opens sessions, default on; not offered in VS Code,
-and inert without a classification provider). Both are read at every use.
+- `sessionWorkEnabled`: the block and the actions, default on.
+- `sessionWorkAutoOpen`: Jev opens sessions, default on; not offered in VS
+  Code, and inert without a classification provider.
+- `sessionReviewOfferEnabled`: the review offer, default off (Settings → Chat →
+  Session Assistance); not offered in VS Code, inert without a classification
+  provider, independent of the other two.
+- `sessionWorkKeepInGroup`: a tracked session also stays under its project
+  group and folders, default off; Recent, Timeline, and Chats still place it
+  once.
+
+All four are read at every use.
 
 ## Runtime parity
 
 - Web, desktop, hosted mobile, Capacitor: all of it; the server owns Jev.
-- VS Code: no OpenChamber server, so no Jev and no done hint. The block and
+- VS Code: no OpenChamber server, so no Jev, no done hint and no review offer. The block and
   Track / Done work through the extension's metadata bridge.
 
 ## Tests
 
 `state.test.js` (patches, reopen rule, hint lifecycle), `runtime.test.js`
 (send-time open, no repeat asks, ineligible sessions, the combined turn-end
-call, a late answer after the next turn started, never closing, failure as
+call, the review offer with and without In work and looks done winning over
+it, a late answer after the next turn started, never closing, failure as
 unknown), plus the gate cases in
 `../session-assist/runtime.test.js`, `loadSettledTurns` in
 `../session-assist/context.test.js`, and `updateSessionMetadata` in

package/server/lib/session-work/questions.js

@@ -36,10 +36,31 @@ const TOWARD_CHANGE = {
  * held-out 70 hints in 106 work sessions (18 followed by more edits) against
  * 60 (16), and 47 of 81 shipping steps hinted against 33. The threshold then
  * went from 0.85 to 0.8: 80 hints (22), 53 of 81 shipping steps, so a closing
- * turn whose answer hands the user a last check still gets the hint.
+ * turn whose answer hands the user a last check still gets the hint. The
+ * answer excerpt then grew from 300+300 to 500+500 characters for
+ * `review_ready`; re-run with the production request cut, wrap-up held: 80
+ * hints (22) against 81 (24), 53 of 77 shipping steps either way.
  */
 const WRAP_UP = 'Does this turn close out the work in this conversation: in `request` the user confirms it works or is good, thanks the agent, or asks to commit, push, merge, sync, or release it, without asking for any further change, and `answer` reports that step done?';
 
+/**
+ * Asked with `wrap_up`: the turn handed over changes the user could look over
+ * (the composer then offers an AI review or a walkthrough). Measured against
+ * whether the turn ran an edit tool, which Jev never sees: on 190 held-out
+ * sessions at 0.7, with a looks-done hint taking precedence, it hinted after
+ * 271 of 362 edit turns and after 14 of 823 turns without edits. Two other
+ * wordings (handed over as done; no criteria) hinted 4-7x more on turns
+ * without edits. Most false hints are cleanups outside the code (deleted
+ * builds); most misses say "did not change the app" after scratch edits.
+ */
+const REVIEW_READY = {
+  question: 'Did the agent change the project in this turn, so there are new changes the user could look over now?',
+  criteria: {
+    true: '`answer` reports that the agent itself edited the project in this turn: implemented, fixed, added, removed, refactored, or rewrote code, UI, docs, tests, or configuration.',
+    false: 'The agent only explained, answered a question, investigated, reviewed code or a PR, proposed or planned a change without making it, drafted a message, ran commands to show output, or committed, pushed, or merged changes made earlier; or it failed before changing anything.',
+  },
+};
+
 const RECAP = {
   question: 'Is there substantive work or a finding in this conversation worth a one-line reminder later: something the agent changed, fixed, found out, or a decision that was reached?',
   criteria: {
@@ -59,6 +80,7 @@ const NEXT_STEP = {
 /** Open when either passes (measured together). */
 const OPEN_THRESHOLDS = { change: 0.85, towardChange: 0.9 };
 const WRAP_UP_THRESHOLD = 0.8;
+const REVIEW_READY_THRESHOLD = 0.7;
 /** The recap is skipped only when Jev is nearly sure there is nothing to remind. */
 const RECAP_SKIP_BELOW = 0.3;
 const NEXT_STEP_THRESHOLD = 0.5;
@@ -81,7 +103,8 @@ export const buildSendRequest = ({ history, request }) => ({
 /**
  * The request Jev reads when a turn ended, or null when nothing is asked.
  * `ask` names the groups: `open` (the session is not in work), `wrapUp` (it
- * is), `recap` and `nextStep` (the assist fields the user has on).
+ * is), `reviewReady` (the review offer is on), `recap` and `nextStep` (the
+ * assist fields the user has on).
  */
 export const buildTurnEndRequest = ({ history, request, answer, ask }) => {
   const questions = {};
@@ -90,6 +113,7 @@ export const buildTurnEndRequest = ({ history, request, answer, ask }) => {
     questions.toward_change = noul(TURN_END_CONTEXT, TOWARD_CHANGE);
   }
   if (ask.wrapUp) questions.wrap_up = noul(TURN_END_CONTEXT, { question: WRAP_UP });
+  if (ask.reviewReady) questions.review_ready = noul(TURN_END_CONTEXT, REVIEW_READY);
   if (ask.recap) questions.recap = noul(TURN_END_CONTEXT, RECAP);
   if (ask.nextStep) questions.next_step = noul(TURN_END_CONTEXT, NEXT_STEP);
   if (Object.keys(questions).length === 0) return null;
@@ -112,6 +136,11 @@ export const decideWrapUp = (answers) => {
   return score !== null && score >= WRAP_UP_THRESHOLD;
 };
 
+export const decideReviewReady = (answers) => {
+  const score = answerOf(answers, 'review_ready');
+  return score !== null && score >= REVIEW_READY_THRESHOLD;
+};
+
 /**
  * Which assist fields are worth the Small Model. A field Jev did not answer
  * stays allowed: an unanswered question must not silence the assist.