@moxxy/sdk 0.41.3 → 0.42.0

package/src/json-file-store.test.ts

@@ -1,9 +1,11 @@
-import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, readFile, readdir, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { posixFileModes } from '@moxxy/vitest-preset/platform';
 import { z } from 'zod';
 import { createJsonFileStore } from './json-file-store.js';
+import { removeDir } from '@moxxy/vitest-preset/fs';
 
 interface Item {
   id: string;
@@ -34,7 +36,7 @@ describe('createJsonFileStore', () => {
   });
 
   afterEach(async () => {
-    await rm(dir, { recursive: true, force: true });
+    await removeDir(dir);
   });
 
   function store() {
@@ -230,7 +232,7 @@ describe('createJsonFileStore', () => {
     // versionless, name-key `rows`, compact, trailing newline
     expect(raw).toBe('{"rows":[{"id":"a","n":1}]}\n');
     const { stat } = await import('node:fs/promises');
-    expect((await stat(f)).mode & 0o777).toBe(0o600);
+    if (posixFileModes) expect((await stat(f)).mode & 0o777).toBe(0o600);
   });
 
   it('invalidate() forces a re-read from disk', async () => {

package/src/locale.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { utf8Locale } from './locale.js';
+
+describe('utf8Locale', () => {
+  it('gives a GUI-launched runner on macOS a UTF-8 character type, so pbcopy keeps Polish letters', () => {
+    expect(utf8Locale({}, 'darwin')).toEqual({ LC_CTYPE: 'en_US.UTF-8' });
+  });
+
+  it('uses the C.UTF-8 locale on Linux, where en_US may not be installed', () => {
+    expect(utf8Locale({ LANG: '' }, 'linux')).toEqual({ LC_CTYPE: 'C.UTF-8' });
+  });
+
+  it('treats the C and POSIX locales as unset', () => {
+    expect(utf8Locale({ LANG: 'C' }, 'darwin')).toEqual({ LC_CTYPE: 'en_US.UTF-8' });
+    expect(utf8Locale({ LC_CTYPE: 'POSIX' }, 'darwin')).toEqual({ LC_CTYPE: 'en_US.UTF-8' });
+  });
+
+  it('leaves a locale that already speaks UTF-8 alone', () => {
+    expect(utf8Locale({ LANG: 'pl_PL.UTF-8' }, 'darwin')).toEqual({});
+    expect(utf8Locale({ LC_CTYPE: 'UTF-8' }, 'darwin')).toEqual({});
+    expect(utf8Locale({ LC_ALL: 'en_US.utf8' }, 'linux')).toEqual({});
+  });
+
+  it('respects a non-UTF-8 locale the user chose on purpose', () => {
+    expect(utf8Locale({ LANG: 'pl_PL.ISO8859-2' }, 'darwin')).toEqual({});
+  });
+
+  it('changes nothing on Windows, which has no POSIX locale variables', () => {
+    expect(utf8Locale({}, 'win32')).toEqual({});
+  });
+});

package/src/locale.ts

@@ -0,0 +1,16 @@
+/**
+ * A process started from the Dock or Finder gets no `LANG`, so every command
+ * the agent runs falls back to the legacy encoding: `pbcopy` then reads UTF-8
+ * as Mac Central European and "pamięć" lands in the clipboard as "pamińôńá".
+ * Returns the variables to add so child processes read and write UTF-8; only
+ * the character type is set, so messages keep the user's language.
+ */
+export function utf8Locale(
+  env: Readonly<Record<string, string | undefined>>,
+  platform: NodeJS.Platform,
+): Record<string, string> {
+  if (platform === 'win32') return {};
+  const effective = env['LC_ALL'] || env['LC_CTYPE'] || env['LANG'] || '';
+  if (effective !== '' && effective !== 'C' && effective !== 'POSIX') return {};
+  return { LC_CTYPE: platform === 'darwin' ? 'en_US.UTF-8' : 'C.UTF-8' };
+}

package/src/mode/checkpoint.ts

@@ -101,5 +101,12 @@ export interface TurnCheckpoint {
    * (goal/collab-style stall handling wants these too).
    */
   readonly gateOn?: 'end_turn' | 'idle';
+  /**
+   * A cheap test of whether this turn needs the checkpoint at all. When it
+   * says no, the checkpoint is skipped without a trace — no lifecycle events —
+   * so a check that rarely applies can sit on every turn without adding to
+   * every conversation's log.
+   */
+  applies?(ctx: ModeContext): boolean;
   run(check: CheckpointContext, ctx: ModeContext): Promise<CheckpointResult>;
 }

package/src/mode/collect-stream.ts

@@ -1,7 +1,7 @@
 import type { ProviderEvent, ProviderMessage, TokenUsage } from '../provider.js';
 import type { ModeContext } from '../mode.js';
 import type { StopReason } from '../provider-utils.js';
-import { applyLazyTools } from '../tool-gating.js';
+import { applyLazyTools, shouldGateTools } from '../tool-gating.js';
 import type { ProviderCallTiming } from '../events.js';
 import { providerTiming } from './provider-timing.js';
 
@@ -110,7 +110,7 @@ export async function collectProviderStream(
     opts.includeTools === false || descriptor?.supportsTools === false
       ? undefined
       : ctx.tools.list();
-  if (ctx.lazyTools && toolList) {
+  if (toolList && shouldGateTools(ctx.lazyTools, toolList.length)) {
     const gated = applyLazyTools(messages, toolList, ctx.log);
     effectiveMessages = gated.messages;
     toolList = gated.tools;
@@ -151,6 +151,7 @@ export async function collectProviderStream(
     ...(cacheHints && cacheHints.length > 0 ? { cacheHints } : {}),
     ...(opts.maxTokens !== undefined ? { maxTokens: opts.maxTokens } : {}),
     ...(reqReasoning ? { reasoning: reqReasoning } : {}),
+    ...(ctx.fast && descriptor?.supportsFast ? { fast: true } : {}),
     signal: ctx.signal,
   };
   const prepared=performance.now();

package/src/mode/project-messages.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
-import { projectMessagesFromLog, projectUserPrompt, resolvedCallIdSet } from './project-messages.js';
+import { projectMessagesFromLog, projectUserPrompt, resolvedCallIdSet, skillsWithinReach } from './project-messages.js';
+import type { Skill } from '../skill.js';
 import { computeElisionState } from '../elision-state.js';
 import { asEventId, asSessionId, asTurnId } from '../ids.js';
 import type { EventLogReader } from '../log.js';
@@ -181,3 +182,73 @@ describe('projectMessagesFromLog tool_result stringify hardening', () => {
     expect(toolResultText(logWith('plain text'))).toBe('plain text');
   });
 });
+
+describe('skillsWithinReach', () => {
+  const skill = (name: string, tools?: string[]): Skill => ({
+    id: name as Skill['id'], path: `/skills/${name}.md`, scope: 'user', body: '',
+    frontmatter: { name, description: name, ...(tools ? { 'allowed-tools': tools } : {}) },
+  });
+  const names = (skills: ReadonlyArray<Skill>) => skills.map((entry) => entry.frontmatter.name);
+  const tools = ['Bash', 'Read', 'mcp__gmail__send', 'computer_click'];
+
+  it('keeps a skill that names no tools or at least one tool of the session', () => {
+    const kept = skillsWithinReach([skill('prose'), skill('empty', []), skill('mixed', ['Bash', 'web-research']), skill('mail', ['mcp__gmail__*'])], tools);
+    expect(names(kept)).toEqual(['prose', 'empty', 'mixed', 'mail']);
+  });
+
+  it('drops a skill when none of the tools it is written for exists', () => {
+    const kept = skillsWithinReach([skill('charts', ['mcp__tradingview__tv_quote']), skill('zoho', ['mcp__zoho__*']), skill('old', ['AppleScript', 'computer'])], tools);
+    expect(kept).toEqual([]);
+  });
+});
+
+describe('projectMessagesFromLog tool pairing across a compaction boundary', () => {
+  const t2 = asTurnId('t2');
+  const call = (seq: number, callId: string): MoxxyEvent =>
+    event(seq, { type: 'tool_call_requested', turnId: t1, source: 'model', callId, name: 'terminal', input: {} });
+  const result = (seq: number, callId: string): MoxxyEvent =>
+    event(seq, { type: 'tool_result', turnId: t1, source: 'tool', callId, ok: true, output: 'installed' });
+  const compaction = (seq: number, replacedRange: [number, number]): MoxxyEvent =>
+    event(seq, {
+      type: 'compaction',
+      turnId: t2,
+      source: 'compactor',
+      compactor: 'segments',
+      replacedRange,
+      summary: 'earlier work',
+      tokensSaved: 10,
+    });
+
+  const blocksOf = (events: ReadonlyArray<MoxxyEvent>) =>
+    projectMessagesFromLog({ log: reader(events) }).flatMap((m) => m.content);
+
+  it('drops a late tool_result whose tool call was summarized away', () => {
+    const blocks = blocksOf([
+      userPrompt(0, { text: 'install it' }),
+      call(1, 'late'),
+      userPrompt(2, { text: 'anything new?', turnId: t2 }),
+      result(3, 'late'),
+      compaction(4, [0, 1]),
+    ]);
+    expect(blocks.filter((b) => b.type === 'tool_result')).toEqual([]);
+    expect(blocks.filter((b) => b.type === 'tool_use')).toEqual([]);
+  });
+
+  it('answers a visible tool call whose result was summarized away', () => {
+    const messages = projectMessagesFromLog({
+      log: reader([
+        userPrompt(0, { text: 'install it' }),
+        call(1, 'cut'),
+        userPrompt(2, { text: 'anything new?', turnId: t2 }),
+        result(3, 'cut'),
+        compaction(4, [2, 3]),
+      ]),
+    });
+    const useIndex = messages.findIndex((m) => m.content.some((b) => b.type === 'tool_use' && b.id === 'cut'));
+    expect(useIndex).toBeGreaterThanOrEqual(0);
+    expect(messages[useIndex + 1]).toMatchObject({
+      role: 'tool_result',
+      content: [{ type: 'tool_result', toolUseId: 'cut', isError: true }],
+    });
+  });
+});

package/src/mode/project-messages.ts

@@ -1,6 +1,7 @@
 import type { ContentBlock, ProviderMessage } from '../provider.js';
 import type { ModeContext } from '../mode.js';
 import type { Skill } from '../skill.js';
+import { toolPatternMatches } from '../skill-mentions.js';
 import type { MoxxyEvent, UserPromptEvent } from '../events.js';
 import {
   activeCompactionRanges,
@@ -11,8 +12,7 @@ import {
   computeElisionState,
   conversationalStub,
   conversationalStubbed,
-  toolResultBytes,
-  toolResultStub,
+  toolResultStubText,
   toolResultStubbed,
   type ElisionState,
 } from '../elision-state.js';
@@ -70,6 +70,20 @@ export const ELISION_SYSTEM_NOTE =
   'the full text before relying on any detail from an elided turn. Recent turns are always ' +
   'shown verbatim.';
 
+/**
+ * Skills worth advertising: one that lists `allowed-tools` is written for those
+ * tools, so it is left out when none of them exists in the session (an MCP
+ * server that is not connected, a plugin that was replaced). Lists are loose in
+ * practice, so one tool that exists is enough; a trailing `*` matches a prefix.
+ */
+export function skillsWithinReach(skills: ReadonlyArray<Skill>, toolNames: ReadonlyArray<string>): ReadonlyArray<Skill> {
+  const exists = (pattern: string) => toolNames.some((name) => toolPatternMatches(pattern, name));
+  return skills.filter((skill) => {
+    const wanted = skill.frontmatter['allowed-tools'] ?? [];
+    return wanted.length === 0 || wanted.some(exists);
+  });
+}
+
 /**
  * Compose a model-facing system prompt that includes any base prompt
  * plus a COMPACT skill index (name + description + triggers only).
@@ -260,7 +274,13 @@ export function projectMessages(
   // (or tool_call_denied) somewhere in the log. Used to synthesize a
   // fallback `[interrupted]` tool_result for orphan tool_use blocks
   // when the assistant message gets flushed.
-  const resolvedCallIds = resolvedCallIdSet(allEvents);
+  // Only VISIBLE results count: one swallowed by a compaction is never sent, so
+  // its still-visible tool_use needs the fallback just like a missing one.
+  const resolvedCallIds = resolvedCallIdSet(allEvents.filter((e) => !compactionFor(e.seq)));
+  // callIds whose tool_use block is projected. A tool_result outside this set
+  // answers a call a compaction summarized away (the result landed after later
+  // turns began); providers reject a result with no matching call.
+  const projectedCallIds = new Set<string>();
 
   let pendingAssistant: ProviderMessage | null = null;
   let pendingAssistantMaxSeq = -1;
@@ -391,6 +411,7 @@ export function projectMessages(
           }
         }
         pendingAssistantMaxSeq = Math.max(pendingAssistantMaxSeq, e.seq);
+        projectedCallIds.add(e.callId);
         (pendingAssistant.content as Array<ProviderMessage['content'][number]>).push({
           type: 'tool_use',
           id: e.callId,
@@ -400,6 +421,7 @@ export function projectMessages(
         break;
       }
       case 'tool_result': {
+        if (!projectedCallIds.has(e.callId)) break;
         flush();
         // Stub bulky old tool output to a recall-able marker (decision shared
         // with estimateContextTokens via toolResultStubbed).
@@ -409,8 +431,7 @@ export function projectMessages(
         // result isn't stubbed (elided) or an error and the call succeeded.
         let image: Extract<ContentBlock, { type: 'image' }> | null = null;
         if (toolResultStubbed(e, el)) {
-          const recalled = el.recalledCallIds.has(e.callId) || el.recalledSeqs.has(e.seq);
-          text = toolResultStub(e.callId, toolResultBytes(e.output), recalled);
+          text = toolResultStubText(e, el);
         } else if (e.error) {
           text = `[error:${e.error.kind}] ${e.error.message}`;
         } else if (isToolDisplayResult(e.output)) {

package/src/mode/react-loop.ts

@@ -16,7 +16,7 @@ import {
 import { nextBackoffMs, sleepWithAbort } from './abort-backoff.js';
 import type { CheckpointResult, TurnCheckpoint } from './checkpoint.js';
 import { collectProviderStream, type CollectedToolUse } from './collect-stream.js';
-import { buildSystemPromptWithSkills, projectMessages } from './project-messages.js';
+import { buildSystemPromptWithSkills, projectMessages, skillsWithinReach } from './project-messages.js';
 import { createStuckLoopDetector } from './stuck-loop.js';
 
 /**
@@ -269,7 +269,9 @@ export async function* runReactLoop(
     // conservative capability fallback.
     const projectionStarted=performance.now();
     const descriptor = ctx.provider.models.find((candidate) => candidate.id === ctx.model);
-    const availableSkills = descriptor?.supportsTools === false ? [] : ctx.skills.list();
+    const availableSkills = descriptor?.supportsTools === false
+      ? []
+      : skillsWithinReach(ctx.skills.list(), ctx.tools.list().map((tool) => tool.name));
     const systemPrompt = buildSystemPromptWithSkills(ctx.systemPrompt, availableSkills);
     const { messages, stablePrefixIndex } = projectMessages(ctx, {
       ...(systemPrompt ? { systemPrompt } : {}),
@@ -518,7 +520,8 @@ async function* runCheckpointGate(
   // only face the idle-tolerant ones — reviewing a half-sentence as if it
   // were a completion claim wastes a checker run and confuses the model.
   const eligible = checkpoints.filter(
-    (cp) => round.stopReason === 'end_turn' || (cp.gateOn ?? 'end_turn') === 'idle',
+    (cp) =>
+      (round.stopReason === 'end_turn' || (cp.gateOn ?? 'end_turn') === 'idle') && (cp.applies?.(ctx) ?? true),
   );
   if (eligible.length === 0) return { kind: 'end' };
 

package/src/mode/stuck-loop.ts

@@ -30,8 +30,12 @@ export interface StuckSignal {
 export interface StuckLoopDetector {
   readonly windowSize: number;
   readonly repeatThreshold: number;
-  /** Record the call and report whether the loop guard should trip. */
-  record(toolName: string, input: unknown): StuckSignal;
+  /**
+   * Record the call and report whether the loop guard should trip. A
+   * `liveState` tool (see `ToolDef.liveState`) is expected to repeat between
+   * other calls, so only a back-to-back run of the same call counts for it.
+   */
+  record(toolName: string, input: unknown, opts?: { readonly liveState?: boolean }): StuckSignal;
   /**
    * Clear both sliding windows. Used by the nudge (steer-don't-stop) stuck
    * policy: after a trip is surfaced to the model, the detector starts a fresh
@@ -86,13 +90,18 @@ export function createStuckLoopDetector(opts: LoopGuardSettings = {}): StuckLoop
   const nearThreshold = opts.nearThreshold ?? Math.max(repeatThreshold + 2, 5);
   const recent: string[] = [];
   const recentNear: string[] = [];
+  let last: string | null = null;
+  let streak = 0;
   return {
     windowSize,
     repeatThreshold,
-    record(toolName, input): StuckSignal {
+    record(toolName, input, opts): StuckSignal {
       // Disabled → never trip (rely on the maxIterations cap alone).
       if (!enabled) return { stuck: false, count: 0, kind: 'exact' };
       const key = `${toolName}|${stableHash(input)}`;
+      streak = key === last ? streak + 1 : 1;
+      last = key;
+      if (opts?.liveState) return { stuck: streak >= repeatThreshold, count: streak, kind: 'exact' };
       recent.push(key);
       if (recent.length > windowSize) recent.shift();
       const exactCount = recent.filter((k) => k === key).length;
@@ -112,6 +121,8 @@ export function createStuckLoopDetector(opts: LoopGuardSettings = {}): StuckLoop
     reset(): void {
       recent.length = 0;
       recentNear.length = 0;
+      last = null;
+      streak = 0;
     },
   };
 }

package/src/mode-helpers.ts

@@ -16,6 +16,7 @@
 export {
   ELISION_SYSTEM_NOTE,
   buildSystemPromptWithSkills,
+  skillsWithinReach,
   projectMessagesFromLog,
   projectMessages,
   type ProjectMessagesOptions,

package/src/mode.ts

@@ -6,7 +6,7 @@ import type { ServiceRegistry } from './services.js';
 import type { SessionId, TurnId } from './ids.js';
 import type { EventLogReader } from './log.js';
 import type { PermissionResolver } from './permission.js';
-import type { LLMProvider } from './provider.js';
+import type { LLMProvider, ReasoningEffort } from './provider.js';
 import type { LoopGuardSettings } from './mode/stuck-loop.js';
 import type { Skill } from './skill.js';
 import type { SubagentSpawner } from './subagent.js';
@@ -84,6 +84,8 @@ export interface ModeContext {
   readonly cwd: string;
   readonly env: Readonly<Record<string, string | undefined>>;
   readonly model: string;
+  /** User-supplied context-window estimate for a custom model, if known. */
+  readonly contextWindowOverride?: number;
   readonly systemPrompt?: string;
   readonly provider: LLMProvider;
   readonly tools: ToolRegistry;
@@ -94,7 +96,10 @@ export interface ModeContext {
   readonly cacheStrategy: CacheStrategyDef | null;
   /** Elision (context-on-demand) settings; undefined → defaults apply. */
   readonly elision?: ElisionSettings;
-  /** When true, send only always-on + loaded tool schemas; index the rest. */
+  /**
+   * Send only always-on + loaded tool schemas and index the rest. Unset means
+   * automatic: on once the registry holds more than `LAZY_TOOLS_AUTO_THRESHOLD` tools.
+   */
   readonly lazyTools?: boolean;
   /**
    * Per-provider reasoning/thinking preference, resolved from the active
@@ -102,7 +107,9 @@ export interface ModeContext {
    * `ProviderRequest.reasoning` by {@link collectProviderStream}, gated on the
    * active model's `supportsReasoning`. Absent/false → reasoning off.
    */
-  readonly reasoning?: { readonly effort?: 'low' | 'medium' | 'high' } | boolean;
+  readonly reasoning?: { readonly effort?: ReasoningEffort } | boolean;
+  /** Ask for the provider's faster tier; forwarded only to a model with `supportsFast`. */
+  readonly fast?: boolean;
   readonly permissions: PermissionResolver;
   /**
    * Optional generic "ask the user a question" gate. Any loop strategy can

package/src/permission.ts

@@ -7,6 +7,12 @@ export interface PermissionDecision {
   readonly reason?: string;
   /** Narrow an `allow_session` grant to calls with matching input values. */
   readonly sessionScope?: { readonly inputKeys: ReadonlyArray<string> };
+  /**
+   * This call was decided now: a prompt answered for it, or the run's own
+   * allow-list or auto-approve. Left unset by a standing rule and by an earlier
+   * answer reused, so a tool can tell consent to this call from a blanket one.
+   */
+  readonly decidedNow?: boolean;
 }
 
 export interface PermissionRule {

package/src/process-invocation.test.ts

@@ -1,12 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import {
-  chmodSync,
-  mkdtempSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs';
+import { chmodSync, mkdtempSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import * as path from 'node:path';
 
@@ -19,6 +12,7 @@ import {
   resolveExecutableTarget,
   spawnExecutableTarget,
 } from './process-invocation.js';
+import { removeDirSync } from '@moxxy/vitest-preset/fs';
 
 let root: string;
 
@@ -27,7 +21,7 @@ beforeEach(() => {
 });
 
 afterEach(() => {
-  rmSync(root, { recursive: true, force: true });
+  removeDirSync(root);
 });
 
 function put(relative: string, body = ''): string {

package/src/progress.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest';
+import { asEventId, asSessionId, asTurnId } from './ids.js';
+import type { MoxxyEvent } from './events.js';
+import { progressOf, unfinishedWork } from './progress.js';
+
+/**
+ * What a tool last saw of something may be work that has not finished yet: a
+ * page still busy, a job still running. In the Coolify task the agent pressed
+ * Deploy and reported the address as down from a check made before it — the
+ * service came up minutes later. A result that names what it looked at
+ * (`progress.key`) and says whether that was still under way
+ * (`progress.pending`) lets the loop tell finished from not-yet.
+ */
+const sid = asSessionId('s1');
+const t1 = asTurnId('t1');
+
+function event(seq: number, partial: Omit<MoxxyEvent, 'id' | 'seq' | 'ts' | 'sessionId'>): MoxxyEvent {
+  return { id: asEventId(`e${seq}`), seq, ts: seq, sessionId: sid, ...partial } as MoxxyEvent;
+}
+
+function look(seq: number, callId: string, output: unknown, ok = true): MoxxyEvent[] {
+  return [
+    event(seq, { type: 'tool_call_requested', turnId: t1, source: 'model', callId, name: 'look', input: {} }),
+    event(seq + 1, { type: 'tool_result', turnId: t1, source: 'tool', callId, ok, output }),
+  ];
+}
+
+describe('progressOf', () => {
+  it('reads what a result says it looked at and whether that was still under way', () => {
+    expect(progressOf({ text: 'x', progress: { key: 'browser:t1', pending: 'uploading' } })).toEqual({
+      key: 'browser:t1',
+      pending: 'uploading',
+    });
+    expect(progressOf({ progress: { key: 'browser:t1', pending: null } })).toEqual({ key: 'browser:t1', pending: null });
+  });
+
+  it('is null for a result that says nothing about it', () => {
+    expect(progressOf('plain text')).toBeNull();
+    expect(progressOf({ text: 'x' })).toBeNull();
+    expect(progressOf({ progress: { pending: 'no key' } })).toBeNull();
+  });
+});
+
+describe('unfinishedWork', () => {
+  it('names what was still under way the last time it was looked at', () => {
+    const events = [
+      ...look(0, 'c1', { progress: { key: 'browser:t1', pending: 'progressbar "Deploying"' } }),
+      ...look(2, 'c2', { text: 'something else entirely' }),
+    ];
+
+    expect(unfinishedWork(events)).toEqual(['progressbar "Deploying"']);
+  });
+
+  it('lets a later look that found it finished settle it', () => {
+    const events = [
+      ...look(0, 'c1', { progress: { key: 'browser:t1', pending: 'busy' } }),
+      ...look(2, 'c2', { progress: { key: 'browser:t1', pending: null } }),
+    ];
+
+    expect(unfinishedWork(events)).toEqual([]);
+  });
+
+  it('keeps one thing still running while another finished', () => {
+    const events = [
+      ...look(0, 'c1', { progress: { key: 'browser:t1', pending: 'busy' } }),
+      ...look(2, 'c2', { progress: { key: 'browser:t2', pending: 'uploading' } }),
+      ...look(4, 'c3', { progress: { key: 'browser:t1', pending: null } }),
+    ];
+
+    expect(unfinishedWork(events)).toEqual(['uploading']);
+  });
+
+  it('does not count a failed call as a look', () => {
+    const events = [
+      ...look(0, 'c1', { progress: { key: 'browser:t1', pending: 'busy' } }),
+      ...look(2, 'c2', { progress: { key: 'browser:t1', pending: null } }, false),
+    ];
+
+    expect(unfinishedWork(events)).toEqual(['busy']);
+  });
+});

package/src/progress.ts

@@ -0,0 +1,73 @@
+import type { MoxxyEvent } from './events.js';
+import type { ModeContext } from './mode.js';
+import type { TurnCheckpoint } from './mode/checkpoint.js';
+
+/**
+ * What a tool result says about the thing it looked at: `key` names it (a
+ * browser tab, a job), `pending` says what was still under way there, or null
+ * when nothing was. A result that knows nothing about it leaves `progress` out.
+ */
+export interface Progress {
+  readonly key: string;
+  readonly pending: string | null;
+}
+
+export function progressOf(output: unknown): Progress | null {
+  if (typeof output !== 'object' || output === null) return null;
+  const progress = (output as { progress?: unknown }).progress;
+  if (typeof progress !== 'object' || progress === null) return null;
+  const { key, pending } = progress as { key?: unknown; pending?: unknown };
+  if (typeof key !== 'string') return null;
+  return { key, pending: typeof pending === 'string' ? pending : null };
+}
+
+/** What was still under way the last time each thing was looked at, in `events`. */
+export function unfinishedWork(events: ReadonlyArray<MoxxyEvent>): string[] {
+  const latest = new Map<string, string | null>();
+  for (const e of events) {
+    if (e.type !== 'tool_result' || !e.ok) continue;
+    const progress = progressOf(e.output);
+    if (progress) latest.set(progress.key, progress.pending);
+  }
+  return [...latest.values()].filter((pending): pending is string => pending !== null);
+}
+
+export function unfinishedWorkNudge(pending: ReadonlyArray<string>): string {
+  return (
+    `Before you report: the last time you looked, this was still in progress — ${pending.join('; ')}. ` +
+    'What it leads to is not known yet, and anything you checked before it may no longer hold. ' +
+    'Wait for it to finish (with a tool’s own wait, if it has one), look again, and report what you see then. ' +
+    'If it does not finish, say plainly that it has not.'
+  );
+}
+
+const turnOf = (ctx: ModeContext): string => `${ctx.sessionId}/${ctx.turnId}`;
+
+/** Turns already asked, so one turn is asked at most once. Bounded: oldest go first. */
+const MAX_REMEMBERED_TURNS = 256;
+
+/**
+ * At the end of a turn, one reminder when the last look at something found
+ * work still under way. The report is then based on a state that has not
+ * settled — the agent pressed Deploy and reported the address from a check
+ * made before it. Asked once per turn: the agent may well have good reason to
+ * report anyway, and it is told how to say so.
+ */
+export function unfinishedWorkCheckpoint(): TurnCheckpoint {
+  const asked = new Set<string>();
+  return {
+    name: 'unfinished-work',
+    applies: (ctx: ModeContext) =>
+      !asked.has(turnOf(ctx)) && unfinishedWork(ctx.log.byTurn(ctx.turnId)).length > 0,
+    async run(_check, ctx: ModeContext) {
+      const pending = unfinishedWork(ctx.log.byTurn(ctx.turnId));
+      if (pending.length === 0) return { action: 'pass' };
+      asked.add(turnOf(ctx));
+      for (const oldest of asked) {
+        if (asked.size <= MAX_REMEMBERED_TURNS) break;
+        asked.delete(oldest);
+      }
+      return { action: 'inject', text: unfinishedWorkNudge(pending), volatile: true };
+    },
+  };
+}

package/src/provider.ts

@@ -53,6 +53,9 @@ export interface CacheHint {
   readonly target: 'tools' | 'system' | { readonly messageIndex: number };
 }
 
+/** How deeply a reasoning model should think; `xhigh` is the deepest. */
+export type ReasoningEffort = 'low' | 'medium' | 'high' | 'xhigh';
+
 export interface ProviderRequest {
   readonly model: string;
   /**
@@ -81,7 +84,13 @@ export interface ProviderRequest {
    * each provider's native knob (Anthropic thinking budget, OpenAI/Codex
    * `reasoning.effort`).
    */
-  readonly reasoning?: { readonly effort?: 'low' | 'medium' | 'high' } | boolean;
+  readonly reasoning?: { readonly effort?: ReasoningEffort } | boolean;
+  /**
+   * Serve this request on the provider's faster, pricier tier (OpenAI
+   * `service_tier: "priority"`). Set by the loop only for a model whose
+   * descriptor has `supportsFast`.
+   */
+  readonly fast?: boolean;
 }
 
 export type ProviderEvent =
@@ -148,6 +157,8 @@ export interface ModelDescriptor {
    * for this model. When false, `ProviderRequest.reasoning` is ignored.
    */
   readonly supportsReasoning?: boolean;
+  /** Whether the provider can serve this model on a faster tier (see `ProviderRequest.fast`). */
+  readonly supportsFast?: boolean;
   /**
    * Tools executed by the provider on behalf of this model (for example
    * OpenAI Responses or Anthropic server tools). A matching client ToolDef