mixdog 1.4.2 → 1.4.3

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

@@ -18,7 +18,14 @@ import {
   withDefaultPresets,
 } from '../runtime/agent/orchestrator/config-presets.mjs';
 import { syncSessionCompaction } from './session-compaction-sync.mjs';
-import { createConfigWriters } from './config-lifecycle/config-writers.mjs';
+import {
+  configChangeDomains,
+  configChangeIsEmpty,
+  configChangeSnapshot,
+  diffConfigSnapshots,
+  withConfigDomainPending,
+} from './config-change-effects.mjs';
+import { configWithOutputStyle, createConfigWriters } from './config-lifecycle/config-writers.mjs';
 import { createLeadRouteSync } from './config-lifecycle/lead-route-sync.mjs';
 import { createOutputStyleStatusCache } from './config-lifecycle/output-style-cache.mjs';
 
@@ -45,9 +52,19 @@ function seedChanges(config, changes) {
     .map((key) => ({ path: [key], value: structuredClone(config[key]), ifAbsent: true }));
 }
 
+// The agent config load carries no root `outputStyle`; the stored root value
+// is laid on it (absent: the default style applies).
+function withStoredOutputStyle(config, storedOutputStyle) {
+  return typeof storedOutputStyle === 'string' && storedOutputStyle.trim()
+    ? { ...config, outputStyle: storedOutputStyle.trim() }
+    : config;
+}
+
 // The config just read from disk with this runtime's still-pending edits laid
 // back on it (the config and skills writers hold the only copy of them).
