theslopmachine 0.7.5 → 0.7.6

package/README.md

@@ -170,6 +170,8 @@ Important details:
 - `--adopt` moves the current project files into `repo/`, preserves root workflow state in the parent workspace, and skips the automatic bootstrap commit
 - `--continue-from <PX>` is a smoother alias for existing-project bootstrap; it implies adoption mode and seeds the requested start phase in one step
 - if `--continue-from <PX>` is run while your current working directory is already the real project `repo/`, SlopMachine automatically treats `..` as the workspace root and writes the workflow state there instead of creating `repo/repo`
+- when a later start phase is seeded for adoption or recovery, the Beads workflow phases before that requested phase are created and immediately marked completed so tracker state matches the seeded entry point
+- in the `slopmachine-claude` path, if adopted or resumed later-phase work has no recoverable tracked Claude developer session yet, the owner must launch and orient the needed Claude lane first and only then continue the substantive work in that same session
 - `--phase <PX>` seeds the initial `current_phase` for adoption/recovery bootstrap; the owner should still fall back if the real repo evidence does not support that later phase
 
 ### `slopmachine set-token`

package/assets/agents/slopmachine-claude.md

@@ -209,6 +209,7 @@ Maintain exactly one active developer session at a time.
 - the live Claude lane must run the installed Claude `developer` agent for normal work, and implementation-capable helper branches should stay developer-scoped when the environment supports explicit agent selection
 - launch Claude lanes with an explicit model choice rather than relying on the CLI default: use `opus` with `medium` effort for normal work, raise to `opus` with `xhigh` effort only when the planning/debugging/security difficulty genuinely justifies it, use `sonnet` with `medium` effort for documentation-heavy or otherwise simpler work, and keep helper subagents on `sonnet` by default unless there is a concrete reason to raise them too
 - do not create a fresh `develop-N` Claude session unless controlled replacement or explicit user direction actually requires it
+- if adopted or resumed work needs Claude developer execution but no recoverable tracked Claude session exists yet, determine the correct lane for the current boundary, launch and orient that lane through `claude-worker-management`, persist the returned session id, and only then continue the substantive work
 - when `P7` begins, do not automatically switch away from `develop-N`
 - each fresh evaluation result decides the remediation lane:
   - `fail` -> route the issue list back to the latest `develop-N` Claude session and discard the working audit report file after triage
@@ -231,6 +232,8 @@ Maintain exactly one active developer session at a time.
 
 Do not launch the developer before clarification is complete and the workflow is ready to enter `P2`.
 
+If later-phase adopted or repaired work reaches scaffold, development, verification, hardening, or evaluator remediation with no recoverable Claude session yet, do not stall there or treat the absence itself as a blocker. Launch the required live Claude lane first, complete its first orientation exchange, persist the session id and lane metadata, and then continue the bounded work in that same session.
+
 When the first develop developer session begins in `P2`, start it in this exact order through the live bridge:
 
 1. launch the live `develop-1` Claude `developer` lane

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

@@ -37,6 +37,23 @@ Use this skill whenever `slopmachine-claude` needs to launch, inspect, or messag
 - each substantive message should state the current engineering boundary, exact expected outcomes for that turn, the evidence required back, the important shortcuts that are not acceptable, and the stopping point
 - default to one bounded engineering objective per owner turn; if a request would naturally cross planning, scaffold, development, or gate-review boundaries, split it into separate turns
 
+## Session-presence rule
+
+Before any Claude-backed developer work continues:
+
+- determine whether the intended developer lane already has a recoverable live Claude session
+- if the intended lane exists and its bridge state is recoverable, recover that same session and continue there
+- if the current workflow boundary requires Claude developer work and no recoverable session is present yet, launch the necessary Claude lane first instead of treating the missing session as a handoff blocker
+- do not send substantive work until the live lane exists, bridge registration has captured the Claude `session_id`, owner metadata and Beads comments have been synced, and the first session-start message for that lane has completed
+- a missing Claude session during adoption, conservative phase repair, or other first-entry work is not itself an error; it means the owner must establish the correct live lane before continuing
+
+Choose the first-launch action by boundary:
+
+- `P2` planning entry with no Claude session yet -> launch `develop-1` and perform the planning handshake
+- `P3` through `P6` entry with no recoverable `develop-N` session yet -> launch the appropriate `develop-N` lane, orient it to the current repo state, then continue with the bounded scaffold, development, verification, or hardening turn
+- `P7` remediation routed to `develop-N` after a `fail` audit with no recoverable develop session yet -> launch the intended `develop-N` lane, orient it to the current delivered repo state and upcoming evaluator-driven remediation, then continue with the issue list
+- `P7` remediation routed to `bugfix-N` after a `partial pass` audit -> launch the fresh `bugfix-N` lane and use the bugfix orientation handshake below
+
 ## Lane launch rule
 
 For a new bounded developer session slot:
