theslopmachine 0.6.1 → 0.6.2

package/assets/agents/slopmachine-claude.md

@@ -390,10 +390,10 @@ Timeout rule:
 - when you call the Claude create or resume wrappers through the OpenCode Bash tool, use a long-running timeout of at least `3600000` ms (1 hour)
 - do not use ordinary short Bash timeouts for Claude worker turns
 
-Use wrapper outputs as the owner-facing contract:
+Use wrapper files as the owner-facing contract:
 
-- success: compact parsed fields such as `sid` and `res`
-- failure: compact parsed fields such as `code` and `msg`
+- read the wrapper `result-file` after process completion and use that as the semantic Claude response contract
+- treat wrapper terminal stdout as only a tiny pointer or status channel
 - for long-running or flaky calls, inspect the wrapper `state-file` and `result-file` rather than treating Bash process lifetime alone as the source of truth
 
 Do not paste raw Claude JSON payloads into owner prompts, Beads comments, or metadata fields.

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

@@ -20,8 +20,9 @@ Use this skill whenever `slopmachine-claude` needs to create, resume, or message
 - do not read Claude transcript files as the normal communication channel
 - communicate with the Claude worker through the packaged wrapper scripts in `~/slopmachine/utils/`
 - treat raw Claude stdout and stderr as trace artifacts written to files, not as owner-session context
-- consume only the compact parsed wrapper output in normal owner flow
-- always capture the compact `sid` and `res` fields from wrapper output
+- treat the wrapper `result-file` as the semantic source of truth in normal owner flow
+- treat terminal stdout from the wrapper as only a tiny pointer or status channel
+- always capture the session id and normalized result from the `result-file`
 - always re-pass `--agent developer` on every call, even when resuming an existing session
 - always constrain Claude to a single-session developer lane by limiting tools to `Read Write Edit Bash Glob Grep`
 - do not allow Claude internal agent fan-out in the normal developer path
@@ -68,9 +69,9 @@ node ~/slopmachine/utils/claude_resume_session.mjs --cwd "$PWD" --session-id <se
 
 ## Result capture rule
 
-The wrapper scripts should reduce the raw Claude result to a tiny machine-parseable object and also persist state/result files for monitoring.
+The wrapper scripts should pipe the raw Claude JSON output to file, parse it after process exit, and persist a normalized `result-file` plus a live `state-file`.
 
-Use these fields only:
+Use the `result-file` fields only:
 
 - `sid`
 - `res`
@@ -84,6 +85,7 @@ Treat `res` as the worker's answer.
 Do not feed raw Claude JSON into the owner session.
 Do not rely on transcript scraping for normal turn-to-turn orchestration.
 Do not rely on Bash stdout alone when the wrapper state or result files provide a clearer source of truth.
+Read `result-file` after process completion before deciding the next owner turn.
 
 ## Developer-slot continuity
 

package/assets/slopmachine/utils/claude_create_session.mjs

