theslopmachine 1.0.26-beta.2 → 1.0.26-beta.3

package/assets/slopmachine/utils/claude_live_common.mjs

@@ -274,7 +274,7 @@ export async function captureTmuxPaneArtifact(sessionName, filePath) {
 }
 
 export async function tmuxSendEnter(sessionName) {
-  return runCommand('tmux', ['send-keys', '-t', sessionName, 'Enter'])
+  return runCommand('tmux', ['send-keys', '-t', sessionName, 'C-m'])
 }
 
 export async function tmuxSendKeys(sessionName, ...keys) {
@@ -282,11 +282,37 @@ export async function tmuxSendKeys(sessionName, ...keys) {
 }
 
 export async function tmuxSendCommand(sessionName, command) {
-  return tmuxSendKeys(sessionName, command, 'Enter')
+  return tmuxSendKeys(sessionName, command, 'C-m')
+}
+
+async function executableExists(filePath) {
+  try {
+    await fs.access(filePath, fsConstants.X_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function resolveTmuxShell() {
+  const candidates = [
+    process.env.SHELL,
+    '/bin/zsh',
+    '/usr/bin/zsh',
+    '/bin/bash',
+    '/usr/bin/bash',
+    '/bin/sh',
+    '/usr/bin/sh',
+  ].filter(Boolean)
+
+  for (const candidate of candidates) {
+    if (await executableExists(candidate)) return candidate
+  }
+  return process.env.SHELL || '/bin/sh'
 }
 
 export async function tmuxStartShellSession(sessionName, cwd) {
-  const shell = process.env.SHELL || '/bin/zsh'
+  const shell = await resolveTmuxShell()
   const args = ['new-session', '-d', '-s', sessionName, '-c', cwd, shell]
   if (path.basename(shell) === 'zsh') args.push('-f')
   if (path.basename(shell) === 'bash') args.push('--noprofile', '--norc')
@@ -294,7 +320,7 @@ export async function tmuxStartShellSession(sessionName, cwd) {
 }
 
 export async function tmuxRespawnShellPane(sessionName, cwd) {
-  const shell = process.env.SHELL || '/bin/zsh'
+  const shell = await resolveTmuxShell()
   const args = ['respawn-pane', '-k', '-t', sessionName, '-c', cwd, shell]
   if (path.basename(shell) === 'zsh') args.push('-f')
   if (path.basename(shell) === 'bash') args.push('--noprofile', '--norc')
@@ -491,6 +517,10 @@ function detectClaudeStartupPrompt(pane) {
     return 'workspace-trust'
   }
 
+  if (pane.includes('Choose the text style that looks best with your terminal')) {
+    return 'theme-selection'
+  }
+
   return null
 }
 
@@ -537,6 +567,14 @@ export function detectClaudePopupOrBlockedPane(pane) {
   }
 
   const normalized = pane.toLowerCase()
+  if (normalized.includes('select login method') || normalized.includes('not logged in') || normalized.includes('run /login')) {
+    return 'login-required'
+  }
+
+  if (normalized.includes('cannot be used with root/sudo privileges')) {
+    return 'root-not-allowed'
+  }
+
   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'
   }

package/assets/slopmachine/utils/claude_live_launch.mjs

@@ -63,12 +63,25 @@ function shouldRetryFreshTmuxLaunch(error) {
   return [
     'claude_launch_no_sessionstart',
     'claude_launch_not_ready',
-    'claude_launch_prompt_blocked',
     'claude_launch_missing_session_id',
     'claude_orientation_submit_hook_missing',
   ].includes(code)
 }
 
+function hasProvenClaudeSession(state) {
+  if (!state?.sid) return false
+  if (!['idle', 'running', 'stopped'].includes(state.status)) return false
+  return Boolean(
+    state.last_hook_event === 'SessionStart'
+    || state.transcript_path
+    || state.orientation_verified_at
+  )
+}
+
+function resumableSidFromState(state) {
+  return hasProvenClaudeSession(state) ? state.sid : null
+}
+
 async function waitForLaunchReadyWithRecovery({ paths, runtimeDir, launchTimeoutMs }) {
   const windows = buildLaunchAttemptWindows(launchTimeoutMs)
   let lastInspection = null
@@ -380,18 +393,19 @@ try {
 }
 
 const paths = buildRuntimePaths(runtimeDir)
+let provenSidBeforeLaunch = null
 
 try {
   await ensureRuntimeDirs(paths)
 
   const existingState = await readJsonIfExists(paths.stateFile)
-  const preSessionFailedState = existingState
-    && existingState.status === 'failed'
-    && !existingState.sid
-    && !existingState.transcript_path
-    && !await tmuxHasSession(existingState.tmux_session)
+  provenSidBeforeLaunch = resumableSidFromState(existingState)
+  const existingTmuxAlive = existingState?.tmux_session ? await tmuxHasSession(existingState.tmux_session) : false
+  const incompleteLaunchState = existingState
+    && ['starting', 'failed'].includes(existingState.status)
+    && !hasProvenClaudeSession(existingState)
   let resumeSessionId = explicitResumeSessionId
-  if (!preSessionFailedState && existingState?.tmux_session && await tmuxHasSession(existingState.tmux_session)) {
+  if (!incompleteLaunchState && existingState?.tmux_session && existingTmuxAlive) {
     if (!replace) {
       const existingInspection = await inspectLaunchState(paths, existingState.tmux_session)
       const canReuseExistingClaudeProcess = existingState.status !== 'stopped' && !resumeRequested
@@ -420,7 +434,15 @@ try {
         process.exit(0)
       }
       if (existingState.status === 'stopped' || resumeRequested) {
-        resumeSessionId = resumeSessionId || existingState.sid || null
+        resumeSessionId = resumeSessionId || resumableSidFromState(existingState)
+        if (resumeRequested && !resumeSessionId) {
+          emitFailure('claude_live_resume_unproven_sid', 'Cannot resume: runtime state does not contain a proven Claude session id.', {
+            sid: existingState.sid || null,
+            state_file: paths.stateFile,
+            result_file: paths.resultFile,
+          })
+          process.exit(1)
+        }
         await writeState(runtimeDir, {
           status: 'starting',
           sid: resumeSessionId,
@@ -438,7 +460,7 @@ try {
         })
         process.exit(1)
       }
-      resumeSessionId = resumeSessionId || existingState.sid || null
+      resumeSessionId = resumeSessionId || resumableSidFromState(existingState)
       await writeState(runtimeDir, {
         status: 'starting',
         sid: resumeSessionId,
@@ -458,28 +480,30 @@ try {
         })
         process.exit(1)
       }
-      if (resumeRequested && !resumeSessionId) resumeSessionId = existingState.sid || null
+      if (resumeRequested && !resumeSessionId) resumeSessionId = resumableSidFromState(existingState)
     }
-  } else if (existingState && !preSessionFailedState && !replace && existingState.status && existingState.status !== 'stopped') {
-    if (!existingState.sid) {
-      emitFailure('claude_live_state_stale', 'Existing runtime state is stale and has no Claude session id to resume.', {
+  } else if (existingState && !incompleteLaunchState && !replace && existingState.status && existingState.status !== 'stopped') {
+    const existingSid = resumableSidFromState(existingState)
+    if (!existingSid) {
+      emitFailure('claude_live_state_stale', 'Existing runtime state is stale and has no proven Claude session id to resume.', {
         sid: existingState.sid || null,
         state_file: paths.stateFile,
         result_file: paths.resultFile,
       })
       process.exit(1)
     }
-    resumeSessionId = resumeSessionId || existingState.sid
+    resumeSessionId = resumeSessionId || existingSid
   } else if (resumeRequested && !resumeSessionId) {
-    if (!existingState?.sid) {
-      emitFailure('claude_live_resume_missing_sid', 'Cannot resume: no --resume-sid was provided and runtime state has no Claude session id.', {
-        sid: null,
+    const existingSid = resumableSidFromState(existingState)
+    if (!existingSid) {
+      emitFailure('claude_live_resume_missing_sid', 'Cannot resume: no --resume-sid was provided and runtime state has no proven Claude session id.', {
+        sid: existingState?.sid || null,
         state_file: paths.stateFile,
         result_file: paths.resultFile,
       })
       process.exit(1)
     }
-    resumeSessionId = existingState.sid
+    resumeSessionId = existingSid
   }
 
   const utilsDir = resolveUtilsDir()
@@ -491,20 +515,22 @@ try {
       : buildStableTmuxSessionName({ cwd })
 
     const tmuxAlreadyAlive = await tmuxHasSession(tmuxSession)
-    if (tmuxAlreadyAlive && !replace && !existingState?.tmux_session) {
+    const currentState = await readJsonIfExists(paths.stateFile)
+    if (tmuxAlreadyAlive && !replace && !existingState?.tmux_session && currentState?.tmux_session !== tmuxSession) {
       throw Object.assign(new Error(`Project tmux host already exists: ${tmuxSession}. Reuse the active runtime state or relaunch with --replace 1.`), {
         code: 'claude_live_tmux_name_in_use',
       })
     }
 
-    const resumingExistingLane = Boolean(resumeSessionId || existingState?.sid)
+    const provenExistingSid = resumableSidFromState(existingState)
+    const resumingExistingLane = Boolean(resumeSessionId || provenExistingSid)
     await clearRuntimeArtifacts(paths)
     await writeState(runtimeDir, {
       lane,
       backend: 'claude-live',
       status: 'starting',
       cwd,
-      sid: resumeSessionId || existingState?.sid || null,
+      sid: resumeSessionId || provenExistingSid,
       resume_from_sid: resumeSessionId,
       agent_name: agentName,
       model: laneModel,
@@ -667,6 +693,8 @@ try {
   }
   await writeState(runtimeDir, {
     status: 'failed',
+    sid: provenSidBeforeLaunch,
+    resume_from_sid: null,
     last_error: error instanceof Error ? error.message : String(error),
     cleanup_warning: cleanupWarning,
   })
@@ -674,7 +702,7 @@ try {
     ? error.code
     : 'claude_live_launch_failed'
   emitFailure(failureCode, error instanceof Error ? error.message : String(error), {
-    sid: state?.sid || null,
+    sid: provenSidBeforeLaunch,
     state_file: paths.stateFile,
     result_file: paths.resultFile,
   })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theslopmachine",
-  "version": "1.0.26-beta.2",
+  "version": "1.0.26-beta.3",
   "description": "SlopMachine installer and project bootstrap CLI",
   "license": "MIT",
   "type": "module",