@galda/cli 0.10.95 → 0.10.96

package/engine/completion-contract.mjs

@@ -40,8 +40,46 @@ export const COMPLETION_CONTRACT_PROMPT = [
   '- The latest explicit user instruction can revise an older product decision or code comment. Treat old comments as context, not proof that the requested change is impossible. If the change has consequences, explain them and implement the latest request; only a real safety, permission, legal, or external-system constraint is a blocker.',
   '- A test must assert the observable outcome the user requested. Never replace the request with a tooltip, explanation, or a test that permanently preserves the opposite behavior.',
   '- Do not report a change request as complete with “cannot fix”, “直せません”, or equivalent. If a real external blocker remains, state the concrete blocker and leave the work explicitly unfinished instead of presenting it for Review as completed.',
+  '- You own the routing decision. When the run is not complete, append exactly one single-line receipt: MANAGER_OUTCOME: {"outcome":"needs-input|blocked|rebind-workspace","summary":"short reason","question":"question for the user when needed","options":["optional choice"],"workingDirectory":"absolute path for rebind-workspace"}. Do not emit this receipt for completed work. Galda transports this declaration verbatim; it does not reinterpret your prose.',
 ].join('\n');
 
+const MANAGER_OUTCOMES = new Set(['needs-input', 'blocked', 'rebind-workspace']);
+
+// A transport receipt written by the worker, not a Manager inference. Keep the
+// schema deliberately tiny: the agent decides what happened; Galda only checks
+// that the envelope is safe to route.
+export function parseManagerOutcome(raw) {
+  const m = String(raw ?? '').match(/MANAGER_OUTCOME:\s*(\{[^\n]+\})/);
+  if (!m) return null;
+  let value;
+  try { value = JSON.parse(m[1]); } catch { return null; }
+  if (!MANAGER_OUTCOMES.has(value?.outcome)) return null;
+  const summary = typeof value.summary === 'string' ? value.summary.trim().slice(0, 500) : '';
+  const question = typeof value.question === 'string' ? value.question.trim().slice(0, 300) : '';
+  const options = Array.isArray(value.options)
+    ? value.options.map((x) => typeof x === 'string' ? x.trim().slice(0, 60) : '').filter(Boolean).slice(0, 4)
+    : [];
+  const workingDirectory = typeof value.workingDirectory === 'string' ? value.workingDirectory.trim().slice(0, 1000) : '';
+  if (value.outcome === 'needs-input' && !question) return null;
+  if (value.outcome === 'blocked' && !summary) return null;
+  if (value.outcome === 'rebind-workspace' && !workingDirectory.startsWith('/')) return null;
+  return { outcome: value.outcome, summary, question, options, workingDirectory };
+}
+
+// Existing requirement evidence is also an explicit worker declaration. A
+// worker cannot say `partial`/`not-addressed` and simultaneously be routed to
+// Review as complete. This is schema consistency, not semantic judgment.
+export function incompleteEvidenceOutcome(evidence) {
+  const incomplete = (evidence?.requirements ?? []).filter((r) => ['partial', 'not-addressed'].includes(r?.status));
+  if (!incomplete.length) return null;
+  return {
+    outcome: 'blocked',
+    summary: incomplete.map((r) => r.evidence || `${r.id}: ${r.status}`).filter(Boolean).join('; ').slice(0, 500)
+      || 'The worker declared one or more requirements incomplete.',
+    question: '', options: [], workingDirectory: '',
+  };
+}
+
 export function completionContractIssue({ request = '', followUp = '', result = '', status = '', changedFiles = [] } = {}) {
   if (status !== 'done') return null;
   const requested = `${request}\n${followUp}`;

package/engine/server.mjs

@@ -26,7 +26,7 @@ import { createSerialQueue } from './lib.mjs';
 import { parseRequirementEvidence, unmappedChangedFiles } from './lib.mjs';
 import { isPrClosed } from './lib.mjs';
 import { collectProjectRules } from './lib.mjs';
-import { COMPLETION_CONTRACT_PROMPT, completionContractIssue } from './completion-contract.mjs';
+import { COMPLETION_CONTRACT_PROMPT, completionContractIssue, parseManagerOutcome, incompleteEvidenceOutcome } from './completion-contract.mjs';
 import { FALLBACK_CODEX_MODELS, loadCodexModels } from './codex-models.mjs';
 import { CLAUDE_MODELS } from './claude-models.mjs';
 import { classifyWorkerPreflight, shouldProbeClaudeAuth, workerCanStart } from './worker-availability.mjs';
@@ -2310,6 +2310,66 @@ function pauseGoalForApproval(goal, task, request) {
   return true;
 }
 
+// The worker decides where its result belongs. Galda does not classify prose;
+// it only validates and transports the explicit receipt (or the worker's
+// existing partial/not-addressed evidence) into the corresponding board state.
+function routeWorkerOutcome(goal, task, project) {
+  if (!goal || !task || task.status !== 'done') return false;
+  const outcome = parseManagerOutcome(task.result) || incompleteEvidenceOutcome(task.requirementEvidence);
+  if (!outcome) return false; // backwards-compatible completed run
+  task.managerOutcome = outcome;
+  task.finishedAt = new Date().toISOString();
+
+  if (outcome.outcome === 'rebind-workspace') {
+    const rebound = rebindGoalWorkspace(goal, project, outcome.workingDirectory);
+    if (rebound.ok) {
+      task.status = 'skipped';
+      task.result = `${task.result}\n\n[Galda: continuing in ${rebound.dir} with a fresh session]`.slice(0, RESULT_MAX);
+      saveTask(task);
+      goal.status = 'running';
+      goal.startedAt = null;
+      goal.question = null;
+      goal.blocked = null;
+      saveGoal(goal);
+      const continuation = queueReplyTask(goal, [
+        `Continue the same request in the newly bound working directory: ${rebound.dir}`,
+        outcome.summary,
+        'Inspect the files already present there and complete the original request. Do not repeat the old sandbox diagnosis.',
+      ].filter(Boolean).join('\n'), { from: 'manager', via: 'system' });
+      continuation.workspaceRebindContinuation = true;
+      saveTask(continuation);
+      sendProcessAct(task, `Worker requested a workspace rebind; continuing in ${rebound.dir} with a fresh session.`);
+      return true;
+    }
+    // An unsafe/unavailable path is not silently retried in the old sandbox.
+    outcome.outcome = 'needs-input';
+    outcome.question = rebound.error;
+    outcome.options = [];
+    outcome.summary = rebound.error;
+  }
+
+  // This turn ended successfully as a routing hand-off, not as a failed unit
+  // of implementation. Keeping it `interrupted` would poison the eventual
+  // closeout even after the user answers and the continuation completes.
+  task.status = 'skipped';
+  saveTask(task);
+  goal.startedAt = null;
+  if (outcome.outcome === 'needs-input') {
+    goal.status = 'needsInput';
+    goal.blocked = null;
+    goal.question = { kind: 'worker', text: outcome.question, options: outcome.options };
+    sendProcessAct(task, `Worker asked for input: ${outcome.question}`);
+  } else {
+    goal.status = 'blocked';
+    goal.question = null;
+    goal.blocked = { kind: 'worker-outcome', reason: outcome.summary };
+    sendProcessAct(task, `Worker declared the work blocked: ${outcome.summary}`);
+  }
+  saveGoal(goal);
+  startNextStacked(goal.projectId);
+  return true;
+}
+
 // split (docs/design/ONE-CONVERSATION.md §1.3): 「それは別件」と返された時の受け皿。
 // 元のゴールには触らない——新しいチケットを1枚起こし、そこに「どこから生まれたか」だけ
 // 片方向の印（bornFrom）を残す。
@@ -2821,6 +2881,9 @@ async function runTask(task) {
     task.unmappedChangedFiles = unmappedChangedFiles(task.changedFiles, task.requirementEvidence);
     task.requirementVerification = { proof: task.proof ?? null, run: task.run ?? null, changedFiles: task.changedFiles };
     sendProcessAct(task, `Detected ${task.changedFiles.length} changed file${task.changedFiles.length === 1 ? '' : 's'} from this follow-up.`);
+    // An explicit worker receipt takes precedence over Galda's legacy prose
+    // guard. The agent owns this decision; Manager only transports it.
+    if (routeWorkerOutcome(goal, task, project)) return;
     const completionIssue = completionContractIssue({
       request: goal?.text,
       followUp: task.detail,
@@ -3043,6 +3106,9 @@ async function runTask(task) {
   task.unmappedChangedFiles = unmappedChangedFiles(task.changedFiles, task.requirementEvidence);
   task.requirementVerification = { proof: task.proof ?? null, run: task.run ?? null, changedFiles: task.changedFiles };
   sendProcessAct(task, `Detected ${task.changedFiles.length} changed file${task.changedFiles.length === 1 ? '' : 's'} from this task.`);
+  // An explicit worker receipt takes precedence over Galda's legacy prose
+  // guard. The agent owns this decision; Manager only transports it.
+  if (routeWorkerOutcome(goal, task, project)) return;
   // task 450: taskStatusAfterVerify decided 'done' from `code` alone, before
   // changedFiles existed to check against. Don't trust a clean exit code by
   // itself — a worker that changed nothing and left a cut-off-looking result
@@ -5143,6 +5209,18 @@ const server = createServer(async (req, res) => {
       let answer = '';
       try { answer = String(JSON.parse(body || '{}').answer ?? '').trim(); } catch {}
       if (!answer) return json(res, 400, { error: 'answer required' });
+      // A worker-authored question is a transport pause, not a new planning
+      // cycle. Preserve the worker session and pass the user's answer straight
+      // back to it; Galda must not reinterpret or rewrite the answer.
+      if (goal.question?.kind === 'worker') {
+        goal.question = null;
+        goal.blocked = null;
+        goal.status = 'running';
+        goal.startedAt = null;
+        saveGoal(goal);
+        const replyTask = queueReplyTask(goal, answer, { from: 'you', via: 'question' });
+        return json(res, 200, { ...goal, replyTaskId: replyTask.id });
+      }
       // Bind this goal to a project rooted at `dir` and start planning. Shared by
       // the "picked a repo" and "git-init'd a new folder" paths below.
       const bindAndPlan = (dir) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galda/cli",
-  "version": "0.10.95",
+  "version": "0.10.96",
   "type": "module",
   "description": "Galda - hand off work to Claude Code or Codex, get proof back. Runs on your existing subscription, no extra API cost.",
   "scripts": {