@aiworker/web 1.22.0 → 1.22.2

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

@@ -1,5 +1,5 @@
 // Session goal: a persisted, self-continuing objective attached to a session
-// (metadata.openchamber.goal). While the goal is active, the server keeps the
+// (metadata.aiworker.goal). While the goal is active, the server keeps the
 // session working toward it: after each busy→idle transition it accounts token
 // usage, asks the small model to audit progress (continue / complete /
 // blocked), and either re-prompts the session's own model with a continuation
@@ -20,16 +20,16 @@ import path from 'path';
 
 import { GOAL_OBJECTIVE_CHAR_LIMIT, readObjective } from './objectives.js';
 
-const OPENCHAMBER_SETTINGS_FILE = path.join(
-  process.env.OPENCHAMBER_DATA_DIR
-    ? path.resolve(process.env.OPENCHAMBER_DATA_DIR)
-    : path.join(os.homedir(), '.config', 'openchamber'),
+const AIWORKER_SETTINGS_FILE = path.join(
+  process.env.AIWORKER_DATA_DIR
+    ? path.resolve(process.env.AIWORKER_DATA_DIR)
+    : path.join(os.homedir(), '.config', 'aiworker'),
   'settings.json',
 );
 
 const isSessionGoalEnabled = () => {
   try {
-    const raw = fs.readFileSync(OPENCHAMBER_SETTINGS_FILE, 'utf8');
+    const raw = fs.readFileSync(AIWORKER_SETTINGS_FILE, 'utf8');
     const settings = JSON.parse(raw);
     return settings?.sessionGoalEnabled !== false;
   } catch {
@@ -188,7 +188,7 @@ const extractSessionUpdate = (payload) => {
 const parseGoalMetadata = (session) => {
   const metadata = session?.metadata;
   if (!metadata || typeof metadata !== 'object') return null;
-  const namespace = metadata.openchamber;
+  const namespace = metadata.aiworker;
   if (!namespace || typeof namespace !== 'object') return null;
   const goal = namespace.goal;
   if (!goal || typeof goal !== 'object') return null;
@@ -244,6 +244,57 @@ const messageTokenTotal = (info) => {
   return input + cachedRead + output;
 };
 
+const getErrorName = (error) => error?.name?.trim?.() ?? '';
+
+const isLengthTruncated = (info, errorName = getErrorName(info?.error)) => {
+  const error = info?.error;
+  const hasError = error !== null && error !== undefined;
+  return errorName === 'MessageOutputLengthError' || (!hasError && info?.finish === 'length');
+};
+
+// Summary messages are assistant-shaped, but they are compaction turns rather
+// than agent turns. They must not break or satisfy the consecutive truncation
+// check; only completed, non-summary assistant turns participate. Chronology
+// comes from `time.created`, never from message IDs; array position is only a
+// tie-breaker for equal timestamps.
+const hasRepeatedLengthTail = (messages, latestAssistant, goalCreatedAt) => {
+  const latestInfo = latestAssistant?.info;
+  if (latestInfo?.summary === true) return false;
+  const latestIndex = messages.indexOf(latestAssistant);
+  const latestCreated = latestInfo?.time?.created;
+  if (
+    latestIndex < 0
+    || !(latestInfo?.time?.completed > 0)
+    || !(Number.isFinite(latestCreated) && latestCreated > 0)
+    || !isLengthTruncated(latestInfo)
+  ) return false;
+
+  let previous = null;
+  for (let i = 0; i < messages.length; i += 1) {
+    const info = messages[i]?.info;
+    if (info?.role !== 'assistant' || info.summary === true || !(info.time?.completed > 0)) continue;
+    const created = info.time?.created;
+    // An unknown timestamp cannot safely participate in chronology. Ignore it
+    // rather than letting an unrelated older message hide known chronology.
+    if (!(Number.isFinite(created) && created > 0)) continue;
+    if (i === latestIndex) continue;
+    if (created > latestCreated || (created === latestCreated && i > latestIndex)) continue;
+    if (
+      !previous
+      || created > previous.created
+      || (created === previous.created && i > previous.index)
+    ) {
+      previous = { info, created, index: i };
+    }
+  }
+
+  return Boolean(
+    previous
+    && previous.created > goalCreatedAt
+    && isLengthTruncated(previous.info),
+  );
+};
+
 export const createSessionGoalRuntime = ({
   buildOpenCodeUrl,
   getOpenCodeAuthHeaders,
@@ -319,8 +370,8 @@ export const createSessionGoalRuntime = ({
     if (!currentGoal || currentGoal.id !== expectedGoalId) return null;
     const nextGoal = { ...currentGoal, ...mutate(currentGoal), updatedAt: Date.now() };
     const currentMetadata = session?.metadata && typeof session.metadata === 'object' ? session.metadata : {};
-    const currentNamespace = currentMetadata.openchamber && typeof currentMetadata.openchamber === 'object'
-      ? currentMetadata.openchamber
+    const currentNamespace = currentMetadata.aiworker && typeof currentMetadata.aiworker === 'object'
+      ? currentMetadata.aiworker
       : {};
     await openCodeFetch(`/session/${encodeURIComponent(sessionId)}`, {
       directory,
@@ -328,7 +379,7 @@ export const createSessionGoalRuntime = ({
       body: {
         metadata: {
           ...currentMetadata,
-          openchamber: { ...currentNamespace, goal: nextGoal },
+          aiworker: { ...currentNamespace, goal: nextGoal },
         },
       },
     });
@@ -378,6 +429,7 @@ export const createSessionGoalRuntime = ({
         prompt: `The goal objective:\n\n<objective>\n${goal.objective}\n</objective>\n\nThe agent's latest turn:\n\n${assistantText}\n\nReturn the verdict JSON. Write the note in the SAME language as this sample from the objective: "${goal.objective.slice(0, 200).replace(/\s+/g, ' ').trim()}"`,
         system: buildAuditSystemPrompt(),
         directory,
+        sessionID: typeof lastAssistantInfo?.sessionID === 'string' ? lastAssistantInfo.sessionID : undefined,
         preferredProviderID: typeof lastAssistantInfo?.providerID === 'string' ? lastAssistantInfo.providerID : undefined,
         preferredModelID: typeof lastAssistantInfo?.modelID === 'string' ? lastAssistantInfo.modelID : undefined,
       });
@@ -460,7 +512,7 @@ export const createSessionGoalRuntime = ({
     if (!goal || goal.status !== 'active') return;
 
     // File-backed objectives: the metadata carries only a flag; the objective
-    // TEXT lives under the OpenChamber data dir keyed by session id and is
+    // TEXT lives under the AiWorker data dir keyed by session id and is
     // read fresh on every tick (live-editable). A missing file falls back to
     // whatever inline objective the metadata still has — the goal must never
     // die just because a file went away.
@@ -608,7 +660,11 @@ export const createSessionGoalRuntime = ({
     // resumed over an aborted tail: that is an explicit "keep going", so it
     // falls through to the continuation below (skipping the audit — an
     // aborted reply is not evidence of anything).
-    const abortedTail = lastAssistantInfo.error?.name === 'MessageAbortedError';
+    const error = lastAssistantInfo.error;
+    const errorName = getErrorName(error);
+    const hasError = error !== null && error !== undefined;
+    const abortedTail = errorName === 'MessageAbortedError';
+    const lengthTail = isLengthTruncated(lastAssistantInfo, errorName);
     if (abortedTail && goal.statusReason !== 'resumed') {
       await writeGoal(sessionId, directory, goal.id, () => ({
         status: 'paused',
@@ -622,13 +678,12 @@ export const createSessionGoalRuntime = ({
       return;
     }
 
-    // Turn error → blocked (prevents runaway auto-continuation into failures).
-    if (!abortedTail && lastAssistantInfo.error && typeof lastAssistantInfo.error === 'object') {
-      const reason = typeof lastAssistantInfo.error.name === 'string' && lastAssistantInfo.error.name
-        ? lastAssistantInfo.error.name
-        : 'assistant turn failed';
+    // Non-length turn error → blocked (prevents runaway auto-continuation into
+    // failures). Recognized length cutoffs are in-progress continuations, not
+    // hard failures.
+    if (!abortedTail && !lengthTail && hasError) {
       await settleGoal({
-        sessionId, directory, goal, status: 'blocked', statusReason: reason, tokensUsed, tokensBaseline, tokensCommitted, lastAccountedMessageID,
+        sessionId, directory, goal, status: 'blocked', statusReason: errorName || 'assistant turn failed', tokensUsed, tokensBaseline, tokensCommitted, lastAccountedMessageID,
       });
       return;
     }
@@ -649,17 +704,28 @@ export const createSessionGoalRuntime = ({
       return;
     }
 
+    // A second consecutive completed, non-summary length-truncated turn is a
+    // bounded recovery failure. Derive this from the loaded transcript rather
+    // than persisting another goal counter.
+    if (lengthTail && goal.statusReason !== 'resumed' && hasRepeatedLengthTail(messages, lastAssistant, goal.createdAt)) {
+      await settleGoal({
+        sessionId, directory, goal, status: 'blocked', statusReason: 'repeated output truncation', tokensUsed, tokensBaseline, tokensCommitted, lastAccountedMessageID,
+      });
+      return;
+    }
+
     // --- Small-model audit: the sole termination authority besides the hard
     // stops above (turn error, budget, continuation cap). The working agent
     // has no channel to settle its own goal.
     //
-    // Exception: when the latest message is a compaction summary, the agent
-    // by definition ran into the context window mid-work — that IS
-    // "in progress, not finished". No audit call; continue unconditionally.
+    // Exception: when the latest message is a compaction summary or was cut off
+    // by the output token limit (length stop), the agent by definition ran into
+    // the context/output limit mid-work — that IS "in progress, not finished".
+    // No audit call; continue unconditionally.
     let audit = null;
     let blockedStreak = 0;
     let auditFailStreak = goal.auditFailStreak;
-    if (lastAssistantInfo.summary === true || abortedTail) {
+    if (lastAssistantInfo.summary === true || abortedTail || lengthTail) {
       blockedStreak = goal.blockedStreak;
     } else {
       audit = await runAudit({ goal: { ...goal, objective: effectiveObjective }, assistantText, directory, lastAssistantInfo: executionInfo ?? lastAssistantInfo });

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

@@ -18,7 +18,7 @@ const goal = {
 const session = {
   id: SESSION_ID,
   directory: DIRECTORY,
-  metadata: { openchamber: { goal } },
+  metadata: { aiworker: { goal } },
 };
 
 const jsonResponse = (body, status = 200) => new Response(JSON.stringify(body), {
@@ -46,6 +46,78 @@ const startIdleTick = async (fetchImpl) => {
   return { runtime, getSmallModelService };
 };
 
+const assistantMessage = (id, infoOverrides = {}) => ({
+  info: {
+    id,
+    sessionID: SESSION_ID,
+    role: 'assistant',
+    providerID: 'provider',
+    modelID: 'model',
+    time: { created: 2, completed: 2 },
+    tokens: { input: 1, output: 1, cache: { read: 0 } },
+    ...infoOverrides,
+  },
+  parts: [{ type: 'text', text: 'The agent made progress.' }],
+});
+
+const createRuntimeHarness = ({ messages, messageFactory, goalOverrides = {}, maxAutoTurns = 20 }) => {
+  const requests = [];
+  let messageFetchCount = 0;
+  const activeSession = {
+    ...session,
+    metadata: { aiworker: { goal: { ...goal, ...goalOverrides } } },
+  };
+  const service = {
+    generateSmallModelText: vi.fn(async () => ({
+      text: '{"verdict":"continue","note":"More work remains"}',
+      providerID: 'provider',
+      modelID: 'model',
+    })),
+  };
+  const fetchImpl = vi.fn(async (input, init = {}) => {
+    const pathname = requestPath(input);
+    requests.push({ pathname, method: init.method ?? 'GET', body: init.body });
+    if (pathname === `/session/${SESSION_ID}` && init.method === 'PATCH') {
+      activeSession.metadata = JSON.parse(init.body).metadata;
+      return jsonResponse(activeSession);
+    }
+    if (pathname === `/session/${SESSION_ID}`) return jsonResponse(activeSession);
+    if (pathname === '/session/status') return jsonResponse({});
+    if (pathname === `/session/${SESSION_ID}/children`) return jsonResponse([]);
+    if (pathname === `/session/${SESSION_ID}/message`) {
+      const nextMessages = messageFactory ? messageFactory(messageFetchCount) : messages;
+      messageFetchCount += 1;
+      return jsonResponse(nextMessages);
+    }
+    if (pathname === `/session/${SESSION_ID}/prompt_async`) return jsonResponse({ ok: true });
+    throw new Error(`Unexpected request: ${pathname}`);
+  });
+  vi.stubGlobal('fetch', fetchImpl);
+  const runtime = createSessionGoalRuntime({
+    buildOpenCodeUrl: (pathname) => `http://opencode.test${pathname}`,
+    getOpenCodeAuthHeaders: () => ({}),
+    getSmallModelService: async () => service,
+    isEnabled: () => true,
+    idleQuietMs: 10,
+    maxAutoTurns,
+  });
+  return { runtime, requests, service, activeSession };
+};
+
+const runIdleTick = async (runtime) => {
+  runtime.processPayload({
+    type: 'session.status',
+    properties: { sessionID: SESSION_ID, status: { type: 'idle' }, directory: DIRECTORY },
+  });
+  await vi.runOnlyPendingTimersAsync();
+};
+
+const lastPatchedGoal = (requests) => {
+  const patches = requests.filter((request) => request.pathname === `/session/${SESSION_ID}` && request.method === 'PATCH');
+  expect(patches.length).toBeGreaterThan(0);
+  return JSON.parse(patches.at(-1).body).metadata.aiworker.goal;
+};
+
 describe('session goal live activity gate', () => {
   beforeEach(() => {
     vi.useFakeTimers();
@@ -170,7 +242,7 @@ describe('session goal live activity gate', () => {
     expect(service.generateSmallModelText).toHaveBeenCalledOnce();
     const patch = requests.find((request) => request.pathname === `/session/${SESSION_ID}` && request.method === 'PATCH');
     expect(patch).toBeDefined();
-    const writtenGoal = JSON.parse(patch.body).metadata.openchamber.goal;
+    const writtenGoal = JSON.parse(patch.body).metadata.aiworker.goal;
     expect(writtenGoal).toMatchObject({
       status: 'complete',
       evaluationProviderID: 'provider',
@@ -178,4 +250,358 @@ describe('session goal live activity gate', () => {
     });
     runtime.stop();
   });
+
+  it('skips audit and sends continuation prompt when assistant message finishes with length stop', async () => {
+    const requests = [];
+    const fetchImpl = vi.fn(async (input, init = {}) => {
+      const pathname = requestPath(input);
+      requests.push({ pathname, method: init.method ?? 'GET', body: init.body });
+      if (pathname === `/session/${SESSION_ID}` && init.method === 'PATCH') return jsonResponse(session);
+      if (pathname === `/session/${SESSION_ID}`) return jsonResponse(session);
+      if (pathname === '/session/status') return jsonResponse({});
+      if (pathname === `/session/${SESSION_ID}/children`) return jsonResponse([]);
+      if (pathname === `/session/${SESSION_ID}/prompt_async`) return jsonResponse({ ok: true });
+      if (pathname === `/session/${SESSION_ID}/message`) {
+        return jsonResponse([{
+          info: {
+            id: 'msg_assistant_len',
+            sessionID: SESSION_ID,
+            role: 'assistant',
+            providerID: 'provider',
+            modelID: 'model',
+            finish: 'length',
+            time: { completed: 2 },
+            tokens: { input: 100, output: 4096, reasoning: 4096, cache: { read: 0 } },
+          },
+          parts: [{ type: 'reasoning', text: 'Drafting extensive implementation...' }],
+        }]);
+      }
+      throw new Error(`Unexpected request: ${pathname}`);
+    });
+    const service = {
+      generateSmallModelText: vi.fn(),
+    };
+    vi.stubGlobal('fetch', fetchImpl);
+    const runtime = createSessionGoalRuntime({
+      buildOpenCodeUrl: (pathname) => `http://opencode.test${pathname}`,
+      getOpenCodeAuthHeaders: () => ({}),
+      getSmallModelService: async () => service,
+      isEnabled: () => true,
+      idleQuietMs: 10,
+    });
+
+    runtime.processPayload({
+      type: 'session.status',
+      properties: { sessionID: SESSION_ID, status: { type: 'idle' }, directory: DIRECTORY },
+    });
+    await vi.runOnlyPendingTimersAsync();
+
+    // Audit must be skipped on length-truncated turn
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+
+    // Goal accounting is persisted and turnsUsed incremented
+    const patch = requests.find((request) => request.pathname === `/session/${SESSION_ID}` && request.method === 'PATCH');
+    expect(patch).toBeDefined();
+    const writtenGoal = JSON.parse(patch.body).metadata.aiworker.goal;
+    expect(writtenGoal).toMatchObject({
+      status: 'active',
+      turnsUsed: 2,
+    });
+
+    // Continuation prompt is dispatched
+    const promptAsync = requests.find((request) => request.pathname === `/session/${SESSION_ID}/prompt_async` && request.method === 'POST');
+    expect(promptAsync).toBeDefined();
+    const promptBody = JSON.parse(promptAsync.body);
+    expect(promptBody.parts[0].text).toContain('Continue working toward the active session goal.');
+    runtime.stop();
+  });
+
+  it('skips audit and sends continuation prompt when assistant message carries MessageOutputLengthError', async () => {
+    const requests = [];
+    const fetchImpl = vi.fn(async (input, init = {}) => {
+      const pathname = requestPath(input);
+      requests.push({ pathname, method: init.method ?? 'GET', body: init.body });
+      if (pathname === `/session/${SESSION_ID}` && init.method === 'PATCH') return jsonResponse(session);
+      if (pathname === `/session/${SESSION_ID}`) return jsonResponse(session);
+      if (pathname === '/session/status') return jsonResponse({});
+      if (pathname === `/session/${SESSION_ID}/children`) return jsonResponse([]);
+      if (pathname === `/session/${SESSION_ID}/prompt_async`) return jsonResponse({ ok: true });
+      if (pathname === `/session/${SESSION_ID}/message`) {
+        return jsonResponse([{
+          info: {
+            id: 'msg_assistant_len_err',
+            sessionID: SESSION_ID,
+            role: 'assistant',
+            providerID: 'provider',
+            modelID: 'model',
+            error: { name: 'MessageOutputLengthError', message: 'Maximum token limit reached' },
+            time: { completed: 2 },
+            tokens: { input: 100, output: 4096, reasoning: 4096, cache: { read: 0 } },
+          },
+          parts: [{ type: 'reasoning', text: 'Drafting extensive implementation...' }],
+        }]);
+      }
+      throw new Error(`Unexpected request: ${pathname}`);
+    });
+    const service = {
+      generateSmallModelText: vi.fn(),
+    };
+    vi.stubGlobal('fetch', fetchImpl);
+    const runtime = createSessionGoalRuntime({
+      buildOpenCodeUrl: (pathname) => `http://opencode.test${pathname}`,
+      getOpenCodeAuthHeaders: () => ({}),
+      getSmallModelService: async () => service,
+      isEnabled: () => true,
+      idleQuietMs: 10,
+    });
+
+    runtime.processPayload({
+      type: 'session.status',
+      properties: { sessionID: SESSION_ID, status: { type: 'idle' }, directory: DIRECTORY },
+    });
+    await vi.runOnlyPendingTimersAsync();
+
+    // Audit must be skipped on MessageOutputLengthError
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+
+    // Goal remains active and turnsUsed incremented
+    const patch = requests.find((request) => request.pathname === `/session/${SESSION_ID}` && request.method === 'PATCH');
+    expect(patch).toBeDefined();
+    const writtenGoal = JSON.parse(patch.body).metadata.aiworker.goal;
+    expect(writtenGoal).toMatchObject({
+      status: 'active',
+      turnsUsed: 2,
+    });
+
+    // Continuation prompt is dispatched
+    const promptAsync = requests.find((request) => request.pathname === `/session/${SESSION_ID}/prompt_async` && request.method === 'POST');
+    expect(promptAsync).toBeDefined();
+    runtime.stop();
+  });
+
+  it.each([
+    { name: 'APIError', error: { name: 'APIError', message: 'provider failed' } },
+    { name: 'StructuredOutputError', error: { name: 'StructuredOutputError', message: 'invalid output' } },
+    { name: 'unnamed errors', error: {} },
+  ])('blocks a length finish when the assistant also has a non-length $name', async ({ error }) => {
+    const { runtime, requests, service } = createRuntimeHarness({
+      messages: [assistantMessage('msg_assistant_error', { finish: 'length', error })],
+    });
+
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.some((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toBe(false);
+    expect(lastPatchedGoal(requests)).toMatchObject({
+      status: 'blocked',
+      statusReason: error.name || 'assistant turn failed',
+    });
+    runtime.stop();
+  });
+
+  it('blocks after two consecutive length-truncated agent turns without persisting a counter, regardless of message IDs', async () => {
+    const firstLength = assistantMessage('z', { finish: 'length', time: { created: 10, completed: 11 } });
+    const summary = assistantMessage('summary', { summary: true, time: { created: 15, completed: 16 } });
+    const secondLength = assistantMessage('a', { finish: 'length', time: { created: 20, completed: 21 } });
+    const { runtime, requests, service } = createRuntimeHarness({
+      messageFactory: (fetchCount) => fetchCount < 2 ? [firstLength] : [firstLength, summary, secondLength],
+    });
+
+    await runIdleTick(runtime);
+    runtime.processPayload({
+      type: 'session.status',
+      properties: { sessionID: SESSION_ID, status: { type: 'idle' }, directory: DIRECTORY },
+    });
+    await vi.runOnlyPendingTimersAsync();
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.filter((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toHaveLength(1);
+    expect(lastPatchedGoal(requests)).toMatchObject({
+      status: 'blocked',
+      statusReason: 'repeated output truncation',
+    });
+    runtime.stop();
+  });
+
+  it('allows one explicit Resume after repeated truncation, then blocks another cutoff', async () => {
+    const first = assistantMessage('first', { finish: 'length', time: { created: 10, completed: 11 } });
+    const second = assistantMessage('second', { finish: 'length', time: { created: 20, completed: 21 } });
+    const messages = [first, second];
+    const { runtime, requests, activeSession } = createRuntimeHarness({ messages });
+    try {
+      await runIdleTick(runtime);
+      expect(lastPatchedGoal(requests).status).toBe('blocked');
+      expect(requests.filter((request) => request.pathname.endsWith('/prompt_async'))).toHaveLength(0);
+      Object.assign(activeSession.metadata.aiworker.goal, { status: 'active', statusReason: 'resumed', turnsUsed: 0 });
+      await runIdleTick(runtime);
+      expect(lastPatchedGoal(requests)).toMatchObject({ status: 'active', statusReason: '', turnsUsed: 1 });
+      expect(requests.filter((request) => request.pathname.endsWith('/prompt_async'))).toHaveLength(1);
+      messages.push(assistantMessage('third', { finish: 'length', time: { created: 30, completed: 31 } }));
+      await runIdleTick(runtime);
+      expect(lastPatchedGoal(requests)).toMatchObject({ status: 'blocked', statusReason: 'repeated output truncation' });
+      expect(requests.filter((request) => request.pathname.endsWith('/prompt_async'))).toHaveLength(1);
+    } finally {
+      runtime.stop();
+    }
+  });
+
+  it.each([
+    { tokenBudget: 1, error: undefined, expectedStatus: 'budgetLimited' },
+    { tokenBudget: null, error: { name: 'APIError' }, expectedStatus: 'blocked' },
+  ])('keeps $expectedStatus protection on explicit Resume', async ({ tokenBudget, error, expectedStatus }) => {
+    const { runtime, requests } = createRuntimeHarness({
+      goalOverrides: { statusReason: 'resumed', tokenBudget },
+      messages: [assistantMessage('resumed', { finish: 'length', error })],
+    });
+    try {
+      await runIdleTick(runtime);
+      expect(lastPatchedGoal(requests).status).toBe(expectedStatus);
+      expect(requests.filter((request) => request.pathname.endsWith('/prompt_async'))).toHaveLength(0);
+    } finally {
+      runtime.stop();
+    }
+  });
+
+  it('continues after a truncated agent turn followed by a length-finished summary', async () => {
+    const firstLength = assistantMessage('agent-length', { finish: 'length', time: { created: 10, completed: 11 } });
+    const summary = assistantMessage('summary', {
+      summary: true,
+      finish: 'length',
+      time: { created: 15, completed: 16 },
+    });
+    const { runtime, requests, service } = createRuntimeHarness({
+      messageFactory: (fetchCount) => fetchCount < 2 ? [firstLength] : [firstLength, summary],
+    });
+
+    await runIdleTick(runtime);
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.filter((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toHaveLength(2);
+    expect(lastPatchedGoal(requests)).toMatchObject({ status: 'active' });
+    runtime.stop();
+  });
+
+  it('does not infer a repeated streak when a completed assistant timestamp is missing', async () => {
+    const firstLength = assistantMessage('z', { finish: 'length', time: { completed: 11 } });
+    const secondLength = assistantMessage('a', { finish: 'length', time: { created: 20, completed: 21 } });
+    const { runtime, requests, service } = createRuntimeHarness({
+      messageFactory: (fetchCount) => fetchCount < 2 ? [firstLength] : [firstLength, secondLength],
+    });
+
+    await runIdleTick(runtime);
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.filter((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toHaveLength(2);
+    expect(lastPatchedGoal(requests)).toMatchObject({ status: 'active' });
+    runtime.stop();
+  });
+
+  it('ignores a missing timestamp on an older assistant when known post-goal turns establish a streak', async () => {
+    const olderLength = assistantMessage('legacy', { finish: 'length', time: { completed: 5 } });
+    const firstLength = assistantMessage('z', { finish: 'length', time: { created: 10, completed: 11 } });
+    const secondLength = assistantMessage('a', { finish: 'length', time: { created: 20, completed: 21 } });
+    const { runtime, requests, service } = createRuntimeHarness({
+      goalOverrides: { createdAt: 6 },
+      messageFactory: (fetchCount) => fetchCount < 2 ? [firstLength] : [olderLength, firstLength, secondLength],
+    });
+
+    await runIdleTick(runtime);
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.filter((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toHaveLength(1);
+    expect(lastPatchedGoal(requests)).toMatchObject({
+      status: 'blocked',
+      statusReason: 'repeated output truncation',
+    });
+    runtime.stop();
+  });
+
+  it('does not count a previous truncated turn created at the goal boundary', async () => {
+    const firstLength = assistantMessage('before-boundary', { finish: 'length', time: { created: 10, completed: 11 } });
+    const secondLength = assistantMessage('after-boundary', { finish: 'length', time: { created: 20, completed: 21 } });
+    const { runtime, requests, service } = createRuntimeHarness({
+      goalOverrides: { createdAt: 10 },
+      messageFactory: (fetchCount) => fetchCount < 2 ? [firstLength] : [firstLength, secondLength],
+    });
+
+    await runIdleTick(runtime);
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.filter((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toHaveLength(2);
+    expect(lastPatchedGoal(requests)).toMatchObject({ status: 'active' });
+    runtime.stop();
+  });
+
+  it('allows length recovery after an ordinary assistant turn breaks the streak', async () => {
+    const firstLength = assistantMessage('msg_length_before_normal', { finish: 'length' });
+    const normal = assistantMessage('msg_normal');
+    const secondLength = assistantMessage('msg_length_after_normal', { finish: 'length' });
+    const { runtime, requests, service } = createRuntimeHarness({
+      messageFactory: (fetchCount) => fetchCount < 2
+        ? [firstLength]
+        : [firstLength, normal, secondLength],
+    });
+
+    await runIdleTick(runtime);
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.filter((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toHaveLength(2);
+    expect(lastPatchedGoal(requests)).toMatchObject({ status: 'active' });
+    runtime.stop();
+  });
+
+  it('keeps MessageAbortedError pause behavior instead of continuing', async () => {
+    const { runtime, requests, service } = createRuntimeHarness({
+      messages: [assistantMessage('msg_aborted', { error: { name: 'MessageAbortedError' } })],
+    });
+
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.some((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toBe(false);
+    expect(lastPatchedGoal(requests)).toMatchObject({
+      status: 'paused',
+      statusReason: 'paused after abort',
+    });
+    runtime.stop();
+  });
+
+  it('checks the token budget before allowing length recovery', async () => {
+    const { runtime, requests, service } = createRuntimeHarness({
+      goalOverrides: { tokenBudget: 5 },
+      messages: [assistantMessage('msg_budget_length', {
+        finish: 'length',
+        tokens: { input: 3, output: 3, cache: { read: 0 } },
+      })],
+    });
+
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.some((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toBe(false);
+    expect(lastPatchedGoal(requests)).toMatchObject({ status: 'budgetLimited' });
+    runtime.stop();
+  });
+
+  it('checks the auto-continuation cap before allowing length recovery', async () => {
+    const { runtime, requests, service } = createRuntimeHarness({
+      maxAutoTurns: 1,
+      messages: [assistantMessage('msg_cap_length', { finish: 'length' })],
+    });
+
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.some((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toBe(false);
+    expect(lastPatchedGoal(requests)).toMatchObject({
+      status: 'blocked',
+      statusReason: 'auto-continuation limit reached',
+    });
+    runtime.stop();
+  });
 });