agent-composer 0.3.1 → 0.4.1

package/plugin/composer-mastermind/skills/composer-mastermind/SKILL.md

@@ -60,6 +60,7 @@ system — spend it on planning, not on raw worker output.
 | Generate a patch WITHOUT applying (rare) | `coder` subagent (`composer_code` → `coder` applies) |
 | Reviewing a candidate patch / diff / implementation | `composer_review` directly; use `reviewer` only for high-volume isolation |
 | Claude review explicitly requested, or high-risk/security-sensitive second opinion | `composer_review_claude` directly after the default review gate |
+| Deep architecture / feature planning, migration design, hard root-cause debugging, or high-risk review where you want ChatGPT Pro's extended reasoning (opt-in) | `composer_oracle_plan` directly; advisory planning only — file edits still go through `composer_code_cli` |
 | Anything that mutates state outside the conversation (push, deploy, install) | Escalate to the user. Do not act. |
 
 When an edit targets a project other than the Composer MCP server cwd (for
@@ -68,6 +69,40 @@ example dotfiles or another repo), pass `projectDir: "<absolute path>"` to
 (a git repo or a `config.toml` projects entry) or it will refuse; do not add
 `--skip-git-repo-check`.
 
+## Oracle planning lane (ChatGPT Pro — opt-in)
+
+`composer_oracle_plan` consults ChatGPT Pro through the Oracle browser
+(`scripts/oracle-pro-safe.sh`) for extended-reasoning planning, design,
+migration, hard debugging, or high-risk review. It is OPT-IN and NOT the
+default research lane — `composer_research` stays on Codex to keep routine
+lookups fast and cheap.
+
+- Use it deliberately: a `deep` / `review` / `debug` run drives a real browser
+  ChatGPT Pro session (slow, supervised). Do not route routine research here.
+- `mode` selects thinking depth: `quick` / `standard` keep a fast model;
+  `deep` / `plan` / `review` / `debug` select ChatGPT Pro; `research` adds Deep
+  Research. Omit (`auto`) to let the script classify.
+- It is ADVISORY: the tool never edits files. Hand its plan to
+  `composer_code_cli` for implementation, then `composer_review`.
+- **Ground it in real code, never a paraphrase.** When asking Oracle to review
+  committed branch work, do NOT describe the diff in prose —
+  `scripts/oracle-pro-safe.sh` auto-attaches the real branch diff (`base...HEAD`)
+  plus changed-file contents. Pass `--base <branch>` (or set
+  `ORACLE_PRO_DIFF_BASE`) when auto-detection (main/master/develop) would pick
+  the wrong base. Reviewing from a summary yields `[inference]` false positives.
+- Requires a one-time Oracle browser login and the `oraclePlanner` role in the
+  active config. Full answers persist under `.composer/oracle/answers/`
+  (gitignored); the tool returns a bounded summary.
+- For long deep-research, large architectural reviews, or when the user says not
+  to block, use the async pair instead: `composer_oracle_job_start` returns a
+  `jobId` immediately, then `composer_oracle_job_result` (optionally with
+  `waitMs`) pulls the answer when the job reaches `succeeded`. Both run off-CC and
+  return bounded summaries.
+- Default to the synchronous `composer_oracle_plan` whenever the next step
+  depends on the answer (most planning/review). Reach for the async job pair only
+  when the answer is useful but not immediately blocking, or on an explicit
+  `[oracle:async]` request. Do not make every deep/review/debug call async.
+
 ## Codex rescue (second-opinion lane)
 
 Use Codex rescue when the same bug has 2+ failed fix attempts, root-cause
@@ -87,6 +122,84 @@ or the user asks for a second opinion.
   latest failing command, changed files, and smallest repro. Do not include the
   whole transcript, secrets, or `.env.json`.
 
+## Codex lifecycle participation
+
+Use `codexLifecycle` for ambient Codex involvement across the development
+loop. This is separate from `codexReview` (mechanical diff gate) and
+`codexRescue` (stuck-debug escalation). It answers one question: should Codex
+join this lifecycle step now?
+
+- Read root `composer.config.json` `codexLifecycle`.
+- If omitted or `enabled:false`, skip lifecycle participation. Existing
+  `composer_code_cli`, `codexReview`, and `codexRescue` rules still apply.
+- For non-trivial feature/debug work, call `composer_handoff_create` first so
+  Codex and reviewers share the same objective, constraints, files, and
+  acceptance criteria.
+- Call `composer_codex_lifecycle_decide` at eligible points with compact
+  signals: `event`, `expectedOutputTokens`, `changedFiles`, `diffLines`,
+  `failedAttempts`, `failingTests`, `touchesSecurity`, `touchesInfra`,
+  `userRequestedCodex`, `hasHandoff`, `isTrivial`, `isDestructive`, and `risk`.
+- Treat the decision literally:
+  - `skip`: do not involve Codex for this lifecycle step.
+  - `ask`: ask the user before involving Codex, naming the event and reason.
+  - `run`: Codex may participate automatically within the configured mode,
+    model, execution, and spend/safety constraints.
+- When the decision is `run`, call `composer_codex_lifecycle_run` with the
+  same event, handoff, prompt, and signals.
+- When the decision is `ask` and the user confirms, call
+  `composer_codex_lifecycle_run` with `confirmed:true`; do not set
+  `confirmed:true` for policy `skip` outcomes.
+- If lifecycle execution is `foreground`, use the returned result before
+  continuing.
+- If lifecycle execution is `background`, keep the returned `jobId` and call
+  `composer_codex_lifecycle_result` before reporting the lifecycle step done.
+  Background Codex output is not complete until its durable result record is
+  `succeeded`, `failed`, `unavailable`, or deliberately `skipped`.
+- Treat `skipped` as a policy decision and `unavailable` as a provider/session
+  failure (`auth`, `quota`, `rate_limit`, `timeout`, `cancelled`, `provider`,
+  or `unknown`). If `codexLifecycle.fallback.enabled`, Composer tries
+  `coderCli` first and then configured fallback roles such as `reviewerClaude`,
+  `reviewer`, or `coder`; always surface `providerRole`, `fallbackUsed`, and
+  the attempts list when a fallback handled the checkpoint. Optional lifecycle
+  jobs may continue after surfacing this; forced pre-commit review gates must
+  fail closed through `codexReview`.
+- Lifecycle Codex runs are companion/advisory passes. Do not let background
+  lifecycle runs silently mutate files; integrate any suggestions deliberately
+  and gate code changes through review.
+
+## Composer config tools
+
+When the user asks to turn Composer/Codex lifecycle behavior on/off, set
+fallback providers, or harden the pre-commit gate, prefer MCP config tools over
+manual JSON editing:
+
+- Call `composer_config_get` first with `scope:"active"` unless the user names
+  project or global config explicitly.
+- Call `composer_config_set` with a narrow patch for `codexLifecycle` and/or
+  `codexReview`; the server validates before writing.
+- Use `scope:"project"` for repo-local `composer.config.json` and
+  `scope:"global"` for `~/.config/composer/composer.config.json`.
+- If `scope:"active"` resolves to the user-global fallback, call
+  `composer_config_set` again with `scope:"global"` explicitly; Composer
+  refuses implicit global writes.
+- After config changes, run `agent-composer doctor` and report the effective
+  lifecycle mode, fallback order, and pre-commit gate state.
+
+Default trigger intent:
+
+| Event | Use when |
+|---|---|
+| `postPlan` | a plan is ready and design risk is non-trivial |
+| `postCodeApply` | code was applied and the diff is broad or risky |
+| `postTestFailure` | targeted checks fail after implementation |
+| `afterFailedAttempts` | the same bug/fix has failed repeatedly |
+| `postResearch` | research output needs a second synthesis pass |
+| `preCommit` | optional policy layer before the mechanical gate |
+| `stopWarm` | passive background/warm participation is configured |
+
+Never use lifecycle participation to bypass user confirmation for destructive
+actions, secret handling, deploys, pushes, or billing-affecting changes.
+
 **Class-based route policy:** route by task class, not by a blanket
 "always dispatch" rule.
 
@@ -127,6 +240,62 @@ expected-output estimate; if under 5 lines, just answer.
 
 **Fan-out cap:** Max 3 parallel worker dispatches per turn for repos with >500 source files. Beyond 3, the prompt-cache misses compound faster than the parallelism saves wall time. If file slices overlap across workers, dispatch SEQUENTIALLY — parallel workers on the same files duplicate every Read.
 
