@atolis-hq/wake 0.2.59 → 0.2.60

package/dist/src/adapters/claude/claude-runner.js

@@ -1,6 +1,6 @@
 import { parseClaudePrintResult, parseRunnerResult } from '../../domain/schema.js';
 import { runAgentCliCommand } from '../runner/cli-command.js';
-import { buildStagePrompt } from '../runner/stage-prompt.js';
+import { buildStagePrompt, sentinelListForApproval } from '../runner/stage-prompt.js';
 import { emitRuntimeEvent, runnerRuntimeEvent } from '../runner/runtime-events.js';
 import { writeRunnerTranscript } from '../runner/transcripts.js';
 import { createAgentExecution } from '../../core/live-execution.js';
@@ -120,6 +120,80 @@ function extractTokenUsage(parsed) {
     };
 }
 const CLAUDE_CLI_NAME = 'Claude';
+// Bounded — this is a single "just tell me the status" follow-up, not a
+// second attempt at the task, so it never needs more than one turn.
+const ENVELOPE_REPAIR_MAX_TURNS = 1;
+const ENVELOPE_REPAIR_TIMEOUT_MS = 60_000;
+function buildEnvelopeRepairPrompt(skipApproval) {
+    return [
+        'Your previous reply did not end with the required `wake-result` envelope, so it could not be parsed.',
+        'Reply with ONLY a fenced `wake-result` JSON block containing a `status` field, then repeat that status word on its own line after the closing fence.',
+        `The status must be exactly one of: ${sentinelListForApproval(skipApproval)}, reflecting the outcome of your previous turn.`,
+        'Do not repeat, summarize, or redo any of your previous work — this reply is parsed automatically and anything besides the envelope is discarded.',
+    ].join('\n');
+}
+function mergeTokenUsage(base, extra) {
+    if (extra === undefined) {
+        return base;
+    }
+    if (base === undefined) {
+        return extra;
+    }
+    return {
+        inputTokens: base.inputTokens + extra.inputTokens,
+        outputTokens: base.outputTokens + extra.outputTokens,
+        ...(base.cacheCreationInputTokens === undefined && extra.cacheCreationInputTokens === undefined
+            ? {}
+            : {
+                cacheCreationInputTokens: (base.cacheCreationInputTokens ?? 0) + (extra.cacheCreationInputTokens ?? 0),
+            }),
+        ...(base.cacheReadInputTokens === undefined && extra.cacheReadInputTokens === undefined
+            ? {}
+            : {
+                cacheReadInputTokens: (base.cacheReadInputTokens ?? 0) + (extra.cacheReadInputTokens ?? 0),
+            }),
+        ...(base.costUsd === undefined && extra.costUsd === undefined
+            ? {}
+            : { costUsd: (base.costUsd ?? 0) + (extra.costUsd ?? 0) }),
+        ...(base.turns === undefined && extra.turns === undefined
+            ? {}
+            : { turns: (base.turns ?? 0) + (extra.turns ?? 0) }),
+    };
+}
+// Asks the same (still-live) session to restate just its result envelope,
+// for the case where a run otherwise completed but the model forgot the
+// mandatory trailer — cheaper and more honest than defaulting the whole run
+// to BLOCKED because of a formatting slip. Returns undefined on any failure
+// so the caller falls back to the original (unparseable) result untouched.
+async function attemptEnvelopeRepair(input) {
+    const args = buildClaudePrintArgs({
+        model: input.model,
+        prompt: buildEnvelopeRepairPrompt(input.skipApproval),
+        sessionName: input.sessionName,
+        resumeSessionId: input.sessionId,
+        maxTurns: ENVELOPE_REPAIR_MAX_TURNS,
+    });
+    const result = await runClaudeCommand({
+        command: input.command,
+        args,
+        cwd: input.cwd,
+        timeoutMs: input.timeoutMs,
+    });
+    if (result.exitCode !== 0 || result.timedOut || result.stdout.trim().length === 0) {
+        return undefined;
+    }
+    try {
+        const parsed = parseClaudePrintOutput(result.stdout);
+        const repairTokenUsage = extractTokenUsage(parsed);
+        return {
+            text: parsed.result,
+            ...(repairTokenUsage === undefined ? {} : { tokenUsage: repairTokenUsage }),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
 export function classifyClaudeCliFailure(input) {
     if (input.timedOut) {
         return 'infra';
@@ -341,6 +415,30 @@ export function createClaudeRunner(options) {
             ...(parsed.session_id === undefined ? {} : { sessionId: parsed.session_id }),
         }));
         const tokenUsage = extractTokenUsage(parsed);
+        let effectiveResultText = parsed.result;
+        let effectiveTokenUsage = tokenUsage;
+        let envelopeRepaired = false;
+        if (parseRunnerResult(effectiveResultText).envelope === 'missing' &&
+            parsed.session_id !== undefined) {
+            const repair = await attemptEnvelopeRepair({
+                command: options.command,
+                cwd: input.workspacePath ?? options.cwd,
+                model,
+                sessionName,
+                sessionId: parsed.session_id,
+                skipApproval: stagePrompt.skipApproval,
+                timeoutMs: Math.min(options.settings.timeoutMs, ENVELOPE_REPAIR_TIMEOUT_MS),
+            });
+            if (repair !== undefined && parseRunnerResult(repair.text).envelope !== 'missing') {
+                effectiveResultText = `${effectiveResultText.trimEnd()}\n\n${repair.text.trim()}`;
+                effectiveTokenUsage = mergeTokenUsage(effectiveTokenUsage, repair.tokenUsage);
+                envelopeRepaired = true;
+                console.log(`[claude-run] envelope repair succeeded runId=${input.runId} sessionId=${parsed.session_id}`);
+            }
+            else {
+                console.error(`[claude-run] envelope repair failed runId=${input.runId} sessionId=${parsed.session_id}`);
+            }
+        }
         if (tokenUsage !== undefined) {
             await emitRuntimeEvent(input.onRuntimeEvent, runnerRuntimeEvent({
                 type: 'agent.usage.updated',
@@ -364,20 +462,21 @@ export function createClaudeRunner(options) {
             payload: { exitCode: result.exitCode, timedOut: result.timedOut },
         }));
         return {
-            result: parsed.result,
+            result: effectiveResultText,
             model,
             cli: CLAUDE_CLI_NAME,
-            ...(parseRunnerResult(parsed.result).status === 'FAILED'
+            ...(parseRunnerResult(effectiveResultText).status === 'FAILED'
                 ? { failureClass: 'task' }
                 : {}),
             ...(parsed.session_id === undefined ? {} : { session_id: parsed.session_id }),
-            ...(tokenUsage === undefined ? {} : { tokenUsage }),
+            ...(effectiveTokenUsage === undefined ? {} : { tokenUsage: effectiveTokenUsage }),
             metadata: {
                 stdout: result.stdout,
                 stderr: result.stderr,
                 raw: parsed,
                 skipApproval: stagePrompt.skipApproval,
                 allowAutoApproval: stagePrompt.allowAutoApproval,
+                ...(envelopeRepaired ? { envelopeRepaired: true } : {}),
                 ...(promptTranscriptPath === undefined ? {} : { promptTranscriptPath }),
                 ...(responseTranscriptPath === undefined ? {} : { responseTranscriptPath }),
                 ...(sandboxLog?.metadata ?? {}),

package/dist/src/adapters/runner/stage-prompt.js

@@ -82,7 +82,7 @@ function parseFrontmatterMaxTurns(input) {
     }
     return parsed;
 }
-function sentinelListForApproval(skipApproval) {
+export function sentinelListForApproval(skipApproval) {
     return skipApproval ? 'DONE, BLOCKED, FAILED' : 'AWAITING_APPROVAL, BLOCKED, FAILED';
 }
 function sentinelInstructionsForApproval(skipApproval) {
@@ -121,7 +121,7 @@ function buildHarnessPrompt(input) {
     if (input.upstreamChanges !== undefined && input.upstreamChanges.trim().length > 0) {
         lines.push('', 'Upstream update notice:', 'Before resuming this session, Wake pulled the latest default-branch changes into your workspace. New commits included:', input.upstreamChanges.trimEnd());
     }
-    lines.push('', 'Result envelope ABI:', 'Respond concisely. End your response with a fenced `wake-result` JSON block, then on its own line after the closing fence repeat the status word for degraded-mode fallback.', `The JSON \`status\` and final line must be exactly one of: ${sentinelListForApproval(input.skipApproval)}.`, sentinelInstructionsForApproval(input.skipApproval), 'The JSON object must contain only the `status` field. Do not add other fields.');
+    lines.push('', 'Result envelope ABI:', 'Respond concisely. End your response with a fenced `wake-result` JSON block, then on its own line after the closing fence repeat the status word for degraded-mode fallback.', `The JSON \`status\` and final line must be exactly one of: ${sentinelListForApproval(input.skipApproval)}.`, sentinelInstructionsForApproval(input.skipApproval), 'The JSON object must contain only the `status` field. Do not add other fields.', 'This envelope is mandatory, not optional formatting: an automated parser reads only your final lines, and a reply that omits it is discarded and treated as BLOCKED regardless of the work you actually completed.');
     if (input.prTrackingEnabled) {
         lines.push('', 'Artifact reporting:', 'If you created a pull request during this stage, report it before the result envelope by adding a fenced `wake-artifacts` JSON block:', '```wake-artifacts', '{ "artifacts": [{ "kind": "pr", "url": "<the PR URL>" }] }', '```', 'Only report a PR you actually created in this run. Omit the block entirely if you created no PR.');
     }
@@ -232,8 +232,9 @@ export async function buildStagePrompt(input) {
         commentSections,
         includeRepoDetails: resolvedWorkspaceMode === 'read-only',
     });
+    const envelopeReminder = 'Before you finish: end this reply with the `wake-result` envelope exactly as your instructions describe, or this run is discarded and marked BLOCKED.';
     return {
-        prompt: `${renderedTemplate}\n\n${untrustedDataBlock}`,
+        prompt: `${renderedTemplate}\n\n${untrustedDataBlock}\n\n${envelopeReminder}`,
         harnessPrompt: buildHarnessPrompt({
             skipApproval,
             prTrackingEnabled: input.config?.sources.github.enabled === true &&

package/dist/src/core/tick-runner.js

@@ -108,7 +108,7 @@ function classifyFailedRun(input) {
             ? 'unknown'
             : 'none';
     const failurePhase = input.failurePhase ??
-        (input.envelope === 'degraded' && input.sentinel === 'FAILED'
+        ((input.envelope === 'degraded' || input.envelope === 'missing') && input.sentinel === 'FAILED'
             ? 'result-parsing'
             : failurePhaseForRecord(input.record));
     let retrySafety;

package/dist/src/domain/schema.js

@@ -1117,7 +1117,11 @@ export function parseRunnerResult(result) {
         return {
             status: body.length === 0 ? 'FAILED' : 'BLOCKED',
             body,
-            envelope: 'degraded',
+            // No structured envelope AND no recognizable bare sentinel at all —
+            // distinct from 'degraded' (a deliberate bare-sentinel reply) so
+            // callers can retry a runner that simply forgot the trailer instead
+            // of trusting a fabricated BLOCKED/FAILED default.
+            envelope: 'missing',
         };
     }
     let removed = false;

package/dist/src/version.js

@@ -124,4 +124,4 @@ export function resolveWakeVersion(options = {}) {
     }
     return '0.1.0-dev';
 }
-export const wakeVersion = "g2fd2fbe";
+export const wakeVersion = "gf59c4fc";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.2.59",
+  "version": "0.2.60",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {