@hegemonart/get-design-done 1.27.0 → 1.27.1

package/.claude-plugin/marketplace.json

@@ -5,14 +5,14 @@
   },
   "metadata": {
     "description": "Get Design Done — 5-stage agent-orchestrated design pipeline with 9 connections, handoff-first workflow, bidirectional Figma write-back, 22+ specialized agents, queryable knowledge layer (intel store, dependency analysis, learnings extraction), and a self-improvement loop (reflector, frontmatter + budget feedback, global-skills layer). v1.20.0 ships the SDK foundation: gdd-state MCP server (11 typed tools), lockfile-safe STATE.md mutations, event stream, and resilience primitives (jittered-backoff, rate-guard, error-classifier, iteration-budget) for rate-limit + 429 + context-overflow recovery. Full CI/CD pipeline (Node 22/24 × Linux/macOS/Windows) and release automation (auto-tag + GitHub Release + release-time smoke test).",
-    "version": "1.27.0"
+    "version": "1.27.1"
   },
   "plugins": [
     {
       "name": "get-design-done",
       "source": "./",
       "description": "Agent-orchestrated 5-stage design pipeline: Brief → Explore → Plan → Design → Verify. 22+ specialized agents, 9 connections (Figma, Refero, Preview, Storybook, Chromatic, Figma Writer, Graphify, Pinterest, Claude Design), Claude Design handoff, bidirectional Figma write-back, and a queryable intel store (.design/intel/) for dependency and learnings queries. Standalone commands: style, darkmode, compare, figma-write, graphify, handoff, analyze-dependencies, skill-manifest, extract-learnings. Embeds NNG heuristics, WCAG thresholds, typographic systems, motion framework, and anti-pattern catalog. Ships with a full CI/CD pipeline (Node 22/24 × Linux/macOS/Windows) and release automation. Optimization layer (v1.0.4.1, retroactive): gdd-router + gdd-cache-manager skills, PreToolUse budget-enforcer hook, tier-aware agent frontmatter, lazy checker gates, streaming synthesizer, /gdd:warm-cache + /gdd:optimize commands, and cost telemetry at .design/telemetry/costs.jsonl — targeting 50-70% per-task token-cost reduction with no quality-floor regression. v1.20.0 SDK foundation: gdd-state MCP server (11 typed tools), lockfile-safe STATE.md mutations, event stream at .design/telemetry/events.jsonl, resilience primitives (jittered-backoff, rate-guard, error-classifier, iteration-budget) with rate-limit + 429 + context-overflow recovery, and TypeScript toolchain.",
-      "version": "1.27.0",
+      "version": "1.27.1",
       "author": {
         "name": "hegemonart"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "get-design-done",
   "short_name": "gdd",
-  "version": "1.27.0",
+  "version": "1.27.1",
   "description": "Agent-orchestrated 5-stage design pipeline: Brief → Explore → Plan → Design → Verify. 22+ specialized agents, 9 connections (Figma, Refero, Preview, Storybook, Chromatic, Figma Writer, Graphify, Pinterest, Claude Design), handoff-first workflow via Claude Design bundles, bidirectional Figma write-back (annotations, Code Connect), queryable intel store (`.design/intel/`) for O(1) design surface lookups, and self-improvement loop (reflector agent, frontmatter + budget feedback, global-skills layer at `~/.claude/gdd/global-skills/`). Standalone commands: style, darkmode, compare, figma-write, graphify, handoff, analyze-dependencies, skill-manifest, extract-learnings, reflect, apply-reflections. Embeds NNG heuristics, WCAG thresholds, typographic systems, motion framework, and anti-pattern catalog. Ships with a full CI/CD pipeline (Node 22/24 × Linux/macOS/Windows, lint + schema + frontmatter + stale-ref + shellcheck + gitleaks + injection-scan + blocking size-budget) and release automation (auto-tag + GitHub Release + release-time smoke test). Optimization layer (v1.0.4.1, retroactive): gdd-router + gdd-cache-manager skills, PreToolUse budget-enforcer hook, tier-aware agent frontmatter, lazy checker gates, streaming synthesizer, /gdd:warm-cache + /gdd:optimize commands, and cost telemetry at .design/telemetry/costs.jsonl — targeting 50-70% per-task token-cost reduction with no quality-floor regression. v1.20.0 SDK foundation: gdd-state MCP server (11 typed tools), lockfile-safe STATE.md mutations, event stream at .design/telemetry/events.jsonl, resilience primitives (jittered-backoff, rate-guard, error-classifier, iteration-budget) with rate-limit + 429 + context-overflow recovery, and TypeScript toolchain.",
   "author": {
     "name": "hegemonart",

package/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to get-design-done are documented here. Versions follow [sem
 
 ---
 
+## [1.27.1] — 2026-04-30
+
+Phase 27 wiring patch — closes the production-integration gaps left by v1.27.0's "structural ship". v1.27.0 landed all peer-CLI library code + tests + docs but the helpers were exported without callers, so `delegate_to:` on agent frontmatter was validated and then ignored at runtime. v1.27.1 wires the four integration points so delegation actually fires for users who set `delegate_to:` AND allowlist the peer.
+
+### Fixed
+
+- **`session-runner.run()` now invokes `tryDelegate` (Plan 27-06 wiring)** — when `opts.delegateTo` is set to a `<peer>-<role>` value AND the registry can route AND the peer is in `.design/config.json#peer_cli.enabled_peers`, the prompt runs on the peer-CLI and `run()` returns the peer result. On peer-absent / peer-error / null result, falls through transparently to the local Anthropic SDK loop (D-07). Previously the `tryDelegate` helper existed in the file but `run()` never called it.
+
+- **Real `appendEvent('peer_call_started|complete|failed', ...)` emission (Plan 27-08 wiring)** — replaced the stderr-only placeholder in session-runner with three real event-emission calls. Events flow through Phase 22's `appendEvent()` API using the constants registered in v1.27.0, tagged with `runtime_role: 'peer'` and `peer_id`. Reflector cross-runtime cost-arbitrage (Plan 26-06) now sees peer telemetry. `GDD_PEER_DEBUG=1` continues to mirror the failed events to stderr for live tailing.
+
+- **`install.cjs` interactive peer-detection nudge (Plan 27-11 wiring)** — after a successful (non-uninstall, non-dry-run) install in a TTY, scans `peerBinary` paths via `detectInstalledPeers()`. If 1+ peer detected, prompts via `@clack/prompts` with `confirm()` (default: NO). On yes, writes `.design/config.json#peer_cli.enabled_peers`. New `--no-peer-prompt` flag suppresses the prompt entirely (CI-friendly). Silent skip when zero peers detected. Default-NO preserves the opt-in trust contract (D-11).
+
+### Out of scope (known, deferred)
+
+- **Bandit `pullWithDelegate` caller (Plan 27-07 wiring)** — `pullWithDelegate` and `updateWithDelegate` ship in the bandit module surface (v1.27.0) but no production caller invokes them yet. Wiring requires `gdd-router` SKILL.md change (procedural, not code) which is out of scope for a wiring patch. Phase 28+ territory once the integration shape is decided. The `delegate?` dimension stays exported as a library extension for ad-hoc use.
+
+### Tests
+
+- Existing 23 peer-CLI session-runner / events / end-to-end tests pass after wiring.
+- Existing 33 install.cjs + peer-detect tests pass after the nudge addition.
+- Full Phase 27 surface tests stay green; no new test files (this is a wiring patch, not a new surface).
+
+---
+
 ## [1.27.0] — 2026-04-30
 
 Phase 27 Peer-CLI Delegation Layer milestone — closes the **outbound** half of multi-runtime. Phase 24 made gdd installable on 14 runtimes; Phase 21 made the same pipeline run on each; Phase 26 made tier→model resolve correctly per runtime. v1.27.0 adds the missing piece: gdd agents OPTIONALLY delegate to local peer CLIs (Codex via App Server Protocol; Gemini/Cursor/Copilot/Qwen via Agent Client Protocol) when measurably cheaper or higher-quality for the role. Falls back to in-process Anthropic SDK when peer is unavailable. Honors Phase 26 tier maps + Phase 22 event chain + Phase 23.5 bandit posterior — `delegate?` becomes another arm in `(agent_type × tier × delegate)` Thompson sampling, no new ML.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hegemonart/get-design-done",
-  "version": "1.27.0",
+  "version": "1.27.1",
   "description": "A design-quality pipeline for AI coding agents: brief, plan, implement, and verify UI work against your design system.",
   "author": "Hegemon",
   "homepage": "https://github.com/hegemonart/get-design-done",
@@ -37,7 +37,7 @@
     "provenance": true
   },
   "scripts": {
-    "test": "node --test --experimental-strip-types \"tests/**/*.cjs\" \"tests/**/*.ts\"",
+    "test": "node --test --experimental-strip-types \"tests/**/*.test.cjs\" \"tests/**/*.test.ts\"",
     "typecheck": "tsc --noEmit",
     "codegen:schemas": "node --experimental-strip-types scripts/codegen-schema-types.ts",
     "lint:md": "npx --yes markdownlint-cli2 \"**/*.md\" \"#node_modules\" \"#.planning\" \"#.claude\" \"#test-fixture/baselines\"",

package/reference/peer-protocols.md

@@ -4,7 +4,7 @@
 
 For ops-level guidance (when delegation fires, how to enable/disable, fallback diagnostics), see `docs/PEER-DELEGATION.md`.
 
-Protocol shapes are adapted from [`greenpolo/cc-multi-cli`](https://github.com/greenpolo/cc-multi-cli) under Apache 2.0 — see `NOTICE` for full attribution.
+Protocol shapes are adapted from [`greenpolo/cc-multi-cli-plugin`](https://github.com/greenpolo/cc-multi-cli-plugin) under Apache 2.0 — see `NOTICE` for full attribution.
 
 ---
 

package/scripts/install.cjs

@@ -18,8 +18,9 @@
 
 const path = require('node:path');
 
-const { listRuntimes, listRuntimeIds } = require('./lib/install/runtimes.cjs');
+const { listRuntimes, listRuntimeIds, detectInstalledPeers, listPeerCapableRuntimes } = require('./lib/install/runtimes.cjs');
 const { installRuntime, uninstallRuntime } = require('./lib/install/installer.cjs');
+const fs = require('node:fs');
 
 function parseArgs(argv) {
   const args = argv.slice(2);
@@ -60,6 +61,7 @@ function helpText() {
     '  --uninstall     Remove the plugin from selected runtimes',
     '  --dry-run       Print the diff without writing',
     '  --config-dir D  Override the config directory',
+    '  --no-peer-prompt  Suppress the post-install peer-CLI detection nudge',
     '  --help, -h      Show this message',
     '',
     'Environment overrides (per-runtime):',
@@ -196,6 +198,103 @@ async function main() {
       '',
     ].join('\n'),
   );
+
+  // v1.27.1 — Plan 27-11 wiring: post-install peer-CLI detection nudge.
+  // Fires only on real install (not uninstall, not dry-run) when not
+  // suppressed by --no-peer-prompt. Silently skips when no peers detected.
+  // Always opt-in: writes .design/config.json#peer_cli.enabled_peers
+  // ONLY on explicit y/Y; default is no.
+  if (!uninstall && !dryRun && !flags.has('--no-peer-prompt')) {
+    try {
+      await maybeNudgePeerCli({ flags });
+    } catch (e) {
+      // Nudge is non-critical. Surface a one-line warning but don't fail
+      // the install — the plugin is fully functional without peer-CLI.
+      process.stderr.write(
+        `\n[peer-cli] post-install nudge skipped: ${e && e.message ? e.message : e}\n`,
+      );
+    }
+  }
+}
+
+// v1.27.1 — Plan 27-11: post-install nudge. Detects installed peer CLIs,
+// asks the user (interactive y/N) whether to wire them as peers, writes
+// .design/config.json#peer_cli.enabled_peers on yes. Default = NO (opt-in).
+async function maybeNudgePeerCli({ flags }) {
+  const detected = detectInstalledPeers();
+  if (!detected || detected.length === 0) {
+    // Nothing detected — silent skip. (No bad UX of "we found 0 peers".)
+    return;
+  }
+
+  // Build the human-readable peer line for the prompt.
+  const allPeerCapable = listPeerCapableRuntimes();
+  const detectedDisplay = detected
+    .map((id) => {
+      const r = allPeerCapable.find((x) => x.id === id);
+      return r && r.displayName ? r.displayName : id;
+    })
+    .join(', ');
+
+  process.stdout.write(
+    [
+      '',
+      '✓ Detected peer CLIs: ' + detectedDisplay,
+      '',
+      'gdd v1.27.0 introduced optional peer-CLI delegation. With your',
+      'agents\\u2019 frontmatter `delegate_to:` set, gdd can route specific',
+      'roles through these peer CLIs (cost or quality wins per Phase 23.5',
+      'bandit). You can change this anytime via .design/config.json.',
+      '',
+    ].join('\n'),
+  );
+
+  // Decide interactive vs scripted. shouldUseInteractive lives in this
+  // file; reuse it. If non-TTY, default to no (silent opt-out) so CI
+  // installers don't hang waiting for input.
+  let confirmed = false;
+  if (shouldUseInteractive(flags)) {
+    try {
+      const clack = require('@clack/prompts');
+      const ans = await clack.confirm({
+        message: 'Enable peer-CLI delegation for these peers?',
+        initialValue: false,
+      });
+      confirmed = (ans === true);
+    } catch {
+      // @clack/prompts unavailable — silently default to no.
+      confirmed = false;
+    }
+  }
+
+  if (!confirmed) {
+    process.stdout.write(
+      'Skipped — peer-CLI delegation remains disabled.\n' +
+      'Enable later by adding to .design/config.json:\n' +
+      '  { "peer_cli": { "enabled_peers": ' + JSON.stringify(detected) + ' } }\n\n',
+    );
+    return;
+  }
+
+  // Write the allowlist. Merge with any existing .design/config.json.
+  const cfgPath = path.join(process.cwd(), '.design', 'config.json');
+  let cfg = {};
+  try {
+    if (fs.existsSync(cfgPath)) {
+      cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+    }
+  } catch {
+    cfg = {};
+  }
+  if (!cfg.peer_cli || typeof cfg.peer_cli !== 'object') cfg.peer_cli = {};
+  cfg.peer_cli.enabled_peers = detected;
+  fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
+  fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + '\n');
+  process.stdout.write(
+    `✓ Wrote .design/config.json — peer-CLI enabled for: ${detected.join(', ')}\n` +
+    '  Set delegate_to: <peer>-<role> on agent frontmatter to opt agents in.\n' +
+    '  See docs/PEER-DELEGATION.md for the full ops guide.\n\n',
+  );
 }
 
 main().catch((err) => {

package/scripts/lib/peer-cli/spawn-cmd.cjs

@@ -21,8 +21,8 @@
 // string with `shell: true`. We forward-slash the path so Windows shell
 // resolves it correctly even when the path contains backslashes:
 //
-//     // BROKEN on Windows for .cmd shims:
-//     spawn('C:\\Users\\me\\AppData\\Local\\codex.cmd', ['app-server'])
+//     // BROKEN on Windows for .cmd shims (absPath ends in .cmd):
+//     spawn(absPath, ['app-server'])
 //
 //     // WORKS everywhere (.cmd via cmd.exe; non-.cmd via direct exec):
 //     const fwd = absPath.replace(/\\/g, '/');

package/scripts/lib/session-runner/index.ts

@@ -200,15 +200,22 @@ async function tryDelegate(args: {
     return reg !== null ? reg.dispatch : null;
   })();
   if (dispatcher === null) {
-    // No registry available at all — fall through to local. Phase 22
-    // event emission (Plan 27-08) hooks here as `peer_call_failed`
-    // with reason="registry_missing". For now, a placeholder stderr
-    // breadcrumb so operators can grep for delegation drops without
-    // CI-failing on stdout pollution.
-    _logPeerCallFailed({ peer: parsed.peer, role, errorClass: 'registry_missing' });
+    // No registry available at all — fall through to local.
+    _logPeerCallFailed({
+      peer: parsed.peer, role, errorClass: 'registry_missing',
+      sessionId: args.sessionId, stage: opts.stage,
+    });
     return null;
   }
 
+  // v1.27.1 — emit peer_call_started before dispatcher invocation so the
+  // events.jsonl trail captures the attempt even if the dispatcher hangs.
+  _logPeerCallStarted({
+    peer: parsed.peer, role,
+    sessionId: args.sessionId, stage: opts.stage,
+  });
+  const dispatchStartedAt = Date.now();
+
   let dispatchResult: { result: unknown; peer: string; protocol: 'acp' | 'asp' } | null = null;
   try {
     dispatchResult = await dispatcher(role, tier, sanitizedPrompt, { cwd: process.cwd() });
@@ -218,6 +225,8 @@ async function tryDelegate(args: {
       role,
       errorClass: 'dispatch_threw',
       message: err instanceof Error ? err.message : String(err),
+      sessionId: args.sessionId,
+      stage: opts.stage,
     });
     return null; // transparent fallback
   }
@@ -225,10 +234,28 @@ async function tryDelegate(args: {
   if (dispatchResult === null) {
     // Registry returned null — peer absent, capability mismatch, or
     // adapter-side error. Per D-07 we fall back silently.
-    _logPeerCallFailed({ peer: parsed.peer, role, errorClass: 'registry_returned_null' });
+    _logPeerCallFailed({
+      peer: parsed.peer, role, errorClass: 'registry_returned_null',
+      sessionId: args.sessionId, stage: opts.stage,
+    });
     return null;
   }
 
+  // v1.27.1 — peer round-trip succeeded. Emit peer_call_complete with the
+  // measured latency. Token counts + cost are 0 / null because adapters
+  // don't surface usage in v1.27 (Plan 27-04 spec deferred it); reflector
+  // tolerates null cost (Plan 26-06 cost-arbitrage analysis).
+  _logPeerCallComplete({
+    peer: dispatchResult.peer,
+    role,
+    latencyMs: Date.now() - dispatchStartedAt,
+    tokensIn: 0,
+    tokensOut: 0,
+    costUsd: null,
+    sessionId: args.sessionId,
+    stage: opts.stage,
+  });
+
   // Peer succeeded. Build a SessionResult that mirrors the local path's
   // shape so downstream consumers (stage-handlers, transcript readers,
   // tests) treat both paths uniformly. We do NOT write a transcript file
@@ -271,34 +298,122 @@ function _coerceFinalText(result: unknown): string | undefined {
 }
 
 /**
- * Placeholder for Plan 27-08's `peer_call_failed` event. Until 27-08
- * wires real `appendEvent('peer_call_failed', ...)`, we write a single
- * stderr line so operators can grep for silent delegation drops. We
- * deliberately don't go through `appendEvent` here because the Phase 22
- * event-stream hasn't gained a `peer_call_failed` type yet (that's
- * 27-08's job) and pushing an unknown event type today would create a
- * migration mess for the reflector.
+ * v1.27.1 — wires Plan 27-08's `peer_call_failed` event for real.
+ * Phase 22 `appendEvent` accepts the new event type (registered in
+ * KNOWN_EVENT_TYPES via Plan 27-08), so the reflector and downstream
+ * telemetry consumers see delegation drops as a measurement signal.
+ *
+ * Errors from `appendEvent` (e.g., events.jsonl unwritable) are
+ * swallowed — peer-call telemetry is observability, not critical
+ * path. STATE.md remains the durable record of session outcomes.
+ *
+ * Operators can additionally set `GDD_PEER_DEBUG=1` to emit a
+ * one-line stderr breadcrumb mirroring the event for live tailing.
  */
 function _logPeerCallFailed(args: {
   peer: string;
   role: string;
   errorClass: string;
   message?: string;
+  sessionId?: string;
+  stage?: SessionRunnerOptions['stage'];
 }): void {
-  // One-line, machine-greppable. Quiet by default in test runs (NODE_ENV)
-  // so the test output stays clean. Operators set GDD_PEER_DEBUG=1 to see
-  // the breadcrumb in production logs.
-  if (process.env['GDD_PEER_DEBUG'] !== '1') return;
-  const payload = JSON.stringify({
-    type: 'peer_call_failed',
-    peer_id: args.peer,
-    role: args.role,
-    error_class: args.errorClass,
-    ...(args.message !== undefined ? { message: args.message } : {}),
-    ts: new Date().toISOString(),
-  });
-  // eslint-disable-next-line no-console
-  console.error(`[peer-cli] ${payload}`);
+  try {
+    appendEvent({
+      type: 'peer_call_failed',
+      timestamp: new Date().toISOString(),
+      sessionId: args.sessionId ?? 'unknown',
+      ...(args.stage !== undefined && args.stage !== 'init' && args.stage !== 'custom' ? { stage: args.stage } : {}),
+      payload: {
+        runtime_role: 'peer',
+        peer_id: args.peer,
+        role: args.role,
+        error_class: args.errorClass,
+        ...(args.message !== undefined ? { message: args.message } : {}),
+      },
+    });
+  } catch {
+    // Telemetry is best-effort — never let an event-stream failure
+    // break the actual session flow.
+  }
+  if (process.env['GDD_PEER_DEBUG'] === '1') {
+    const payload = JSON.stringify({
+      type: 'peer_call_failed',
+      peer_id: args.peer,
+      role: args.role,
+      error_class: args.errorClass,
+      ...(args.message !== undefined ? { message: args.message } : {}),
+      ts: new Date().toISOString(),
+    });
+    // eslint-disable-next-line no-console
+    console.error(`[peer-cli] ${payload}`);
+  }
+}
+
+/**
+ * v1.27.1 — emit `peer_call_started` event. Fired once at the beginning
+ * of a delegation attempt, before the dispatcher is invoked. Pairs with
+ * `peer_call_complete` (success path) or `peer_call_failed` (any failure
+ * path, transparent to caller per D-07).
+ */
+function _logPeerCallStarted(args: {
+  peer: string;
+  role: string;
+  sessionId?: string;
+  stage?: SessionRunnerOptions['stage'];
+}): void {
+  try {
+    appendEvent({
+      type: 'peer_call_started',
+      timestamp: new Date().toISOString(),
+      sessionId: args.sessionId ?? 'unknown',
+      ...(args.stage !== undefined && args.stage !== 'init' && args.stage !== 'custom' ? { stage: args.stage } : {}),
+      payload: {
+        runtime_role: 'peer',
+        peer_id: args.peer,
+        role: args.role,
+      },
+    });
+  } catch {
+    // best-effort
+  }
+}
+
+/**
+ * v1.27.1 — emit `peer_call_complete` event. Fired after a successful
+ * dispatcher round-trip. Cost is null when the adapter doesn't return
+ * usage data (some peers don't surface token counts); the reflector
+ * tolerates null cost for arbitrage analysis (Plan 26-06).
+ */
+function _logPeerCallComplete(args: {
+  peer: string;
+  role: string;
+  latencyMs: number;
+  tokensIn: number;
+  tokensOut: number;
+  costUsd: number | null;
+  sessionId?: string;
+  stage?: SessionRunnerOptions['stage'];
+}): void {
+  try {
+    appendEvent({
+      type: 'peer_call_complete',
+      timestamp: new Date().toISOString(),
+      sessionId: args.sessionId ?? 'unknown',
+      ...(args.stage !== undefined && args.stage !== 'init' && args.stage !== 'custom' ? { stage: args.stage } : {}),
+      payload: {
+        runtime_role: 'peer',
+        peer_id: args.peer,
+        role: args.role,
+        latency_ms: args.latencyMs,
+        tokens_in: args.tokensIn,
+        tokens_out: args.tokensOut,
+        cost_usd: args.costUsd,
+      },
+    });
+  } catch {
+    // best-effort
+  }
 }
 
 /** Baseline retry backoff parameters (matches jittered-backoff defaults for
@@ -623,6 +738,38 @@ export async function run(opts: SessionRunnerOptions): Promise<SessionResult> {
     }
   }
 
+  // -- 6.5. Peer-CLI delegation try (Plan 27-06 wiring, v1.27.1). ---------
+  // If the agent's frontmatter declares `delegate_to: <peer>-<role>` AND the
+  // peer is allowlisted AND the registry can route, run the prompt on the
+  // peer-CLI and return early. On peer-absent / peer-error / null result,
+  // fall through transparently to the local SDK loop (D-07).
+  //
+  // tryDelegate is a no-op when opts.delegateTo is undefined / 'none', when
+  // the registry can't load, when the peer isn't allowlisted, when the
+  // dispatcher returns null, or when the dispatcher throws. In all those
+  // cases tryDelegate returns null and we proceed to the local SDK path.
+  const peerResult = await tryDelegate({
+    opts,
+    sanitizedPrompt,
+    transcriptPath,
+    sessionId,
+    sanitizer: sanResult,
+  });
+  if (peerResult !== null) {
+    emit('session.completed', opts.stage, sessionId, {
+      stage: opts.stage,
+      sessionId,
+      status: peerResult.status,
+      turns: peerResult.turns,
+      usage: peerResult.usage,
+      transcript_path: transcriptPath,
+      sanitizer: { applied: [...peerResult.sanitizer.applied], removedSections: [...peerResult.sanitizer.removedSections] },
+    });
+    transcript.close();
+    if (opts.signal !== undefined) opts.signal.removeEventListener('abort', onExternalAbort);
+    return peerResult;
+  }
+
   // -- 7. Retry-once loop. ------------------------------------------------
   const maxAttempts = opts.maxRetries !== undefined && opts.maxRetries > 0
     ? opts.maxRetries