+# Control plane (status, route, workflow, session, audit)
+
+These tools make routing explicit and cheap. Prefer them over re-deriving policy from this skill every turn.
+
+- **`composer_status`** — read-only state snapshot: mode, integrations (review / lifecycle / oracle / git-hook / disabled), the active FOREGROUND worker, active/latest async jobs, latest audit facts, and a recommended next action. Inside Claude Code prefer this over the `agent-composer status` CLI — only the MCP tool sees live in-session `composer_session_*` overrides.
+- **`composer_route_decide`** — preview the route for a prompt WITHOUT executing: returns `target`, `taskClass`, `contextBudget`, and `recommendedNextTools`. Output is `compact` by default; pass `format:"full"` only when debugging the classifier. Call it before a worker dispatch when the right lane is unclear; it spends no worker tokens.
+- **`composer_workflow_plan`** — recommend (do NOT execute) the ordered tool sequence for a goal (`feature` / `debug` / `review` / `research`, tuned by mode + risk). It returns steps; you still call each tool yourself.
+- **`composer_session_get` / `composer_session_set`** — EPHEMERAL per-session overrides (mode, oracle, code_cli `profile`) that do NOT write `composer.config.json`. Use for "this session only" toggles; `clear:true` resets. For durable changes use `composer_config_set`.
+- **`composer_audit_record` / `composer_audit_read` / `composer_audit_summary`** — durable route/outcome trail. After a dispatch, record what happened (route, provider, `reviewVerdict`, `testsPassed`, `userCorrection`, `status`) so `/evolve` learns from real failures, not transcripts. Recording is EXPLICIT — these tools are never auto-called; keep `note`/`objective` short (capped on write). Read/summary to inspect route accuracy.
+
+# Subagent speed contract
+
+Fast path for quick inspection and minimal wait:
+
+1. Call `composer_route_decide` with `format:"compact"` — local, no model.
+   Do NOT request `format:"full"` unless debugging the classifier.
+2. Honor returned `contextBudget` (`inline` / `handoff` / `scoped-diff` /
+   `full-brief` / `oracle-brief`). Send only matching context, NEVER a raw
+   transcript.
+3. Prefer `composer_code_cli` for implementation; the executor applies off-CC.
+4. Use `reviewScope` (`staged` / `working-tree` / `branch`). NEVER paste broad
+   diffs.
+5. Background, don't block: use `composer_review_job_start` +
+   `composer_review_job_result` for routine/advisory review while continuing
+   work. Reserve synchronous `composer_review` for the pre-commit / merge gate
+   or explicit "review now". Likewise prefer background lifecycle
+   (`execution:"background"`).
+6. NEVER call Oracle unless explicitly tagged `[oracle:<mode>]` or the route
+   says premium escalation.
+7. For quick state checks use `agent-composer status --fast` (skips audit /
+   job / goal scans). Do NOT pull full status/audit unless debugging
+   orchestration.
+8. Reserve the synchronous fail-closed review gate for commits. If a greenfield
+   subsystem oscillates the gate, set
+   `codexReview.preCommitHook.maxConsecutiveBlocks` instead of grinding.
+
+## contextBudget (how much context to send)
+
+`composer_route_decide` returns a `contextBudget`. Honor it — send ONLY the matching context, NEVER a raw transcript:
+
+| contextBudget | Send |
+|---|---|
+| `inline` | the prompt only (or answer inline; no worker) |
+| `handoff` | a `composer_handoff_create` `handoffPath` |
+| `scoped-diff` | a `reviewScope` (let the server compute the diff) |
+| `full-brief` | handoff + the exact files / constraints |
+| `oracle-brief` | a compact problem / architecture brief, never a repo dump |
+
+## Scoped review (do not paste broad diffs)
+
+`composer_review` / `composer_review_claude` accept `reviewScope` (`staged` | `unstaged` | `working-tree` | `branch`) plus optional `base` and `reviewFiles`. Pass a scope and let the server compute the diff off-CC — do NOT paste a broad diff into the prompt. Use `staged` for pre-commit review, `working-tree` for routine review, `branch` (+ `base`) for a PR-sized review. A pasted `diff` still works but costs main-session tokens.
+
+## Codex profiles
+
+`composer_code_cli` accepts `profile` to select a `codexProfiles` lane from config (model / reasoning effort / sandbox) — e.g. a cheap `fast` lane or a `deep` lane. A session `profile` set via `composer_session_set` applies when no explicit `profile` is passed.
+
 # Explorer protocol (large-repo dispatches)
 
 For repos with >500 source files (or any unfamiliar codebase), prefer an
