mixdog 1.1.0 → 1.1.2

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

@@ -3,6 +3,7 @@ import {
   buildJobNotFoundMessage,
   peekShellJob,
   killShellJob,
+  otherSessionBackgroundShellJobCount,
   cancelBackgroundShellJobWatch,
   clearShellJobNotifyCtx,
   shellJobPublicTaskResult,
@@ -23,6 +24,7 @@ import {
 } from '../../../../shared/background-tasks.mjs';
 import { recordDeliveredCompletion } from '../../session/manager/delivered-completions.mjs';
 import { listShellJobRecords, readShellJobRecord } from './lib/shell-job-records.mjs';
+import { resourceAdmission } from '../../../../shared/resource-admission.mjs';
 import { readShellTaskOutput } from './lib/shell-task-output.mjs';
 
 // Ceiling for confirming that a cancelled task's process really exited. The
@@ -88,18 +90,42 @@ function resolveTaskWaitTimeoutMs(value) {
   return Math.min(TASK_WAIT_TIMEOUT_MAX_MS, Math.max(TASK_WAIT_TIMEOUT_MIN_MS, Math.floor(raw)));
 }
 
+// Read-only counts of this runtime's shell work owned by OTHER sessions.
+// Admission is runtime-wide while task list/cancel are session-scoped, so
+// without this those holders are invisible. Counts only: another session's
+// command text is never shown.
+function otherSessionShellHolders(options) {
+  const context =
+    options?.context && typeof options.context === 'object' ? { ...options.context, ...options } : options;
+  const mine = new Set(
+    [context?.callerSessionId, context?.routingSessionId, context?.sessionId].filter(Boolean).map(String)
+  );
+  if (mine.size === 0) return '';
+  const leases = (resourceAdmission.snapshot().activeLeases || []).filter(
+    (lease) => lease.kind === 'shell' && !mine.has(String(lease.ownerKey || ''))
+  ).length;
+  const jobs = otherSessionBackgroundShellJobCount(mine);
+  if (!leases && !jobs) return '';
+  return `[other sessions in this runtime] ${leases} foreground shell lease(s), ${jobs} background shell job(s) — read-only; only their owner sessions can cancel them.`;
+}
+
 async function listTasks(options) {
   const rendered = renderBackgroundTaskList({ context: options });
   const liveIds = new Set([...rendered.matchAll(/^-\s+(\S+)/gm)].map((match) => match[1]));
   const recovered = (await listShellJobRecords()).filter(
     (record) => recoveredTaskMatches(record, options) && !liveIds.has(record.jobId)
   );
-  if (recovered.length === 0) return rendered;
-  const rows = recovered.map(
-    (record) =>
-      `- ${record.jobId} shell ${record.terminal ? record.status : 'state-unavailable'} recovered=true command=${JSON.stringify(record.command || '')}`
-  );
-  return `${rendered}\n[recovered shell tasks]\n${rows.join('\n')}`;
+  const sections = [rendered];
+  if (recovered.length > 0) {
+    const rows = recovered.map(
+      (record) =>
+        `- ${record.jobId} shell ${record.terminal ? record.status : 'state-unavailable'} recovered=true command=${JSON.stringify(record.command || '')}`
+    );
+    sections.push(`[recovered shell tasks]\n${rows.join('\n')}`);
+  }
+  const others = otherSessionShellHolders(options);
+  if (others) sections.push(others);
+  return sections.join('\n');
 }
 
 // Blocks until the shell task settles, the timeout elapses, or the turn/user

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

@@ -1,6 +1,12 @@
 import { createIoTrace } from './io-trace.mjs';
 import { classifyResultKind } from '../session/result-classification.mjs';
-import { coerceShapeFlex, normalizeInputPath, normalizeOutputPath, resolveAgainstCwd } from './builtin/path-utils.mjs';
+import {
+  coerceShapeFlex,
+  normalizeInputPath,
+  normalizeOutputPath,
+  resolveAgainstCwd,
+  splitJoinedPathScopes,
+} from './builtin/path-utils.mjs';
 import {
   SMART_BASH_HEAD_LINES,
   SMART_BASH_MAX_BYTES,
@@ -387,7 +393,8 @@ export async function executeBuiltinTool(name, args, cwd, options = {}) {
       readOffsetBase: args && Object.hasOwn(args, 'file_path') ? 1 : (options.readOffsetBase ?? 0),
     };
   }
-  let argError;
+  let argError = splitJoinedPathScopes(toolName, args, cwd);
+  if (argError) return argError;
   if (toolName === 'grep') {
     const prepared = prepareGrepArgs(args);
     argError = prepared.error;

package/src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs

@@ -133,7 +133,9 @@ function collectGraphParseWarnings(graph, options) {
 // instead of erroring "file not found in graph: (missing file)".
 function _resolveRequestedMode(args) {
   let mode = String(args?.mode || '').trim();
-  if (!mode) throw new Error('code_graph: "mode" is required');
+  if (!mode) {
+    throw new Error(`code_graph: "mode" is required, one of ${[...Object.keys(CODE_GRAPH_MODES), 'search'].join('|')}`);
+  }
   if (mode === 'search') mode = 'symbol_search';
   const nameOnlySymbols =
     mode === 'symbols' &&

package/src/runtime/agent/orchestrator/tools/lib/shell-run-background/promote-job.mjs

@@ -1,9 +1,9 @@
 /**
  * promote-job.mjs — hand the still-running foreground child to the shell-jobs
- * registry: the bounded promotion attempt, the lease hand-over that follows
- * a successful one, and the kill fallback that follows a failed one.
+ * registry: the bounded promotion attempt, the lease release that follows a
+ * successful one, and the kill fallback that follows a failed one.
  */
-import { attachShellJobResourceLease, promoteForegroundShellJob } from '../../builtin/shell-jobs.mjs';
+import { promoteForegroundShellJob } from '../../builtin/shell-jobs.mjs';
 import { treeKillForceSettle } from '../shell-run-state.mjs';
 
 export async function promoteWithRetry(
@@ -74,17 +74,14 @@ export function killAfterFailedPromotion(run, reason, promotionFailure) {
   );
 }
 
-export async function handOverLease(run, jobId) {
-  const promotedLease = run.resourceLease;
+/**
+ * The promoted job leaves foreground admission: its lease is RELEASED, which
+ * also restores the parent's high-load share. A long-lived server must never
+ * hold a foreground slot for its whole life; background jobs are not counted
+ * against any cap (session/runtime close stops them via shutdownShellJobs).
+ */
+export async function handOverLease(run) {
+  const lease = run.resourceLease;
   run.resourceLease = null;
-  if (!promotedLease) return;
-  try {
-    await promotedLease.detachDependency?.();
-    attachShellJobResourceLease(jobId, promotedLease);
-  } catch (error) {
-    try {
-      await promotedLease.release();
-    } catch {}
-    throw error;
-  }
+  await lease?.release();
 }

package/src/runtime/agent/orchestrator/tools/lib/shell-run-background.mjs

@@ -11,7 +11,7 @@
 // exclusive with settle() via the autoBackgrounded flag set synchronously at
 // the top before any await.
 //
-//   shell-run-background/promote-job.mjs       — registry promotion, lease hand-over, kill fallback
+//   shell-run-background/promote-job.mjs       — registry promotion, lease release, kill fallback
 //   shell-run-background/promotion-results.mjs — the ExecResult of each promotion outcome
 import { clearForegroundRecord, clearForegroundTimers, elapsedSinceStart } from './shell-run-state.mjs';
 import { readCapturedOutput } from './shell-run-settle.mjs';
@@ -108,7 +108,7 @@ export function createAutoBackground({
     }
     const jobId = job.jobId;
     run.autoBackgroundJobId = jobId;
-    await handOverLease(run, jobId);
+    await handOverLease(run);
     // Snapshot the partial output captured so far for the immediate result.
     const { stdout, stderr } = await readCapturedOutput(taskOutput);
     const capture = { stdout, stderr, spill: { ...promotedSpillPaths(taskOutput), stdoutPath } };

package/src/runtime/agent/orchestrator/tools/lib/shell-run-state.mjs

@@ -20,7 +20,7 @@ import { ShellTextDecoder, TaskOutput, treeKill } from '../shell-exec-output.mjs
 const KILL_CONFIRM_INTERVAL_MS = 5000;
 const KILL_CONFIRM_ATTEMPTS = 3;
 
-export function createShellRun({ abortSignal, resolve }) {
+export function createShellRun({ abortSignal, resolve, jobId = null }) {
   const taskId = `shell_${randomUUID().slice(0, 8)}`;
   let resultResolved = false;
   return {
@@ -80,7 +80,9 @@ export function createShellRun({ abortSignal, resolve }) {
     // reached a shell — not lease/preflight entry, and not a warm standby's
     // process-creation time.
     commandStartedAtMs: 0,
-    foregroundRecordId: `job_${Date.now()}_${randomUUID().slice(0, 6)}`,
+    // Also the task_id the command keeps once promoted. A queued command
+    // passes its queued task's id so one id names it before and after.
+    foregroundRecordId: jobId || `job_${Date.now()}_${randomUUID().slice(0, 6)}`,
     foregroundRecordTimer: null,
     foregroundRecordPublished: false,
   };

package/src/runtime/agent/orchestrator/tools/shell-command.mjs

@@ -1,22 +1,13 @@
 // Async one-shot shell runner.
 //
-// Replaces the legacy spawnSync path in builtin.mjs shell execution. The
-// improvements over spawnSync are:
-//   - native process-tree termination on timeout / abort.
-//   - automatic spill to $PLUGIN_DATA/shell-output/<taskId>.* once the
-//     in-memory buffers exceed SHELL_OUTPUT_INLINE_CAP bytes. The caller
-//     receives an outputFilePath marker the model can FileRead later
-//     instead of losing the tail past the inline cap.
-//   - external AbortSignal hookup so a session-scoped abort (ESC, new
-//     prompt) cancels in-flight bash work without orphaning the child.
-//
 // One run is an explicit state record (lib/shell-run-state.mjs) driven
 // through three phases: spawn (lib/shell-run-spawn.mjs), settle
 // (lib/shell-run-settle.mjs) and the auto-background promotion
 // (lib/shell-run-background.mjs). This module owns admission, preflight and
 // the wiring between those phases.
-import { startBackgroundTask } from '../../../shared/background-tasks.mjs';
+import { getBackgroundTask, startBackgroundTask } from '../../../shared/background-tasks.mjs';
 import { resourceAdmission } from '../../../shared/resource-admission.mjs';
+import { buildShellCompletion, killShellJob, peekShellJob, subscribeShellJobSettled } from './builtin/shell-jobs.mjs';
 import { ExecResult, treeKill } from './shell-exec-output.mjs';
 import {
   clearForegroundTimers,
@@ -50,25 +41,49 @@ const _envAdmissionWait = Math.floor(Number(process.env.MIXDOG_SHELL_ADMISSION_W
 const SHELL_ADMISSION_WAIT_MS =
   Number.isFinite(_envAdmissionWait) && _envAdmissionWait >= 0 ? _envAdmissionWait : 30_000;
 
-function _admissionSaturationError(admission, waitMs) {
+// Foreground leases are labeled `[task_id: X] command` at spawn (X is the id
+// the command keeps once promoted, or its queued task's id).
+const LEASE_TASK_ID = /^\[task_id: ([^\]\s]+)\]/;
+
+// Only the caller's OWN holders are described (oldest first, with task_id and
+// an exact `task cancel` call when cancellable). Other sessions' holders are
+// reported as a count with ages: their command text is never shown here.
+function _admissionSaturationError(admission, waitMs, ownerKey = null) {
+  const own = String(ownerKey || '');
   let detail = '';
   try {
     const snap = admission.snapshot();
-    const held = (snap.activeLeases || [])
+    const holders = (snap.activeLeases || [])
       .filter((lease) => lease.kind === 'shell')
-      .map((lease) => `[${Math.round(lease.ageMs / 1000)}s] ${String(lease.label || '(unlabeled)')}`)
-      .join(' | ');
+      .sort((a, b) => b.ageMs - a.ageMs);
+    const rows = [];
+    const cancels = [];
+    const otherAges = [];
+    for (const lease of holders) {
+      const age = `${Math.round(lease.ageMs / 1000)}s`;
+      if (!own || lease.ownerKey !== own) {
+        otherAges.push(age);
+        continue;
+      }
+      const label = String(lease.label || '(unlabeled)');
+      const taskId = LEASE_TASK_ID.exec(label)?.[1] || null;
+      const cancellable = taskId && getBackgroundTask(taskId);
+      if (cancellable) cancels.push(`task cancel task_id=${taskId}`);
+      rows.push(`[${age}] ${label}${cancellable ? '' : ' (foreground call)'}`);
+    }
     detail =
-      ` ${snap.active.shell}/${snap.limits.maxShells} shell leases active` +
-      (held ? ` (${held})` : '') +
-      `, ${snap.queued} queued.`;
+      ` ${snap.active.shell}/${snap.limits.maxShells} shell leases active, ${snap.queued} queued.` +
+      (rows.length ? ` Your holders, oldest first: ${rows.join(' | ')}.` : '') +
+      (cancels.length ? ` Free your own slots: ${cancels.join('; ')}.` : '') +
+      (otherAges.length
+        ? ` ${otherAges.length} holder(s) belong to other sessions of this runtime (ages ${otherAges.join(', ')}); only their owners can cancel them.`
+        : '');
   } catch {
     /* diagnostics must not mask the timeout */
   }
   const error = new Error(
     `shell admission wait exceeded ${waitMs}ms —${detail} ` +
-      'Long-held leases usually mean stuck background shell process trees: ' +
-      'check task list, cancel stale tasks, kill lingering child processes, or restart the CLI.'
+      'A lease returns when its call ends or is promoted to the background; background jobs hold none.'
   );
   error.code = 'ERESOURCEPRESSURE';
   error.admissionSaturated = true;
@@ -168,7 +183,7 @@ async function acquireShellLeaseBounded(
   const deadlineAt = Date.now() + waitMs;
   const deadline = setTimeout(() => {
     try {
-      ctl.abort(_admissionSaturationError(admission, waitMs));
+      ctl.abort(_admissionSaturationError(admission, waitMs, ownerKey));
     } catch {}
   }, waitMs);
   if (deadline.unref) deadline.unref();
@@ -223,7 +238,7 @@ async function admitAndSpawn(run, params, { admissionWaitMs, onSaturated }) {
     run.resourceLease = await acquireShellLeaseBounded(admission, {
       abortSignal,
       waitMs: admissionWaitMs,
-      label: String(command || '').slice(0, 120),
+      label: `[task_id: ${run.foregroundRecordId}] ${String(command || '').slice(0, 120)}`,
       ownerKey: ownerSessionId,
     });
     const policyErr = await _execPolicyBlockMessage(command);
@@ -252,36 +267,62 @@ async function admitAndSpawn(run, params, { admissionWaitMs, onSaturated }) {
   }
 }
 
+// A queued command that outlived its foreground window was promoted under the
+// queued task's id; the task settles with that job.
+async function settleQueuedPromotion(jobId) {
+  await new Promise((resolve) => {
+    if (!subscribeShellJobSettled(jobId, resolve)) resolve();
+  });
+  const completion = buildShellCompletion(jobId, peekShellJob(jobId));
+  if (completion.taskStatus !== 'completed') {
+    throw new Error(completion.error || `shell task ${completion.taskStatus}`);
+  }
+  return completion.result;
+}
+
 // A saturated shell lane must not fail the call: the command becomes a tracked
-// background task that waits (no admission ceiling) for a lease, runs, and
-// completes like any other task. The call returns its task_id immediately.
+// background task that waits (no admission ceiling) for a lease and then runs
+// as a normal foreground-then-promote command under the task's id, so a
+// long-lived one releases its lease at promotion like any other. The call
+// returns its task_id immediately.
 function queueSaturatedAsTask(run, saturation, spec) {
   const queuedAbort = new AbortController();
+  const taskId = run.foregroundRecordId;
   let task;
   try {
     task = startBackgroundTask({
-      taskId: run.taskId,
+      taskId,
       surface: 'shell',
       operation: 'shell',
-      label: String(spec.command || '').replace(/\s+/g, ' ').slice(0, 120),
+      label: String(spec.command || '')
+        .replace(/\s+/g, ' ')
+        .slice(0, 120),
       context: { callerSessionId: spec.ownerSessionId, clientHostPid: spec.clientHostPid },
       input: { command: spec.command, cwd: spec.cwd },
-      meta: { task_id: run.taskId, stdout: null, stderr: null, cwd: spec.cwd, timeoutMs: spec.timeoutMs },
+      meta: { task_id: taskId, stdout: null, stderr: null, cwd: spec.cwd, timeoutMs: spec.backgroundDeadlineMs || 0 },
       resultType: 'shell_task_result',
-      cancel: () => queuedAbort.abort(),
+      cancel: () => {
+        queuedAbort.abort();
+        try {
+          killShellJob(taskId);
+        } catch {}
+      },
       run: async () => {
         const result = await execShellCommand({
           ...spec,
+          jobId: taskId,
           abortSignal: queuedAbort.signal,
-          autoBackgroundMs: 0,
-          backgroundOnTimeout: false,
           admissionWaitMs: 0,
+          // The call already returned: nobody renders live progress.
+          onProgress: null,
+          onOutputTail: null,
         });
+        if (result.backgrounded && result.jobId) return settleQueuedPromotion(result.jobId);
         const output = [result.stdout, result.stderr].filter(Boolean).join('\n');
         if (result.exitCode !== 0) {
           throw new Error(`exit code ${result.exitCode ?? result.signal ?? 'unknown'}${output ? `\n${output}` : ''}`);
         }
-        return { task_id: run.taskId, status: 'completed', exit_code: 0, output };
+        return { task_id: taskId, status: 'completed', exit_code: 0, output };
       },
     });
   } catch {
@@ -474,72 +515,64 @@ function armDeadlines(run, { timeoutMs, autoBackgroundMs, backgroundOnTimeout, a
 
 // Run one command to a terminal ExecResult. Spawn-time EPERM retries (Windows
 // Defender scanning the child image) live in lib/shell-spawn-retry.mjs.
-export function execShellCommand({
-  shell,
-  shellArg,
-  shellArgs,
-  command,
-  env,
-  cwd,
-  timeoutMs,
-  abortSignal,
-  autoBackgroundMs,
-  onProgress,
-  onOutputTail,
-  clientHostPid,
-  ownerSessionId,
-  backgroundOnTimeout,
-  promotedTimeoutMs = 0,
-  backgroundDeadlineMs = 0,
-  admissionWaitMs = SHELL_ADMISSION_WAIT_MS,
-  admission = resourceAdmission,
-  directArgv = null,
-  // What the shell PARSES, when that must differ from what the caller shows.
-  // `command` stays the display/record text (job labels, telemetry, shell-job
-  // rows); `execScript` is the argv payload. They diverge only when a caller
-  // hands the script to the shell out-of-band — see the POSIX env+eval path in
-  // bash-tool.mjs, which keeps the command body out of the child's argv.
-  execScript = null,
-}) {
+export function execShellCommand(options) {
+  const {
+    shell,
+    shellArg,
+    shellArgs,
+    command,
+    env,
+    cwd,
+    timeoutMs,
+    abortSignal,
+    autoBackgroundMs,
+    onProgress,
+    onOutputTail,
+    clientHostPid,
+    ownerSessionId,
+    backgroundOnTimeout,
+    promotedTimeoutMs = 0,
+    backgroundDeadlineMs = 0,
+    // Fixed task_id for the run (a queued command reuses its task's id).
+    jobId = null,
+    admissionWaitMs = SHELL_ADMISSION_WAIT_MS,
+    admission = resourceAdmission,
+    directArgv = null,
+    // What the shell PARSES, when that must differ from what the caller shows.
+    // `command` stays the display/record text (job labels, telemetry, shell-job
+    // rows); `execScript` is the argv payload. They diverge only when a caller
+    // hands the script to the shell out-of-band — see the POSIX env+eval path in
+    // bash-tool.mjs, which keeps the command body out of the child's argv.
+    execScript = null,
+  } = options;
   return new Promise(async (resolve) => {
-    const run = createShellRun({ abortSignal, resolve });
+    const run = createShellRun({ abortSignal, resolve, jobId });
     // An async executor's throw is NOT routed to this Promise — it becomes an
     // unhandled rejection of the executor's own promise while the awaiting
     // caller hangs forever. Every path below therefore has to settle the run
     // itself, including the unexpected one.
     try {
-      const spawned = await admitAndSpawn(run, {
-        admission,
-        shell,
-        shellArg,
-        shellArgs,
-        command,
-        env,
-        cwd,
-        abortSignal,
-        directArgv,
-        execScript,
-        ownerSessionId,
-        clientHostPid,
-      }, {
-        admissionWaitMs,
-        onSaturated: (err) =>
-          backgroundOnTimeout &&
-          queueSaturatedAsTask(run, err, {
-            shell,
-            shellArg,
-            shellArgs,
-            command,
-            env,
-            cwd,
-            timeoutMs: backgroundDeadlineMs,
-            clientHostPid,
-            ownerSessionId,
-            admission,
-            directArgv,
-            execScript,
-          }),
-      });
+      const spawned = await admitAndSpawn(
+        run,
+        {
+          admission,
+          shell,
+          shellArg,
+          shellArgs,
+          command,
+          env,
+          cwd,
+          abortSignal,
+          directArgv,
+          execScript,
+          ownerSessionId,
+          clientHostPid,
+        },
+        {
+          admissionWaitMs,
+          onSaturated: (err) => backgroundOnTimeout && queueSaturatedAsTask(run, err, options),
+        }
+      );
       if (!spawned) return;
 
       // Pre-aborted signal: kill immediately if the abort already fired

package/src/runtime/agent/orchestrator/tools/shell-exec-policy.mjs

@@ -83,23 +83,36 @@ function classifyExecPolicy(command) {
   const decodedPowerShell = decodePowerShellEncodedCommand(text);
   if (decodedPowerShell) executableTargets.push(stripQuotedAndHeredoc(decodedPowerShell));
   if (executableTargets.some((target) => isBlockedCommand(target))) {
-    return { decision: 'deny', reason: 'destructive or system-destabilising pattern (hard block)' };
+    return {
+      decision: 'deny',
+      reason: 'destructive or system-destabilising pattern (hard block)',
+      rule: 'hard-block',
+    };
   }
   // Hard-deny only real executable syntax. The policy scanner also sees user
   // search strings / regex literals (e.g. `-match 'powershell|bash|grep'`), so
   // high-risk pipe-to-shell / IEX / RunAs patterns must ignore quoted spans.
   const executableText = stripQuotedAndHeredoc(text);
   for (const pat of EXEC_POLICY_DENY_PATTERNS) {
-    if (pat.test(executableText)) {
+    const hit = pat.exec(executableText);
+    if (hit) {
       return {
         decision: 'deny',
         reason: 'high-risk shell invocation (pipe-to-shell, elevated launcher, or remote-exec pattern)',
+        rule: `high-risk-pattern-${EXEC_POLICY_DENY_PATTERNS.indexOf(pat) + 1}`,
+        match: hit[0].trim().slice(0, 80),
+        alternative: 'save the script to a file, inspect it, then run it directly',
       };
     }
   }
   for (const name of _commandNamesAtPositions(executableText)) {
     if (EXEC_POLICY_DENY_COMMANDS.has(name)) {
-      return { decision: 'deny', reason: `command "${name}" is not permitted` };
+      return {
+        decision: 'deny',
+        reason: `command "${name}" is not permitted`,
+        rule: 'denied-command',
+        match: name,
+      };
     }
   }
   // Destructive-but-legitimate commands are NOT judged here. The caller
@@ -131,7 +144,9 @@ export function evaluateExecPolicyFromTargets(targets) {
 export function formatExecPolicyBlockMessage(policyResult) {
   const r = policyResult || { decision: 'allow' };
   if (r.decision === 'deny') {
-    return `Error: command blocked by exec policy${r.reason ? ` — ${r.reason}` : ''}`;
+    const rule = r.rule ? ` [rule ${r.rule}${r.match ? `: "${r.match}"` : ''}]` : '';
+    const alt = r.alternative ? `; instead: ${r.alternative}` : '';
+    return `Error: command blocked by exec policy${r.reason ? ` — ${r.reason}` : ''}${rule}${alt}`;
   }
   return null;
 }

package/src/runtime/channels/index.mjs

@@ -1,13 +1,9 @@
 // Thin facade for the channels worker runtime. The implementation was split
 // out into ./lib/worker-main.mjs plus focused lib/ modules; this file preserves
-// the exact public API and boot side-effects by re-exporting from worker-main.
+// the current worker API and boot side-effects by re-exporting from worker-main.
 // Kept as the channels worker entrypoint the daemon loads.
 export {
-  TOOL_DEFS,
   handleToolCall,
-  handleToolCallWithBridgeRetry,
-  init,
-  instructions,
   isChannelBridgeActive,
   isChannelsDegraded,
   start,

package/src/runtime/channels/lib/runtime-paths.mjs

@@ -114,8 +114,7 @@ function getControlResponsePath(instanceId) {
 function getStopFlagPath(instanceId) {
   return join(RUNTIME_ROOT, `stop-${sanitize(instanceId)}.flag`);
 }
-// Pure metadata-advert read: ownership is the OS seat lock, so a leftover
-// advert is never evicted here. A transient read during an atomic rename may
+// Pure metadata-advert read. A transient read during an atomic rename may
 // yield empty/partial content: retry once after 50 ms before reporting the
 // advert as unreadable.
 function readActiveInstance() {
@@ -141,8 +140,6 @@ function buildActiveInstanceState(instanceId, meta) {
     supervisor_started_at: Date.now(),
     server_started_at: Date.now(),
     updatedAt: Date.now(),
-    turnEndFile: getTurnEndPath(instanceId),
-    statusFile: getStatusPath(instanceId),
     ...metaFields(meta),
   };
 }
@@ -193,26 +190,14 @@ function refreshActiveInstance(instanceId, meta, options) {
     (curRaw) => {
       const prevForPreserve = curRaw;
       const prev = activeInstanceStaleReason(curRaw) ? null : curRaw;
-      // CAS guard (opt-in via options.onlyIfOwned): heartbeat/refresh ticks
-      // check ownership OUTSIDE this lock, so a newer session can claim the
-      // seat between that check and this locked update. Without this re-read,
-      // the tick would overwrite the newer owner's instanceId (TOCTOU
-      // re-steal -> ownership ping-pong / double provider connections).
-      // Returning undefined aborts the update with no write. Explicit claims
-      // (boot, claimBridgeOwnership) omit the option and stay last-wins.
-      if (options?.onlyIfOwned && (!prev?.instanceId || prev.instanceId !== instanceId)) {
-        return undefined;
-      }
-      // CAS guard (opt-in via options.onlyIfVacant): auto-start claim-if-vacant.
-      // Abort the write when a live (non-stale) owner OTHER than us already holds
-      // the seat — an auto-start must never steal from a live owner. A stale/dead
-      // prior owner leaves prev=null above, so it does NOT block the claim; an
-      // absent seat (prev=null) is claimable too.
-      if (options?.onlyIfVacant && prev?.instanceId && prev.instanceId !== instanceId) {
-        return undefined;
-      }
       // Drop stale fields (pid/startedAt) written by older server versions.
-      const { pid: _legacyPid, startedAt: _legacyStartedAt, ...prevRest } = prev ?? {};
+      const {
+        pid: _legacyPid,
+        startedAt: _legacyStartedAt,
+        turnEndFile: _turnEndFile,
+        statusFile: _statusFile,
+        ...prevRest
+      } = prev ?? {};
       const identity = buildRuntimeIdentity();
       // server_started_at tracks the CURRENT server_pid's start time so the
       // dev-sync barrier can verify the CHILD's freshness (the supervisor's

package/src/runtime/channels/lib/tool-dispatch.mjs

@@ -82,12 +82,6 @@ function createToolDispatch({ isChannelsDegraded, lifecycle }) {
           };
           break;
         }
-        case 'rebind_current_transcript': {
-          // Transcript forwarding is retired with channel messaging: accept
-          // and no-op so legacy lead-side pushes never surface an error.
-          result = { content: [{ type: 'text', text: 'transcript rebind retired' }] };
-          break;
-        }
         // memory — handled by memory-service.mjs MCP
         default:
           result = {
@@ -105,13 +99,7 @@ function createToolDispatch({ isChannelsDegraded, lifecycle }) {
     return result;
   }
 
-  // IPC/HTTP wrapper: with channel messaging retired there is no transcript
-  // pre-flush or tool-log relay — plain dispatch.
-  async function handleToolCallWithBridgeRetry(toolName, args, signal) {
-    return handleToolCall(toolName, args, signal);
-  }
-
-  return { handleToolCall, handleToolCallWithBridgeRetry };
+  return { handleToolCall };
 }
 
 export { createToolDispatch };

package/src/runtime/channels/lib/worker-ipc.mjs

@@ -14,7 +14,7 @@ export function runWorkerIpc({
   getProvider: _getProvider,
   getConfig: _getConfig,
   handleMemoryCallResponse,
-  handleToolCallWithBridgeRetry,
+  handleToolCall,
   bootProfile,
 }) {
   const sendToParent = (message) =>
@@ -94,7 +94,7 @@ export function runWorkerIpc({
       _inFlightChannelCalls.set(msg.callId, ac);
       let result;
       try {
-        result = await handleToolCallWithBridgeRetry(msg.name, msg.args || {}, ac.signal);
+        result = await handleToolCall(msg.name, msg.args || {}, ac.signal);
       } finally {
         _inFlightChannelCalls.delete(msg.callId);
       }