theslopmachine 1.0.6 → 1.0.8

package/assets/skills/claude-worker-management/SKILL.md

@@ -134,18 +134,20 @@ Metadata for a Claude lane should include:
 
 - Rate-limit handling must be uninterrupted and script-managed. Use the live helper scripts only; never type manually into the tmux pane, send an ad hoc shell command to Claude, switch lanes, or ask the user whether to wait.
 - The live helpers read the tmux pane when a rate-limit/usage-limit prompt appears.
-- If Claude shows a wait/continue prompt, the helper presses Enter to select the wait/continue path.
+- If Claude shows a wait/continue prompt such as `Stop and wait for limit to reset`, the helper presses Enter to select the wait/continue path.
 - The helper records blocked and dismissed pane snapshots under the lane runtime directory.
-- The helper calculates the reset time from structured metadata or screen/error text, falls back to the default quota reset window when needed, records the timer fields in `state.json`, waits, then continues the same turn in the same Claude lane.
+- The helper calculates the reset time from structured metadata, hook payload text, `last_assistant_message`, and tmux pane text, falls back to the default quota reset window only when those sources do not contain a usable reset time, records the timer fields in `state.json`, waits, then continues the same turn in the same Claude lane.
+- If a shell command is interrupted during a wait, rerun the same turn/status helper. It must reuse the blocked turn state and continue waiting/recovering from the recorded reset time instead of starting a duplicate prompt.
 - The continuation prompt must tell Claude to continue from the interruption point, not restart from scratch.
 - Shell timeouts during a rate-limit wait do not mean the turn failed. Run `claude_live_status.mjs`, let it reconcile or keep waiting on the same lane, then continue the same workflow step until a terminal result exists.
 - Do not report the workflow as blocked or finished because of a rate limit unless the helper scripts themselves hit an unrecoverable technical failure that cannot be repaired without user action.
 
-## Development Channel Recovery
+## Tmux Prompt Injection Recovery
 
-- Launch must verify both `SessionStart` and channel readiness before a lane is usable.
-- If development channels are disabled, missing, or never become ready during launch, the helper kills only the proven-owned tmux session and relaunches the same lane before any prompt is sent.
-- If an existing lane has a live tmux session but the channel is unusable, relaunch with `--resume`/existing `sid` continuity when available.
+- Launch must verify `SessionStart` and a captured `sid` before a lane is usable.
+- Turns are sent by writing the prompt file, loading it into a tmux paste buffer, pasting it into Claude's interactive input, and pressing Enter. Hook events remain the response/completion source of truth.
+- Before pasting, the helper must inspect the pane and handle known startup, confirmation, busy, and rate-limit popups heuristically. Do not paste into a pane while a popup or busy state is detected.
+- If an existing lane has a live tmux session but no usable `SessionStart`/`sid`, relaunch with `--resume`/existing `sid` continuity when available.
 - If ownership cannot be proven, stop and ask the user rather than killing or replacing the session.
 
 ## Session Continuity Guarantees

package/assets/slopmachine/utils/README.md

@@ -22,7 +22,7 @@ The current type-check gate covers the Claude/session tooling family because the
 
 ### `claude_live_launch.mjs`
 
-Launches a live Claude Code session in tmux with the slopmachine channel bridge.
+Launches a live Claude Code session in tmux with hook-based result capture.
 
 Required:
 - `--task-root <task-root>`
@@ -40,7 +40,7 @@ Output is JSON. Success includes `ok: true`, `sid`, `state_file`, and `result_fi
 
 ### `claude_live_turn.mjs`
 
-Sends one prompt into an existing live Claude lane through the channel bridge and waits for completion.
+Sends one prompt into an existing live Claude lane by loading the prompt file into a tmux paste buffer, pasting it into Claude's interactive input, pressing Enter, and waiting for hook completion.
 
 Required:
 - `--runtime-dir <dir>`
@@ -58,7 +58,7 @@ Reads the live-lane runtime state.
 Required:
 - `--runtime-dir <dir>`
 
-Output is JSON with lane status, cwd, sid, runtime files, transcript path, channel state, and last error.
+Output is JSON with lane status, cwd, sid, runtime files, transcript path, tmux state, and last error.
 
 ### `claude_live_stop.mjs`
 
@@ -69,16 +69,6 @@ Required:
 
 The helper only kills tmux when bridge state proves ownership. If ownership is ambiguous, it leaves tmux alone and reports the reason.
 
-### `claude_live_channel.mjs`
-
-Internal JSON-RPC/HTTP bridge used by live lanes. It accepts Claude initialization over stdio and POSTs from `claude_live_turn.mjs`, then emits `notifications/claude/channel` to Claude.
-
-Required:
-- `--port <port>`
-- `--token <secret>`
-- `--state-file <file>`
-- `--log-file <file>`
-
 ### `claude_live_hook.py`
 
 Claude Code hook used by live lanes to append hook events under the runtime directory.
@@ -123,14 +113,12 @@ Packages the Claude project directory associated with a task root.
 
 Required:
 - `--task-root <task-root>`
-- `--output <zip-path>`
 
 Important options:
-- `--session-ids <comma-separated-session-ids>` narrows the expected tracked sessions
-- `--metadata-file <path>` overrides the default `<task-root>/metadata.json`
+- `--output <zip-path>` writes the zip to a custom path; default is `<task-root>/claude-sessions.zip`
 - `--label <text>` adds reporting context
 
-The helper normalizes top-level JSONL transcripts, preserves the raw project directory structure, and writes a single zip.
+The helper copies the Claude project/session directory as-is, removes `.DS_Store` files and top-level `.jsonl` transcripts under 25KB from the staged copy, zips the folder contents directly, and writes a single zip. It does not normalize or rewrite transcript files.
 
 ### `analyze_claude_project_dir.mjs`
 
@@ -194,10 +182,6 @@ Common usage:
 - `python3 convert_ai_session.py -i session.jsonl -o converted.json`
 - `python3 convert_ai_session.py -i session.jsonl --format claude`
 
-### `normalize_claude_session.py`
-
-Normalizes Claude JSONL transcript structure for packaging and review.
-
 ### `strip_session_parent.py`
 
 Removes parent/session ancestry fields from exported session artifacts when needed for sanitized review.

package/assets/slopmachine/utils/claude_live_common.mjs

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 import fs from 'node:fs/promises'
-import http from 'node:http'
 import net from 'node:net'
 import path from 'node:path'
 import crypto from 'node:crypto'
@@ -14,7 +13,6 @@ export { emitFailure, emitSuccess, parseArgs, printUsageAndExit, readPrompt, rea
 
 export const DEFAULT_LAUNCH_TIMEOUT_MS = 3600000
 export const DEFAULT_TURN_TIMEOUT_MS = 3600000
-export const DEFAULT_CHANNEL_POST_TIMEOUT_MS = 10000
 export const DEFAULT_POLL_INTERVAL_MS = 500
 export const ROOT_PHASE_TITLES = [
   'P1 Clarification',
@@ -35,9 +33,6 @@ export function buildRuntimePaths(runtimeDir) {
     stateFile: path.join(absoluteRuntimeDir, 'state.json'),
     resultFile: path.join(absoluteRuntimeDir, 'result.json'),
     settingsFile: path.join(absoluteRuntimeDir, 'settings.json'),
-    mcpConfigFile: path.join(absoluteRuntimeDir, 'mcp.json'),
-    channelStateFile: path.join(absoluteRuntimeDir, 'channel-state.json'),
-    channelLogFile: path.join(absoluteRuntimeDir, 'channel.log'),
     hookEventsFile: path.join(absoluteRuntimeDir, 'hook-events.jsonl'),
     turnsDir: path.join(absoluteRuntimeDir, 'turns'),
   }
@@ -81,8 +76,6 @@ export async function writeState(runtimeDir, patch) {
 
 export async function clearRuntimeArtifacts(paths) {
   await writeFileIfNeeded(paths.hookEventsFile, '')
-  await writeFileIfNeeded(paths.channelLogFile, '')
-  await fs.rm(paths.channelStateFile, { force: true })
   await fs.rm(paths.resultFile, { force: true })
 }
 
@@ -324,21 +317,23 @@ export async function captureTmuxPaneArtifact(sessionName, filePath) {
   return pane
 }
 
-export function detectClaudeDevelopmentChannelDisabled(pane) {
-  if (!pane) {
-    return false
-  }
+export async function tmuxSendEnter(sessionName) {
+  return runCommand('tmux', ['send-keys', '-t', sessionName, 'Enter'])
+}
 
-  const normalized = pane.toLowerCase()
-  if (normalized.includes('listening for channel messages from:')) {
-    return false
+export async function tmuxPasteFileAndEnter(sessionName, filePath, bufferName) {
+  const loadResult = await runCommand('tmux', ['load-buffer', '-b', bufferName, filePath])
+  if (loadResult.code !== 0) {
+    return loadResult
   }
 
-  return /development channels? (?:are )?(?:disabled|not enabled|unavailable)|channels? (?:are )?disabled|failed to (?:load|start).*development channels?|unknown option.*dangerously-load-development-channels|mcp .*?(?:disabled|failed|unavailable)/i.test(normalized)
-}
+  const pasteResult = await runCommand('tmux', ['paste-buffer', '-t', sessionName, '-b', bufferName])
+  await runCommand('tmux', ['delete-buffer', '-b', bufferName])
+  if (pasteResult.code !== 0) {
+    return pasteResult
+  }
 
-export async function tmuxSendEnter(sessionName) {
-  return runCommand('tmux', ['send-keys', '-t', sessionName, 'Enter'])
+  return tmuxSendEnter(sessionName)
 }
 
 function detectClaudeRateLimitPrompt(pane) {
@@ -348,17 +343,20 @@ function detectClaudeRateLimitPrompt(pane) {
 
   const normalized = pane.toLowerCase()
   const hasRateLimitSignal = /hit your limit|usage limit|rate limit|capacity|overloaded|try again/i.test(normalized)
+  const hasResetTimeSignal = /\breset(?:s| time)?\s+(?:at\s+)?\d{1,2}(?::\d{2})?\s*(?:am|pm)?(?:\s*\([^)]+\))?/i.test(pane)
   const hasContinueSignal = /press\s+(enter|return)|hit\s+(enter|return)|enter\s+to\s+continue|return\s+to\s+continue|enter\s+to\s+confirm|return\s+to\s+confirm/i.test(normalized)
+  const hasSelectedWaitOption = /(?:❯|>|➜|→)?\s*\d+\.\s*stop and wait for limit to reset/i.test(pane)
+  const hasPlainWaitOption = /stop and wait for limit to reset/i.test(normalized)
   const hasWaitMenuSignal = normalized.includes('what do you want to do?')
     && normalized.includes('stop and wait for limit to reset')
   const hasWaitMenuOptions = normalized.includes('request more')
     && /enter\s+to\s+confirm|return\s+to\s+confirm/.test(normalized)
 
-  if (hasWaitMenuSignal || hasWaitMenuOptions) {
+  if (hasSelectedWaitOption || hasWaitMenuSignal || hasWaitMenuOptions) {
     return true
   }
 
-  return hasRateLimitSignal && (hasContinueSignal || hasWaitMenuSignal)
+  return hasRateLimitSignal && (hasContinueSignal || hasPlainWaitOption || hasResetTimeSignal)
 }
 
 export async function maybeDismissClaudeRateLimitPrompt(sessionName, timeoutMs = 15000) {
@@ -440,13 +438,6 @@ function detectClaudeStartupPrompt(pane) {
     return 'workspace-trust'
   }
 
-  if (
-    pane.includes('WARNING: Loading development channels')
-    || pane.includes('I am using this for local development')
-  ) {
-    return 'development-channels'
-  }
-
   return null
 }
 
@@ -457,10 +448,6 @@ export async function maybeAcceptClaudeStartupPrompts(sessionName, timeoutMs = 3
 
   while (Date.now() < deadline) {
     const pane = await tmuxCapturePane(sessionName)
-    if (pane.includes('Listening for channel messages from:')) {
-      return false
-    }
-
     const promptKind = detectClaudeStartupPrompt(pane)
     if (promptKind) {
       const now = Date.now()
@@ -482,17 +469,64 @@ export async function maybeAcceptClaudeStartupPrompts(sessionName, timeoutMs = 3
   return false
 }
 
-export async function waitForChannelReady(paths, timeoutMs) {
-  return waitFor(async () => {
-    const channelState = await readJsonIfExists(paths.channelStateFile)
-    if (channelState?.ready_for_notifications) {
-      return channelState
-    }
+export function detectClaudePopupOrBlockedPane(pane) {
+  if (!pane) {
     return null
-  }, {
-    timeoutMs,
-    errorMessage: 'Timed out waiting for Claude channel readiness',
-  })
+  }
+
+  const startupPrompt = detectClaudeStartupPrompt(pane)
+  if (startupPrompt) {
+    return startupPrompt
+  }
+
+  if (detectClaudeRateLimitPrompt(pane)) {
+    return 'rate-limit'
+  }
+
+  const normalized = pane.toLowerCase()
+  if (/press\s+(enter|return)|hit\s+(enter|return)|enter\s+to\s+continue|return\s+to\s+continue|enter\s+to\s+confirm|return\s+to\s+confirm/.test(normalized)) {
+    return 'enter-confirmation'
+  }
+
+  if (/\b(yes|no)\b.*\b(continue|proceed|trust|allow)|\b(continue|proceed|trust|allow)\b.*\b(yes|no)\b/.test(normalized)) {
+    return 'confirmation-menu'
+  }
+
+  if (/esc to interrupt|ctrl-c to cancel|interrupt/i.test(pane)) {
+    return 'busy'
+  }
+
+  return null
+}
+
+export async function prepareClaudePaneForPrompt(sessionName, { statePath = null, timeoutMs = 30000 } = {}) {
+  const deadline = Date.now() + timeoutMs
+  let lastPane = ''
+  let lastBlocker = null
+
+  while (Date.now() < deadline) {
+    await maybeAcceptClaudeStartupPrompts(sessionName, 1000)
+    const pane = await tmuxCapturePane(sessionName)
+    lastPane = pane
+    lastBlocker = detectClaudePopupOrBlockedPane(pane)
+
+    if (lastBlocker === 'rate-limit') {
+      const popupDismissed = await maybeDismissClaudeRateLimitPrompt(sessionName, 5000)
+      const waitInfo = await waitForRateLimitReset({
+        message: pane,
+        statePath,
+      })
+      return { ready: false, blocker: 'rate-limit', popup_dismissed: popupDismissed, wait_info: waitInfo }
+    }
+
+    if (!lastBlocker) {
+      return { ready: true, blocker: null, pane }
+    }
+
+    await sleep(DEFAULT_POLL_INTERVAL_MS)
+  }
+
+  return { ready: false, blocker: lastBlocker || 'unknown', pane: lastPane }
 }
 
 export async function readJsonl(filePath) {
@@ -550,32 +584,7 @@ export function buildHookSettings({ runtimeDir, utilsDir, agentName = 'developer
   return settings
 }
 
-export function buildMcpConfig({ paths, utilsDir, channelName, lane, port, token }) {
-  return {
-    mcpServers: {
-      [channelName]: {
-        command: 'node',
-        args: [
-          path.join(utilsDir, 'claude_live_channel.mjs'),
-          '--port',
-          String(port),
-          '--token',
-          token,
-          '--state-file',
-          paths.channelStateFile,
-          '--log-file',
-          paths.channelLogFile,
-          '--channel-name',
-          channelName,
-          '--lane',
-          lane,
-        ],
-      },
-    },
-  }
-}
-
-export function buildClaudeLaunchCommand({ claudeCommand, agentName, displayName, settingsFile, mcpConfigFile, channelName, model, effort = null, subagentModel = 'sonnet', supportsSubagentModel = false, resumeSessionId = null }) {
+export function buildClaudeLaunchCommand({ claudeCommand, agentName, settingsFile, model, effort = null, subagentModel = 'sonnet', supportsSubagentModel = false, resumeSessionId = null }) {
   const parts = []
 
   if (subagentModel) {
@@ -586,15 +595,9 @@ export function buildClaudeLaunchCommand({ claudeCommand, agentName, displayName
     shellQuote(claudeCommand),
     '--agent',
     shellQuote(agentName),
-    '-n',
-    shellQuote(displayName),
     '--settings',
     shellQuote(settingsFile),
-    '--mcp-config',
-    shellQuote(mcpConfigFile),
     '--dangerously-skip-permissions',
-    '--dangerously-load-development-channels',
-    shellQuote(`server:${channelName}`),
   )
 
   if (resumeSessionId) {
@@ -616,43 +619,6 @@ export function buildClaudeLaunchCommand({ claudeCommand, agentName, displayName
   return parts.join(' ')
 }
 
-export async function postPromptToChannel({ state, prompt, turnId, timeoutMs = DEFAULT_CHANNEL_POST_TIMEOUT_MS }) {
-  return new Promise((resolve, reject) => {
-    const request = http.request({
-      hostname: '127.0.0.1',
-      port: state.channel_port,
-      path: '/',
-      method: 'POST',
-      headers: {
-        'content-type': 'text/plain; charset=utf-8',
-        'content-length': Buffer.byteLength(prompt, 'utf8'),
-        'x-bridge-token': state.channel_token,
-        'x-lane': state.lane,
-        'x-turn-id': turnId,
-      },
-      timeout: timeoutMs,
-    }, (response) => {
-      let body = ''
-      response.on('data', (chunk) => {
-        body += chunk.toString()
-      })
-      response.on('end', () => {
-        resolve({
-          statusCode: response.statusCode || 0,
-          body,
-        })
-      })
-    })
-
-    request.on('error', reject)
-    request.on('timeout', () => {
-      request.destroy(new Error('channel_post_timeout'))
-    })
-    request.write(prompt)
-    request.end()
-  })
-}
-
 export function buildTurnId(lastTurnNumber) {
   return String(lastTurnNumber + 1).padStart(4, '0')
 }
@@ -673,6 +639,7 @@ export function extractFailureMessage(payload) {
   if (!payload) return ''
 
   const candidates = [
+    payload.last_assistant_message,
     payload.message,
     payload.error,
     payload.failure_reason,
@@ -698,7 +665,7 @@ export function classifyStopFailure(event, fallbackSid = null) {
   const message = extractFailureMessage(payload) || 'claude_stop_failure'
   const rateLimit = extractRateLimitMetadata(payload)
 
-  if (/hit your limit|usage limit|capacity|overloaded/i.test(message)) {
+  if (/hit your limit|usage limit|rate[_ -]?limit|capacity|overloaded/i.test(message)) {
     return {
       result: { ok: false, code: 'claude_usage_limit', msg: 'usage_limit', detail: message, rate_limit: rateLimit, sid },
       nextStatus: 'blocked',

package/assets/slopmachine/utils/claude_live_launch.mjs

@@ -4,21 +4,17 @@ import path from 'node:path'
 
 import {
   DEFAULT_LAUNCH_TIMEOUT_MS,
-  allocatePort,
   assessOwnedTmuxSession,
   buildClaudeLaunchCommand,
   buildHookSettings,
-  buildMcpConfig,
   buildRuntimePaths,
   captureTmuxPaneArtifact,
   clearRuntimeArtifacts,
-  detectClaudeDevelopmentChannelDisabled,
   detectClaudeCliCapabilities,
   emitFailure,
   emitSuccess,
   ensureRuntimeDirs,
   makeSuffix,
-  makeToken,
   maybeAcceptClaudeStartupPrompts,
   maybeDismissClaudeRateLimitPrompt,
   parseArgs,
@@ -32,7 +28,6 @@ import {
   tmuxKillSession,
   tmuxCapturePane,
   waitForRateLimitReset,
-  waitForChannelReady,
   waitForHookEvent,
   writeJsonIfNeeded,
   writeState,
@@ -76,23 +71,20 @@ function detectRateLimitFromPane(pane) {
 
 function detectStartupPromptFromPane(pane) {
   if (!pane) return false
-  return /quick safety check:|yes, i trust this folder|accessing workspace:|warning: loading development channels|i am using this for local development/i.test(pane)
+  return /quick safety check:|yes, i trust this folder|accessing workspace:/i.test(pane)
 }
 
 async function inspectLaunchState(paths, tmuxSession) {
-  const [tmuxAlive, channelState, events, pane] = await Promise.all([
+  const [tmuxAlive, events, pane] = await Promise.all([
     tmuxHasSession(tmuxSession),
-    readJsonIfExists(paths.channelStateFile),
     readJsonl(paths.hookEventsFile),
     tmuxCapturePane(tmuxSession),
   ])
 
   const sessionStart = events.find((event) => event?.label === 'SessionStart') || null
   const sessionId = sessionStart?.payload?.session_id || null
-  const channelReady = Boolean(channelState?.ready_for_notifications)
   const rateLimited = detectRateLimitFromPane(pane)
   const startupPromptVisible = detectStartupPromptFromPane(pane)
-  const developmentChannelDisabled = detectClaudeDevelopmentChannelDisabled(pane)
 
   let code = 'claude_launch_not_ready'
   let message = 'Claude launch did not reach a ready session state yet.'
@@ -102,16 +94,7 @@ async function inspectLaunchState(paths, tmuxSession) {
   } else if (rateLimited) {
     code = 'claude_launch_rate_limited'
     message = 'Claude launch is blocked by a rate-limit or capacity prompt.'
-  } else if (developmentChannelDisabled) {
-    code = 'claude_launch_development_channels_disabled'
-    message = 'Claude launch appears to have development channels disabled; this lane must be restarted before any prompt is sent.'
-  } else if (sessionStart && !channelReady) {
-    code = 'claude_launch_no_channel_ready'
-    message = 'Claude session started but the channel never became ready.'
-  } else if (!sessionStart && channelReady) {
-    code = 'claude_launch_no_sessionstart'
-    message = 'Claude channel became ready but the SessionStart hook event never arrived.'
-  } else if (sessionStart && channelReady && !sessionId) {
+  } else if (sessionStart && !sessionId) {
     code = 'claude_launch_missing_session_id'
     message = 'Claude launch reached partial readiness but no session id was captured.'
   } else if (startupPromptVisible) {
@@ -121,12 +104,10 @@ async function inspectLaunchState(paths, tmuxSession) {
 
   return {
     tmuxAlive,
-    channelReady,
     sessionStart,
     sessionId,
     rateLimited,
     startupPromptVisible,
-    developmentChannelDisabled,
     code,
     message,
   }
@@ -135,8 +116,6 @@ async function inspectLaunchState(paths, tmuxSession) {
 function shouldRetryFreshTmuxLaunch(error) {
   const code = error && typeof error === 'object' ? error.code : null
   return [
-    'claude_launch_development_channels_disabled',
-    'claude_launch_no_channel_ready',
     'claude_launch_no_sessionstart',
     'claude_launch_not_ready',
     'claude_launch_prompt_blocked',
@@ -156,19 +135,21 @@ async function waitForLaunchReadyWithRecovery({ paths, tmuxSession, launchTimeou
       maybeDismissClaudeRateLimitPrompt(tmuxSession, Math.min(windowMs, 5000)),
     ])
 
-    const [hookResult, channelResult] = await Promise.allSettled([
-      waitForHookEvent(paths, 0, new Set(['SessionStart']), windowMs),
-      waitForChannelReady(paths, windowMs),
-    ])
+    let hookReady = null
+    try {
+      hookReady = await waitForHookEvent(
+        paths,
+        0,
+        new Set(['SessionStart']),
+        windowMs,
+      )
+    } catch {}
 
-    const hookReady = hookResult.status === 'fulfilled' ? hookResult.value : null
-    const channelReady = channelResult.status === 'fulfilled' ? channelResult.value : null
     const sessionId = hookReady?.event?.payload?.session_id || null
 
-    if (hookReady && channelReady && sessionId) {
+    if (hookReady && sessionId) {
       return {
         event: hookReady.event,
-        channelState: channelReady,
       }
     }
 
@@ -234,7 +215,6 @@ Options:
   --resume-sid <sid>             Resume an explicit Claude session id
   --replace 1                    Replace an existing live lane state/session
   --tmux-session <name>          Override tmux session name
-  --channel-name <name>          Override bridge channel name
 `)
 }
 