@@ -201,10 +370,12 @@ global stop-gate; it fires on every stop.
 A stronger, optional enforcement: `codexReview.preCommitHook.enabled` turns the
 PreToolUse hook `precommit_codex_review.sh` into a hard gate — a `git commit`
 is DENIED when Codex review returns `needs-attention` with a finding at or above
-`preCommitHook.blockOnSeverity` (default `high`). Fail-open by default
-(`failClosed:false`): if Codex is unavailable the commit proceeds. Run
-`agent-composer doctor` to see the gate state. This is mechanical (hook-enforced),
-unlike the orchestrator-driven triggers above.
+`preCommitHook.blockOnSeverity` (default `high`). The default is fail-open
+(`failClosed:false`), but strict local/project configs should set
+`failClosed:true`; then Codex auth, quota, rate-limit, timeout, or parse
+failures block the commit. Run `agent-composer doctor` to see the gate state.
+This is mechanical (hook-enforced), unlike the orchestrator-driven triggers
+above.
 
 # Headless invocation
 
@@ -231,6 +402,21 @@ Rules:
 - Override when the orchestration plan itself is non-trivial (>3
   dispatches, cross-file integration). Then Opus 4.7 earns its keep.
 
+## Authorizing file-writing workers
+
+`boundary_guard.sh` enforces globally now: it denies main-thread
+`Edit/Update/Write/NotebookEdit` in EVERY repo unless Composer is disabled.
+A headless `claude -p` worker you spawn to AUTHOR files (multi-file
+scaffolding, byte-exact reproduction) runs as its own main thread and will be
+blocked. When you spawn such an authorized worker, set the
+`COMPOSER_DANGEROUSLY_BYPASS_PERMISSIONS` env var to `1` in its environment
+so its writes are allowed — prefix the variable on the worker's command line,
+ahead of `claude -p ...` (the boundary_guard deny message prints the exact
+form to use).
+Do NOT export that variable in your own interactive shell — set it only on the
+spawned worker, so the interactive Brain stays gated and routes through
+`composer_code_cli`.
+
 # Token discipline
 
 - You hold context, plans, and integration. Workers hold execution.

