@openchambery/web 1.18.7-beta.1 → 1.18.7-beta.3

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

@@ -305,6 +305,113 @@ const extractGoalFromSession = (session) => {
   };
 };
 
+/**
+ * Single-shot session outcome for post-run continuation (no polling).
+ * Goal-enabled: terminal complete → success; blocked/budgetLimited → error;
+ * otherwise not-yet-success. Non-goal: busy/retry, assistant error, or
+ * completed assistant; incomplete/empty tails are not treated as success.
+ */
+const snapshotSessionOutcome = async ({
+  client,
+  sessionID,
+  projectPath,
+  goalEnabled,
+  signal,
+}) => {
+  const requestOptions = signal ? { signal } : undefined;
+
+  if (goalEnabled && typeof client?.session?.get === 'function') {
+    try {
+      const sessionResult = await client.session.get({
+        sessionID,
+        directory: projectPath,
+      }, requestOptions);
+      if (!sessionResult?.error) {
+        const goal = extractGoalFromSession(sessionResult?.data);
+        if (goal && GOAL_TERMINAL_STATUSES.has(goal.status)) {
+          if (goal.status === 'complete') {
+            return { outcome: 'success' };
+          }
+          return {
+            outcome: 'error',
+            error: goal.note || `goal ${goal.status}`,
+          };
+        }
+      }
+    } catch (error) {
+      if (signal?.aborted) throw error;
+    }
+    return { outcome: 'busy' };
+  }
+
+  if (typeof client?.session?.status === 'function') {
+    try {
+      const statusResult = await client.session.status({
+        directory: projectPath,
+      }, requestOptions);
+      if (!statusResult?.error && statusResult?.data && typeof statusResult.data === 'object') {
+        const statusValue = statusResult.data[sessionID];
+        const type = statusValue?.type ?? statusValue?.status;
+        if (type === 'busy' || type === 'retry') {
+          return { outcome: 'busy' };
+        }
+      }
+    } catch (error) {
+      if (signal?.aborted) throw error;
+    }
+  }
+
+  if (typeof client?.session?.messages === 'function') {
+    try {
+      const messagesResult = await client.session.messages({
+        sessionID,
+        directory: projectPath,
+        limit: 50,
+      }, requestOptions);
+      if (!messagesResult?.error && Array.isArray(messagesResult?.data)) {
+        const lastInfo = readMessageInfo(messagesResult.data.at(-1));
+        if (lastInfo?.role === 'assistant') {
+          if (lastInfo.error) {
+            return {
+              outcome: 'error',
+              error: formatAssistantError(lastInfo.error),
+            };
+          }
+          if (lastInfo.time?.completed) {
+            return { outcome: 'success' };
+          }
+        }
+      }
+    } catch (error) {
+      if (signal?.aborted) throw error;
+    }
+  }
+
+  return { outcome: 'busy' };
+};
+
+const parseSessionEventPhase = (event) => {
+  const payload = event?.payload?.payload ?? event?.payload;
+  const properties = payload?.properties;
+  const sessionID = typeof properties?.sessionID === 'string' ? properties.sessionID : '';
+  if (!sessionID) {
+    return { phase: '', sessionID: '' };
+  }
+  if (payload?.type === 'session.idle') {
+    return { phase: 'idle', sessionID };
+  }
+  if (payload?.type === 'session.status') {
+    const type = properties?.status?.type ?? properties?.info?.type;
+    if (type === 'idle') {
+      return { phase: 'idle', sessionID };
+    }
+    if (type === 'busy' || type === 'retry') {
+      return { phase: 'busy', sessionID };
+    }
+  }
+  return { phase: '', sessionID };
+};
+
 export const createScheduledTasksRuntime = (deps) => {
   const {
     projectConfigRuntime,
@@ -331,6 +438,34 @@ export const createScheduledTasksRuntime = (deps) => {
   const runningCountByProject = new Map();
   let runningGlobalCount = 0;
   const queue = [];
+  /** sessionID → { projectID, taskID } for post-run continuation correction. */
+  const lastSessionOwners = new Map();
+
+  const rememberLastSession = (projectID, task) => {
+    const sessionID = task?.state?.lastSessionId;
+    if (typeof sessionID !== 'string' || !sessionID || !task?.id) {
+      return;
+    }
+    lastSessionOwners.set(sessionID, { projectID, taskID: task.id });
+  };
+
+  const forgetLastSessionsForProject = (projectID) => {
+    for (const [sessionID, owner] of [...lastSessionOwners.entries()]) {
+      if (owner.projectID === projectID) {
+        lastSessionOwners.delete(sessionID);
+      }
+    }
+  };
+
+  const forgetLastSessionIfOwned = (projectID, taskID, sessionID) => {
+    if (typeof sessionID !== 'string' || !sessionID) {
+      return;
+    }
+    const owner = lastSessionOwners.get(sessionID);
+    if (owner?.projectID === projectID && owner?.taskID === taskID) {
+      lastSessionOwners.delete(sessionID);
+    }
+  };
 
   const clearTimerForKey = (taskKey) => {
     const timer = timersByTaskKey.get(taskKey);
@@ -361,9 +496,11 @@ export const createScheduledTasksRuntime = (deps) => {
 
   const setProjectTasks = (projectID, tasks) => {
     clearProjectTimers(projectID);
+    forgetLastSessionsForProject(projectID);
     const taskMap = new Map();
     for (const task of tasks) {
       taskMap.set(task.id, task);
+      rememberLastSession(projectID, task);
     }
     tasksByProject.set(projectID, taskMap);
   };
@@ -412,7 +549,14 @@ export const createScheduledTasksRuntime = (deps) => {
     if (!taskMap) {
       return;
     }
+    const previous = taskMap.get(nextTask.id);
+    const previousSessionID = previous?.state?.lastSessionId;
+    const nextSessionID = nextTask.state?.lastSessionId;
+    if (previousSessionID && previousSessionID !== nextSessionID) {
+      forgetLastSessionIfOwned(projectID, nextTask.id, previousSessionID);
+    }
     taskMap.set(nextTask.id, nextTask);
+    rememberLastSession(projectID, nextTask);
   };
 
   const syncTaskSchedule = async (projectID, task) => {
@@ -1152,6 +1296,15 @@ export const createScheduledTasksRuntime = (deps) => {
           if (runningState.task) {
             updateInMemoryTask(projectID, runningState.task);
           }
+          try {
+            emitTaskRunEvent?.({
+              projectID,
+              taskID,
+              ranAt: runStartedAt,
+              status: 'running',
+            });
+          } catch {
+          }
         } catch (error) {
           errorMessage = safeErrorMessage(error);
           logger.warn?.('[ScheduledTasks] failed to persist running state', {
@@ -1278,14 +1431,17 @@ export const createScheduledTasksRuntime = (deps) => {
 
       const nextRunAt = computeNextRunAt(latestTask, finishedAt);
       try {
-        stateResult = await projectConfigRuntime.updateScheduledTaskState(projectID, taskID, {
+        const statePatch = {
           lastStatus: status,
           lastDurationMs: durationMs,
           lastError: status === 'error' ? errorMessage : undefined,
-          lastSessionId: status === 'success' ? sessionID : undefined,
           nextRunAt: Number.isFinite(nextRunAt) ? nextRunAt : undefined,
           updatedAt: finishedAt,
-        });
+        };
+        if (sessionID) {
+          statePatch.lastSessionId = sessionID;
+        }
+        stateResult = await projectConfigRuntime.updateScheduledTaskState(projectID, taskID, statePatch);
         if (stateResult.task) {
           updateInMemoryTask(projectID, stateResult.task);
           if (stateResult.task.enabled && Number.isFinite(stateResult.task.state?.nextRunAt)) {
@@ -1301,6 +1457,9 @@ export const createScheduledTasksRuntime = (deps) => {
           error: errorMessage,
         });
       }
+      if (sessionID) {
+        lastSessionOwners.set(sessionID, { projectID, taskID });
+      }
 
       // History final status reflects the ultimate run outcome, including
       // state-persistence failures. A failed finalize leaves the row running
@@ -1441,6 +1600,114 @@ export const createScheduledTasksRuntime = (deps) => {
     };
   };
 
+  const emitContinuationStatus = (projectID, taskID, sessionID, status) => {
+    try {
+      emitTaskRunEvent?.({
+        projectID,
+        taskID,
+        ranAt: Date.now(),
+        status,
+        sessionID,
+      });
+    } catch {
+    }
+  };
+
+  const handleSessionContinuation = async (event) => {
+    const { phase, sessionID } = parseSessionEventPhase(event);
+    if (!phase || !sessionID) {
+      return;
+    }
+
+    const owner = lastSessionOwners.get(sessionID);
+    if (!owner) {
+      return;
+    }
+
+    const { projectID, taskID } = owner;
+    const taskKey = buildTaskKey(projectID, taskID);
+    if (runningTaskKeys.has(taskKey)) {
+      return;
+    }
+
+    const task = tasksByProject.get(projectID)?.get(taskID);
+    const lastStatus = task?.state?.lastStatus;
+
+    if (phase === 'busy') {
+      if (lastStatus !== 'error' && lastStatus !== 'success') {
+        return;
+      }
+      const stateResult = await projectConfigRuntime.updateScheduledTaskState(projectID, taskID, {
+        lastStatus: 'running',
+        lastError: undefined,
+        lastSessionId: sessionID,
+        updatedAt: Date.now(),
+      });
+      if (stateResult.task) {
+        updateInMemoryTask(projectID, stateResult.task);
+      }
+      emitContinuationStatus(projectID, taskID, sessionID, 'running');
+      return;
+    }
+
+    if (lastStatus === 'success') {
+      return;
+    }
+    if (lastStatus !== 'error' && lastStatus !== 'running') {
+      return;
+    }
+
+    const projectPath = projectPathByID.get(projectID) || await ensureProjectPath(projectID);
+    if (!projectPath) {
+      return;
+    }
+
+    const baseUrl = buildOpenCodeUrl('/', '').replace(/\/$/, '');
+    const authHeaders = getOpenCodeAuthHeaders();
+    const client = createOpencodeClient({
+      baseUrl,
+      headers: authHeaders,
+    });
+    const snapshot = await snapshotSessionOutcome({
+      client,
+      sessionID,
+      projectPath,
+      goalEnabled: Boolean(task.execution?.goalEnabled),
+    });
+    if (snapshot.outcome !== 'success') {
+      return;
+    }
+
+    if (runningTaskKeys.has(taskKey)) {
+      return;
+    }
+    const latest = tasksByProject.get(projectID)?.get(taskID);
+    const latestStatus = latest?.state?.lastStatus;
+    if (latestStatus !== 'error' && latestStatus !== 'running') {
+      return;
+    }
+
+    const stateResult = await projectConfigRuntime.updateScheduledTaskState(projectID, taskID, {
+      lastStatus: 'success',
+      lastError: undefined,
+      lastSessionId: sessionID,
+      updatedAt: Date.now(),
+    });
+    if (stateResult.task) {
+      updateInMemoryTask(projectID, stateResult.task);
+    }
+
+    emitContinuationStatus(projectID, taskID, sessionID, 'success');
+  };
+
+  const observeSessionEvent = (event) => {
+    return handleSessionContinuation(event).catch((error) => {
+      logger.warn?.('[ScheduledTasks] observeSessionEvent failed', {
+        error: safeErrorMessage(error),
+      });
+    });
+  };
+
   return {
     start,
     stop,
@@ -1448,5 +1715,6 @@ export const createScheduledTasksRuntime = (deps) => {
     syncProject,
     runNow,
     getStatus,
+    observeSessionEvent,
   };
 };

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

@@ -993,4 +993,312 @@ describe('scheduled-tasks run history and session lifecycle', () => {
 
     vi.unstubAllGlobals();
   });
+
+  it('persists lastSessionId when an error run still created a session', async () => {
+    const history = createHistoryStore();
+    createSuccessfulClient({ settlement: 'assistant-error' });
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('prompt_async')) {
+        return { ok: true, text: async () => '' };
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+    });
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe('error');
+    const finalPatch = updateScheduledTaskState.mock.calls.at(-1)[2];
+    expect(finalPatch.lastStatus).toBe('error');
+    expect(finalPatch.lastSessionId).toBe('ses_1');
+
+    vi.unstubAllGlobals();
+  });
+
+  it('omits lastSessionId from the final patch when the failed run has no session', async () => {
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState);
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe('error');
+    const finalPatch = updateScheduledTaskState.mock.calls.at(-1)[2];
+    expect(finalPatch.lastStatus).toBe('error');
+    expect(Object.hasOwn(finalPatch, 'lastSessionId')).toBe(false);
+  });
+
+  it('marks lastStatus running when a history session continues, then success on idle', async () => {
+    const history = createHistoryStore();
+    const client = createSuccessfulClient({ settlement: 'assistant-error' });
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('prompt_async')) {
+        return { ok: true, text: async () => '' };
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const emitTaskRunEvent = vi.fn();
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+      emitTaskRunEvent,
+    });
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+    expect(result.status).toBe('error');
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+
+    await runtime.observeSessionEvent({
+      payload: {
+        type: 'session.status',
+        properties: { sessionID: 'ses_1', status: { type: 'busy' } },
+      },
+    });
+
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+    const runningPatch = updateScheduledTaskState.mock.calls.at(-1)[2];
+    expect(runningPatch).toEqual(expect.objectContaining({
+      lastStatus: 'running',
+      lastError: undefined,
+      lastSessionId: 'ses_1',
+    }));
+    expect(Object.hasOwn(runningPatch, 'lastRunAt')).toBe(false);
+    expect(emitTaskRunEvent).toHaveBeenCalledWith(expect.objectContaining({
+      projectID: 'project-1',
+      taskID: 'task-1',
+      status: 'running',
+      sessionID: 'ses_1',
+    }));
+
+    client.messages.mockImplementation(async () => ({
+      data: [{
+        info: {
+          id: 'msg_ok',
+          role: 'assistant',
+          time: { completed: Date.now() },
+        },
+      }],
+    }));
+
+    await runtime.observeSessionEvent({
+      payload: {
+        type: 'session.idle',
+        properties: { sessionID: 'ses_1' },
+      },
+    });
+
+    expect(updateScheduledTaskState.mock.calls.at(-1)[2]).toEqual(expect.objectContaining({
+      lastStatus: 'success',
+      lastSessionId: 'ses_1',
+    }));
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+
+    vi.unstubAllGlobals();
+  });
+
+  it('corrects lastStatus error → success on idle after a continuation, without rewriting history', async () => {
+    const history = createHistoryStore();
+    const client = createSuccessfulClient({ settlement: 'assistant-error' });
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('prompt_async')) {
+        return { ok: true, text: async () => '' };
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const emitTaskRunEvent = vi.fn();
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+      emitTaskRunEvent,
+    });
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+    expect(result.status).toBe('error');
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+
+    client.messages.mockImplementation(async () => ({
+      data: [{
+        info: {
+          id: 'msg_ok',
+          role: 'assistant',
+          time: { completed: Date.now() },
+        },
+      }],
+    }));
+
+    await runtime.observeSessionEvent({
+      payload: {
+        type: 'session.idle',
+        properties: { sessionID: 'ses_1' },
+      },
+    });
+
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+    const correctionPatch = updateScheduledTaskState.mock.calls.at(-1)[2];
+    expect(correctionPatch).toEqual(expect.objectContaining({
+      lastStatus: 'success',
+      lastError: undefined,
+      lastSessionId: 'ses_1',
+    }));
+    expect(Object.hasOwn(correctionPatch, 'lastRunAt')).toBe(false);
+    expect(Object.hasOwn(correctionPatch, 'lastDurationMs')).toBe(false);
+    expect(Object.hasOwn(correctionPatch, 'nextRunAt')).toBe(false);
+    expect(emitTaskRunEvent).toHaveBeenCalledWith(expect.objectContaining({
+      projectID: 'project-1',
+      taskID: 'task-1',
+      status: 'success',
+      sessionID: 'ses_1',
+    }));
+
+    vi.unstubAllGlobals();
+  });
+
+  it('does not correct lastStatus while the task is still running', async () => {
+    vi.useFakeTimers();
+    const history = createHistoryStore();
+    const erroredTask = {
+      ...scheduledTask,
+      state: {
+        ...scheduledTask.state,
+        lastStatus: 'error',
+        lastSessionId: 'ses_1',
+        lastError: 'ProviderError',
+      },
+    };
+    createSuccessfulClient({ settlement: 'busy-then-success' });
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('prompt_async')) {
+        return { ok: true, text: async () => '' };
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const emitTaskRunEvent = vi.fn();
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...erroredTask, state: { ...erroredTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      projectConfigRuntime: {
+        listScheduledTasks: vi.fn(async () => [erroredTask]),
+        updateScheduledTaskState,
+        upsertScheduledTask: vi.fn(),
+      },
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+      emitTaskRunEvent,
+    });
+    await runtime.syncProject('project-1');
+
+    const runPromise = runtime.runNow('project-1', 'task-1');
+    await vi.advanceTimersByTimeAsync(0);
+    expect(history.finishRun).not.toHaveBeenCalled();
+
+    const successEmitsBefore = emitTaskRunEvent.mock.calls.filter((call) => call[0].status === 'success').length;
+    const continuationRunningBefore = updateScheduledTaskState.mock.calls.filter((call) => (
+      call[2].lastStatus === 'running' && !Object.hasOwn(call[2], 'lastRunAt')
+    )).length;
+    await runtime.observeSessionEvent({
+      payload: {
+        type: 'session.status',
+        properties: { sessionID: 'ses_1', status: { type: 'busy' } },
+      },
+    });
+    await runtime.observeSessionEvent({
+      payload: {
+        type: 'session.idle',
+        properties: { sessionID: 'ses_1' },
+      },
+    });
+    expect(history.finishRun).not.toHaveBeenCalled();
+    expect(updateScheduledTaskState.mock.calls.map((call) => call[2].lastStatus)).not.toContain('success');
+    expect(emitTaskRunEvent.mock.calls.filter((call) => call[0].status === 'success')).toHaveLength(successEmitsBefore);
+    expect(updateScheduledTaskState.mock.calls.filter((call) => (
+      call[2].lastStatus === 'running' && !Object.hasOwn(call[2], 'lastRunAt')
+    ))).toHaveLength(continuationRunningBefore);
+
+    await vi.advanceTimersByTimeAsync(1_000);
+    const result = await runPromise;
+    expect(result.ok).toBe(true);
+
+    vi.unstubAllGlobals();
+    vi.useRealTimers();
+  });
+
+  it('does not correct lastStatus when it is already success', async () => {
+    const history = createHistoryStore();
+    const client = createSuccessfulClient();
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('prompt_async')) {
+        return { ok: true, text: async () => '' };
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const emitTaskRunEvent = vi.fn();
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+      emitTaskRunEvent,
+    });
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+
+    expect(result.ok).toBe(true);
+    expect(emitTaskRunEvent.mock.calls.map((call) => call[0].status)[0]).toBe('running');
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+    const stateWritesAfterRun = updateScheduledTaskState.mock.calls.length;
+    const successEmitsAfterRun = emitTaskRunEvent.mock.calls.filter((call) => call[0].status === 'success').length;
+
+    client.messages.mockImplementation(async () => ({
+      data: [{
+        info: {
+          id: 'msg_ok',
+          role: 'assistant',
+          time: { completed: Date.now() },
+        },
+      }],
+    }));
+
+    await runtime.observeSessionEvent({
+      payload: {
+        type: 'session.status',
+        properties: {
+          sessionID: 'ses_1',
+          status: { type: 'idle' },
+        },
+      },
+    });
+
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+    expect(updateScheduledTaskState).toHaveBeenCalledTimes(stateWritesAfterRun);
+    expect(emitTaskRunEvent.mock.calls.filter((call) => call[0].status === 'success')).toHaveLength(successEmitsAfterRun);
+
+    vi.unstubAllGlobals();
+  });
 });

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