@@ -80,11 +97,12 @@ The default pattern is to let the live lane start normally and then persist the
 For all later turns in the same bounded developer slot:
 
 ```bash
-printf '%s' "$PROMPT" | node ~/slopmachine/utils/claude_live_turn.mjs --runtime-dir <dir> --timeout-ms <turn-timeout>
+printf '%s' "$PROMPT" | node ~/slopmachine/utils/claude_live_turn.mjs --runtime-dir <dir> --prompt-stdin 1 --timeout-ms <turn-timeout>
 ```
 
 - inject exactly one message at a time into the idle live lane
 - pass the prompt directly to the wrapper through stdin as the primary input path instead of requiring an owner-side prompt file
+- when invoking the turn wrapper from the OpenCode Bash tool, pass `--prompt-stdin 1` explicitly so prompt detection does not depend on host stdin/TTY quirks
 - wait for `Stop` or `StopFailure` before sending the next message
 - do not bypass the bridge by calling the channel HTTP endpoint directly from owner logic
 - if turn execution fails, stop and recover explicitly instead of silently creating a new worker
@@ -286,6 +304,25 @@ Do not tell the developer worker to read files outside `repo/`.
 If project-lead artifacts outside `repo/` matter, restate their content directly in the message instead of passing file paths.
 Do not mention session names, slot labels, or workflow phase labels to the developer worker.
 
+### Adopted or repaired `develop-N` orientation handshake
+
+When work enters scaffold, development, integrated verification, hardening, or `fail`-routed remediation without a recoverable `develop-N` Claude session yet:
+
+1. launch the live `develop-N` lane needed for that boundary
+2. use the first message only to orient that session to the current repo and delivered state
+3. make clear in plain engineering language that the codebase already exists and work is continuing from the current state rather than starting from zero
+4. say what kind of bounded follow-up work will come next, such as scaffold completion, a development slice, verification corrections, hardening, or evaluator-driven remediation
+5. wait for the first response and store the Claude session id from bridge `state.json`
+6. only after that orientation exchange, continue the same live lane with the first bounded work request
+
+The orientation message should:
+
+- identify the project and current repo as the working context
+- summarize the current delivered state and the accepted constraints that matter immediately
+- restate only the current engineering boundary and the next work type that will be requested after orientation
+- avoid broad replanning unless the owner has intentionally reopened planning
+- avoid mentioning workflow internals, phase labels, or session-lane labels
+
 ### `bugfix-N` orientation handshake
 
 When a fresh `partial pass` evaluation result opens the next remediation lane:

package/assets/skills/developer-session-lifecycle/SKILL.md

@@ -206,6 +206,8 @@ Keep `../metadata.json` focused on project facts and exported project metadata w
 
 - if session or phase records disagree, stop and repair the inconsistency before proceeding
 - if the current phase already has an active developer session, recover it instead of silently creating a replacement
+- if an adopted, resumed, or conservatively repaired run reaches a developer-work boundary with no recoverable Claude session yet, treat that as a controlled first-launch case rather than a fatal inconsistency; choose the correct lane for the current boundary and hand off to `claude-worker-management` to launch and orient it before work continues
+- if the current boundary requires Claude developer work but `active_developer_session_id` is still empty, do not continue substantive phase work until the missing-session case has been repaired by recovering or launching the intended lane
 - if an evaluator session is marked active, recover it before continuing the current `P7` cycle
 - treat live-lane recovery as deterministic recovery, not guesswork
 - if the active Claude developer session is marked `rate_limited`, do not replace it with owner-side coding; preserve it, record the blocked state, and auto-wait for reset or resume from the same session when the wait helper completes

package/assets/slopmachine/utils/claude_live_common.mjs

@@ -8,9 +8,9 @@ import crypto from 'node:crypto'
 import { fileURLToPath } from 'node:url'
 import { spawn } from 'node:child_process'
 
-import { emitFailure, emitSuccess, extractRateLimitMetadata, parseArgs, readJsonFile, readPrompt, sleep, waitForRateLimitReset, writeFileIfNeeded, writeJsonIfNeeded } from './claude_worker_common.mjs'
+import { emitFailure, emitSuccess, extractRateLimitMetadata, parseArgs, readJsonFile, readPrompt, readPromptInput, sleep, waitForRateLimitReset, writeFileIfNeeded, writeJsonIfNeeded } from './claude_worker_common.mjs'
 
-export { emitFailure, emitSuccess, parseArgs, readPrompt, sleep, waitForRateLimitReset, writeJsonIfNeeded }
+export { emitFailure, emitSuccess, parseArgs, readPrompt, readPromptInput, sleep, waitForRateLimitReset, writeJsonIfNeeded }
 
 export const DEFAULT_LAUNCH_TIMEOUT_MS = 3600000
 export const DEFAULT_TURN_TIMEOUT_MS = 3600000