package/scripts/composer-oracle-router-safe.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Router intended for agent-composer's existing `researcher` cli provider.
+# Composer appends the prompt as the final argv item; this wrapper joins args into one prompt.
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+ORACLE_SCRIPT="${ORACLE_COMPOSER_ORACLE_SCRIPT:-$ROOT_DIR/scripts/oracle-pro-safe.sh}"
+CODEX_BIN="${ORACLE_COMPOSER_CODEX_BIN:-codex}"
+
+prompt="$*"
+[[ -n "$prompt" ]] || { echo "composer-oracle-router-safe: prompt required" >&2; exit 1; }
+
+lower="$(printf '%s' "$prompt" | tr '[:upper:]' '[:lower:]')"
+
+route="codex"
+mode="standard"
+
+case "$lower" in
+  *'[codex]'*) route="codex" ;;
+  *'[oracle:quick]'*) route="oracle"; mode="quick" ;;
+  *'[oracle:standard]'*) route="oracle"; mode="standard" ;;
+  *'[oracle:deep]'*|*'[oracle:plan]'*) route="oracle"; mode="deep" ;;
+  *'[oracle:review]'*) route="oracle"; mode="review" ;;
+  *'[oracle:debug]'*) route="oracle"; mode="debug" ;;
+  *'[oracle:research]'*) route="oracle"; mode="research" ;;
+esac
+
+if [[ "$route" != "codex" ]]; then
+  if [[ ${#prompt} -gt 2500 ]] || [[ "$lower" =~ (architecture|architectural|design|plan|planning|proposal|migration|refactor|roadmap|tradeoff|trade-off|spec|handoff|implementation[[:space:]]+plan) ]]; then mode="deep"; fi
+  if [[ "$lower" =~ (review|audit|regression|security|compatibility|api[[:space:]]+break|edge[[:space:]]+case|risk) ]]; then mode="review"; fi
+  if [[ "$lower" =~ (debug|root[ -]?cause|failing|failure|flaky|bug|stack[[:space:]]+trace|exception|crash|deadlock|race) ]]; then mode="debug"; fi
+  if [[ "$lower" =~ (research|compare[[:space:]]+options|survey|citations|latest|web) ]]; then mode="research"; fi
+fi
+
+if [[ "$route" == "codex" ]]; then
+  if ! command -v "$CODEX_BIN" >/dev/null 2>&1; then
+    echo "[router] Codex requested but '$CODEX_BIN' not found; falling back to Oracle quick." >&2
+    exec "$ORACLE_SCRIPT" --mode quick -- "$prompt"
+  fi
+  echo "[router] route=codex sandbox=read-only" >&2
+  printf "%s\n" "$prompt" | "$CODEX_BIN" exec --ephemeral --sandbox read-only --ask-for-approval never -
+  exit $?
+else
+  echo "[router] route=oracle mode=$mode" >&2
+  exec "$ORACLE_SCRIPT" --mode "$mode" -- "$prompt"
+fi

package/scripts/composer-statusline-segment.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const stateDir = process.env.COMPOSER_STATE_DIR?.trim()
+  ? path.resolve(process.env.COMPOSER_STATE_DIR)
+  : path.join(os.homedir(), ".composer", "state");
+const filePath = path.join(stateDir, "active-runs.json");
+
+try {
+  if (!fs.existsSync(filePath)) process.exit(0);
+  const runs = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  if (!Array.isArray(runs) || runs.length === 0) process.exit(0);
+
+  const now = Date.now();
+  const active = runs
+    .map((run) => ({
+      tool: typeof run.tool === "string" ? run.tool : "",
+      providerLabel: typeof run.providerLabel === "string" ? run.providerLabel : undefined,
+      providerRole: typeof run.providerRole === "string" ? run.providerRole : undefined,
+      startedAtMs: Date.parse(run.startedAt),
+    }))
+    .filter((run) => run.tool && Number.isFinite(run.startedAtMs))
+    .sort((a, b) => a.startedAtMs - b.startedAtMs)[0];
+
+  if (!active) process.exit(0);
+  const tool = active.tool.replace(/^composer_/, "");
+  const provider = active.providerLabel ?? active.providerRole;
+  const elapsed = formatElapsed(now - active.startedAtMs);
+  process.stdout.write(`⚡composer: ${tool}${provider ? `(${provider})` : ""} ${elapsed}\n`);
+} catch {
+  process.exit(0);
+}
+
+function formatElapsed(elapsedMs) {
+  const seconds = Math.max(0, Math.floor(elapsedMs / 1000));
+  if (seconds < 60) return `${seconds}s`;
+  return `${Math.floor(seconds / 60)}m`;
+}

package/scripts/oracle-codex-handoff-safe.sh

@@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'USAGE'
+Usage:
+  scripts/oracle-codex-handoff-safe.sh [--mode deep|review|debug|standard] [--exec] -- "feature/request"
+
+Creates a ChatGPT Pro/Oracle plan under .composer/handoffs/ and optionally sends it to Codex.
+USAGE
+}
+
+MODE="deep"
+EXECUTE=0
+PROMPT=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --mode) MODE="${2:-}"; shift 2 ;;
+    --mode=*) MODE="${1#*=}"; shift ;;
+    --exec) EXECUTE=1; shift ;;
+    -h|--help) usage; exit 0 ;;
+    --) shift; PROMPT="$*"; break ;;
+    *) if [[ -z "$PROMPT" ]]; then PROMPT="$1"; else PROMPT="$PROMPT $1"; fi; shift ;;
+  esac
+done
+[[ -n "$PROMPT" ]] || { usage >&2; exit 1; }
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+ORACLE_SCRIPT="$ROOT_DIR/scripts/oracle-pro-safe.sh"
+mkdir -p .composer/handoffs .composer/results
+slug="$(date +%Y%m%d-%H%M%S)-oracle-handoff"
+plan_path=".composer/handoffs/$slug.md"
+
+handoff_prompt="Create a compact Codex-ready implementation handoff for the following request. Include objective, constraints, likely files, implementation steps, tests, risks, and acceptance criteria. Do not include long code blocks unless essential. Request: $PROMPT"
+
+answer_path="$($ORACLE_SCRIPT --mode "$MODE" --slug "$slug" -- "$handoff_prompt" | tail -1)"
+[[ -f "$answer_path" ]] || { echo "Oracle did not produce an answer path" >&2; exit 1; }
+cp "$answer_path" "$plan_path"
+echo "$plan_path"
+
+if [[ "$EXECUTE" -eq 1 ]]; then
+  result_path=".composer/results/$slug.codex-result.md"
+  {
+    echo "Implement the following plan in the current repository. Keep the diff focused. Run relevant tests. Return summary, changed files, tests run, and unresolved risks."
+    echo
+    cat "$plan_path"
+  } | codex exec --sandbox workspace-write --ask-for-approval on-request --output-last-message "$result_path" -
+  echo "$result_path"
+fi

