mixdog 0.9.166 → 0.9.167

package/src/runtime/shared/schema-value-error.mjs

@@ -0,0 +1,68 @@
+// JSON Schema counts Unicode code points, not JavaScript's UTF-16 code units.
+export function schemaStringLength(value) {
+  let length = 0;
+  for (const _ of value) length++;
+  return length;
+}
+
+// Shared schema checks; tools retain their action-specific target relationships.
+export function schemaValueError(value, schema, path) {
+  if (schema.enum && !schema.enum.includes(value)) {
+    return `${path} must be one of: ${schema.enum.join(', ')}`;
+  }
+  if (schema.type === 'string') {
+    if (typeof value !== 'string') return `${path} must be a string`;
+    const length = schemaStringLength(value);
+    if (schema.minLength !== undefined && length < schema.minLength) {
+      return `${path} requires at least ${schema.minLength} characters`;
+    }
+    if (schema.maxLength !== undefined && length > schema.maxLength) {
+      return `${path} accepts at most ${schema.maxLength} characters`;
+    }
+    if (schema.pattern !== undefined && !new RegExp(schema.pattern).test(value)) {
+      return `${path} must match the required format`;
+    }
+  }
+  if (schema.type === 'boolean' && typeof value !== 'boolean') return `${path} must be a boolean`;
+  if (schema.type === 'number' && (typeof value !== 'number' || !Number.isFinite(value))) {
+    return `${path} must be a finite number`;
+  }
+  if (schema.type === 'integer' && !Number.isInteger(value)) return `${path} must be an integer`;
+  if (schema.type === 'array') {
+    if (!Array.isArray(value)) return `${path} must be an array`;
+    if (schema.minItems !== undefined && value.length < schema.minItems) {
+      return `${path} requires at least ${schema.minItems} items`;
+    }
+    if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+      return `${path} accepts at most ${schema.maxItems} items`;
+    }
+    if (schema.uniqueItems && new Set(value.map((item) => JSON.stringify(item))).size !== value.length) {
+      return `${path} must contain unique items`;
+    }
+    for (let index = 0; index < value.length; index += 1) {
+      const error = schemaValueError(value[index], schema.items || {}, `${path}[${index}]`);
+      if (error) return error;
+    }
+  }
+  if (schema.type === 'object') {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return `${path} must be an object`;
+    const properties = schema.properties || {};
+    const missing = (schema.required || []).filter((name) => !Object.hasOwn(value, name));
+    if (missing.length) return `${path} requires field(s): ${missing.join(', ')}`;
+    if (schema.additionalProperties === false) {
+      const extras = Object.keys(value).filter((name) => !Object.hasOwn(properties, name));
+      if (extras.length) return `${path} does not accept field(s): ${extras.join(', ')}`;
+    }
+    for (const [name, item] of Object.entries(value)) {
+      const field = Object.hasOwn(properties, name) ? properties[name]
+        : (typeof schema.additionalProperties === 'object' ? schema.additionalProperties : {});
+      const error = schemaValueError(item, field, `${path}.${name}`);
+      if (error) return error;
+    }
+  }
+  if (typeof value === 'number') {
+    if (schema.minimum !== undefined && value < schema.minimum) return `${path} must be at least ${schema.minimum}`;
+    if (schema.maximum !== undefined && value > schema.maximum) return `${path} must be at most ${schema.maximum}`;
+  }
+  return null;
+}

package/src/runtime/shared/singleton-owner.mjs

@@ -1,15 +1,8 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { mkdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
+import { readJsonSafe } from './json-file.mjs';
 import { isPidAlive } from './pid-liveness.mjs';
-
-function readJson(path) {
-  try {
-    if (!existsSync(path)) return null;
-    return JSON.parse(readFileSync(path, 'utf8'));
-  } catch {
-    return null;
-  }
-}
+import { sleepSync } from './sleep.mjs';
 
 function writeJsonAtomic(path, value) {
   mkdirSync(dirname(path), { recursive: true });
@@ -18,12 +11,6 @@ function writeJsonAtomic(path, value) {
   renameSync(tmp, path);
 }
 
-function waitSync(ms) {
-  try {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-  } catch {}
-}
-
 function acquireClaimLock(path) {
   const lockPath = `${path}.claim.lock`;
   for (let i = 0; i < 20; i++) {
@@ -39,14 +26,14 @@ function acquireClaimLock(path) {
           continue;
         }
       } catch {}
-      waitSync(25);
+      sleepSync(25);
     }
   }
   return null;
 }
 
 export function readSingletonOwner(path) {
-  const owner = readJson(path);
+  const owner = readJsonSafe(path);
   if (!owner || typeof owner !== 'object') return { owner: null, alive: false };
   return { owner, alive: isPidAlive(owner.pid) };
 }