@@ -18,25 +18,37 @@ try {
   })
 
   if (failure || !parsed || parsed.is_error === true) {
-    await writeJsonIfNeeded(argv['result-file'], {
+    const resultPayload = {
       ok: false,
       code: failure?.code || 'claude_create_failed',
       msg: failure?.msg || 'claude_create_failed',
       sid: failure?.sid || null,
+    }
+    await writeJsonIfNeeded(argv['result-file'], resultPayload)
+    emitFailure(failure?.code || 'claude_create_failed', failure?.msg || 'claude_create_failed', {
+      sid: failure?.sid || null,
+      result_file: argv['result-file'] || null,
+      state_file: argv['state-file'] || null,
     })
-    emitFailure(failure?.code || 'claude_create_failed', failure?.msg || 'claude_create_failed', failure?.sid ? { sid: failure.sid } : {})
     process.exit(1)
   }
 
   const compact = compactClaudeResult(parsed)
   await writeJsonIfNeeded(argv['result-file'], { ok: true, sid: compact.sid, res: compact.res })
-  emitSuccess(compact.sid, compact.res)
+  emitSuccess(compact.sid, {
+    result_file: argv['result-file'] || null,
+    state_file: argv['state-file'] || null,
+  })
 } catch (error) {
-  await writeJsonIfNeeded(argv['result-file'], {
+  const resultPayload = {
     ok: false,
     code: 'claude_create_exception',
     msg: error instanceof Error ? error.message : String(error),
+  }
+  await writeJsonIfNeeded(argv['result-file'], resultPayload)
+  emitFailure('claude_create_exception', error instanceof Error ? error.message : String(error), {
+    result_file: argv['result-file'] || null,
+    state_file: argv['state-file'] || null,
   })
-  emitFailure('claude_create_exception', error instanceof Error ? error.message : String(error))
   process.exit(1)
 }

package/assets/slopmachine/utils/claude_resume_session.mjs

@@ -18,25 +18,37 @@ try {
   })
 
   if (failure || !parsed || parsed.is_error === true) {
-    await writeJsonIfNeeded(argv['result-file'], {
+    const resultPayload = {
       ok: false,
       code: failure?.code || 'claude_resume_failed',
       msg: failure?.msg || 'claude_resume_failed',
       sid: failure?.sid || null,
+    }
+    await writeJsonIfNeeded(argv['result-file'], resultPayload)
+    emitFailure(failure?.code || 'claude_resume_failed', failure?.msg || 'claude_resume_failed', {
+      sid: failure?.sid || null,
+      result_file: argv['result-file'] || null,
+      state_file: argv['state-file'] || null,
     })
-    emitFailure(failure?.code || 'claude_resume_failed', failure?.msg || 'claude_resume_failed', failure?.sid ? { sid: failure.sid } : {})
     process.exit(1)
   }
 
   const compact = compactClaudeResult(parsed)
   await writeJsonIfNeeded(argv['result-file'], { ok: true, sid: compact.sid, res: compact.res })
-  emitSuccess(compact.sid, compact.res)
+  emitSuccess(compact.sid, {
+    result_file: argv['result-file'] || null,
+    state_file: argv['state-file'] || null,
+  })
 } catch (error) {
-  await writeJsonIfNeeded(argv['result-file'], {
+  const resultPayload = {
     ok: false,
     code: 'claude_resume_exception',
     msg: error instanceof Error ? error.message : String(error),
+  }
+  await writeJsonIfNeeded(argv['result-file'], resultPayload)
+  emitFailure('claude_resume_exception', error instanceof Error ? error.message : String(error), {
+    result_file: argv['result-file'] || null,
+    state_file: argv['state-file'] || null,
   })
-  emitFailure('claude_resume_exception', error instanceof Error ? error.message : String(error))
   process.exit(1)
 }

package/assets/slopmachine/utils/claude_worker_common.mjs

@@ -39,6 +39,11 @@ export async function writeJsonIfNeeded(filePath, value) {
   await writeFileIfNeeded(filePath, `${JSON.stringify(value, null, 2)}\n`)
 }
 
+export async function readJsonFile(filePath) {
+  const content = await fs.readFile(filePath, 'utf8')
+  return JSON.parse(content)
+}
+
 export async function readPrompt(promptFile) {
   const content = await fs.readFile(promptFile, 'utf8')
   return content.trim()
@@ -140,27 +145,27 @@ export async function runClaude({ claudeCommand, args, cwd, rawOutputPath, rawEr
       stdio: ['ignore', 'pipe', 'pipe'],
     })
 
-    let stdout = ''
-    let stderr = ''
+    let stdoutBytes = 0
+    let stderrBytes = 0
 
     void stateWriter.update({ status: 'running', pid: child.pid ?? null })
 
     child.stdout.on('data', (chunk) => {
       const text = chunk.toString()
-      stdout += text
       stdoutWriter?.write(text)
+      stdoutBytes += Buffer.byteLength(text, 'utf8')
       void stateWriter.update({
-        stdout_bytes: Buffer.byteLength(stdout, 'utf8'),
+        stdout_bytes: stdoutBytes,
         last_stdout_at: new Date().toISOString(),
       })
     })
 
     child.stderr.on('data', (chunk) => {
       const text = chunk.toString()
-      stderr += text
       stderrWriter?.write(text)
+      stderrBytes += Buffer.byteLength(text, 'utf8')
       void stateWriter.update({
-        stderr_bytes: Buffer.byteLength(stderr, 'utf8'),
+        stderr_bytes: stderrBytes,
         last_stderr_at: new Date().toISOString(),
       })
     })
@@ -174,7 +179,7 @@ export async function runClaude({ claudeCommand, args, cwd, rawOutputPath, rawEr
         finished_at: new Date().toISOString(),
         exit_code: code ?? 1,
       })
-      resolve({ code: code ?? 1, stdout, stderr })
+      resolve({ code: code ?? 1 })
     })
   })
 
@@ -186,8 +191,8 @@ export function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms))
 }
 
-export function emitSuccess(sessionId, result, extra = {}) {
-  process.stdout.write(JSON.stringify({ ok: true, sid: sessionId, res: result, ...extra }))
+export function emitSuccess(sessionId, extra = {}) {
+  process.stdout.write(JSON.stringify({ ok: true, sid: sessionId, ...extra }))
 }
 
 export function emitFailure(code, message, extra = {}) {
@@ -217,6 +222,13 @@ export function compactClaudeResult(parsed) {
   }
 }
 
+export async function parseClaudeResultFile(rawOutputPath) {
+  if (!rawOutputPath) {
+    throw new Error('rawOutputPath is required to parse Claude result files')
+  }
+  return readJsonFile(rawOutputPath)
+}
+
 export function classifyClaudeFailure(parsed, fallbackMessage = '') {
   const rawMessage = String(parsed?.result || fallbackMessage || '').trim()
   const sessionId = parsed?.session_id || null
@@ -286,14 +298,24 @@ export async function runClaudeWithRetry({ claudeCommand, args, cwd, rawOutputPa
     const result = await runClaude({ claudeCommand, args, cwd, rawOutputPath, rawErrorPath, statePath, attempt })
     let parsed = null
     try {
-      parsed = parseClaudeJson(result.stdout)
+      parsed = await parseClaudeResultFile(rawOutputPath)
     } catch {}
 
     if (parsed && parsed.is_error !== true && result.code === 0) {
       return { result, parsed, attempts: attempt }
     }
 
-    const failure = classifyClaudeFailure(parsed, (result.stderr || result.stdout).trim())
+    let stderrText = ''
+    try {
+      stderrText = rawErrorPath ? await fs.readFile(rawErrorPath, 'utf8') : ''
+    } catch {}
+
+    let stdoutText = ''
+    try {
+      stdoutText = rawOutputPath ? await fs.readFile(rawOutputPath, 'utf8') : ''
+    } catch {}
+
+    const failure = classifyClaudeFailure(parsed, (stderrText || stdoutText).trim())
     const canRetry = attempt < maxAttempts && (failure.retryable || (!parsed && result.code !== 0))
     if (!canRetry) {
       return { result, parsed, failure, attempts: attempt }

package/package.json

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