@@ -170,17 +170,56 @@ export async function waitFor(predicate, { timeoutMs, intervalMs = DEFAULT_POLL_
   throw new Error(errorMessage)
 }
 
-export async function maybeAcceptDevelopmentChannelsPrompt(sessionName, timeoutMs = 30000) {
+function detectClaudeStartupPrompt(pane) {
+  if (!pane) {
+    return null
+  }
+
+  if (
+    pane.includes('Quick safety check:')
+    || pane.includes('Yes, I trust this folder')
+    || pane.includes('Accessing workspace:')
+  ) {
+    return 'workspace-trust'
+  }
+
+  if (
+    pane.includes('WARNING: Loading development channels')
+    || pane.includes('I am using this for local development')
+  ) {
+    return 'development-channels'
+  }
+
+  return null
+}
+
+export async function maybeAcceptClaudeStartupPrompts(sessionName, timeoutMs = 30000) {
   const deadline = Date.now() + timeoutMs
+  let lastAcceptedPrompt = null
+  let lastAcceptedAt = 0
+
   while (Date.now() < deadline) {
     const pane = await tmuxCapturePane(sessionName)
     if (pane.includes('Listening for channel messages from:')) {
       return false
     }
-    if (pane.includes('I am using this for local development')) {
-      await tmuxSendEnter(sessionName)
-      return true
+
+    const promptKind = detectClaudeStartupPrompt(pane)
+    if (promptKind) {
+      const now = Date.now()
+      if (promptKind !== lastAcceptedPrompt || now - lastAcceptedAt >= 1500) {
+        lastAcceptedPrompt = promptKind
+        lastAcceptedAt = now
+        await tmuxSendEnter(sessionName)
+      }
+
+      await sleep(DEFAULT_POLL_INTERVAL_MS)
+      continue
     }
+
+    lastAcceptedPrompt = null
+    lastAcceptedAt = 0
+
     await sleep(DEFAULT_POLL_INTERVAL_MS)
   }
   return false

package/assets/slopmachine/utils/claude_live_launch.mjs

@@ -15,7 +15,7 @@ import {
   ensureRuntimeDirs,
   makeSuffix,
   makeToken,
-  maybeAcceptDevelopmentChannelsPrompt,
+  maybeAcceptClaudeStartupPrompts,
   parseArgs,
   readJsonIfExists,
   resolveUtilsDir,
@@ -147,7 +147,7 @@ try {
     process.exit(1)
   }
 
-  await maybeAcceptDevelopmentChannelsPrompt(tmuxSession, Math.min(launchTimeoutMs, 30000))
+  await maybeAcceptClaudeStartupPrompts(tmuxSession, launchTimeoutMs)
 
   const [{ event }, channelState] = await Promise.all([
     waitForHookEvent(paths, 0, new Set(['SessionStart']), launchTimeoutMs),

package/assets/slopmachine/workflow-init.js

@@ -9,6 +9,7 @@ const target = path.resolve(process.cwd(), targetInput)
 const beadsCommand = process.env.BR_COMMAND || 'br'
 
 const ROOT_TITLE = 'SlopMachine Workflow'
+const PHASE_KEYS = ['P1', 'P2', 'P3', 'P4', 'P5', 'P6', 'P7', 'P8', 'P9', 'P10']
 const PHASE_TITLES = [
   'P1 Clarification',
   'P2 Planning',
@@ -21,6 +22,7 @@ const PHASE_TITLES = [
   'P9 Submission Packaging',
   'P10 Retrospective',
 ]
+const requestedStartPhase = process.env.SLOPMACHINE_REQUESTED_START_PHASE || null
 
 function log(message) {
   console.log(`[workflow-init] ${message}`)
@@ -115,10 +117,17 @@ async function ensureLifecycleSeeded() {
 
   log('Seeding workflow root and P1-P10 phases')
   const rootId = await createIssue(ROOT_TITLE)
+  const requestedStartIndex = requestedStartPhase ? PHASE_KEYS.indexOf(requestedStartPhase) : -1
+
+  if (requestedStartPhase && requestedStartIndex === -1) {
+    die(`Unsupported requested start phase '${requestedStartPhase}'. Use one of: ${PHASE_KEYS.join(', ')}`)
+  }
 
   let previousPhaseId = null
+  const phaseIds = []
   for (const title of PHASE_TITLES) {
     const phaseId = await createIssue(title)
+    phaseIds.push(phaseId)
 
     const parentResult = await runBeads(['update', phaseId, '--parent', rootId], { env: { ...process.env, CI: '1' } })
     if (parentResult.code !== 0) {
@@ -136,6 +145,17 @@ async function ensureLifecycleSeeded() {
 
     previousPhaseId = phaseId
   }
+
+  if (requestedStartIndex > 0) {
+    log(`Closing phases before requested start phase ${requestedStartPhase}`)
+    for (let index = 0; index < requestedStartIndex; index += 1) {
+      const closeResult = await runBeads(['close', phaseIds[index]], { env: { ...process.env, CI: '1' } })
+      if (closeResult.code !== 0) {
+        console.error(`${closeResult.stdout}${closeResult.stderr}`.trim())
+        die(`Failed to close seeded phase '${PHASE_TITLES[index]}' before '${requestedStartPhase}'.`)
+      }
+    }
+  }
 }
 
 async function main() {

package/package.json

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

package/src/init.js

@@ -315,6 +315,7 @@ async function runWorkflowBootstrap(paths, targetPath, trackerScript) {
     env: {
       ...process.env,
       BR_COMMAND: trackerCommand || '',
+      SLOPMACHINE_REQUESTED_START_PHASE: options.requestedStartPhase || '',
       HOME: paths.home,
     },
   })