@@ -269,10 +249,8 @@ try {
   if (existingState?.tmux_session && await tmuxHasSession(existingState.tmux_session)) {
     if (!replace) {
       const existingInspection = await inspectLaunchState(paths, existingState.tmux_session)
-      if (existingInspection.developmentChannelDisabled || !existingInspection.channelReady) {
-        const code = existingInspection.developmentChannelDisabled
-          ? 'claude_existing_development_channels_disabled'
-          : 'claude_existing_channel_not_ready'
+      if (!existingInspection.sessionStart || !existingInspection.sessionId) {
+        const code = 'claude_existing_not_ready'
         const ownership = await assessOwnedTmuxSession({ runtimeDir, state: existingState, cwd })
         if (!ownership.ok) {
           emitFailure(code, `${existingInspection.message} Refusing automatic restart because tmux ownership is not proven: ${ownership.reason}`, {
@@ -353,15 +331,10 @@ try {
   const cliCapabilities = await detectClaudeCliCapabilities(claudeCommand)
 
   async function launchAttempt(attemptNumber, attemptsTotal) {
-    const suffix = argv['tmux-session'] || argv['channel-name'] ? makeSuffix() : makeSuffix()
+    const suffix = makeSuffix()
     const tmuxSession = argv['tmux-session'] && attemptNumber === 1
       ? argv['tmux-session']
       : `sm-${sanitizeName(lane)}-${suffix}`
-    const channelName = argv['channel-name'] && attemptNumber === 1
-      ? argv['channel-name']
-      : `slopmachine-${sanitizeName(lane)}-${suffix}`
-    const channelPort = await allocatePort()
-    const channelToken = makeToken()
 
     await clearRuntimeArtifacts(paths)
     await writeState(runtimeDir, {
@@ -376,14 +349,9 @@ try {
       effort: laneEffort,
       subagent_model: subagentModel,
       tmux_session: tmuxSession,
-      channel_name: channelName,
-      channel_port: channelPort,
-      channel_token: channelToken,
       runtime_dir: paths.runtimeDir,
       settings_file: paths.settingsFile,
-      mcp_config_file: paths.mcpConfigFile,
       hook_events_file: paths.hookEventsFile,
-      channel_state_file: paths.channelStateFile,
       result_file: paths.resultFile,
       transcript_path: null,
       current_turn_id: null,
@@ -396,30 +364,17 @@ try {
       started_at: new Date().toISOString(),
     })
 
-    await Promise.all([
-      writeJsonIfNeeded(paths.settingsFile, buildHookSettings({
-        runtimeDir: paths.runtimeDir,
-        utilsDir,
-        agentName,
-        subagentModel,
-      })),
-      writeJsonIfNeeded(paths.mcpConfigFile, buildMcpConfig({
-        paths,
-        utilsDir,
-        channelName,
-        lane,
-        port: channelPort,
-        token: channelToken,
-      })),
-    ])
+    await writeJsonIfNeeded(paths.settingsFile, buildHookSettings({
+      runtimeDir: paths.runtimeDir,
+      utilsDir,
+      agentName,
+      subagentModel,
+    }))
 
     const launchCommand = buildClaudeLaunchCommand({
       claudeCommand,
       agentName,
-      displayName: lane,
       settingsFile: paths.settingsFile,
-      mcpConfigFile: paths.mcpConfigFile,
-      channelName,
       model: laneModel,
       effort: laneEffort,
       subagentModel,
@@ -440,7 +395,7 @@ try {
 
     emitTmuxLaunchHint({ tmuxSession, cwd })
 
-    const { event, channelState } = await waitForLaunchReadyWithRecovery({
+    const { event } = await waitForLaunchReadyWithRecovery({
       paths,
       tmuxSession,
       launchTimeoutMs,
@@ -455,7 +410,6 @@ try {
       transcript_path: transcriptPath,
       last_hook_event: 'SessionStart',
       last_error: null,
-      channel_status: channelState.status || 'ready',
       launch_attempt: attemptNumber,
       launch_attempts_total: attemptsTotal,
     })