-function withPendingEdits(loaded, writers) {
+// The agent config load carries no root `outputStyle`: the stored root value
+// (`storedOutputStyle`) is laid on it, and this runtime's pending pick wins.
+function withPendingEdits(loaded, writers, storedOutputStyle) {
   let next = loaded;
   if (writers.hasPendingConfigChanges()) {
     // Preserve only our pending edits. Peer changes and fresh secret overlays
@@ -67,6 +84,9 @@ function withPendingEdits(loaded, writers) {
   if (pendingSkills !== null) {
     next = { ...next, skills: { ...(next.skills || {}), disabled: pendingSkills } };
   }
+  const pendingOutputStyle = writers.pendingOutputStyle();
+  if (pendingOutputStyle !== null) next = configWithOutputStyle(next, pendingOutputStyle);
+  else next = withStoredOutputStyle(next, storedOutputStyle);
   return next;
 }
 
@@ -85,6 +105,7 @@ function withPendingEdits(loaded, writers) {
 export function resolveInitialConfigState({
   initialConfig,
   loadConfig,
+  readStoredOutputStyle = null,
   resolveRoute,
   provider,
   model,
@@ -97,8 +118,12 @@ export function resolveInitialConfigState({
   selectedContextWindow,
   agentOwned = false,
 }) {
+  // An injected config is complete as given; a loaded one takes the stored
+  // root output style (`readStoredOutputStyle`) as every reload does.
   const config = withGrandfatheredBuiltins(
-    initialConfig && typeof initialConfig === 'object' ? initialConfig : loadConfig()
+    initialConfig && typeof initialConfig === 'object'
+      ? initialConfig
+      : withStoredOutputStyle(loadConfig(), readStoredOutputStyle?.())
   );
   // A requested percent replaces a saved token window; requested tokens
   // replace both (resolveRouteContextState lets tokens win).
@@ -135,10 +160,12 @@ export function createConfigLifecycle({
   getConfigHasSecrets,
   setConfigHasSecrets,
   getRoute,
-  // The live session follows the reloaded global compaction settings, unless
-  // the runtime runs on an injected (headless) config.
+  // The live session follows the reloaded global compaction settings.
   getSession,
-  fixedSessionCompaction = false,
+  // A headless caller injects a complete, deliberately isolated config: it
+  // never reloads from disk (no change subscription either), and its sessions
+  // keep the compaction they were created with.
+  injectedConfig = false,
   // Main route sync on reload (both optional: a lifecycle without them never syncs)
   setRouteState,
   resolveRoute,
@@ -153,9 +180,14 @@ export function createConfigLifecycle({
   clean,
   resolve,
   performanceNow = () => performance.now(),
-  onConfigReloaded,
+  // The runtime's change-driven effects (config-change-effects.mjs), given the
+  // diff against the snapshot this runtime last applied.
+  onConfigChanged,
+  // The backoff of a failed effect's retries; the last delay repeats.
+  effectRetryDelaysMs = [1000, 4000, 15000, 60000],
   STANDALONE_DATA_DIR,
 }) {
+  let disposed = false;
   const outputStyleCache = createOutputStyleStatusCache({
     cfgMod,
     STANDALONE_DATA_DIR,
@@ -217,25 +249,125 @@ export function createConfigLifecycle({
   }
 
   // --- reload / ensure --------------------------------------------------------
-  function reloadFullConfig() {
-    // A pending debounced write holds the only copy of the latest change.
-    // Flush it before re-reading from disk so loadConfig() observes (and the
-    // subsequent adopt preserves) that change instead of reverting to a stale
-    // on-disk snapshot.
+  const changeSnapshot = (config) =>
+    configChangeSnapshot({
+      config,
+      root: sharedCfgMod?.readConfig?.(),
+      secretTokens: sharedCfgMod?.secretChangeTokens?.(),
+    });
+  // What this runtime's effects last ran against, starting from the boot
+  // config (the snapshot does not depend on whether a load read secrets).
+  let appliedSnapshot = changeSnapshot(getConfig());
+  // The stored settings the current config object was taken from (never
+  // marked pending): the object is replaced only when they changed, so a
+  // retry of a failed effect alone keeps it.
+  let loadedSnapshot = appliedSnapshot;
+
+  // A pending debounced write holds the only copy of the latest change.
+  // Flush it before re-reading from disk so loadConfig() observes (and the
+  // subsequent adopt preserves) that change instead of reverting to a stale
+  // on-disk snapshot.
+  function loadFullConfig() {
     writers.flushConfigSave();
-    const next = withPendingEdits(cfgMod.loadConfig(), writers);
+    if (injectedConfig) return null;
+    return withPendingEdits(cfgMod.loadConfig(), writers, sharedCfgMod?.readConfig?.()?.outputStyle);
+  }
+
+  function reloadFullConfig() {
+    return adoptFullConfig(loadFullConfig());
+  }
+
+  function adoptFullConfig(next) {
+    if (!next) return getConfig();
     const adopted = adoptConfig(next, { hasSecrets: true });
     configSaveBaseline = structuredClone(adopted);
     leadRoute.syncEmptyMainRoute(adopted);
-    if (!fixedSessionCompaction) syncSessionCompaction(getSession?.(), adopted);
+    syncSessionCompaction(getSession?.(), adopted);
     return adopted;
   }
 
   function ensureFullConfig() {
-    if (getConfigHasSecrets()) return getConfig();
+    if (injectedConfig || getConfigHasSecrets()) return getConfig();
     return reloadFullConfig();
   }
 
+  /** The change step: reload, then run the effects keyed by what differs from
+   *  the last applied snapshot. A writer that runs it right after its own write
+   *  has applied the change, so the notification that follows finds nothing.
+   *  The config object is replaced only when the stored settings changed (a
+   *  retry of a failed effect alone keeps it): consumers key turn-start
+   *  reconciles on its identity. */
+  function applyConfigChange() {
+    // A load that throws changes nothing: pending domains stay pending.
+    const loaded = loadFullConfig();
+    // Every pending domain is in this step's diff, so it runs again here (and
+    // a scheduled retry is this step).
+    pendingDomains = new Set();
+    clearTimeout(retryTimer);
+    retryTimer = null;
+    outputStyleCache.invalidateOutputStyleStatusCache();
+    const next = changeSnapshot(loaded ?? getConfig());
+    const change = diffConfigSnapshots(appliedSnapshot, next);
+    appliedSnapshot = next;
+    const settingsChanged = !configChangeIsEmpty(diffConfigSnapshots(loadedSnapshot, next));
+    loadedSnapshot = next;
+    const config = settingsChanged ? adoptFullConfig(loaded) : getConfig();
+    let outcome;
+    try {
+      outcome = onConfigChanged?.(change, config);
+    } catch {
+      outcome = configChangeDomains(change);
+    }
+    void Promise.resolve(outcome).then(
+      (failedDomains) => settleConfigEffects(failedDomains),
+      () => settleConfigEffects(configChangeDomains(change))
+    );
+    return change;
+  }
+
+  // A domain whose effect failed is marked not applied, so the next change
+  // step (any notification, a writer's own step, or the retry below) runs it
+  // again; the applied snapshot otherwise advances as the step runs, which
+  // keeps a step overlapping an in-flight effect from repeating it. The retry
+  // backs off to the last delay and keeps going until the domain succeeds or
+  // the sync is disposed.
+  let pendingDomains = new Set();
+  let retryTimer = null;
+  let retryAttempt = 0;
+  function settleConfigEffects(failedDomains) {
+    for (const domain of Array.isArray(failedDomains) ? failedDomains : []) {
+      appliedSnapshot = withConfigDomainPending(appliedSnapshot, domain);
+      pendingDomains.add(domain);
+    }
+    if (!pendingDomains.size) {
+      retryAttempt = 0;
+      return;
+    }
+    if (retryTimer || disposed) return;
+    const delay = effectRetryDelaysMs[Math.min(retryAttempt, effectRetryDelaysMs.length - 1)];
+    retryTimer = setTimeout(() => {
+      retryTimer = null;
+      retryAttempt += 1;
+      try {
+        applyConfigChange();
+      } catch {
+        // The reload failed (e.g. a config mid-write): still pending, retry later.
+        settleConfigEffects([]);
+      }
+    }, delay);
+    retryTimer.unref?.();
+  }
+
+  // The output style this runtime selected but has not yet persisted wins over
+  // a status read from disk, so a concurrent write never shows the old style.
+  function getOutputStyleStatusCached(options) {
+    const status = outputStyleCache.getOutputStyleStatusCached(options);
+    const pending = writers.pendingOutputStyle();
+    if (pending === null || status?.configured === pending) return status;
+    const current = (status?.styles || []).find((style) => style.id === pending) || status?.current;
+    return { ...status, configured: pending, current };
+  }
+
   function ensureConfigForRouteProvider() {
     const config = getConfig();
     const providerId = clean(getRoute().provider);
@@ -246,19 +378,22 @@ export function createConfigLifecycle({
     return ensureFullConfig();
   }
 
-  // Settings persisted by any other runtime (or process) reach this runtime's
-  // in-memory config. reloadFullConfig keeps our own pending edits, and the
-  // shared layer coalesces bursts into one pass per subscriber.
-  const unsubscribeConfigChange = sharedCfgMod?.subscribeConfigChange?.(() => {
-    reloadFullConfig();
-    outputStyleCache.invalidateOutputStyleStatusCache();
-    onConfigReloaded?.();
-  });
+  // Settings and secrets persisted by this or any other runtime (or process)
+  // reach this runtime's config and effects. reloadFullConfig keeps our own
+  // pending edits, and the shared layer coalesces bursts into one pass per
+  // subscriber. An injected config never follows the disk.
+  const unsubscribeConfigChange = injectedConfig ? null : sharedCfgMod?.subscribeConfigChange?.(applyConfigChange);
 
   return {
-    disposeConfigSync: () => unsubscribeConfigChange?.(),
+    disposeConfigSync: () => {
+      disposed = true;
+      clearTimeout(retryTimer);
+      retryTimer = null;
+      unsubscribeConfigChange?.();
+    },
     // output-style cache
     ...outputStyleCache,
+    getOutputStyleStatusCached,
     // adopt / save
     adoptConfig,
     saveConfigAndAdopt,
@@ -270,6 +405,7 @@ export function createConfigLifecycle({
     flushAllConfigSavesAsync: writers.flushAllConfigSavesAsync,
     // reload / ensure
     reloadFullConfig,
+    applyConfigChange,
     ensureFullConfig,
     displayConfig: () => getConfig(),
     ensureConfigForRouteProvider,

package/src/session-runtime/conversation-import/discovery.mjs

@@ -3,6 +3,7 @@
  *
  *   codex   $CODEX_HOME/sessions/**\/rollout-*.jsonl[.zst]   (default ~/.codex)
  *   claude  $CLAUDE_CONFIG_DIR/projects/*\/*.jsonl      (default ~/.claude)
+ *   cowork  %APPDATA%\Claude\local-agent-mode-sessions  (Claude Desktop; Windows only)
  *
  * Enumeration is stat-only; per-file metadata (foreign id, cwd, title, and
  * the message count when the whole file fit the read) comes from a bounded
@@ -11,7 +12,7 @@
  * shares one cache, one candidate registry and one set of listing views.
  */
 import { createHash, randomUUID } from 'node:crypto';
-import { open, readdir, realpath, stat } from 'node:fs/promises';
+import { open, readdir, readFile, realpath, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { pipeline } from 'node:stream';
@@ -77,6 +78,11 @@ const envDir = (value) => (typeof value === 'string' && value.trim() ? resolve(v
 export function sourceRoot(source, env = process.env) {
   if (source === 'codex') return join(envDir(env.CODEX_HOME) || join(homedir(), '.codex'), 'sessions');
   if (source === 'claude') return join(envDir(env.CLAUDE_CONFIG_DIR) || join(homedir(), '.claude'), 'projects');
+  // Only Windows sets APPDATA; elsewhere Claude Desktop has no Cowork folder to search.
+  if (source === 'cowork') {
+    const appData = envDir(env.APPDATA);
+    return appData ? join(appData, 'Claude', 'local-agent-mode-sessions') : null;
+  }
   throw importError('unsupported');
 }
 
@@ -91,8 +97,8 @@ export function loadStoredTitles(source, env = process.env) {
 }
 
 /** The app's stored title of a conversation, else the one derived from its messages. */
-export function displayTitle(meta, titles) {
-  return (meta?.foreignSessionId && titles?.get(meta.foreignSessionId)) || meta?.title || null;
+export function displayTitle(meta, titles, manifestTitle = null) {
+  return manifestTitle || (meta?.foreignSessionId && titles?.get(meta.foreignSessionId)) || meta?.title || null;
 }
 
 const caseFold = (value) => (process.platform === 'win32' ? value.toLowerCase() : value);
@@ -215,6 +221,68 @@ async function walkClaude(rootReal, files) {
   }
 }
 
+// Cowork keeps one `local_<id>.json` manifest per conversation (the account/org folders hold
+// `local_*.json` directly, the agent variant under `agent/`), next to a `local_<id>/` folder whose
+// `.claude/projects/<project>/<cliSessionId>.jsonl` is the Claude Code transcript. The manifest also
+// holds the system prompt and account details, so only title / isStarred / cliSessionId are read.
+// The agent variant (`local_ditto_*`, sessionType "agent") is the user's own Claude desktop chat
+// (its initialMessage is user-typed), so it is listed like the others.
+const COWORK_MANIFEST_MAX_BYTES = 8 * 1024 * 1024;
+const COWORK_TITLE_MAX_CHARS = 200;
+const COWORK_SESSION_ID_RE = /^[\w-]+$/;
+
+async function coworkManifestPaths(rootReal) {
+  const manifests = [];
+  for (const account of await entriesOf(rootReal)) {
+    if (!account.isDirectory()) continue;
+    for (const org of await entriesOf(join(rootReal, account.name))) {
+      if (!org.isDirectory()) continue;
+      for (const dir of [join(rootReal, account.name, org.name), join(rootReal, account.name, org.name, 'agent')]) {
+        for (const file of await entriesOf(dir)) {
+          if (file.isFile() && /^local_.+\.json$/.test(file.name)) manifests.push(join(dir, file.name));
+        }
+      }
+    }
+  }
+  return manifests;
+}
+
+// The transcript a manifest names, with the manifest's title and star; null when it has none.
+async function coworkTranscript(rootReal, manifestPath) {
+  const real = await containedRealpath(rootReal, manifestPath);
+  const info = real ? await stat(real).catch(() => null) : null;
+  if (!info?.isFile() || info.size > COWORK_MANIFEST_MAX_BYTES) return null;
+  let manifest;
+  try {
+    manifest = JSON.parse(await readFile(real, 'utf8'));
+  } catch {
+    return null;
+  }
+  const cliSessionId = manifest?.cliSessionId;
+  if (typeof cliSessionId !== 'string' || !COWORK_SESSION_ID_RE.test(cliSessionId)) return null;
+  const projects = join(real.slice(0, -'.json'.length), '.claude', 'projects');
+  for (const project of await entriesOf(projects)) {
+    if (!project.isDirectory()) continue;
+    const path = join(projects, project.name, `${cliSessionId}.jsonl`);
+    if (await containedRealpath(rootReal, path)) {
+      const title = typeof manifest.title === 'string' ? manifest.title.trim().slice(0, COWORK_TITLE_MAX_CHARS) : '';
+      return { path, title: title || null, starred: manifest.isStarred === true };
+    }
+  }
+  return null;
+}
+
+async function walkCowork(rootReal, files, extras) {
+  const found = await mapBounded(await coworkManifestPaths(rootReal), STAT_CONCURRENCY, (path) =>
+    coworkTranscript(rootReal, path)
+  );
+  for (const entry of found) {
+    if (!entry) continue;
+    files.push(entry.path);
+    extras.set(entry.path, { title: entry.title, starred: entry.starred });
+  }
+}
+
 async function mapBounded(items, limit, fn) {
   const out = new Array(items.length);
   let next = 0;
@@ -231,6 +299,7 @@ async function mapBounded(items, limit, fn) {
 /** Regular files under the source root, canonical and contained, as candidates. */
 export async function enumerateCandidates(source, env = process.env) {
   const root = sourceRoot(source, env);
+  if (!root) return { root: '', candidates: [] };
   let rootReal;
   try {
     rootReal = await realpath(root);
@@ -238,13 +307,17 @@ export async function enumerateCandidates(source, env = process.env) {
     return { root, candidates: [] };
   }
   const paths = [];
+  const extras = new Map(); // transcript path → manifest title / star (Cowork)
   if (source === 'codex') await walkCodex(rootReal, rootReal, paths, new Set([caseFold(rootReal)]));
+  else if (source === 'cowork') await walkCowork(rootReal, paths, extras);
   else await walkClaude(rootReal, paths);
   const stamped = await mapBounded(paths, STAT_CONCURRENCY, async (path) => {
     const real = await containedRealpath(rootReal, path);
     if (!real) return null;
     const info = await stat(real).catch(() => null);
-    return info?.isFile() ? { path: real, size: info.size, mtimeMs: info.mtimeMs, fileId: fileIdentity(info) } : null;
+    return info?.isFile()
+      ? { path: real, size: info.size, mtimeMs: info.mtimeMs, fileId: fileIdentity(info), ...extras.get(path) }
+      : null;
   });
   const unique = new Map();
   for (const file of stamped) {
@@ -261,7 +334,9 @@ function compareCodeUnits(left, right) {
   return left < right ? -1 : 1;
 }
 
+// Starred conversations (Cowork) come first, then newest first.
 function byModifiedThenId(left, right) {
+  if (!left.starred !== !right.starred) return left.starred ? -1 : 1;
   if (right.mtimeMs !== left.mtimeMs) return right.mtimeMs - left.mtimeMs;
   return compareCodeUnits(left.id, right.id);
 }
@@ -418,7 +493,7 @@ async function readPrefixMeta(candidate) {
   // nothing but sidechain messages has been seen the scan streams on, line by
   // line, to EOF or to the import file-size limit. A file over that limit stays
   // unclassified (listed); importing it fails as tooLarge.
-  const claude = candidate.source === 'claude';
+  const claude = candidate.source === 'claude' || candidate.source === 'cowork';
   let read;
   try {
     read = await streamJsonlLines(handle, (line) => converter.pushLine(line), {
@@ -793,7 +868,8 @@ function rowFor(candidate, meta, cwdInfo, imported, titles) {
   return {
     id: candidate.id,
     source: candidate.source,
-    title: displayTitle(meta, titles),
+    title: displayTitle(meta, titles, candidate.title),
+    starred: candidate.starred === true,
     cwd: cwdInfo?.path ?? null,
     modifiedAt: candidate.mtimeMs,
     messageCount: meta?.messageCount ?? null,
@@ -946,7 +1022,10 @@ async function filterCandidates(candidates, filters, imported, titles) {
     const cwdInfo = meta.cwd ? await resolveSourceCwd(meta.cwd, cwdCache) : null;
     if (
       needle &&
-      !(foldText(displayTitle(meta, titles)).includes(needle) || foldText(cwdInfo?.path).includes(needle))
+      !(
+        foldText(displayTitle(meta, titles, candidate.title)).includes(needle) ||
+        foldText(cwdInfo?.path).includes(needle)
+      )
     ) {
       continue;
     }

package/src/session-runtime/conversation-import/service.mjs

@@ -143,7 +143,7 @@ const titlesFor = (candidate, context) => (candidate.source === 'codex' ? contex
 function describeCandidate(candidateId, context) {
   const candidate = getCandidate(candidateId);
   return {
-    title: candidate ? displayTitle(cachedMeta(candidate), titlesFor(candidate, context)) : null,
+    title: candidate ? displayTitle(cachedMeta(candidate), titlesFor(candidate, context), candidate.title) : null,
     sourceName: candidate ? basename(candidate.path) : null,
   };
 }
@@ -196,7 +196,8 @@ async function importOne(candidateId, context) {
   }
   const title = displayTitle(
     { foreignSessionId: conversion.foreignSessionId, title: listedTitle || conversion.title },
-    titlesFor(candidate, context)
+    titlesFor(candidate, context),
+    candidate.title
   );
   if (title) conversion = { ...conversion, title };
   recordConversion(candidate, conversion);

package/src/session-runtime/goal-facade-api.mjs

@@ -1,6 +1,15 @@
 import { markPendingGoalReminder } from '../runtime/agent/orchestrator/runtime-core/goal-reminder.mjs';
+import { adoptLegacyGoalTasks, todoContextBlock } from '../runtime/agent/orchestrator/runtime-core/todo-list.mjs';
+import { SAVE_OUTCOME_SAVED } from '../runtime/agent/orchestrator/session/store/live-state.mjs';
 
-export function createGoalFacadeApi({ agentStatusState, createCurrentSession, getSession, getSessionId, goalRuntime }) {
+export function createGoalFacadeApi({
+  agentStatusState,
+  createCurrentSession,
+  getSession,
+  getSessionId,
+  goalRuntime,
+  persistSession,
+}) {
   const markGoalReminder = (reason = '') => {
     try {
       const pending = markPendingGoalReminder(getSession(), reason);
@@ -14,10 +23,39 @@ export function createGoalFacadeApi({ agentStatusState, createCurrentSession, ge
       return null;
     }
   };
+  // A Goal record written before the todo list still carries its tasks: the
+  // session's list adopts them, and only once that session is saved does the
+  // record let them go. A failed save keeps them on the record, so the next
+  // load adopts again (items already listed are skipped, never duplicated).
+  const adopting = new Map();
+  const adoptLegacyTasks = (sessionId) => {
+    if (adopting.has(sessionId)) return adopting.get(sessionId);
+    const tasks = goalRuntime.legacyTasks?.(sessionId) || [];
+    if (!tasks.length) return null;
+    const session = getSession();
+    if (session?.id !== sessionId) return null;
+    adoptLegacyGoalTasks(session, tasks);
+    const adoption = (async () => {
+      try {
+        // Only an explicit committed write lets the record go: a dropped or
+        // stale save resolves too, without the list on disk.
+        if ((await persistSession(session)) !== SAVE_OUTCOME_SAVED) return;
+        await goalRuntime.clearLegacyTasks(sessionId);
+      } catch {
+        // Kept on the record; retried on the next load.
+      } finally {
+        adopting.delete(sessionId);
+      }
+    })();
+    adopting.set(sessionId, adoption);
+    return adoption;
+  };
   return {
     goalStatus() {
       const sessionId = getSessionId();
-      return sessionId ? goalRuntime.snapshot(sessionId) : null;
+      if (!sessionId) return null;
+      adoptLegacyTasks(sessionId);
+      return goalRuntime.snapshot(sessionId);
     },
     async goalControl(args = {}) {
       let sessionId = getSessionId();
@@ -31,10 +69,18 @@ export function createGoalFacadeApi({ agentStatusState, createCurrentSession, ge
       return result;
     },
     markGoalReminder,
+    /** Settles once a legacy Goal record's tasks are adopted and saved (or kept after a failed save). */
+    adoptLegacyGoalTasks(sessionId = getSessionId()) {
+      return Promise.resolve(sessionId ? adoptLegacyTasks(sessionId) : null);
+    },
     goalContinuation() {
       const sessionId = getSessionId();
       if (!sessionId) return { run: false, reason: 'missing-session', goal: null };
-      return goalRuntime.continuation(sessionId, { agentStatus: agentStatusState() });
+      adoptLegacyTasks(sessionId);
+      return goalRuntime.continuation(sessionId, {
+        agentStatus: agentStatusState(),
+        todo: todoContextBlock(getSession(), 'Todo list for this Goal (exact wordings):', { whole: true }),
+      });
     },
     goalTurnStarted() {
       const sessionId = getSessionId();

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

@@ -8,6 +8,7 @@ import {
   ASK_USER_MAX_TEXT,
 } from '../../runtime/agent/orchestrator/runtime-core/ask-user-tool-defs.mjs';
 import { createCallerContextResolvers } from './caller-context.mjs';
+import { noteTodoUserWait } from '../../runtime/agent/orchestrator/session/loop/no-tool-turn/todo-check.mjs';
 import { runAbortable } from '../../runtime/shared/abort-race.mjs';
 import {
   HANDOFF_OUTCOMES as AGENT_OUTCOMES,
@@ -309,6 +310,8 @@ export function createAskUserToolHandlers({ rt }) {
           normalizeAskUserAnswers(result.answers, questions),
           normalizeAskUserReply(result.reply)
         );
+      // A question left unanswered: the turn may end waiting on the user.
+      noteTodoUserWait(sessionIdFor(callerCtx));
       return DISMISSED;
     },
   };

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

@@ -68,8 +68,9 @@ export function createBridgeToolHandlers({ rt }) {
     if (environmentDisabled(callerCtx, 'MIXDOG_FEATURE_VISUALIZE')) {
       throw new Error('the visualize tool is disabled in this environment');
     }
-    // A conversation keeps its frozen tool list, so honor the Settings toggle
-    // at execution time too (an env override wins, as in builtinFeatureActive).
+    // The Settings toggle at execution time too: it reaches a turn already
+    // running and callers outside the session's deny set (an env override
+    // wins, as in builtinFeatureActive).
     if (!(featureEnvOverride('MIXDOG_FEATURE_VISUALIZE') ?? moduleEnabled(rt.config, 'visualize', true))) {
       return {
         content: [

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

@@ -1,19 +1,13 @@
-// Optional feature tools gated by settings for model-initiated calls: office,
-// media and tidy (each loaded on first use), and the setup tool.
+// Optional feature tools: office, media and tidy (each loaded on first use;
+// their settings gates apply in the executor), and the setup tool.
 import { standaloneDataDir } from '../runtime-paths.mjs';
 import { createCallerContextResolvers } from './caller-context.mjs';
 
-export function createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, mediaToolEnabled, tidyToolEnabled }) {
+export function createFeatureToolHandlers({ rt, setupTool }) {
   const { sessionIdFor, signalFor } = createCallerContextResolvers(rt);
-  const requireEnabled = (callerCtx, enabled, label) => {
-    if (callerCtx?.invocationSource === 'model-tool' && !enabled()) {
-      throw new Error(`${label} is disabled in settings; start a new session to refresh the tool list`);
-    }
-  };
 
   return {
     office: async (args, { callerCtx, callerCwd }) => {
-      requireEnabled(callerCtx, officeToolsEnabled, 'office');
       const { executeOfficeTool } = await import('../../runtime/office/index.mjs');
       return await executeOfficeTool(args, {
         cwd: callerCwd,
@@ -25,7 +19,6 @@ export function createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, m
       });
     },
     media: async (args, { callerCtx, callerCwd }) => {
-      requireEnabled(callerCtx, mediaToolEnabled, 'media');
       const { executeMediaTool } = await import('../../runtime/media/tool.mjs');
       const { getSession } = await import('../../runtime/agent/orchestrator/session/manager/session-crud.mjs');
       // Generation spend is attributed to the calling session in the usage ledger.
@@ -38,7 +31,6 @@ export function createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, m
       });
     },
     tidy: async (args, { callerCtx, callerCwd }) => {
-      requireEnabled(callerCtx, tidyToolEnabled, 'tidy');
       const { executeTidyTool } = await import('../../runtime/tidy/tool.mjs');
       return await executeTidyTool(args, {
         cwd: callerCwd,

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

@@ -17,6 +17,7 @@ import { scheduleCallerScope } from '../services/schedule-access.mjs';
 import { worktreeCallerScope } from '../services/worktree-access.mjs';
 import { resolveHandoffAttachments, sessionRoots } from '../handoff-attachments.mjs';
 import { delegationChainOf } from '../bot-chain.mjs';
+import { openTodoItems } from '../../runtime/agent/orchestrator/runtime-core/todo-list.mjs';
 import { BOT_TARGET_ACTIONS, resolveBotTarget } from '../bot-target.mjs';
 
 const USER_TITLE_ERROR = 'session: the user already titled this session; the title was not changed';
@@ -322,9 +323,21 @@ export function createWorkspaceToolHandlers({
     goal: async (args, { name, callerCtx }) => {
       // A Goal keeps working in its session across turns: a heartbeat's would
       // run on unseen in the hidden session.
-      if (['create', 'resume'].includes(clean(args?.action).toLowerCase()) && callerIsHeartbeat(callerCtx)) {
+      const action = clean(args?.action).toLowerCase();
+      if (action === 'create' && callerIsHeartbeat(callerCtx)) {
         throw new Error(`goal: ${HEARTBEAT_NO_HANDOFF}`);
       }
+      // A completion claim with steps still open in the session's own list
+      // has not finished the work it recorded.
+      const callerSessionId = callerCtx?.callerSessionId || rt.session?.id || null;
+      if (action === 'complete' && rt.session?.id === callerSessionId) {
+        const open = openTodoItems(rt.session);
+        if (open.length) {
+          throw new Error(
+            `goal: cannot complete with ${open.length} open todo item(s) (${open.map((task) => task.content).join('; ')}); finish them, or drop or block each with its reason`
+          );
+        }
+      }
       return await goalRuntime.executeTool(name, args || {}, {
         callerSessionId: callerCtx?.callerSessionId || rt.session?.id || rt.reservedSessionId || null,
       });
@@ -335,9 +348,10 @@ export function createWorkspaceToolHandlers({
       if (['spawn', 'send'].includes((clean(args?.type) || 'spawn').toLowerCase()) && callerIsHeartbeat(callerCtx)) {
         throw new Error(`agent: ${HEARTBEAT_NO_HANDOFF}`);
       }
-      // `attachmentParts` is never the model's to set: only the resolved
-      // `attachments` reach the agent's turn.
-      const { attachments, attachmentParts: _ignored, ...rest } = args || {};
+      // `attachmentParts` and `skillSelection` are never the model's to set:
+      // only the resolved `attachments` reach the agent's turn, and its skills
+      // are selected from its whole prompt.
+      const { attachments, attachmentParts: _ignored, skillSelection: _selection, ...rest } = args || {};
       const attachmentParts = callerAttachmentParts(rt, { attachments }, callerCwd, 'agent');
       return await agentTool.execute(attachmentParts.length ? { ...rest, attachmentParts } : rest, {
         callerCwd,