@try-works/dsh-recursive-mode 0.3.0 → 0.4.0

package/scripts/e2e-run.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+/**
+ * FU-1 — the one-command end-to-end runner.
+ *
+ * Runs the E: harness (`tests/e2e-harness.spec.ts`) and then points at the run directory it produced, so
+ * a human can open the artifacts the workflow actually wrote. It KEEPS the run by default: a harness
+ * that deletes its own evidence is not debuggable, which is the whole reason this exists.
+ *
+ * Why a wrapper at all: the harness must import TypeScript sources, so it runs under vitest rather than
+ * bare node. This is the thin, repeatable entry point; the assertions live in the spec.
+ *
+ * Usage:  pnpm e2e            (keeps the run)
+ *         E2E_RUN_ROOT=D:\x pnpm e2e
+ */
+import { spawnSync } from 'node:child_process'
+import { existsSync, readdirSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+
+const preferred = process.env.E2E_RUN_ROOT ?? 'E:\\dsh-rm-e2e'
+const root = existsSync('E:\\') ? preferred : join(process.env.TEMP ?? '.', 'dsh-rm-e2e')
+
+console.log('[e2e] scratch root: ' + root)
+const result = spawnSync(
+  'pnpm',
+  ['exec', 'vitest', 'run', 'tests/e2e-harness.spec.ts'],
+  {
+    // ⚠ `shell: true` IS REQUIRED ON WINDOWS: spawning `pnpm.cmd` directly fails with EINVAL because
+    // Node cannot execute a batch file without a shell, and the failure is a NULL status with no output —
+    // the runner would exit 1 having printed nothing about why. The error is reported below for the same
+    // reason: a silent runner is worse than a failing one.
+    shell: true,
+    stdio: 'inherit',
+    env: { ...process.env, E2E_KEEP: '1', E2E_RUN_ROOT: root },
+  },
+)
+if (result.error) console.error('[e2e] could not run vitest: ' + result.error.message)
+if (result.status !== 0 && !result.error) console.error('[e2e] vitest exited ' + result.status)
+
+// Point at the newest run so the artifacts can be inspected without hunting for them.
+if (existsSync(root)) {
+  const runs = readdirSync(root)
+    .map((name) => ({ name, path: join(root, name), at: statSync(join(root, name)).mtimeMs }))
+    .sort((a, b) => b.at - a.at)
+  if (runs.length > 0) {
+    console.log('\n[e2e] newest run: ' + runs[0].path)
+    console.log('[e2e] report:     ' + join(runs[0].path, 'e2e-report.md'))
+    console.log('[e2e] run dir:    ' + join(runs[0].path, '.recursive', 'run', 'e2e-run'))
+  }
+}
+
+process.exit(result.status ?? 1)

package/scripts/link-dsh.mjs

@@ -0,0 +1,233 @@
+/**
+ * T34 — re-link the `@deepseek-ai/*` devDependencies at whatever depth this repo
+ * happens to sit.
+ *
+ * THE DEFECT THIS FIXES. `package.json` declares each harness dependency as
+ * `link:D:/deepseek-harness/packages/...` — an ABSOLUTE path — but pnpm records the
+ * target RELATIVE in the lockfile (`version: link:../../deepseek-harness/...`). So
+ * `pnpm install` only produces working links when the repo sits at exactly the depth
+ * the lockfile assumed: two levels below the drive root, beside the checkout. Clone
+ * it anywhere else — deeper, or on another drive — and every `@deepseek-ai/*` module
+ * becomes unresolvable: `tsc` reports `TS2307: Cannot find module` for all of `src/`,
+ * and the specs that import them fail to load. A public repo that cannot be cloned
+ * anywhere is a defect, not a documentation gap.
+ *
+ * THE FIX, AND WHY IT IS THIS ONE. The absolute targets are already IN
+ * `package.json`, so the links can be rebuilt from it with no network, no registry
+ * and no re-resolution — which matters because the pinned revision is a local
+ * checkout that is not published. `DSH_HARNESS_ROOT` relocates the whole set when the
+ * checkout itself moved. An absent checkout DEGRADES with a clear message and exit 0
+ * rather than failing the install: a machine without the harness can still read the
+ * repo, and the failure it will see is the honest "this module is not linked".
+ *
+ * Windows note: directory symlinks need elevation, junctions do not — so this uses
+ * `junction` on win32, which is also what pnpm itself does.
+ */
+import { existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, rmSync, symlinkSync, unlinkSync } from 'node:fs'
+import { dirname, join, relative, resolve, sep } from 'node:path'
+
+/** The package name prefix every harness dependency shares. */
+export const LINKED_SCOPE = '@deepseek-ai/'
+
+/**
+ * Layout directories that the inferred common prefix must not swallow: dropping one
+ * of these from a link target would point it at the wrong place.
+ */
+const LAYOUT_SEGMENTS = new Set(['packages', 'vendor'])
+
+/**
+ * The root the recorded absolute targets share, so a moved checkout can be
+ * relocated coherently. Returns null when the specs do not share one (which would
+ * mean the repo was hand-edited into an inconsistent state).
+ *
+ * The common prefix can OVERSHOOT into a layout directory: when every dependency
+ * happens to live under one subtree (all under `packages/`, say), the prefix stops
+ * at `packages` and re-rooting would silently drop that segment, pointing every link
+ * at `<root>/<pkg>` instead of `<root>/packages/<pkg>`. This repo's real dependency
+ * set spans `packages/` and `vendor/`, so the prefix already lands on the checkout
+ * root — but a set that does not must not silently produce wrong targets, so a
+ * trailing layout segment is stripped. `DSH_HARNESS_ROOT` therefore always means the
+ * CHECKOUT ROOT, which is what a user would expect to pass.
+ * @param {{ [name: string]: string }} devDependencies
+ * @returns {string | null}
+ */
+export function pinnedRootOf(devDependencies) {
+  const targets = linkTargetsOf(devDependencies).map((entry) => entry.target)
+  if (targets.length === 0) return null
+  const split = targets.map((target) => target.split(/[\\/]/))
+  const first = split[0]
+  const common = []
+  for (let i = 0; i < first.length; i += 1) {
+    const candidate = first[i]
+    if (!split.every((parts) => parts[i] === candidate)) break
+    common.push(candidate)
+  }
+  if (common.length > 1 && LAYOUT_SEGMENTS.has(common[common.length - 1])) common.pop()
+  return common.join('/') || null
+}
+
+/**
+ * Every scoped dependency declared as a `link:` spec, with its absolute target.
+ * @param {{ [name: string]: string }} devDependencies
+ * @returns {Array<{ name: string; target: string }>}
+ */
+export function linkTargetsOf(devDependencies) {
+  const out = []
+  for (const [name, spec] of Object.entries(devDependencies ?? {})) {
+    if (!name.startsWith(LINKED_SCOPE)) continue
+    if (typeof spec !== 'string' || !spec.startsWith('link:')) continue
+    out.push({ name, target: spec.slice('link:'.length).replace(/\\/g, '/') })
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name))
+}
+
+/**
+ * Where each dependency should point, given an optional relocated checkout root.
+ * @param {{ devDependencies?: object, harnessRoot?: string | null }} input
+ * @returns {Array<{ name: string; target: string; exists: boolean }>}
+ */
+export function planLinks(input) {
+  const targets = linkTargetsOf(input.devDependencies)
+  const pinned = pinnedRootOf(input.devDependencies)
+  const root = input.harnessRoot ?? pinned
+  return targets.map(({ name, target }) => {
+    let resolvedTarget = target
+    if (input.harnessRoot && pinned && target.startsWith(pinned)) {
+      const rest = relative(pinned, target).split(sep).join('/')
+      resolvedTarget = join(input.harnessRoot, rest).replace(/\\/g, '/')
+    }
+    return { name, target: resolvedTarget, exists: existsSync(resolvedTarget) }
+  })
+}
+
+/** Where a scoped package's link lives inside the repo. */
+export function linkPathOf(repoRoot, name) {
+  return join(repoRoot, 'node_modules', ...name.split('/'))
+}
+
+/** True when the path is already a link (or junction) to the wanted target. */
+function alreadyLinked(path, target) {
+  try {
+    const stat = lstatSync(path)
+    if (!stat.isSymbolicLink()) return false
+    const current = readlinkSync(path).replace(/\\/g, '/')
+    return resolve(current) === resolve(target)
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Remove whatever currently occupies a link path.
+ *
+ * A LINK IS NOT A DIRECTORY. `rmSync(..., { recursive: true })` does not reliably
+ * remove a junction whose target is gone — which is exactly the state a clone at the
+ * wrong depth leaves behind, because pnpm created links to a relative path that does
+ * not exist. The removal then silently failed and every `symlinkSync` after it threw
+ * `EEXIST`. Links are therefore unlinked, not recursed into (which is also the SAFE
+ * choice: recursing through a live junction would delete the checkout's contents).
+ */
+function removeExisting(path) {
+  try {
+    const stat = lstatSync(path)
+    if (stat.isSymbolicLink()) {
+      unlinkSync(path)
+      return
+    }
+    rmSync(path, { recursive: true, force: true })
+  } catch (err) {
+    if (err && err.code === 'ENOENT') return
+    throw err
+  }
+}
+
+/**
+ * Create or repair every harness link under `<repoRoot>/node_modules`.
+ *
+ * Idempotent, and never throws for a missing checkout: the caller gets a report so
+ * it can print an honest message instead of a stack trace. Failures are RETURNED in
+ * `errors` as well as logged, because a logger that defaults to silence once hid
+ * fifteen of them.
+ * @param {{ repoRoot: string; devDependencies?: object; harnessRoot?: string | null; log?: (line: string) => void }} input
+ * @returns {{ linked: string[]; repaired: string[]; missing: string[]; errors: Array<{ name: string; message: string }> }}
+ */
+export function linkDsh(input) {
+  const log = input.log ?? (() => {})
+  const plan = planLinks({ devDependencies: input.devDependencies, harnessRoot: input.harnessRoot })
+  const linked = []
+  const repaired = []
+  const missing = []
+  const errors = []
+  for (const entry of plan) {
+    if (!entry.exists) {
+      missing.push(entry.name)
+      continue
+    }
+    const path = linkPathOf(input.repoRoot, entry.name)
+    if (alreadyLinked(path, entry.target)) {
+      repaired.push(entry.name)
+      continue
+    }
+    try {
+      mkdirSync(dirname(path), { recursive: true })
+      removeExisting(path)
+      symlinkSync(entry.target, path, process.platform === 'win32' ? 'junction' : 'dir')
+      linked.push(entry.name)
+    } catch (err) {
+      // One un-linkable package must not abort the rest: the remaining links are
+      // still worth having, and the caller reports what failed.
+      const message = err instanceof Error ? err.message : String(err)
+      errors.push({ name: entry.name, message })
+      missing.push(entry.name)
+      log('  ! ' + entry.name + ': ' + message)
+    }
+  }
+  return { linked, repaired, missing, errors }
+}
+
+/** Read this repo's devDependencies (the absolute targets live there, not in the lockfile). */
+export function readDevDependencies(repoRoot) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(repoRoot, 'package.json'), 'utf8'))
+    return pkg.devDependencies ?? {}
+  } catch {
+    return {}
+  }
+}
+
+function main() {
+  const repoRoot = resolve(process.argv[2] ?? process.cwd())
+  const harnessRoot = process.env.DSH_HARNESS_ROOT ? resolve(process.env.DSH_HARNESS_ROOT) : null
+  const devDependencies = readDevDependencies(repoRoot)
+  const planned = planLinks({ devDependencies, harnessRoot })
+
+  if (planned.length === 0) {
+    console.log('[link-dsh] no ' + LINKED_SCOPE + '* link: dependencies to place')
+    return
+  }
+  const absentRoot = planned.every((entry) => !entry.exists)
+  if (absentRoot) {
+    console.log('[link-dsh] the DSH checkout was not found at ' + (harnessRoot ?? pinnedRootOf(devDependencies)))
+    console.log('[link-dsh] set DSH_HARNESS_ROOT to its location to link ' + planned.length + ' packages, e.g.')
+    console.log('[link-dsh]   DSH_HARNESS_ROOT=/path/to/deepseek-harness pnpm run link:dsh')
+    console.log('[link-dsh] continuing WITHOUT links: typecheck and tests will report unresolved modules')
+    return
+  }
+
+  const report = linkDsh({ repoRoot, devDependencies, harnessRoot, log: (line) => console.log(line) })
+  const placed = report.linked.length
+  const kept = report.repaired.length
+  console.log('[link-dsh] linked ' + placed + ', already correct ' + kept + ', unresolved ' + report.missing.length)
+  if (report.errors.length > 0) {
+    // Failures are printed unconditionally: a logger defaulting to silence once hid
+    // fifteen of them behind a cheerful "unresolved 15".
+    console.log('[link-dsh] FAILED to link ' + report.errors.length + ' package(s); first error: ' + report.errors[0].message)
+  }
+  if (report.missing.length > 0) {
+    console.log('[link-dsh] unresolved: ' + report.missing.join(', '))
+  }
+}
+
+if (process.argv[1] && import.meta.url === new URL('file://' + resolve(process.argv[1]).replace(/\\/g, '/')).href) {
+  main()
+}