package/scripts/oracle-plan-mcp.sh

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+# oracle-plan-mcp.sh — thin MCP-facing wrapper around oracle-pro-safe.sh.
+#
+# Why: CLIProvider returns a role's STDOUT to the orchestrator. oracle-pro-safe.sh
+# prints the answer FILE PATH on its last stdout line (a contract relied on by
+# oracle-codex-handoff-safe.sh), and oracle's own render/progress is noisy. This
+# wrapper runs oracle-pro-safe.sh, recovers that path, and emits ONLY the final
+# answer file CONTENT on stdout, so composer_oracle_plan returns clean answer text.
+set -euo pipefail
+
+MODE="auto"
+ARGS=()
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --mode) MODE="${2:?missing --mode value}"; shift 2 ;;
+    --mode=*) MODE="${1#*=}"; shift ;;
+    --) shift; ARGS+=("$@"); break ;;
+    *) ARGS+=("$1"); shift ;;
+  esac
+done
+
+PROMPT="${ARGS[*]:-}"
+if [[ -z "$PROMPT" && ! -t 0 ]]; then
+  PROMPT="$(cat)"
+fi
+if [[ -z "$PROMPT" ]]; then
+  echo "oracle-plan-mcp: prompt required" >&2
+  exit 2
+fi
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+ORACLE_SCRIPT="$ROOT_DIR/scripts/oracle-pro-safe.sh"
+
+tmp="$(mktemp)"
+trap 'rm -f "$tmp"' EXIT
+
+# Capture oracle-pro-safe stdout (answer render + final path line) into tmp.
+# Its stderr (logs/progress) is inherited -> our stderr -> not returned to MCP.
+set +e
+bash "$ORACLE_SCRIPT" --mode "$MODE" -- "$PROMPT" > "$tmp"
+status=$?
+set -e
+
+if (( status != 0 )); then
+  echo "oracle-plan-mcp: oracle-pro-safe.sh failed (exit $status); captured output:" >&2
+  cat "$tmp" >&2 || true
+  exit "$status"
+fi
+
+answer_path="$(tail -n 1 "$tmp" | tr -d '\r')"
+if [[ -z "$answer_path" || ! -s "$answer_path" ]]; then
+  echo "oracle-plan-mcp: oracle finished but no answer file at '$answer_path'; captured output:" >&2
+  cat "$tmp" >&2 || true
+  exit 1
+fi
+
+# Write a stable sidecar so async callers (composer_oracle_job_start) can
+# recover the full-answer path even though only bounded text is returned.
+meta_dir="$(dirname "$answer_path")"
+slug="$(basename "$answer_path" .md)"
+if [[ -d "$meta_dir" ]] && command -v node >/dev/null 2>&1; then
+  node -e 'const fs=require("fs");fs.writeFileSync(process.argv[1],JSON.stringify({answerPath:process.argv[2],oracleSlug:process.argv[3],mode:process.argv[4]})+"\n")' \
+    "$meta_dir/.last-plan-meta.json" "$answer_path" "$slug" "$MODE" 2>/dev/null || true
+fi
+
+cat "$answer_path"