theslopmachine 1.0.6 → 1.0.7

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.

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,
     })

package/assets/slopmachine/utils/claude_live_status.mjs

@@ -7,7 +7,6 @@ import {
   classifyStopFailure,
   parseArgs,
   printUsageAndExit,
-  readJsonIfExists,
   readJsonl,
   readPrompt,
   readState,
@@ -36,9 +35,8 @@ if (!state) {
 }
 
 const paths = buildRuntimePaths(runtimeDir)
-let [tmuxAlive, channelState, hookEvents] = await Promise.all([
+let [tmuxAlive, hookEvents] = await Promise.all([
   tmuxHasSession(state.tmux_session),
-  readJsonIfExists(paths.channelStateFile),
   readJsonl(paths.hookEventsFile),
 ])
 
@@ -116,15 +114,13 @@ async function reconcileInterruptedTurn() {
 
 if (await reconcileInterruptedTurn()) {
   state = await readState(runtimeDir)
-  ;[tmuxAlive, channelState, hookEvents] = await Promise.all([
+  ;[tmuxAlive, hookEvents] = await Promise.all([
     tmuxHasSession(state.tmux_session),
-    readJsonIfExists(paths.channelStateFile),
     readJsonl(paths.hookEventsFile),
   ])
 }
 
 const sessionStart = hookEvents.find((event) => event?.label === 'SessionStart') || null
-const channelReady = Boolean(channelState?.ready_for_notifications)
 
 function deriveHealthCode() {
   if (state.status === 'stopped') return 'stopped'
@@ -151,12 +147,10 @@ function deriveHealthCode() {
   }
 
   if (state.status === 'starting') {
-    if (sessionStart && channelReady && state.sid) return 'ready'
+    if (sessionStart && state.sid) return 'ready'
     if (state.launch_recovery_code === 'claude_launch_rate_limited') return 'startup_rate_limited'
     if (state.launch_recovery_code === 'claude_launch_prompt_blocked') return 'startup_prompt_blocked'
-    if (sessionStart && channelReady && !state.sid) return 'partial_ready_missing_session_id'
-    if (sessionStart && !channelReady) return 'partial_ready_missing_channel'
-    if (!sessionStart && channelReady) return 'partial_ready_missing_sessionstart'
+    if (sessionStart && !state.sid) return 'partial_ready_missing_session_id'
     return 'starting'
   }
 
@@ -164,13 +158,10 @@ function deriveHealthCode() {
 }
 
 const healthCode = deriveHealthCode()
-const { channel_token: _channelToken, ...safeState } = state
 process.stdout.write(JSON.stringify({
   ok: true,
-  ...safeState,
+  ...state,
   health_code: healthCode,
   tmux_alive: tmuxAlive,
-  channel_ready: channelReady,
   session_start_seen: Boolean(sessionStart),
-  channel_state_status: channelState?.status || null,
 }))

package/assets/slopmachine/utils/claude_live_turn.mjs

@@ -12,20 +12,18 @@ import {
   buildTurnId,
   captureTmuxPaneArtifact,
   classifyStopFailure,
-  detectClaudeDevelopmentChannelDisabled,
   emitFailure,
   emitSuccess,
   maybeDismissClaudeRateLimitPrompt,
-  postPromptToChannel,
+  prepareClaudePaneForPrompt,
   parseArgs,
   printUsageAndExit,
   readJsonl,
   readPrompt,
   readState,
   tmuxHasSession,
-  tmuxCapturePane,
+  tmuxPasteFileAndEnter,
   waitForRateLimitReset,
-  waitForChannelReady,
   waitForHookEvent,
   writeState,
   writeTurnArtifacts,
@@ -82,7 +80,11 @@ try {
     process.exit(1)
   }
 
-  if (state.status !== 'idle') {
+  const resumingRateLimitTurn = state.status === 'blocked'
+    && Boolean(state.current_turn_id)
+    && Boolean(state.rate_limit_wait_until || state.rate_limit_reset_at)
+
+  if (state.status !== 'idle' && !resumingRateLimitTurn) {
     const resultPayload = buildFailureResult('claude_live_turn_not_idle', `Claude live lane is not idle: ${state.status}`, state.sid || null)
     emitTurnFailure(resultPayload)
     process.exit(1)
@@ -104,17 +106,6 @@ try {
     process.exit(1)
   }
 
-  const pane = await tmuxCapturePane(state.tmux_session)
-  if (detectClaudeDevelopmentChannelDisabled(pane)) {
-    await writeState(runtimeDir, {
-      status: 'failed',
-      last_error: 'Claude development channels are disabled in the live tmux session; restart the lane before sending a prompt.',
-    })
-    const resultPayload = buildFailureResult('claude_development_channels_disabled', 'Claude development channels are disabled in the live tmux session; restart the lane before sending a prompt.', state.sid)
-    emitTurnFailure(resultPayload)
-    process.exit(1)
-  }
-
   prompt = await readPrompt(promptSource)
   originalPrompt = prompt
   if (!prompt.trim()) {
@@ -125,34 +116,73 @@ try {
 
   let hookStartIndex = (await readJsonl(paths.hookEventsFile)).length
   const turnNumber = Number(state.last_turn_number || 0)
-  const turnId = buildTurnId(turnNumber)
+  const turnId = resumingRateLimitTurn ? state.current_turn_id : buildTurnId(turnNumber)
   const turnDir = path.join(paths.turnsDir, turnId)
-  const stagedPromptFile = path.join(turnDir, 'prompt.txt')
+  const stagedPromptFile = resumingRateLimitTurn && state.current_turn_prompt_file
+    ? state.current_turn_prompt_file
+    : path.join(turnDir, 'prompt.txt')
   await fs.mkdir(turnDir, { recursive: true })
-  await fs.writeFile(stagedPromptFile, `${prompt}\n`, 'utf8')
 
-  await writeState(runtimeDir, {
-    status: 'running',
-    current_turn_id: turnId,
-    current_turn_prompt_file: stagedPromptFile,
-    current_turn_prompt_source: promptSource,
-    current_turn_started_at: new Date().toISOString(),
-    last_error: null,
-  })
+  if (resumingRateLimitTurn) {
+    const waitInfo = await waitForRateLimitReset({
+      message: state.rate_limit_message || state.last_error || 'rate_limit',
+      resetAt: state.rate_limit_reset_at || state.rate_limit_wait_until,
+      rateLimitType: state.rate_limit_type || null,
+      rawResetAt: state.rate_limit_raw_reset_at ?? null,
+      statePath: paths.stateFile,
+    })
+    prompt = buildRateLimitContinuationPrompt({ originalPrompt, waitInfo })
+    await fs.writeFile(stagedPromptFile, `${prompt}\n`, 'utf8')
+    await writeState(runtimeDir, {
+      status: 'running',
+      current_turn_id: turnId,
+      current_turn_prompt_file: stagedPromptFile,
+      current_turn_prompt_source: state.current_turn_prompt_source || promptSource,
+      current_turn_started_at: new Date().toISOString(),
+      rate_limit_continuation_prompt_file: stagedPromptFile,
+      last_error: null,
+    })
+  } else {
+    await fs.writeFile(stagedPromptFile, `${prompt}\n`, 'utf8')
+
+    await writeState(runtimeDir, {
+      status: 'running',
+      current_turn_id: turnId,
+      current_turn_prompt_file: stagedPromptFile,
+      current_turn_prompt_source: promptSource,
+      current_turn_started_at: new Date().toISOString(),
+      last_error: null,
+    })
+  }
 
   while (true) {
     const liveState = await readState(runtimeDir) || state
 
-    await waitForChannelReady(paths, 15000)
-
-    const sendResult = await postPromptToChannel({
-      state: liveState,
-      prompt,
-      turnId,
+    const paneReady = await prepareClaudePaneForPrompt(liveState.tmux_session || state.tmux_session, {
+      statePath: paths.stateFile,
+      timeoutMs: 30000,
     })
 
-    if (sendResult.statusCode !== 200) {
-      const resultPayload = buildFailureResult('channel_send_failed', sendResult.body || `Channel send failed with status ${sendResult.statusCode}`, liveState.sid || state.sid)
+    if (paneReady.blocker === 'rate-limit') {
+      prompt = buildRateLimitContinuationPrompt({ originalPrompt, waitInfo: paneReady.wait_info })
+      await fs.writeFile(stagedPromptFile, `${prompt}\n`, 'utf8')
+      await writeState(runtimeDir, {
+        status: 'running',
+        current_turn_id: turnId,
+        current_turn_prompt_file: stagedPromptFile,
+        current_turn_prompt_source: promptSource,
+        current_turn_started_at: new Date().toISOString(),
+        rate_limit_popup_dismissed: paneReady.popup_dismissed,
+        rate_limit_continuation_prompt_file: stagedPromptFile,
+        last_error: null,
+      })
+      continue
+    }
+
+    if (!paneReady.ready) {
+      const blockerFile = path.join(turnDir, `prompt-blocked-pane-${Date.now()}.txt`)
+      await captureTmuxPaneArtifact(liveState.tmux_session || state.tmux_session, blockerFile)
+      const resultPayload = buildFailureResult('claude_prompt_injection_blocked', `Claude pane is not ready for prompt injection: ${paneReady.blocker || 'unknown'}`, liveState.sid || state.sid)
       await writeTurnArtifacts(paths, turnId, prompt, resultPayload, argv['result-file'] || null)
       await writeState(runtimeDir, {
         status: 'failed',
@@ -163,6 +193,7 @@ try {
         last_completed_turn_id: turnId,
         last_turn_number: turnNumber + 1,
         last_error: resultPayload.msg,
+        prompt_blocked_pane_file: blockerFile,
         rate_limit_wait_started_at: null,
         rate_limit_wait_until: null,
         rate_limit_wait_ms: null,
@@ -176,6 +207,36 @@ try {
       process.exit(1)
     }
 
+    const bufferName = `sm-${turnId}-${Date.now()}`
+    await writeState(runtimeDir, {
+      current_turn_transport: 'tmux-paste-buffer',
+      current_turn_prompt_injected_at: null,
+      current_turn_prompt_buffer: bufferName,
+    })
+
+    const sendResult = await tmuxPasteFileAndEnter(liveState.tmux_session || state.tmux_session, stagedPromptFile, bufferName)
+    if (sendResult.code !== 0) {
+      const resultPayload = buildFailureResult('tmux_prompt_send_failed', sendResult.stderr.trim() || sendResult.stdout.trim() || 'Failed to paste prompt into Claude tmux pane', liveState.sid || state.sid)
+      await writeTurnArtifacts(paths, turnId, prompt, resultPayload, argv['result-file'] || null)
+      await writeState(runtimeDir, {
+        status: 'failed',
+        current_turn_id: null,
+        current_turn_prompt_file: null,
+        current_turn_prompt_source: null,
+        current_turn_started_at: null,
+        current_turn_transport: 'tmux-paste-buffer',
+        last_completed_turn_id: turnId,
+        last_turn_number: turnNumber + 1,
+        last_error: resultPayload.msg,
+      })
+      emitTurnFailure(resultPayload)
+      process.exit(1)
+    }
+
+    await writeState(runtimeDir, {
+      current_turn_prompt_injected_at: new Date().toISOString(),
+    })
+
     const { event, eventsLength } = await waitForHookEvent(
       paths,
       hookStartIndex,
@@ -229,9 +290,14 @@ try {
       const tmuxSession = liveState.tmux_session || state.tmux_session
       const blockedPaneFile = path.join(turnDir, `rate-limit-pane-${Date.now()}-blocked.txt`)
       const dismissedPaneFile = path.join(turnDir, `rate-limit-pane-${Date.now()}-dismissed.txt`)
-      await captureTmuxPaneArtifact(tmuxSession, blockedPaneFile)
+      const blockedPane = await captureTmuxPaneArtifact(tmuxSession, blockedPaneFile)
       const popupDismissed = await maybeDismissClaudeRateLimitPrompt(tmuxSession)
-      await captureTmuxPaneArtifact(tmuxSession, dismissedPaneFile)
+      const dismissedPane = await captureTmuxPaneArtifact(tmuxSession, dismissedPaneFile)
+      const rateLimitMessage = [
+        resultPayload.detail || resultPayload.msg,
+        blockedPane,
+        dismissedPane,
+      ].filter(Boolean).join('\n\n')
       await writeState(runtimeDir, {
         status: 'blocked',
         sid: resultPayload.sid || liveState.sid || state.sid,
@@ -241,9 +307,10 @@ try {
         rate_limit_popup_dismissed: popupDismissed,
         rate_limit_blocked_pane_file: blockedPaneFile,
         rate_limit_dismissed_pane_file: dismissedPaneFile,
+        rate_limit_message_source: 'hook_and_tmux_pane',
       })
       const waitInfo = await waitForRateLimitReset({
-        message: resultPayload.detail || resultPayload.msg,
+        message: rateLimitMessage,
         resetAt: resultPayload.rate_limit?.resetAt || null,
         rateLimitType: resultPayload.rate_limit?.rateLimitType || null,
         rawResetAt: resultPayload.rate_limit?.rawResetAt ?? null,

package/assets/slopmachine/utils/claude_wait_for_rate_limit_reset.mjs

@@ -25,15 +25,17 @@ try {
   const tmuxSession = argv['tmux-session'] || (existingState?.tmux_session ?? null)
   let blockedPaneFile = null
   let dismissedPaneFile = null
+  let blockedPane = ''
+  let dismissedPane = ''
   let popupDismissed = false
 
   if (tmuxSession) {
     const artifactDir = statePath ? path.dirname(statePath) : process.cwd()
     blockedPaneFile = path.join(artifactDir, `manual-rate-limit-pane-${Date.now()}-blocked.txt`)
     dismissedPaneFile = path.join(artifactDir, `manual-rate-limit-pane-${Date.now()}-dismissed.txt`)
-    await captureTmuxPaneArtifact(tmuxSession, blockedPaneFile)
+    blockedPane = await captureTmuxPaneArtifact(tmuxSession, blockedPaneFile)
     popupDismissed = await maybeDismissClaudeRateLimitPrompt(tmuxSession)
-    await captureTmuxPaneArtifact(tmuxSession, dismissedPaneFile)
+    dismissedPane = await captureTmuxPaneArtifact(tmuxSession, dismissedPaneFile)
     if (statePath) {
       await writeJsonIfNeeded(statePath, {
         ...(existingState || {}),
@@ -46,7 +48,7 @@ try {
   }
 
   const waitInfo = await waitForRateLimitReset({
-    message: argv.message || '',
+    message: [argv.message || '', blockedPane, dismissedPane].filter(Boolean).join('\n\n'),
     statePath,
     dryRun: argv['dry-run'] === '1',
     bufferMs: argv['buffer-ms'] ? Number.parseInt(argv['buffer-ms'], 10) : undefined,

package/assets/slopmachine/utils/claude_worker_common.mjs

@@ -516,7 +516,24 @@ function buildIsoFromParts({ year, month, day }, hours, minutes, offsetToken) {
   return `${year}-${paddedMonth}-${paddedDay}T${paddedHours}:${paddedMinutes}:00${offsetToken}`
 }
 
+function getOffsetTokenForTimeZone(date, timeZone) {
+  try {
+    const zonedParts = getZonedParts(date, timeZone)
+    const asUtc = Date.UTC(zonedParts.year, zonedParts.month - 1, zonedParts.day, zonedParts.hour, zonedParts.minute, zonedParts.second)
+    const offsetMinutes = Math.round((asUtc - date.getTime()) / 60000)
+    const sign = offsetMinutes >= 0 ? '+' : '-'
+    const absolute = Math.abs(offsetMinutes)
+    const hours = String(Math.floor(absolute / 60)).padStart(2, '0')
+    const minutes = String(absolute % 60).padStart(2, '0')
+    return `${sign}${hours}:${minutes}`
+  } catch {
+    return null
+  }
+}
+
 function parseTimeOnlyCandidate(candidate, now) {
+  const timeZoneMatch = candidate.match(/\(([A-Za-z_]+\/[A-Za-z_]+(?:\/[A-Za-z_]+)?)\)/)
+  const explicitTimeZone = timeZoneMatch?.[1] || null
   const match = candidate.match(/\b(today|tomorrow)?\s*(\d{1,2})(?::(\d{2}))?\s*(am|pm)?(?:\s*(UTC|GMT|Z|[+-]\d{2}:?\d{2}))?\b/i)
   if (!match) {
     return null
@@ -526,7 +543,7 @@ function parseTimeOnlyCandidate(candidate, now) {
   let hours = Number(match[2])
   const minutes = Number(match[3] || '0')
   const meridiem = match[4]?.toLowerCase() || null
-  const offsetToken = normalizeOffset(match[5] || null)
+  const offsetToken = normalizeOffset(match[5] || null) || (explicitTimeZone ? getOffsetTokenForTimeZone(now, explicitTimeZone) : null)
 
   if (meridiem) {
     if (hours === 12) hours = 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theslopmachine",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "SlopMachine installer and project bootstrap CLI",
   "license": "MIT",
   "type": "module",

package/src/constants.js

@@ -55,7 +55,6 @@ export const REQUIRED_SLOPMACHINE_FILES = [
   "templates/CLAUDE.md",
   "utils/claude_worker_common.mjs",
   "utils/claude_live_common.mjs",
-  "utils/claude_live_channel.mjs",
   "utils/claude_live_hook.py",
   "utils/claude_live_launch.mjs",
   "utils/claude_live_turn.mjs",

package/src/install.js

@@ -207,7 +207,8 @@ const OPENCODE_EVALUATOR_AGENT = {
   description: 'Static evaluator for immutable delivery audit reports',
   mode: 'subagent',
   model: 'openai/gpt-5.3-codex',
-  prompt: 'You are a static delivery evaluator. Follow the full audit prompt provided by the user exactly. Do not run code, tests, package managers, Docker, servers, browsers, or external services. Do not modify product code. Base every finding on static evidence with file paths and line references. Generate immutable standalone reports according to the requested output path and format.',
+  variant: 'medium',
+  thinkingLevel: 'medium',
   permission: {
     bash: 'deny',
     edit: 'deny',

package/assets/slopmachine/utils/claude_live_channel.mjs

@@ -1,188 +0,0 @@
-#!/usr/bin/env node
-
-import http from 'node:http'
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-import { parseArgs, writeJsonIfNeeded } from './claude_worker_common.mjs'
-
-const argv = parseArgs(process.argv.slice(2))
-const port = Number.parseInt(argv.port, 10)
-const token = argv.token
-const stateFile = argv['state-file']
-const logFile = argv['log-file']
-const channelName = argv['channel-name'] || 'slopmachine-channel'
-const lane = argv.lane || 'lane'
-
-const instructions = 'Messages arrive as <channel source="slopmachine" ...>. Treat them as ordinary inbound work requests and respond normally in the current Claude session. Do not look for or use any reply tool for this channel.'
-
-let buffer = ''
-let readyForNotifications = false
-let negotiatedProtocolVersion = '2025-11-25'
-
-function writeMessage(message) {
-  process.stdout.write(`${JSON.stringify(message)}\n`)
-}
-
-async function appendLog(record) {
-  const line = `${JSON.stringify({ ts: new Date().toISOString(), ...record })}\n`
-  await fs.mkdir(path.dirname(logFile), { recursive: true })
-  await fs.appendFile(logFile, line, 'utf8')
-}
-
-async function updateState(patch) {
-  await writeJsonIfNeeded(stateFile, {
-    channel_name: channelName,
-    lane,
-    pid: process.pid,
-    port,
-    ready_for_notifications: readyForNotifications,
-    protocol_version: negotiatedProtocolVersion,
-    updated_at: new Date().toISOString(),
-    ...patch,
-  })
-}
-
-async function handleRpc(message) {
-  if (message.method === 'initialize' && Object.prototype.hasOwnProperty.call(message, 'id')) {
-    negotiatedProtocolVersion = message.params?.protocolVersion || negotiatedProtocolVersion
-    await updateState({ status: 'initialized' })
-    writeMessage({
-      jsonrpc: '2.0',
-      id: message.id,
-      result: {
-        protocolVersion: negotiatedProtocolVersion,
-        capabilities: {
-          experimental: {
-            'claude/channel': {},
-          },
-        },
-        serverInfo: {
-          name: channelName,
-          version: '0.1.0',
-        },
-        instructions,
-      },
-    })
-    await appendLog({ type: 'initialize', message })
-    return
-  }
-
-  if (message.method === 'notifications/initialized') {
-    readyForNotifications = true
-    await updateState({ status: 'ready' })
-    await appendLog({ type: 'initialized' })
-    return
-  }
-
-  if (message.method === 'ping' && Object.prototype.hasOwnProperty.call(message, 'id')) {
-    writeMessage({ jsonrpc: '2.0', id: message.id, result: {} })
-    return
-  }
-
-  if (Object.prototype.hasOwnProperty.call(message, 'id')) {
-    writeMessage({
-      jsonrpc: '2.0',
-      id: message.id,
-      error: {
-        code: -32601,
-        message: `Method not found: ${message.method}`,
-      },
-    })
-  }
-}
-
-process.stdin.setEncoding('utf8')
-process.stdin.on('data', async (chunk) => {
-  buffer += chunk
-  while (true) {
-    const newlineIndex = buffer.indexOf('\n')
-    if (newlineIndex === -1) {
-      break
-    }
-    const line = buffer.slice(0, newlineIndex).trim()
-    buffer = buffer.slice(newlineIndex + 1)
-    if (!line) {
-      continue
-    }
-    try {
-      const message = JSON.parse(line)
-      await handleRpc(message)
-    } catch (error) {
-      await updateState({ status: 'failed', last_error: error instanceof Error ? error.message : String(error) })
-      await appendLog({ type: 'rpc_error', error: error instanceof Error ? error.message : String(error) })
-    }
-  }
-})
-
-process.stdin.on('end', async () => {
-  await updateState({ status: 'closed' })
-  process.exit(0)
-})
-
-await updateState({ status: 'starting' })
-
-const server = http.createServer(async (request, response) => {
-  if (request.method !== 'POST') {
-    response.writeHead(404)
-    response.end('not found')
-    return
-  }
-
-  if (request.headers['x-bridge-token'] !== token) {
-    response.writeHead(403)
-    response.end('forbidden')
-    return
-  }
-
-  if (!readyForNotifications) {
-    response.writeHead(503)
-    response.end('channel_not_ready')
-    return
-  }
-
-  let body = ''
-  for await (const chunk of request) {
-    body += chunk.toString()
-  }
-
-  const turnId = String(request.headers['x-turn-id'] || '').trim()
-  const notification = {
-    jsonrpc: '2.0',
-    method: 'notifications/claude/channel',
-    params: {
-      content: body,
-      meta: {
-        lane,
-        turn_id: turnId,
-        method: request.method,
-      },
-    },
-  }
-
-  writeMessage(notification)
-  await updateState({ status: 'ready', last_message_at: new Date().toISOString(), last_turn_id: turnId || null })
-  await appendLog({ type: 'notification', turn_id: turnId || null, body })
-  response.writeHead(200)
-  response.end('ok')
-})
-
-server.listen(port, '127.0.0.1', async () => {
-  await updateState({ status: 'listening' })
-  await appendLog({ type: 'listening' })
-})
-
-async function shutdown(code) {
-  await updateState({ status: 'closed' })
-  server.close(() => {
-    process.exit(code)
-  })
-}
-
-process.on('SIGINT', () => {
-  void shutdown(0)
-})
-
-process.on('SIGTERM', () => {
-  void shutdown(0)
-})