package/scripts/live/fake-llm.mjs

@@ -0,0 +1,150 @@
+/**
+ * FU-10 — a SCRIPTED LLM for the live-session harness.
+ *
+ * WHY THIS EXISTS. A real session needs a model, and a real model would make the verification
+ * non-deterministic and cost money. The harness's own e2e does exactly this: it registers a keyless
+ * `LlmAdapter` on the default provider route and scripts the tool calls it wants to see. The shape below
+ * is copied from `apps/cli/tests/profiles/headless/tests/fixtures/team-llm.mjs` — a class extending
+ * `LlmAdapter` whose `stream()` yields chunk objects, registered through `ctx.llm.registerAdapter`.
+ *
+ * WHAT IT SCRIPTS: the smallest sequence that reaches the delegated review path in a REAL session —
+ * `recursive_init`, then `recursive_review`, then a plain-text answer. Everything else about the session
+ * (the Agent, the tool runtime, the plugin, the enforcement) is the real thing; only the model is fake.
+ */
+import { ToolCallId } from '@deepseek-ai/dsh-llm'
+import { LlmAdapter } from '@deepseek-ai/dsh-llm'
+import { writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+/**
+ * ⚠ FU-9 — THE ADAPTER PLAYS THE CHILD TOO.
+ *
+ * The parent leg alone could never exercise the repair: the review parks waiting for its child's reply, so
+ * a REVISE verdict is what makes the plugin send a `followup` to the SAME child. This adapter therefore
+ * also answers the child's brief, and it flips its verdict on the SECOND round so the loop closes:
+ *
+ *   round 1 (the brief)      → write a REVISE verdict to the reply file the brief names
+ *   round 2 (after REPAIR)   → write an APPROVE verdict to that SAME file
+ *
+ * The reply format is measured from `parseReplyVerdict` (`src/delegation.ts`): a JSON object with a
+ * `verdict` field, fenced or bare. Anything else and the runtime would fail closed — which is correct
+ * behaviour and would prove nothing about the repair.
+ */
+const repliesWritten = new Map()
+
+const REVISE_REPLY = [
+  '# Review reply',
+  '',
+  '```json',
+  '{"verdict":"REVISE","findings":[{"title":"the lock chain permits an out-of-order transition"}]}',
+  '```',
+  '',
+].join('\n')
+
+const APPROVE_REPLY = [
+  '# Review reply (after repair)',
+  '',
+  '```json',
+  '{"verdict":"APPROVE","findings":[]}',
+  '```',
+  '',
+].join('\n')
+
+/** The text a turn was handed, from the user and system messages. */
+function inputText(messages) {
+  return messages
+    .filter((message) => message.role === 'user' || message.role === 'system')
+    .flatMap((message) => (message.content ?? []).filter((block) => block.type === 'text').map((block) => block.text))
+    .join('\n')
+}
+
+/** Every tool call this session has already made, read back from the conversation. */
+function calledTools(messages) {
+  return messages.flatMap((message) => message.role === 'assistant'
+    ? message.content.filter((block) => block.type === 'tool-call').map((block) => block.name)
+    : [])
+}
+
+function toolCallChunks(specs, counter) {
+  const chunks = []
+  for (const [index, spec] of specs.entries()) {
+    const id = ToolCallId(`live-fixture-${counter.n++}`)
+    const args = JSON.stringify(spec.args)
+    chunks.push(
+      { type: 'block-start', index, blockType: 'tool-call' },
+      { type: 'tool-call-delta', index, id, name: spec.name, argumentsDelta: args },
+      { type: 'block-end', index, block: { type: 'tool-call', id, name: spec.name, arguments: args } },
+    )
+  }
+  chunks.push(
+    { type: 'usage', usage: { inputTokens: 10, outputTokens: 5 } },
+    { type: 'finish', reason: { kind: 'tool-calls' } },
+  )
+  return chunks
+}
+
+function textChunks(text) {
+  return [
+    { type: 'block-start', index: 0, blockType: 'text' },
+    { type: 'text-delta', index: 0, text },
+    { type: 'block-end', index: 0, block: { type: 'text', text } },
+    { type: 'usage', usage: { inputTokens: 10, outputTokens: 5 } },
+    { type: 'finish', reason: { kind: 'stop' } },
+  ]
+}
+
+const RUN_ID = 'live-run'
+
+class LiveFixtureAdapter extends LlmAdapter {
+  counter = { n: 0 }
+
+  async * stream(options) {
+    const messages = options.messages ?? []
+    const called = calledTools(messages)
+
+    // THE CHILD'S TURN — the brief names the reply file, so this turn belongs to the delegated reviewer.
+    // First time: REVISE (which is what makes the plugin send a repair to this SAME child). Second time:
+    // APPROVE, closing the loop.
+    const reply = inputText(messages).match(/Reply file:\s*(\S+)/i)
+    if (reply) {
+      const replyPath = reply[1]
+      const already = repliesWritten.get(replyPath) === true
+      writeFileSync(join(process.cwd(), replyPath), already ? APPROVE_REPLY : REVISE_REPLY, 'utf8')
+      repliesWritten.set(replyPath, true)
+      yield* textChunks(already
+        ? 'APPROVE written to ' + replyPath + ' after the repair.'
+        : 'REVISE written to ' + replyPath + '.')
+      return
+    }
+
+    // 1. Scaffold the run.
+    if (!called.includes('recursive_init')) {
+      yield* toolCallChunks([{ name: 'recursive_init', args: { runId: RUN_ID } }], this.counter)
+      return
+    }
+    // 2. Ask for a review of phase 03 — the delegated path FU-9 is about.
+    //
+    // ⚠ ASKED REPEATEDLY, ON PURPOSE, because the review is TURN-SHAPED: the first call PARKS waiting for
+    // the child, and it is a LATER turn that resumes the SAME child (T36: "park, resume the SAME child").
+    // A script that asked once left the child with no turn at all — proven by a run whose reply.md was
+    // never written. Each further call drives one more round, which is what lets a REVISE verdict produce a
+    // repair and then an APPROVE.
+    const reviewCalls = called.filter((name) => name === 'recursive_review').length
+    if (reviewCalls < 4) {
+      yield* toolCallChunks([{ name: 'recursive_review', args: { runId: RUN_ID, phase: '03', role: 'code-reviewer' } }], this.counter)
+      return
+    }
+    // 3. Report and stop. The marker is what the harness greps for in the session log.
+    yield* textChunks('LIVE_SESSION_REACHED_REVIEW')
+  }
+}
+
+/** Cordis plugin name. */
+export const name = 'live-fixture-llm'
+/** The LLM registry this adapter registers into. */
+export const inject = ['llm']
+
+/** Register the keyless adapter on the shipped default provider route. */
+export function apply(ctx) {
+  ctx.llm.registerAdapter(['deepseek-official'], new LiveFixtureAdapter())
+}

package/scripts/live-session-plugin.mjs

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+/**
+ * FU-10 step 2 — THE LIVE SESSION WITH THIS PLUGIN MOUNTED.
+ *
+ * Derived from `live-session-stock.mjs`, which is PROVEN to boot (exit 0, agents ran, session logs
+ * written). Exactly two things change, and nothing else — that is the point of deriving rather than
+ * rewriting:
+ *
+ *   1. the scripted LLM is OURS (`scripts/live/fake-llm.mjs`), scripting `recursive_init` then
+ *      `recursive_review`, so a session that gets that far has reached the delegated review path;
+ *   2. THIS PLUGIN is inserted into the profile **by file URL**, the pattern the harness uses for its own
+ *      fixture — so no install and no dependency added to this repo.
+ *
+ * ⚠ EVERYTHING ELSE IS THE PROVEN RECIPE: the fixture's `dependencies` AND its three bundles (my
+ * hand-written profile was rejected as invalid without them), the same patch shape, the filtered env (a
+ * child must not inherit this session's `DSH_PROFILE=web`), and the absolute tsx loader file URL.
+ */
+import { spawnSync } from 'node:child_process'
+import { existsSync, mkdirSync, openSync, closeSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const HARNESS = 'D:\\deepseek-harness'
+const PLUGIN = 'D:\\DEV\\dsh-recursive-mode'
+const SRC_BIN = join(HARNESS, 'apps', 'cli', 'src', 'bin.ts')
+const TSCONFIG = join(HARNESS, 'tsconfig.json')
+const TSX_LOADER = 'file:///D:/deepseek-harness/node_modules/.pnpm/tsx@4.22.4/node_modules/tsx/dist/loader.mjs'
+const PROMPT = 'Run recursive_init for run live-run, then ask recursive_review to review phase 03.'
+
+const fileUrl = (path) => 'file:///' + path.replace(/\\/g, '/')
+const base = join(existsSync('E:\\') ? 'E:\\dsh-rm-live' : tmpdir(), 'plugin-' + new Date().toISOString().replace(/[:.]/g, '-'))
+const home = join(base, '.dsh')
+const repo = join(base, 'repo')
+const sessions = join(home, 'sessions')
+const profileDir = join(home, 'profiles', 'headless')
+
+mkdirSync(profileDir, { recursive: true })
+mkdirSync(sessions, { recursive: true })
+mkdirSync(join(repo, 'src'), { recursive: true })
+writeFileSync(join(repo, 'README.md'), '# live session scratch repo\n', 'utf8')
+spawnSync('git', ['init', '-q'], { cwd: repo, stdio: 'ignore' })
+
+// The PROVEN profile (fixture deps + fixture bundles), verbatim.
+writeFileSync(join(profileDir, 'package.json'), JSON.stringify({
+  name: 'dsh-profile-headless',
+  private: true,
+  dependencies: { '@deepseek-ai/dsh-experimental-agent-team-profile': 'workspace:^' },
+  dsh: {
+    profile: {
+      bundles: [
+        '@deepseek-ai/dsh-base',
+        '@deepseek-ai/dsh-headless',
+        '@deepseek-ai/dsh-experimental-agent-team-profile',
+      ],
+    },
+  },
+}, undefined, 2) + '\n', 'utf8')
+
+// The patch: real provider off, sessions into the temp home, OUR LLM and OUR PLUGIN inserted by file URL.
+writeFileSync(join(profileDir, 'cordis.patch.yml'), [
+  '- id: llm-deepseek',
+  '  disabled: true',
+  '- id: session-persistence-jsonl',
+  '  config:',
+  "    root: '" + sessions.replace(/\\/g, '/') + "'",
+  '    compression: none',
+  '- insert:',
+  '    - id: live-fixture-llm',
+  "      name: '" + fileUrl(join(PLUGIN, 'scripts', 'live', 'fake-llm.mjs')) + "'",
+  '    - id: recursive-mode',
+  "      name: '" + fileUrl(join(PLUGIN, 'src', 'index.ts')) + "'",
+  '',
+].join('\n'), 'utf8')
+
+const outFile = join(base, 'stdout.txt')
+const errFile = join(base, 'stderr.txt')
+const outFd = openSync(outFile, 'w')
+const errFd = openSync(errFile, 'w')
+
+const env = { ...process.env }
+for (const key of ['DSH_PROFILE', 'DSH_PROFILE_DIR', 'DSH_SESSION_ID', 'DSH_SHELL', 'DSH_WEB_URL']) delete env[key]
+
+console.log('[plugin] base: ' + base)
+console.log('[plugin] repo: ' + repo)
+const result = spawnSync(process.execPath, [
+  '--import', TSX_LOADER,
+  SRC_BIN,
+  '--profile', 'headless',
+  PROMPT,
+], {
+  cwd: repo,
+  stdio: ['ignore', outFd, errFd],
+  env: {
+    ...env,
+    DSH_HOME: home,
+    DSH_AGENTS_HOME: join(base, '.agents'),
+    DSH_TELEMETRY_DISABLED: '1',
+    DEEPSEEK_API_KEY: '',
+    TSX_TSCONFIG_PATH: TSCONFIG,
+  },
+})
+closeSync(outFd)
+closeSync(errFd)
+
+const stdout = existsSync(outFile) ? readFileSync(outFile, 'utf8') : ''
+const stderr = existsSync(errFile) ? readFileSync(errFile, 'utf8') : ''
+console.log('[plugin] exit: ' + result.status + (result.error ? ' (spawn error: ' + result.error.message + ')' : ''))
+console.log('[plugin] stdout: ' + stdout.length + ' bytes | stderr: ' + stderr.length + ' bytes')
+if (stdout.trim() !== '') console.log('--- stdout tail ---\n' + stdout.trim().split('\n').slice(-14).join('\n'))
+if (stderr.trim() !== '') console.log('--- stderr tail ---\n' + stderr.trim().split('\n').slice(-14).join('\n'))
+
+/**
+ * FU-9 — THE SECOND, RESUMED INVOCATION.
+ *
+ * ⚠ WHY IT IS NEEDED, MEASURED: the review PARKS (T36's turn-shaped driver treats waiting as not-an-error)
+ * and a ONE-SHOT session exits before the child's first turn is ever scheduled — a run left no child
+ * session, no settlement and no reply. The headless app supports `--session-id`, documented as *"resumes a
+ * conversation that already exists"* (`packages/bundle/headless/src/index.ts`, via
+ * `agents.resume({ resumeSessionId })`), so the parked round gets a later turn in the SAME conversation —
+ * which is the shape this plugin was built for.
+ */
+function sessionIdUnder(root) {
+  if (!existsSync(root)) return null
+  for (const scoped of readdirSync(root, { withFileTypes: true })) {
+    if (!scoped.isDirectory()) continue
+    for (const inner of readdirSync(join(root, scoped.name), { withFileTypes: true })) {
+      // ⚠ THE PREFIX STAYS. Measured: passing the bare uuid gives
+      // `dsh: session "<uuid>" does not exist; omit --session-id to start a new Session` — the session id
+      // the CLI knows is the whole `session-<uuid>`, which is also what the log's first record carries.
+      if (inner.isDirectory() && inner.name.startsWith('session-')) return inner.name
+    }
+  }
+  return null
+}
+
+const sessionId = sessionIdUnder(sessions)
+if (sessionId !== null) {
+  const outFile2 = join(base, 'stdout-resume.txt')
+  const errFile2 = join(base, 'stderr-resume.txt')
+  const outFd2 = openSync(outFile2, 'w')
+  const errFd2 = openSync(errFile2, 'w')
+  console.log('[plugin] resuming session: ' + sessionId)
+  const resumed = spawnSync(process.execPath, [
+    '--import', TSX_LOADER,
+    SRC_BIN,
+    '--profile', 'headless',
+    '--session-id', sessionId,
+    'The reviewer has replied. Continue the review round and report the verdict.',
+  ], {
+    cwd: repo,
+    stdio: ['ignore', outFd2, errFd2],
+    env: {
+      ...env,
+      DSH_HOME: home,
+      DSH_AGENTS_HOME: join(base, '.agents'),
+      DSH_TELEMETRY_DISABLED: '1',
+      DEEPSEEK_API_KEY: '',
+      TSX_TSCONFIG_PATH: TSCONFIG,
+    },
+  })
+  closeSync(outFd2)
+  closeSync(errFd2)
+  const out2 = existsSync(outFile2) ? readFileSync(outFile2, 'utf8') : ''
+  console.log('[plugin] resume exit: ' + resumed.status + ' | stdout: ' + out2.trim().split('\n').slice(-4).join(' / '))
+} else {
+  console.log('[plugin] resume SKIPPED: no session id found to resume')
+}
+
+// The evidence a run happened: OUR plugin's run directory, written by its own tools in a real session.
+const runDir = join(repo, '.recursive', 'run', 'live-run')
+console.log('[plugin] run directory exists: ' + existsSync(runDir))
+if (existsSync(runDir)) {
+  const files = readdirSync(runDir).slice(0, 12)
+  console.log('[plugin] run artifacts: ' + files.join(', '))
+}
+const reviews = existsSync(join(runDir, 'subagents')) ? readdirSync(join(runDir, 'subagents')).slice(0, 6) : []
+console.log('[plugin] subagents dir: ' + (reviews.length > 0 ? reviews.join(', ') : '(none)'))
+const logs = existsSync(sessions) ? readdirSync(sessions, { recursive: true }).map(String).filter((n) => n.endsWith('.jsonl')) : []
+console.log('[plugin] session logs: ' + logs.length)