@@ -63,15 +50,15 @@ export function claimSingletonOwner(path, {
     ...meta,
   };
 
-  const current = readJson(path);
+  const current = readJsonSafe(path);
   if (current?.pid && Number(current.pid) !== Number(pid) && isPidAlive(current.pid)) {
     return { owned: false, owner: current };
   }
 
   const lockPath = acquireClaimLock(path);
-  if (!lockPath) return { owned: false, owner: readJson(path) };
+  if (!lockPath) return { owned: false, owner: readJsonSafe(path) };
   try {
-    const lockedCurrent = readJson(path);
+    const lockedCurrent = readJsonSafe(path);
     if (lockedCurrent?.pid && Number(lockedCurrent.pid) !== Number(pid) && isPidAlive(lockedCurrent.pid)) {
       return { owned: false, owner: lockedCurrent };
     }
@@ -83,7 +70,7 @@ export function claimSingletonOwner(path, {
 }
 
 export function releaseSingletonOwner(path, pid = process.pid) {
-  const current = readJson(path);
+  const current = readJsonSafe(path);
   if (!current?.pid || Number(current.pid) !== Number(pid)) return false;
   try {
     rmSync(path, { force: true });
@@ -101,9 +88,9 @@ export function releaseSingletonOwner(path, pid = process.pid) {
 // should fall back to the winner rather than overwrite it.
 export function handoffSingletonOwner(path, fromPid, toOwner = {}) {
   const lockPath = acquireClaimLock(path);
-  if (!lockPath) return { owned: false, owner: readJson(path) };
+  if (!lockPath) return { owned: false, owner: readJsonSafe(path) };
   try {
-    const current = readJson(path);
+    const current = readJsonSafe(path);
     if (current?.pid && Number(current.pid) !== Number(fromPid)) {
       return { owned: false, owner: current };
     }

package/src/runtime/shared/staged-update.mjs

@@ -38,6 +38,7 @@ import { spawn } from 'node:child_process';
 import { resolvePluginData } from './plugin-paths.mjs';
 // Same probe every discovery/lock reader uses; `process.pid` is trivially alive.
 import { isPidAlive as pidAlive } from './pid-liveness.mjs';
+import { sleepSync } from './sleep.mjs';
 import { detachedSpawnOpts, hiddenSpawnOpts } from './spawn-flags.mjs';
 import { renameWithRetrySync } from './atomic-file.mjs';
 import {
@@ -69,16 +70,6 @@ function rmDir(dir) {
   try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
 }
 
-function sleepSync(ms) {
-  const dur = Math.max(1, Number(ms) || 1);
-  try {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, dur);
-  } catch {
-    const end = Date.now() + dur;
-    while (Date.now() < end) { /* spin fallback */ }
-  }
-}
-
 // ── Live-session refcount (pid files) ─────────────────────────────────────
 // Each runtime registers a `<pid>.pid` file on boot and removes it on close.
 // The swap consults these to skip while another mixdog is running. Liveness is

package/src/runtime/shared/tool-card-model.mjs

@@ -21,6 +21,7 @@ import {
   summarizeToolResult,
   toolLoadingTargets,
 } from './tool-surface.mjs';
+import { pluralize } from './tool-primitives.mjs';
 import { backgroundTaskFailureStatusLabel, isBackgroundErrorOnlyBody } from './err-text.mjs';
 import { normalizeToolTerminalStatus, toolResultTerminalStatus } from './tool-status.mjs';
 import { formatElapsed } from './time-format.mjs';
@@ -67,9 +68,7 @@ export function normalizeCountMap(value = {}) {
   return out;
 }
 
-export function plural(count, singular, pluralText = `${singular}s`) {
-  return count === 1 ? singular : pluralText;
-}
+export { pluralize as plural };
 
 export function shellResultStatus(value) {
   const match = String(value || '').match(/(?:^|\b)status:\s*(running|pending|queued|completed|failed|cancelled|canceled)\b/im);
@@ -188,7 +187,7 @@ export function shellDisplayStatus({ pending = false, failedCount = 0, exitFaile
 
 export function shellHeader(status, count = 1, verifying = false) {
   const n = Math.max(1, Number(count) || 1);
-  const object = `${n} ${plural(n, 'command')}`;
+  const object = `${n} ${pluralize(n, 'command')}`;
   // A shell that follows an edit in the same batch IS the verification —
   // label it as such while healthy; failures keep the neutral Ran + detail.
   if (verifying && status === 'running') return `Verifying ${object}`;
@@ -205,8 +204,12 @@ export const SKILL_SURFACE_NAMES = new Set([
   'skill', 'skill_execute', 'skill_view', 'skills_list', 'use_skill',
 ]);
 
+const BACKGROUND_TASK_TOOL_NAMES = new Set([
+  'web_search', 'shell', 'bash', 'bash_session', 'shell_command', 'task',
+]);
+
 export function isBackgroundTaskTool(normalizedName) {
-  return new Set(['web_search', 'shell', 'bash', 'bash_session', 'shell_command', 'task']).has(String(normalizedName || '').toLowerCase());
+  return BACKGROUND_TASK_TOOL_NAMES.has(String(normalizedName || '').toLowerCase());
 }
 
 const AGENT_DISPLAY_NAMES = new Map([

package/src/runtime/shared/tool-execution-contract.mjs

@@ -1,7 +1,7 @@
 import { clean } from './clean.mjs';
 
 export const TOOL_SYNC_EXECUTION_CONTRACT =
-  'Runs synchronously in this tool call.';
+  'Returns final results in this call.';
 
 export const TOOL_ASYNC_EXECUTION_CONTRACT =
   'Runs sync inline by default; async returns a background task_id and delivers a completion notification.';

package/src/runtime/shared/tool-surface.mjs

@@ -493,11 +493,7 @@ const TOOL_CATEGORY = new Map([
 export function classifyToolCategory(name, args = {}) {
   if (isExternalMcpToolName(name)) return 'MCP';
   const normalized = normalizeToolName(name);
-  if (normalized === 'code_graph') {
-    const mode = String(args.mode || args.action || '').toLowerCase();
-    if (mode === 'prewarm' || mode === 'index' || mode === 'build' || mode === 'refresh') return 'Setup';
-    return (mode === 'search' || mode === 'find_symbol' || mode === 'references' || mode === 'callers' || mode === 'callees') ? 'Search' : 'Read';
-  }
+  if (normalized === 'code_graph') return codeGraphLabel(args);
   return TOOL_CATEGORY.get(normalized) || 'Other';
 }
 

package/src/runtime/shared/user-data-guard.mjs

@@ -18,6 +18,7 @@ import {
 import { dirname, join } from 'path';
 import { homedir } from 'os';
 import { createHash } from 'crypto';
+import { isPlainObject } from './object.mjs';
 
 function mixdogConfigBaseDir() {
   return process.env.MIXDOG_CONFIG_DIR || join(homedir(), '.mixdog');
@@ -53,10 +54,6 @@ function initMarkerPath(dataDir) {
   return join(getBackupRoot(), `.initialized-${id}.json`);
 }
 
-function isPlainObject(value) {
-  return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-
 export function hasUserDataInitMarker(dataDir) {
   return existsSync(initMarkerPath(dataDir));
 }

package/src/runtime/shared/webhooks-db.mjs

@@ -15,16 +15,11 @@
  */
 
 import { ensurePgInstance, withSchemaBootstrapLock } from '../memory/lib/pg/adapter.mjs';
+import { createPgSchemaDb } from './pg-schema-db.mjs';
 import { resolvePluginData } from './plugin-paths.mjs';
 
 const SCHEMA = 'webhooks';
 
-// ---------------------------------------------------------------------------
-// Lazy connection + one-shot idempotent DDL (keyed per resolved dataDir).
-// ---------------------------------------------------------------------------
-
-const _ready = new Map(); // dataDir → Promise<db>
-
 const DDL = `
 CREATE SCHEMA IF NOT EXISTS webhooks;
 CREATE TABLE IF NOT EXISTS webhooks.endpoints (
@@ -59,24 +54,13 @@ CREATE TABLE IF NOT EXISTS webhooks.deliveries (
 );
 `;
 
-async function getDb(dataDir = resolvePluginData()) {
-  if (_ready.has(dataDir)) return _ready.get(dataDir);
-  const p = (async () => {
-    const { db, pool } = await ensurePgInstance(dataDir, { schema: SCHEMA });
-    // Serialize the CREATE TABLE across concurrent first-boot processes on the
-    // same cluster-global advisory lock the adapter uses for schema bootstrap,
-    // so racing first calls can't run the DDL simultaneously.
-    await withSchemaBootstrapLock(pool, () => db.exec(DDL));
-    return db;
-  })();
-  _ready.set(dataDir, p);
-  try {
-    return await p;
-  } catch (err) {
-    _ready.delete(dataDir); // let the next call retry DDL after a transient failure
-    throw err;
-  }
-}
+const getDb = createPgSchemaDb({
+  schema: SCHEMA,
+  ddl: DDL,
+  defaultDataDir: resolvePluginData,
+  ensurePg: ensurePgInstance,
+  withLock: withSchemaBootstrapLock,
+});
 
 // ---------------------------------------------------------------------------
 // Row <-> def mapping

package/src/runtime/web-search/index.mjs

@@ -75,11 +75,8 @@ function normalizeWebSearchArgs(rawArgs) {
     }
   }
   if (Array.isArray(args.keywords)) {
-    const keywords = args.keywords
+    args.keywords = args.keywords
       .map(value => typeof value === 'string' ? value.trim() : value)
-      .filter(value => typeof value === 'string' ? value.length > 0 : Boolean(value))
-    if (keywords.length > 0) args.keywords = keywords
-    else delete args.keywords
   }
   return args
 }
@@ -203,16 +200,35 @@ function buildAgentWebSearchPrompt(args) {
   return lines.join('\n')
 }
 
+// Native providers disagree on citation field names. These lists are the
+// accepted shapes, not a guess: the first present string wins.
+const NATIVE_SOURCE_URL_FIELDS = ['url', 'uri', 'href', 'source_url']
+const NATIVE_SOURCE_TITLE_FIELDS = ['title', 'query', 'name']
+const NATIVE_SOURCE_SNIPPET_FIELDS = ['snippet', 'text', 'description']
+
+function firstSourceField(source, names, fallback = '') {
+  let raw = fallback
+  if (source && typeof source === 'object') {
+    for (const name of names) {
+      if (source[name]) {
+        raw = source[name]
+        break
+      }
+    }
+  }
+  return String(raw || '').trim()
+}
+
 function sourceUrl(source) {
-  return String(source?.url || source?.uri || source?.href || source?.source_url || '').trim()
+  return firstSourceField(source, NATIVE_SOURCE_URL_FIELDS)
 }
 
 function sourceTitle(source, fallbackUrl = '') {
-  return String(source?.title || source?.query || source?.name || fallbackUrl || '(untitled)').trim()
+  return firstSourceField(source, NATIVE_SOURCE_TITLE_FIELDS, fallbackUrl || '(untitled)')
 }
 
 function sourceSnippet(source) {
-  return String(source?.snippet || source?.text || source?.description || '').replace(/\s+/g, ' ').trim()
+  return firstSourceField(source, NATIVE_SOURCE_SNIPPET_FIELDS).replace(/\s+/g, ' ').trim()
 }
 
 function collectNativeWebSearchSources(result) {
@@ -457,16 +473,24 @@ async function handleToolCall(name, rawArgs, options = {}) {
           const keywords = [...new Set(args.keywords.map(kw => String(kw || '').trim()).filter(Boolean))]
           const sections = new Array(keywords.length)
           let cursor = 0
+          let failed = 0
           await Promise.all(Array.from({ length: Math.min(concurrency, keywords.length) }, async () => {
             while (cursor < keywords.length) {
               const index = cursor++
               const kw = keywords[index]
               const sub = await handleToolCall('web_search', { ...rawArgs, keywords: kw }, { signal, nativeWebSearch })
               const text = (sub.content || []).filter(p => p.type === 'text').map(p => p.text).join('\n')
+              if (sub.isError) failed++
               sections[index] = `### Query: ${kw}\n\n${text}`
             }
           }))
-          return { content: [{ type: 'text', text: sections.join('\n\n---\n\n') }] }
+          const summary = failed
+            ? `[web_search] ${failed}/${keywords.length} queries failed; successful results are retained.\n\n`
+            : ''
+          return {
+            content: [{ type: 'text', text: summary + sections.join('\n\n---\n\n') }],
+            ...(failed ? { isError: true } : {}),
+          }
         }
         try {
           const result = await _webSearchCore(args, { cacheState, nativeWebSearch, signal })

package/src/runtime/web-search/tool-defs.mjs

@@ -8,11 +8,11 @@ export const TOOL_DEFS = [
   {
     name: 'web_search',
     title: 'Mixdog Web Search',
-    description: `Cached web/docs/current-info search. ${TOOL_SYNC_EXECUTION_CONTRACT}`,
+    description: `Cached web/docs/current-info search; batch queries sharing filters. ${TOOL_SYNC_EXECUTION_CONTRACT}`,
     inputSchema: {
       type: 'object',
       properties: {
-        query: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }], description: 'Required query or array for lossless fan-out.' },
+        query: { anyOf: [{ type: 'string', minLength: 1, pattern: '\\S' }, { type: 'array', minItems: 1, items: { type: 'string', minLength: 1, pattern: '\\S' } }], description: 'Non-empty query or array for lossless fan-out.' },
         site: { type: 'string', description: 'Site/domain filter.' },
         type: { type: 'string', enum: ['web', 'news', 'images'], description: 'Default web.' },
         maxResults: { type: 'integer', minimum: 1, maximum: 20, description: 'Result count; default 10; 1-20.' },
@@ -27,11 +27,11 @@ export const TOOL_DEFS = [
   {
     name: 'web_fetch',
     title: 'Mixdog Web Fetch',
-    description: 'Fetch page/docs body from URL.',
+    description: 'Fetch page/docs body from URL; batch known URLs with shared slice options.',
     inputSchema: {
       type: 'object',
       properties: {
-        url: { anyOf: [{ type: 'string', format: 'uri' }, { type: 'array', items: { type: 'string', format: 'uri' }, maxItems: 10 }], description: 'Public HTTP(S) URL or array of up to 10 URLs.' },
+        url: { anyOf: [{ type: 'string', format: 'uri' }, { type: 'array', items: { type: 'string', format: 'uri' }, minItems: 1, maxItems: 10 }], description: 'Public HTTP(S) URL or array of up to 10 URLs.' },
         startIndex: { type: 'integer', minimum: 0, description: 'Character offset; default 0.' },
         maxLength: { type: 'integer', minimum: 0, description: 'Maximum characters; default 50000; 0 unlimited.' },
       },

package/src/session-runtime/config-lifecycle.mjs

@@ -18,8 +18,42 @@
 const CONFIG_SAVE_DEBOUNCE_MS = 150;
 
 import { withGrandfatheredBuiltins } from './builtin-features.mjs';
+import { webSearchRouteOrDefault } from './workflow.mjs';
 import { createDebouncedWriter } from '../runtime/shared/debounced-writer.mjs';
 
+/**
+ * Boot-time config/route state for one runtime. Caller overrides are applied
+ * ONLY when supplied, so an option left out keeps the persisted route value
+ * (`effort: undefined` must not erase a stored effort, and `fast` is a tri-state
+ * where only an explicit boolean overrides).
+ */
+export function resolveInitialConfigState({
+  initialConfig,
+  loadConfig,
+  resolveRoute,
+  provider,
+  model,
+  effort,
+  fast,
+  modelParameters,
+}) {
+  const config = withGrandfatheredBuiltins(
+    initialConfig && typeof initialConfig === 'object' ? initialConfig : loadConfig(),
+  );
+  return {
+    config,
+    route: {
+      ...resolveRoute(config, { provider, model }),
+      ...(effort === undefined ? {} : { effort: effort || null }),
+      ...(fast === true || fast === false ? { fast } : {}),
+      ...(modelParameters && typeof modelParameters === 'object'
+        ? { modelParameters: { ...modelParameters } }
+        : {}),
+    },
+    webSearchRoute: webSearchRouteOrDefault(config.webSearchRoute),
+  };
+}
+
 export function createConfigLifecycle({
   // config mutable-state injection
   getConfig,

package/src/session-runtime/context-status.mjs

@@ -393,3 +393,22 @@ export function createContextStatus({
 
   return { contextStatus, invalidateContextStatusCache };
 }
+
+// One-shot gauge for a session that is NOT the runtime's current session (a
+// listed/foreign session). The route is read off the session itself and the
+// calculator is thrown away with its cache, so a foreign read can never poison
+// the live gauge's memoization.
+export function contextStatusForSession(session, { getMode, fallbackCwd = '' } = {}) {
+  if (!session || typeof session !== 'object') return null;
+  const { contextStatus } = createContextStatus({
+    getSession: () => session,
+    getRoute: () => ({
+      provider: session.provider || '',
+      model: session.model || '',
+      contextWindow: session.contextWindow || null,
+    }),
+    getCurrentCwd: () => session.cwd || fallbackCwd,
+    getMode,
+  });
+  return contextStatus();
+}

package/src/session-runtime/cwd-plugins.mjs

@@ -23,7 +23,6 @@ export function createCwdPlugins({
   isCodeGraphPrewarmLazy,
   isCodeGraphFirstTurnPrewarmDone,
   getCodeGraphPrewarmDelayMs,
-  setSessionNeedsCwdRefresh,
   // callbacks / deps
   scheduleCodeGraphPrewarm,
   hooks,
@@ -99,11 +98,11 @@ export function createCwdPlugins({
     return next;
   }
 
-  function applyResolvedCwd(nextCwd, {
-    markRefresh = true,
-    waitForMcpReset = false,
-    persistProjectSelection = false,
-  } = {}) {
+  // cwd changes NEVER recreate the session and never reload MCP or Skills
+  // (extension settings are global): a mid-conversation cwd switch must
+  // preserve the full message history. The live execution cwd is retargeted in
+  // place; the BP3 session snapshot remains the session-start environment.
+  function applyResolvedCwd(nextCwd, { persistProjectSelection = false } = {}) {
     const resolved = resolve(nextCwd);
     const stat = statSync(resolved);
     if (!stat.isDirectory()) throw new Error(`cwd: not a directory: ${resolved}`);
@@ -114,22 +113,18 @@ export function createCwdPlugins({
     if (session) session.cwd = currentCwd;
     updateCurrentCwdOverride?.(currentCwd);
     writeLastSessionCwd(currentCwd, session?.clientHostPid);
-    if (persistProjectSelection && session) {
-      const desktop = getDesktopSession?.() || session.desktopSession;
+    if (persistProjectSelection) {
+      const desktop = getDesktopSession?.() || session?.desktopSession;
       if (desktop && typeof desktop === 'object') {
         const nextDesktop = { classification: 'project', projectPath: currentCwd };
         setDesktopSession?.(nextDesktop);
-        session.desktopSession = nextDesktop;
+        if (session) session.desktopSession = nextDesktop;
+      }
+      if (session) {
+        session.updatedAt = Date.now();
+        persistSession(session);
       }
-      session.updatedAt = Date.now();
-      persistSession(session);
     }
-    // cwd changes NEVER recreate the session: a mid-conversation cwd switch must
-    // preserve the full message history. We retarget the live execution cwd in
-    // place; the BP3 session snapshot remains the session-start environment.
-    // `markRefresh`/`changed` are kept only for signature compatibility with
-    // existing callers.
-    void markRefresh;
     // Lazy mode: before the first turn (e.g. the initial project-selection
     // cwd set), do NOT prewarm — that is exactly the post-first-frame freeze
     // we are avoiding. Once a turn has run, an in-session cwd switch DOES
@@ -140,8 +135,6 @@ export function createCwdPlugins({
       const delay = getCodeGraphPrewarmDelayMs();
       scheduleCodeGraphPrewarm(changed ? 0 : delay, changed ? 'cwd-change' : 'cwd');
     }
-    // Extension settings are global; cwd changes never reload MCP or Skills.
-    void waitForMcpReset;
     // CwdChanged: bridge an effective cwd switch to the standard hook bus.
     // No matcher event — payload is minimal { cwd }. Fire-and-forget.
     if (changed) {
@@ -150,15 +143,6 @@ export function createCwdPlugins({
     return currentCwd;
   }
 
-  async function refreshSessionForCwdIfNeeded(reason = 'cwd-change') {
-    // No-op: cwd changes are applied in place by applyResolvedCwd and never
-    // tear down the session. Retained as a stable hook for ask()'s pre-turn
-    // call so the surrounding turn flow is unchanged.
-    void reason;
-    setSessionNeedsCwdRefresh(false);
-    return getSession();
-  }
-
   function pluginsStatus() {
     const config = getConfig();
     const dataDir = cfgMod.getPluginData?.();
@@ -272,7 +256,6 @@ export function createCwdPlugins({
   return {
     resolveCwdPath,
     applyResolvedCwd,
-    refreshSessionForCwdIfNeeded,
     pluginsStatus,
     formatCoreMemoryLines,
     loadCoreMemoryContext,

package/src/session-runtime/goal-tasks.mjs

@@ -1,4 +1,4 @@
-import { GOAL_TASK_SETTLED, GOAL_TASK_STATUSES, MAX_GOAL_TASKS } from './goal-tool-defs.mjs';
+import { GOAL_TASK_SETTLED, GOAL_TASK_STATUSES, MAX_GOAL_TASKS, MAX_GOAL_TASK_TEXT_LENGTH } from './goal-tool-defs.mjs';
 import { clean } from '../runtime/shared/clean.mjs';
 
 // Dropped rows remain in the record but are no longer requested work.
@@ -42,7 +42,7 @@ export function normalizeGoalTasks(input, previous = [], { strict = false } = {}
     if (!source || typeof source !== 'object') throw new Error(`goal task ${index + 1} is invalid`);
     const text = clean(source.text);
     if (!text) throw new Error('goal task text is required');
-    if ([...text].length > 500) throw new Error('goal task exceeds 500 characters');
+    if ([...text].length > MAX_GOAL_TASK_TEXT_LENGTH) throw new Error(`goal task exceeds ${MAX_GOAL_TASK_TEXT_LENGTH} characters`);
     if (seenText.has(text)) throw new Error(`duplicate goal task: ${text}`);
     seenText.add(text);
     const id = clean(source.id) || clean(previousByText.get(text)?.id) || `task_${nextId++}`;

package/src/session-runtime/goal-tool-defs.mjs

@@ -4,10 +4,11 @@ export const GOAL_TASK_STATUSES = Object.freeze([
 ]);
 export const GOAL_TASK_SETTLED = Object.freeze(['completed', 'dropped']);
 export const MAX_GOAL_TASKS = 20;
+export const MAX_GOAL_TASK_TEXT_LENGTH = 500;
 
 const taskFields = {
   id: { type: 'string', description: 'Stable task id; omit only for new tasks.' },
-  text: { type: 'string', description: 'Required work or verification outcome.' },
+  text: { type: 'string', minLength: 1, maxLength: MAX_GOAL_TASK_TEXT_LENGTH, description: 'Required work or verification outcome.' },
   status: {
     type: 'string',
     enum: GOAL_TASK_STATUSES,
@@ -47,7 +48,7 @@ export const GOAL_TOOL_DEFS = Object.freeze([{
       tasks: {
         type: 'array', minItems: 1, maxItems: MAX_GOAL_TASKS,
         items: { type: 'object', properties: taskFields, required: ['text', 'status', 'kind'], additionalProperties: false },
-        description: 'create/set_tasks: full list; update_tasks/resume: new tasks to append, without ids.',
+        description: `create/set_tasks: full list; update_tasks/resume: new tasks, no ids. Max ${MAX_GOAL_TASKS} total, including completed/dropped.`,
       },
       updates: {
         type: 'array', minItems: 1, maxItems: MAX_GOAL_TASKS,

package/src/session-runtime/internal-tool-executor.mjs

@@ -15,6 +15,7 @@ import { featureEnvOverride } from './config-helpers.mjs';
 import { renderToolSearch } from './tool-catalog.mjs';
 import { clean } from './session-text.mjs';
 import { STANDALONE_DATA_DIR } from './runtime-paths.mjs';
+import { listProjects } from '../standalone/projects.mjs';
 import {
   dispatchWebSearchRuntimeTool,
   memoryToolArgsForCaller,
@@ -149,6 +150,12 @@ export function createInternalToolExecutor({
     if (name === 'cwd') {
       const action = clean(args?.action || (args?.path ? 'set' : 'get')).toLowerCase();
       let currentCwd = callerCwd;
+      if (action === 'list') {
+        return JSON.stringify({
+          cwd: currentCwd,
+          projects: listProjects().map((project) => ({ name: project.name, path: project.path })),
+        }, null, 2);
+      }
       if (action === 'set') {
         const rawPath = clean(args?.path);
         if (!rawPath) throw new Error('cwd: path is required for action=set');