mixdog 1.4.0 → 1.4.1

package/src/runtime/agent/orchestrator/session/store-summary-index.mjs

@@ -24,6 +24,8 @@ import {
   inheritedFromSessionId,
   isStoredSessionId,
   positiveNumber as _positiveNumber,
+  compactCount,
+  compactCountField,
   realTurnCount,
   workspaceSummary,
 } from './store-summary-fields.mjs';
@@ -54,26 +56,50 @@ const _computeCleanPreview = cleanSummaryPreview;
 // cleaning runs a chain of regex replaces that each allocate a copy. Those
 // short strings repeat from flush to flush, so the pure result is memoized per
 // (max, text). Long raw message text is not kept here (see _previewFromMessage).
+// Every new message's raw text (up to the text limit) also passes through, so
+// the memo is bounded by the characters it holds, least recently used first
+// out: at 8192 entries alone it kept ~16–32 MB of message text per `max`.
 const CLEAN_PREVIEW_MEMO_TEXT_LIMIT = 2048;
 const CLEAN_PREVIEW_MEMO_ENTRIES = 8192;
-const cleanPreviewMemo = new Map(); // max → Map<text, cleaned>
+const CLEAN_PREVIEW_MEMO_MAX_CHARS = 512 * 1024;
+const cleanPreviewMemo = new Map(); // max → { byText: Map<text, cleaned>, chars }
 
 function _cleanPreview(text, max = 240) {
   if (typeof text !== 'string' || text.length > CLEAN_PREVIEW_MEMO_TEXT_LIMIT) return _computeCleanPreview(text, max);
-  let byText = cleanPreviewMemo.get(max);
-  if (!byText) {
-    byText = new Map();
-    cleanPreviewMemo.set(max, byText);
+  let memo = cleanPreviewMemo.get(max);
+  if (!memo) {
+    memo = { byText: new Map(), chars: 0 };
+    cleanPreviewMemo.set(max, memo);
   }
+  const { byText } = memo;
   let cleaned = byText.get(text);
-  if (cleaned === undefined) {
-    cleaned = _computeCleanPreview(text, max);
-    if (byText.size >= CLEAN_PREVIEW_MEMO_ENTRIES) byText.clear();
+  if (cleaned !== undefined) {
+    byText.delete(text);
     byText.set(text, cleaned);
+    return cleaned;
+  }
+  cleaned = _computeCleanPreview(text, max);
+  byText.set(text, cleaned);
+  memo.chars += text.length + cleaned.length;
+  for (const [oldText, oldCleaned] of byText) {
+    if (byText.size <= CLEAN_PREVIEW_MEMO_ENTRIES && memo.chars <= CLEAN_PREVIEW_MEMO_MAX_CHARS) break;
+    byText.delete(oldText);
+    memo.chars -= oldText.length + oldCleaned.length;
   }
   return cleaned;
 }
 
+/** Entries and characters the preview memo holds, summed over every `max` (tests). */
+export function _cleanPreviewMemoStatsForTest() {
+  let entries = 0;
+  let chars = 0;
+  for (const memo of cleanPreviewMemo.values()) {
+    entries += memo.byText.size;
+    chars += memo.chars;
+  }
+  return { entries, chars };
+}
+
 const sessionMessageProjectionMemo = new WeakMap();
 // message → { raw, preview }. A session's first real user message is
 // re-checked on every save; its text is re-derived (cheap) and the preview is
@@ -265,6 +291,8 @@ export function _sessionSummary(session) {
     taskType: session.taskType || null,
     messageCount: messageProjection.count,
     ...(messageProjection.incoming ? { incomingTail: messageProjection.incoming.slice() } : {}),
+    // The numbering epoch of messageCount: a compaction restarts it.
+    compactCount: compactCount(session.compaction) ?? 0,
     realTurnCount: messageProjection.real,
     title: _cleanPreview(session.title || '', 100),
     preview: messageProjection.preview,
@@ -324,6 +352,7 @@ function _normalizeSummaryRow(row) {
     taskType: row.taskType || null,
     messageCount: Math.max(0, Math.floor(Number(row.messageCount) || 0)),
     ...(Array.isArray(row.incomingTail) ? { incomingTail: normalizedIncomingTail(row.incomingTail) } : {}),
+    ...compactCountField(row),
     realTurnCount: realTurnCount(row),
     title: _cleanPreview(row.title || '', 100),
     preview: _cleanPreview(row.preview || ''),

package/src/runtime/agent/orchestrator/session/store-summary-reader.mjs

@@ -44,7 +44,11 @@ import {
 import { attachmentHistoryRows } from './stored-attachment-history.mjs';
 import { currentSessionCatalogDb, onSessionCatalogDbChange, sessionCatalogDb } from './catalog-db/index.mjs';
 import { decodeCatalogCursor, encodeCatalogCursor, isAfterCursor } from './catalog-db/schema.mjs';
-import { onSessionActivityChange, onSessionApprovalCardChange } from '../../../shared/session-activity-signal.mjs';
+import {
+  onSessionActivityChange,
+  onSessionApprovalCardChange,
+  onSessionBotWorkChange,
+} from '../../../shared/session-activity-signal.mjs';
 import { inFlightSessionActivity } from './manager/runtime-state.mjs';
 import {
   readCanonicalSessionRecord as readCanonicalLifecycle,
@@ -136,6 +140,10 @@ onSessionActivityChange(() => {
 // A session started or stopped waiting on the user's approval: its catalog row
 // (`awaitingApproval`) changed, though no store file did.
 onSessionApprovalCardChange(() => notifyCatalogListeners('approval'));
+// A bot started or stopped having a send in flight in a session: its catalog
+// row (`handedBy`) changed, though neither a file nor the set of working
+// sessions did (the work may already be running, or continue past the end).
+onSessionBotWorkChange(() => notifyCatalogListeners('bot-work'));
 
 /** `listener()` runs when a background pass finds a session file that changed
  *  without a directory or index change, i.e. when an ordinary listing would

package/src/runtime/agent/orchestrator/session/transcript-restore/restore.mjs

@@ -44,6 +44,7 @@ import {
 } from '../../../../shared/transcript-metadata.mjs';
 import { routineTriggerField } from '../../../../shared/routine-trigger.mjs';
 import { isImportedMessage } from '../imported-message.mjs';
+import { toolRunLine } from '../conversation-import/turns.mjs';
 import { isContextAckMessage } from '../compact/user-message-kind.mjs';
 import { isRoutineResultMessage, routineResultNotice } from '../routine-result.mjs';
 import { heldRequestNotice, isHeldRequestMessage } from '../human-gate/held-message.mjs';
@@ -140,7 +141,64 @@ function restoredContentText(message) {
   return typeof message?.content === 'string' ? message.content : toolResultText(message?.content);
 }
 
+// The runs of tool use an imported assistant message recorded (conversation-import
+// turns.mjs), kept only where the text still holds exactly their canonical line.
+function importedToolRuns(message) {
+  const runs = message?.meta?.importedToolRuns;
+  if (!isImportedMessage(message) || typeof message.content !== 'string' || !Array.isArray(runs)) return [];
+  let cursor = 0;
+  return runs.filter((run) => {
+    const valid =
+      Number.isInteger(run?.start) &&
+      Number.isInteger(run?.end) &&
+      run.start >= cursor &&
+      run.end > run.start &&
+      run.end <= message.content.length &&
+      Array.isArray(run.tools) &&
+      run.tools.length > 0 &&
+      run.tools.every((tool) => typeof tool?.name === 'string' && Number.isInteger(tool.count) && tool.count > 0) &&
+      message.content.slice(run.start, run.end) === toolRunLine(run.tools);
+    if (valid) cursor = run.end;
+    return valid;
+  });
+}
+
+// An imported reply with tool use: its text around each run as assistant rows,
+// each run as tool rows (one per tool, counted). The calls' results were never
+// imported; the `imported` mark lets the row say so.
+function restoredImportedAssistantItems(message, runs, nextId) {
+  const { completion: _completion, ...metadata } = restoredTranscriptMetadata(message);
+  const at = Number(message?.meta?.transcript?.at);
+  const items = [];
+  const pushText = (raw) => {
+    const text = raw.trim();
+    if (text) items.push({ kind: 'assistant', id: nextId(), text, ...metadata });
+  };
+  let cursor = 0;
+  for (const run of runs) {
+    pushText(message.content.slice(cursor, run.start));
+    for (const { name, count } of run.tools) {
+      if (isTranscriptHiddenControlToolName(name)) continue;
+      items.push({
+        kind: 'tool',
+        id: nextId(),
+        name,
+        imported: true,
+        expanded: false,
+        count,
+        completedCount: count,
+        ...(Number.isFinite(at) ? { at, startedAt: at, completedAt: at } : {}),
+      });
+    }
+    cursor = run.end;
+  }
+  pushText(message.content.slice(cursor));
+  return items;
+}
+
 function restoredAssistantTranscriptItems(message, nextId) {
+  const runs = importedToolRuns(message);
+  if (runs.length) return restoredImportedAssistantItems(message, runs, nextId);
   const text = restoredContentText(message).trim();
   if (!text) return [];
   const { completion, ...metadata } = restoredTranscriptMetadata(message);
@@ -339,7 +397,7 @@ function mergeRestoredToolItems(items) {
     // Result-dependent hiding (built-in skill loads) resolves here, after
     // every role:'tool' result has been attached to its restored call.
     if (item?.kind === 'tool' && isTranscriptHiddenToolItem(item)) continue;
-    const mergeable = item?.kind === 'tool' && item.aggregate !== true;
+    const mergeable = item?.kind === 'tool' && item.aggregate !== true && item.imported !== true;
     if (!mergeable) {
       flushRun();
       merged.push(item);
@@ -379,7 +437,8 @@ function restoredMessageItemUpperBound(message) {
   const calls = restoredMessageToolCalls(message);
   const content = message?.content;
   const hasContent = typeof content === 'string' ? content.length > 0 : Array.isArray(content) && content.length > 0;
-  return Number(hasContent) + completionCount + calls.length + boundaries;
+  const importedRows = importedToolRuns(message).reduce((total, run) => total + run.tools.length + 1, 0);
+  return Number(hasContent) + completionCount + calls.length + importedRows + boundaries;
 }
 
 // One restored tool card for a parsed notification/completion envelope.

package/src/runtime/agent/orchestrator/stall-policy.mjs

@@ -259,6 +259,29 @@ export const PROVIDER_WS_SEMANTIC_IDLE_TIMEOUT_MS = resolveTimeoutMs(
   { minMs: 10_000, maxMs: Math.max(10_000, STALL_ABORT_MS - STALL_TICK_MS) }
 );
 
+// First-OUTPUT window of one provider stream: from the stream opening until
+// the model's first semantic output (reasoning, text or a tool call). Server
+// metadata and keepalives (response.created / in_progress, an empty reasoning
+// or message item, a role-only chunk, pings) neither end this phase nor start
+// the semantic-idle clock, so a reasoning model may think silently past the
+// idle window (issue #244: 4–6 min on a large post-tool-result prompt). The
+// window sits one tick under the stall abort — the same ceiling the semantic
+// idle uses — so the provider still fails (and may retry or fall back) before
+// the agent watchdog's first-output deadline (600s default), and it is never
+// shorter than the idle window it replaces. Not separately tunable: it
+// follows STALL_TIMEOUT_S.
+export const PROVIDER_FIRST_OUTPUT_TIMEOUT_MS = Math.max(
+  PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS,
+  PROVIDER_WS_SEMANTIC_IDLE_TIMEOUT_MS,
+  STALL_ABORT_MS - STALL_TICK_MS
+);
+
+/** The first-output window of a stream whose semantic idle is `idleMs`: a
+ *  longer idle window (a provider profile) is never cut short by it. */
+export function providerFirstOutputTimeoutMs(idleMs) {
+  return Math.max(idleMs, PROVIDER_FIRST_OUTPUT_TIMEOUT_MS);
+}
+
 /**
  * The longest a provider's own first-byte handling may legitimately run
  * before it gives up, over every attempt it permits: `windowMs(n)` is the wait

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/invocation-plan.mjs

@@ -28,9 +28,9 @@ function prefixPowerShellUtf8(command) {
 // UTF-8 prefix (+ optional filter-tee rescue), or a POSIX bash/zsh snapshot
 // wrapper delivered through the environment. Returns `{ failure }` when the
 // snapshot wrapper cannot be built.
-export async function planShellInvocation({ command, resolvedSpec, cwd }) {
+export async function planShellInvocation({ command, resolvedSpec, cwd, sessionId = null }) {
   const { shell, shellArg, shellArgs, shellType } = resolvedSpec;
-  const spawnEnv = buildShellSpawnEnv(cwd);
+  const spawnEnv = buildShellSpawnEnv(cwd, process.env, sessionId);
   const plan = {
     execShell: shell,
     execShellArg: shellArg,

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/spawn-env.mjs

@@ -1,3 +1,4 @@
+import { applySessionScratchEnv } from '../../../../../shared/session-scratch.mjs';
 import { withSkillLauncherPath } from '../../../../../shared/skill-script-runtime.mjs';
 import {
   applyShellEgressPolicy,
@@ -6,7 +7,8 @@ import {
   scrubRuntimeRootVars,
 } from '../../env-scrub.mjs';
 
-export function buildShellSpawnEnv(cwd, baseEnv = process.env) {
+// `sessionId` points TEMP/TMP/TMPDIR at that session's scratch directory.
+export function buildShellSpawnEnv(cwd, baseEnv = process.env, sessionId = null) {
   const spawnEnv = {
     ...baseEnv,
     LANG: 'C.UTF-8',
@@ -24,5 +26,5 @@ export function buildShellSpawnEnv(cwd, baseEnv = process.env) {
   // `mixdog-skill-node` (a skill's ${MIXDOG_SKILL_NODE}) resolves in every
   // model shell; only this env gets the entry, never the daemon's own.
   withSkillLauncherPath(spawnEnv);
-  return spawnEnv;
+  return applySessionScratchEnv(spawnEnv, sessionId);
 }

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs

@@ -116,7 +116,12 @@ export async function executeBashTool(args, workDir, options = {}) {
   // A queued run, or a foreground tree that may outlive its result, settles later.
   let runSettled = null;
   try {
-    const invocation = await planShellInvocation({ command, resolvedSpec, cwd: bashWorkDir });
+    const invocation = await planShellInvocation({
+      command,
+      resolvedSpec,
+      cwd: bashWorkDir,
+      sessionId: options?.callerSessionId || options?.sessionId || null,
+    });
     if (invocation.failure) return invocation.failure;
     combinedAbort = combineAbortSignals(await sessionAbortSignal(options?.sessionId), options?.abortSignal || null);
     const startedAtMs = Date.now();

package/src/runtime/agent/orchestrator/tools/builtin/builtin-tools.mjs

@@ -5,7 +5,7 @@
 // behavior, argument shapes, and the usage boundaries that only apply to that
 // tool; cross-tool policy lives in rules/shared/*.md.
 // Platform-specific command syntax belongs next to the command argument.
-import { GIT_TOOL_DEF } from './git-command-tool.mjs';
+import { GIT_AGENT_TOOL_DEF, GIT_TOOL_DEF } from './git-command-tool.mjs';
 import { PUBLIC_PATH_BATCH_LIMIT, PUBLIC_READ_WINDOW_MAX } from './arg-guard.mjs';
 import { GITHUB_TOOL_DEF } from '../../../../github/tool.mjs';
 import { envFlag } from '../../../../shared/env.mjs';
@@ -50,7 +50,7 @@ export function buildShellRoutingRules(kind = _defaultShellKind) {
 function buildShellDescription(kind) {
   const run = _shellBackgroundDisabled
     ? 'Commands run in the foreground until completion.'
-    : `Holds ${_holdS}s; then, or on input/task notification, backgrounds with task_id (command keeps running). Completion is automatic; never poll, and never sleep/poll-loop inside the shell (background:true or wait_ms instead; for an external job, background a command that exits when it ends). Result needed now: task wait. Known-long finite run: wait_ms up to ${SHELL_HOLD_MAX_MS}. Independent long runs, servers/watchers: background:true; cancel them when done.`;
+    : `Holds ${_holdS}s; then, or on input/task notification, backgrounds with task_id (command keeps running). Completion is automatic; never poll, and never sleep/poll-loop inside the shell (background:true or wait_ms instead; for an external job, background a command that exits when it ends). Result needed now: task wait. Independent long runs: background:true; cancel when done.`;
   return `Run programs, builds, tests and computation. ${buildShellRoutingRules(kind)} ${run}`;
 }
 
@@ -88,6 +88,10 @@ export function bindShellKind(tool, kind) {
   return bound;
 }
 
+function taskTimeoutDescription(defaultMs) {
+  return `Wait ceiling in ms; else current output at the ceiling. Default ${defaultMs}; clamped to ${TASK_WAIT_TIMEOUT_MIN_MS}-${TASK_WAIT_TIMEOUT_MAX_MS}.`;
+}
+
 export const BUILTIN_TOOLS = [
   {
     name: 'read',
@@ -101,7 +105,7 @@ export const BUILTIN_TOOLS = [
       compressible: false,
     },
     description:
-      "Read file windows or images. One call per read stage: {file_path, offset, limit} entries for every located site (≤10 files per call), never a whole large file. Content in context is never read again. Missing paths are reported, never replaced. Directories: list. Binaries: bounded hex. Rows carry no line numbers; `[lines a-b]` gives each block's range. Never count rows: before writing a line number, copy it from grep, code_graph or git diff output; otherwise cite path and symbol.",
+      "Read file windows or images. One call per read stage: {file_path, offset, limit} entries for every located site, never a whole large file. Content in context is never read again. Missing paths are reported, never replaced. Directories: list. Binaries: bounded hex. Rows carry no line numbers; `[lines a-b]` gives each block's range. Never count rows: before writing a line number, copy it from grep, code_graph or git diff output; otherwise cite path and symbol.",
     inputSchema: {
       type: 'object',
       properties: {
@@ -129,8 +133,7 @@ export const BUILTIN_TOOLS = [
               },
             },
           ],
-          description:
-            'Path(s) or {file_path, offset, limit} entries; overlapping windows of one file merge. A glob fans out to ≤10 newest files, 25 lines each.',
+          description: 'Overlapping windows of one file merge. A glob fans out to ≤10 newest files.',
         },
         offset: {
           type: 'integer',
@@ -167,14 +170,11 @@ export const BUILTIN_TOOLS = [
       compressibleLossless: true,
     },
     description:
-      'Replace exact text in one file. old_string must match once unless replace_all is true. Every non-overlapping edit of the stage in one response, using existing text, not text another edit creates; many files → one edit per file, all in that response. Widened replacements keep intervening lines verbatim.',
+      'Replace exact text in one file. old_string must match once unless replace_all is true. Every non-overlapping edit of the stage in one response, using existing text, not text another edit creates; many files → one edit per file. Widened replacements keep intervening lines verbatim.',
     inputSchema: {
       type: 'object',
       properties: {
-        file_path: {
-          type: 'string',
-          description: 'Path to the file to modify.',
-        },
+        file_path: { type: 'string' },
         old_string: {
           type: 'string',
           description:
@@ -187,7 +187,7 @@ export const BUILTIN_TOOLS = [
         replace_all: {
           type: 'boolean',
           default: false,
-          description: 'Replace all occurrences of old_string; default false.',
+          description: 'Replace all occurrences of old_string.',
         },
       },
       required: ['file_path', 'old_string', 'new_string'],
@@ -254,7 +254,7 @@ export const BUILTIN_TOOLS = [
       openWorldHint: false,
     },
     description:
-      'Manage shell tasks. Completion is delivered automatically; wait only when you need the result now, never poll with read. wait returns when the task finishes, or when new user input or any task notification arrives (the task keeps running). read/wait return new output, prioritizing the tail on completion. output:tail re-reads recent output without advancing the cursor; use read on the log path for omitted content.',
+      'Manage shell tasks. Completion is delivered automatically; wait only when you need the result now, never poll with read. wait returns when the task finishes, or when new user input or any task notification arrives (the task keeps running). read/wait return new output, prioritizing the tail on completion. Use read on the log path for omitted content.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -267,13 +267,13 @@ export const BUILTIN_TOOLS = [
         timeout_ms: {
           type: 'integer',
           minimum: 0,
-          description: `Wait ceiling in ms; returns on completion, new user input or a task notification, else current output at the ceiling. Default ${TASK_WAIT_TIMEOUT_DEFAULT_MS} (agents ${AGENT_TASK_WAIT_DEFAULT_MS}); clamped to ${TASK_WAIT_TIMEOUT_MIN_MS}-${TASK_WAIT_TIMEOUT_MAX_MS}.`,
+          description: taskTimeoutDescription(TASK_WAIT_TIMEOUT_DEFAULT_MS),
         },
         output: {
           type: 'string',
           enum: ['new', 'tail'],
           description:
-            'read/wait only. Default new; tail replays recent output after an interruption or context loss. Up to 8 KiB per stream while running, 12 KiB on completion or replay; original logs are preserved.',
+            'read/wait only. Default new; tail re-reads recent output without advancing the cursor, after an interruption or context loss. Up to 8 KiB per stream while running, 12 KiB on completion or replay; original logs are preserved.',
         },
       },
       required: ['action'],
@@ -324,7 +324,7 @@ export const BUILTIN_TOOLS = [
           description:
             'Requested results; default 250; 0 unlimited. Context output caps at 40 blocks; continue via the returned offset.',
         },
-        offset: { type: 'integer', minimum: 0, description: 'Result offset.' },
+        offset: { type: 'integer', minimum: 0 },
         context: {
           type: 'integer',
           minimum: 0,
@@ -356,7 +356,7 @@ export const BUILTIN_TOOLS = [
       compressible: true,
     },
     description:
-      'Wildcard file-path lookup under a known directory; directories never match. Omit path for the current Project; no preliminary listing. Unknown base: find first with a known path fragment. Gitignored paths need include_noise:true.',
+      'Wildcard file-path lookup under a known directory; directories never match. No preliminary listing. Unknown base: find first with a known path fragment.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -374,7 +374,7 @@ export const BUILTIN_TOOLS = [
           description: 'mtime default (newest first); natural = raw walk order, cheaper on huge trees.',
         },
         limit: { type: 'integer', minimum: 0, description: 'Max entries; default 100; 0 unlimited.' },
-        offset: { type: 'integer', minimum: 0, description: 'Entry offset.' },
+        offset: { type: 'integer', minimum: 0 },
         include_noise: {
           type: 'boolean',
           description: 'Also search gitignored trees.',
@@ -404,7 +404,7 @@ export const BUILTIN_TOOLS = [
           type: 'string',
           minLength: 1,
           pattern: '\\S',
-          description: 'Non-empty filename/path fragment; space-separated fragments AND-match within one path.',
+          description: 'Filename/path fragment; space-separated fragments AND-match within one path.',
         },
         path: { type: 'string', description: 'Base directory; omit for the current Project.' },
         limit: { type: 'integer', minimum: 0, description: 'Max paths; default 25; 0 unlimited.' },
@@ -445,10 +445,36 @@ export const BUILTIN_TOOLS = [
           maximum: 100,
           description: 'Max entries; default 100; 0 = no page cap (absolute cap still applies).',
         },
-        offset: { type: 'integer', minimum: 0, description: 'Entry offset.' },
+        offset: { type: 'integer', minimum: 0 },
       },
-      required: [],
       additionalProperties: false,
     },
   },
 ];
+
+// What a delegated agent's session sees of the tools whose text differs from
+// the Lead's: git (worktree operations are Lead-only) and task (the agent wait
+// default). Keyed by the shared definition, so a rebuilt list binds once.
+const _taskTool = BUILTIN_TOOLS.find((tool) => tool.name === 'task');
+const _agentTaskTool = {
+  ..._taskTool,
+  inputSchema: {
+    ..._taskTool.inputSchema,
+    properties: {
+      ..._taskTool.inputSchema.properties,
+      timeout_ms: {
+        ..._taskTool.inputSchema.properties.timeout_ms,
+        description: taskTimeoutDescription(AGENT_TASK_WAIT_DEFAULT_MS),
+      },
+    },
+  },
+};
+const _agentToolVariants = new Map([
+  [GIT_TOOL_DEF, GIT_AGENT_TOOL_DEF],
+  [_taskTool, _agentTaskTool],
+]);
+
+/** The agent-session variant of `tool`, or `tool` itself when it has none. */
+export function bindAgentOwner(tool) {
+  return _agentToolVariants.get(tool) ?? tool;
+}

package/src/runtime/agent/orchestrator/tools/builtin/cache-layers.mjs

@@ -324,7 +324,13 @@ export function rawContentCacheSet(fullPath, stat, rawBuf, now = Date.now()) {
   if (!canPublishReadCache(fullPath)) return;
   if (!fullPath || !Buffer.isBuffer(rawBuf)) return;
   const version = fileVersion(stat);
-  if (!version || !canCacheReadFile(version) || rawBuf.length !== version.size || rawBuf.length > RAW_CONTENT_CACHE_MAX_BYTES) return;
+  if (
+    !version ||
+    !canCacheReadFile(version) ||
+    rawBuf.length !== version.size ||
+    rawBuf.length > RAW_CONTENT_CACHE_MAX_BYTES
+  )
+    return;
   const key = canonicalCachePath(fullPath);
   rawContentCacheDelete(key);
   RAW_CONTENT_CACHE.set(key, {

package/src/runtime/agent/orchestrator/tools/builtin/git-command-tool.mjs

@@ -83,6 +83,9 @@ const SERVER_OPERATIONS = new Set(['daemon', 'instaweb']);
 // probe into `git rev-parse exited 128` inside a plain directory.
 const REPO_FREE_OPERATIONS = new Set(['version', 'help']);
 
+const GIT_DESCRIPTION_HEAD =
+  'Run Git here, never through shell. An array runs in order and stops on failure; batch read-only commands in one. diff for known changes, status to discover them; history only when needed. git diff or git diff -- <paths> includes untracked files. Set include_stage_ids:true to select changes, then action:stage with diff_id/change_ids. Staging rejects stale or cross-Project diffs and returns per-file staged counts.';
+
 export const GIT_TOOL_DEF = {
   name: 'git',
   title: 'Git',
@@ -94,8 +97,7 @@ export const GIT_TOOL_DEF = {
     openWorldHint: true,
     compressible: true,
   },
-  description:
-    'Run Git here, never through shell. An array (max 10) runs in order and stops on failure; batch read-only commands in one. diff for known changes, status to discover them; history only when needed. git diff or git diff -- <paths> includes untracked files. Set include_stage_ids:true to select changes, then action:stage with diff_id/change_ids. Staging rejects stale or cross-Project diffs and returns per-file staged counts. Worktrees are managed only: action:worktree (Lead only) moves a session into/out of its managed worktree, merges, removes, lists, prunes; git worktree add/remove/list/prune map to managed operations (add -b keeps the session in place; add --detach makes a read-only snapshot worktree, removed when its turn ends; list --porcelain stays raw git; move/lock/unlock/repair are refused). Merge or remove only when the user asks; carry and large-size answers come from the user; force only on explicit request.',
+  description: `${GIT_DESCRIPTION_HEAD} Worktrees are managed only: action:worktree; git worktree add/remove/list/prune map to managed operations (add -b keeps the session in place; add --detach makes a read-only snapshot worktree, removed when its turn ends; list --porcelain stays raw git; move/lock/unlock/repair are refused). Merge or remove only when the user asks.`,
   inputSchema: {
     type: 'object',
     properties: {
@@ -118,14 +120,14 @@ export const GIT_TOOL_DEF = {
         minimum: 1,
         maximum: GIT_OUTPUT_LIMIT_MAX,
         description:
-          'Body line cap, max 1000; staging IDs are not capped. Default 500; git log defaults to 100. A cut ends with [output capped …] naming how to continue.',
+          'Body line cap; staging IDs are not capped. Default 500; git log defaults to 100. A cut ends with [output capped …] naming how to continue.',
       },
       include_stage_ids: {
         type: 'boolean',
         description:
           'Include staging IDs outside the body cap for git diff or git diff -- <paths> only. Default false.',
       },
-      diff_id: { type: 'string', description: 'stage: exact diff_id from git diff with include_stage_ids:true.' },
+      diff_id: { type: 'string', description: 'stage: exact diff_id from git diff.' },
       change_ids: {
         anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 50 }],
         description: 'stage: exact change ID or IDs to stage, including new files.',
@@ -158,6 +160,29 @@ export const GIT_TOOL_DEF = {
   },
 };
 
+// Only the Lead host runs enter/return/merge/remove/prune (git-worktree-tool.mjs
+// leadHost); an agent keeps `list`, so its schema omits every field the other
+// operations take.
+const LEAD_ONLY_WORKTREE_FIELDS = ['session_id', 'name', 'branch', 'create', 'carry', 'confirm_large', 'force'];
+
+function buildGitAgentToolDef(base) {
+  const properties = { ...base.inputSchema.properties };
+  for (const field of LEAD_ONLY_WORKTREE_FIELDS) delete properties[field];
+  properties.action = {
+    ...properties.action,
+    description: 'Default command. stage uses diff_id/change_ids instead of command. worktree uses worktree_action.',
+  };
+  properties.worktree_action = { type: 'string', enum: ['list'], description: 'list only.' };
+  return {
+    ...base,
+    description: `${GIT_DESCRIPTION_HEAD} Worktrees are Lead-managed: only worktree_action:list and git worktree list work; every other worktree operation is refused.`,
+    inputSchema: { ...base.inputSchema, properties },
+  };
+}
+
+/** The git tool as a delegated agent sees it (see bindAgentOwner). */
+export const GIT_AGENT_TOOL_DEF = buildGitAgentToolDef(GIT_TOOL_DEF);
+
 function cleanText(value) {
   return String(value || '')
     .replace(/\r\n/g, '\n')
@@ -849,7 +874,8 @@ function snapshotContaining(repo) {
   }
   return (
     Object.values(entries).find(
-      (record) => record?.kind === WORKTREE_SNAPSHOT_KIND && typeof record.path === 'string' && isWithin(record.path, repo)
+      (record) =>
+        record?.kind === WORKTREE_SNAPSHOT_KIND && typeof record.path === 'string' && isWithin(record.path, repo)
     ) ?? null
   );
 }

package/src/runtime/agent/orchestrator/tools/builtin/git-worktree-tool.mjs

@@ -101,6 +101,8 @@ function worktreeFailureText(code, message, details) {
       return typeof details.path === 'string' && details.path
         ? `This branch is already checked out in ${details.path}.`
         : 'This branch is already checked out in another worktree.';
+    case 'WORKTREE_DEFAULT_BRANCH':
+      return "The repository's default branch can't be opened in a worktree: the project folder could not switch to it while the worktree exists. Check it out in the project folder, or create a new branch for the worktree.";
     case 'WORKTREE_REMOVAL_INCOMPLETE':
       return 'The worktree could not be removed completely because a file is still in use. Close it and remove the worktree again.';
     case 'WORKTREE_PATH_UNSAFE':
@@ -162,6 +164,8 @@ function nextStep(code, details, { raw }) {
       return 'The workspace changed meanwhile; call again (the workspace is read afresh).';
     case 'WORKTREE_BUSY_JOBS':
       return 'Nothing was changed; try again once the session and its workers are idle.';
+    case 'WORKTREE_DEFAULT_BRANCH':
+      return 'Nothing was created. Work on a new branch instead (worktree_action:"enter" with branch and create:true), or ask the user to check the default branch out in the project folder.';
     case 'MERGE_CONFLICT':
       return 'Nothing was merged or forced. Resolve the conflict in the worktree (merge the target branch into it there), or ask the user.';
     case 'WORKTREE_DIRTY':
@@ -316,7 +320,8 @@ async function rawAdd(plan, input, options) {
       throw new Error(`git worktree add: ${value} is not supported for managed worktrees`);
     }
     if (ADD_BARE_FLAGS.has(value)) continue;
-    if (value.startsWith('-')) throw new Error(`git worktree add: option ${value} is not supported for managed worktrees`);
+    if (value.startsWith('-'))
+      throw new Error(`git worktree add: option ${value} is not supported for managed worktrees`);
     positional.push(value);
   }
   const [path, commitish = null] = positional;
@@ -436,8 +441,9 @@ async function rawPrune(plan, options) {
 const WORKTREE_HELP = Object.freeze({
   add: 'git worktree add [-b <branch>] [--detach] <path> [<commit-ish>]: a managed worktree for the branch (the session stays put), or a read-only snapshot for a detached commit.',
   remove: 'git worktree remove [-f] <path>: the managed removal of that worktree.',
-  list: 'git worktree list [-v]: managed worktrees plus the repository\'s other worktrees. --porcelain stays raw git.',
-  prune: 'git worktree prune [-n|--dry-run] [-v]: the managed prune of this repository (clean, merged worktrees no session retains); -n only lists what it would remove.',
+  list: "git worktree list [-v]: managed worktrees plus the repository's other worktrees. --porcelain stays raw git.",
+  prune:
+    'git worktree prune [-n|--dry-run] [-v]: the managed prune of this repository (clean, merged worktrees no session retains); -n only lists what it would remove.',
 });
 
 /** -h/--help before any `--` (the help answers instead of the operation running). */
@@ -450,7 +456,9 @@ function wantsHelp(args) {
 function checkListArgs(args) {
   for (const value of args) {
     if (value === '-v' || value === '--verbose') continue;
-    throw new Error(`git worktree list: ${value.startsWith('-') ? `option ${value} is not supported` : `unexpected argument ${value}`}`);
+    throw new Error(
+      `git worktree list: ${value.startsWith('-') ? `option ${value} is not supported` : `unexpected argument ${value}`}`
+    );
   }
 }
 
@@ -466,7 +474,8 @@ export async function executeRawWorktree(plan, input, options = {}) {
   if (sub === 'list' && plan.args.includes('--porcelain')) return null;
   try {
     if (sub === 'list') checkListArgs(plan.args.slice(1));
-    if (sub === 'list') return { text: okJson({ mapped: plan.command, ...(await listRows(options, plan.cwd)) }), failed: false };
+    if (sub === 'list')
+      return { text: okJson({ mapped: plan.command, ...(await listRows(options, plan.cwd)) }), failed: false };
     if (sub === 'add') return { text: await rawAdd(plan, input, options), failed: false };
     if (sub === 'remove') return { text: await rawRemove(plan, options), failed: false };
     if (sub === 'prune') return { text: await rawPrune(plan, options), failed: false };
@@ -479,7 +488,9 @@ export async function executeRawWorktree(plan, input, options = {}) {
       };
     }
     return {
-      text: fail(`git worktree ${sub || '(no subcommand)'} is not supported; use add, remove, list, prune or action:"worktree"`),
+      text: fail(
+        `git worktree ${sub || '(no subcommand)'} is not supported; use add, remove, list, prune or action:"worktree"`
+      ),
       failed: true,
     };
   } catch (error) {
@@ -529,7 +540,8 @@ export async function executeWorktreeAction(input, workDir, options = {}) {
   if (problem) return fail(problem);
   const action = input.worktree_action;
   try {
-    if (action === 'list') return okJson({ worktree_action: action, ...(await listRows(options, resolve(workDir || process.cwd()))) });
+    if (action === 'list')
+      return okJson({ worktree_action: action, ...(await listRows(options, resolve(workDir || process.cwd()))) });
     const host = leadHost(options, `git worktree_action ${action}`);
     const sessionId = input.session_id?.trim() || null;
     const request = {
@@ -545,7 +557,9 @@ export async function executeWorktreeAction(input, workDir, options = {}) {
           }
         : {}),
       ...(action === 'remove' ? { force: input.force === true } : {}),
-      ...(action === 'prune' ? { repoCommonDir: (await repositoryAt(resolve(workDir || process.cwd())))?.repoCommonDir ?? null } : {}),
+      ...(action === 'prune'
+        ? { repoCommonDir: (await repositoryAt(resolve(workDir || process.cwd())))?.repoCommonDir ?? null }
+        : {}),
       txId: txIdOf(options, action),
     };
     const result = await runOn(host, request, options);