@@ -3,7 +3,7 @@
 Server-side control loop that keeps a session working toward a user-defined
 objective stored under `metadata.openchamber.goal`, with the small model as
 an independent progress auditor. Built on OpenChamber's backend-driven
-architecture (session-assist is the structural template): the loop lives in
+architecture: the loop lives in
 the web server and survives UI disconnects.
 
 ## Goal payload (`metadata.openchamber.goal`)
@@ -69,8 +69,8 @@ before touching the filesystem). Rationale: metadata rides every
 
 ## Flow
 
-1. `createSessionGoalRuntime` subscribes to the global SSE hub (same pattern
-   as session-assist — it needs the envelope's `directory`).
+1. `createSessionGoalRuntime` subscribes to the global SSE hub (it needs
+   the envelope's `directory`).
 2. `session.status: idle` arms a 15s per-session timer; `busy`/`retry` clears
    it. A `session.updated` carrying a fresh active goal (`turnsUsed === 0` or
    `statusReason === 'resumed'`) arms a kickoff timer — 3s for fresh goals,

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

@@ -11,7 +11,7 @@
 // has no channel to settle its own goal. When the small model is unavailable
 // the loop still terminates via the budget and the continuation cap.
 //
-// Purely event-driven like session-assist: no polling, no backfill, no session
+// Purely event-driven: no polling, no backfill, no session
 // scans. Only sessions that emit events while the server runs ever tick.
 
 import fs from 'fs';
@@ -110,8 +110,8 @@ const buildAuditSystemPrompt = () => [
 ].join('\n');
 
 // Hard guard against language hallucination (account-side personalization
-// can leak a different language despite the instruction — same issue
-// session-assist hit): if the note uses a script absent from the objective
+// can leak a different language despite the instruction): if the note uses
+// a script absent from the objective
 // and the agent's reply, drop the note but keep the verdict.
 const SCRIPT_RANGES = [
   /[Ѐ-ӿ]/, // Cyrillic