oh-my-codex 0.13.2 → 0.14.1

package/dist/cli/__tests__/autoresearch-guided.test.js

@@ -1,33 +1,29 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { parseSandboxContract } from '../../autoresearch/contracts.js';
-import { isLaunchReadyEvaluatorCommand, resolveAutoresearchDeepInterviewResult, writeAutoresearchDeepInterviewArtifacts, writeAutoresearchDraftArtifact, } from '../autoresearch-intake.js';
-import { buildAutoresearchDeepInterviewPrompt, initAutoresearchMission, parseInitArgs, checkTmuxAvailable, runAutoresearchNoviceBridge, spawnAutoresearchTmux, } from '../autoresearch-guided.js';
-import { OMX_ENTRY_PATH_ENV, OMX_STARTUP_CWD_ENV } from '../../utils/paths.js';
-async function initRepo() {
-    const cwd = await mkdtemp(join(tmpdir(), 'omx-autoresearch-guided-test-'));
-    execFileSync('git', ['init'], { cwd, stdio: 'ignore' });
-    execFileSync('git', ['config', 'user.email', 'test@example.com'], { cwd, stdio: 'ignore' });
-    execFileSync('git', ['config', 'user.name', 'Test User'], { cwd, stdio: 'ignore' });
-    const { writeFile } = await import('node:fs/promises');
-    await writeFile(join(cwd, 'README.md'), 'hello\n', 'utf-8');
-    execFileSync('git', ['add', 'README.md'], { cwd, stdio: 'ignore' });
-    execFileSync('git', ['commit', '-m', 'init'], { cwd, stdio: 'ignore' });
-    return cwd;
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+import { OmxQuestionError } from "../../question/client.js";
+import { buildAutoresearchDeepInterviewPrompt, parseInitArgs, runAutoresearchNoviceBridge, } from "../autoresearch-guided.js";
+import { isLaunchReadyEvaluatorCommand, resolveAutoresearchDeepInterviewResult, writeAutoresearchDeepInterviewArtifacts, writeAutoresearchDraftArtifact, } from "../autoresearch-intake.js";
+async function initWorkspace() {
+    return mkdtemp(join(tmpdir(), "omx-autoresearch-guided-test-"));
 }
 function withMockedTty(fn) {
-    const descriptor = Object.getOwnPropertyDescriptor(process.stdin, 'isTTY');
-    Object.defineProperty(process.stdin, 'isTTY', { configurable: true, value: true });
+    const descriptor = Object.getOwnPropertyDescriptor(process.stdin, "isTTY");
+    Object.defineProperty(process.stdin, "isTTY", {
+        configurable: true,
+        value: true,
+    });
     return fn().finally(() => {
         if (descriptor) {
-            Object.defineProperty(process.stdin, 'isTTY', descriptor);
+            Object.defineProperty(process.stdin, "isTTY", descriptor);
         }
         else {
-            Object.defineProperty(process.stdin, 'isTTY', { configurable: true, value: false });
+            Object.defineProperty(process.stdin, "isTTY", {
+                configurable: true,
+                value: false,
+            });
         }
     });
 }
@@ -35,222 +31,122 @@ function makeFakeIo(answers) {
     const queue = [...answers];
     return {
         async question() {
-            return queue.shift() ?? '';
+            return queue.shift() ?? "";
         },
         close() { },
     };
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-describe('initAutoresearchMission', () => {
-    it('creates mission.md with correct content', async () => {
-        const repo = await initRepo();
-        try {
-            const result = await initAutoresearchMission({
-                topic: 'Improve test coverage for the auth module',
-                evaluatorCommand: 'node scripts/eval.js',
-                keepPolicy: 'score_improvement',
-                slug: 'auth-coverage',
-                repoRoot: repo,
-            });
-            assert.equal(result.slug, 'auth-coverage');
-            assert.equal(result.missionDir, join(repo, 'missions', 'auth-coverage'));
-            const missionContent = await readFile(join(result.missionDir, 'mission.md'), 'utf-8');
-            assert.match(missionContent, /# Mission/);
-            assert.match(missionContent, /Improve test coverage for the auth module/);
-        }
-        finally {
-            await rm(repo, { recursive: true, force: true });
-        }
-    });
-    it('creates sandbox.md with valid YAML frontmatter', async () => {
-        const repo = await initRepo();
-        try {
-            const result = await initAutoresearchMission({
-                topic: 'Optimize database queries',
-                evaluatorCommand: 'node scripts/eval-perf.js',
-                keepPolicy: 'pass_only',
-                slug: 'db-perf',
-                repoRoot: repo,
-            });
-            const sandboxContent = await readFile(join(result.missionDir, 'sandbox.md'), 'utf-8');
-            assert.match(sandboxContent, /^---\n/);
-            assert.match(sandboxContent, /evaluator:/);
-            assert.match(sandboxContent, /command: node scripts\/eval-perf\.js/);
-            assert.match(sandboxContent, /format: json/);
-            assert.match(sandboxContent, /keep_policy: pass_only/);
-        }
-        finally {
-            await rm(repo, { recursive: true, force: true });
-        }
-    });
-    it('generated sandbox.md passes parseSandboxContract validation', async () => {
-        const repo = await initRepo();
-        try {
-            const result = await initAutoresearchMission({
-                topic: 'Fix flaky tests',
-                evaluatorCommand: 'bash run-tests.sh',
-                keepPolicy: 'score_improvement',
-                slug: 'flaky-tests',
-                repoRoot: repo,
-            });
-            const sandboxContent = await readFile(join(result.missionDir, 'sandbox.md'), 'utf-8');
-            const parsed = parseSandboxContract(sandboxContent);
-            assert.equal(parsed.evaluator.command, 'bash run-tests.sh');
-            assert.equal(parsed.evaluator.format, 'json');
-            assert.equal(parsed.evaluator.keep_policy, 'score_improvement');
-        }
-        finally {
-            await rm(repo, { recursive: true, force: true });
-        }
-    });
-    it('throws if mission directory already exists', async () => {
-        const repo = await initRepo();
-        try {
-            const missionDir = join(repo, 'missions', 'existing');
-            await mkdir(missionDir, { recursive: true });
-            await assert.rejects(() => initAutoresearchMission({
-                topic: 'duplicate',
-                evaluatorCommand: 'echo ok',
-                keepPolicy: 'pass_only',
-                slug: 'existing',
-                repoRoot: repo,
-            }), /already exists/);
-        }
-        finally {
-            await rm(repo, { recursive: true, force: true });
+function makeFakeStructuredQuestionAsker(answers, questions = []) {
+    const queue = [...answers];
+    return async (input) => {
+        questions.push({
+            question: input.question,
+            options: input.options.map((option) => option.value),
+            allowOther: input.allow_other,
+        });
+        const next = queue.shift() ?? "";
+        const matchingOption = input.options.find((option) => option.value === next);
+        if (matchingOption) {
+            return {
+                ok: true,
+                question_id: `q-${questions.length}`,
+                prompt: {
+                    header: input.header,
+                    question: input.question,
+                    options: input.options,
+                    allow_other: input.allow_other,
+                    other_label: input.other_label ?? "Other",
+                    multi_select: input.multi_select ?? false,
+                    source: input.source,
+                },
+                answer: {
+                    kind: "option",
+                    value: matchingOption.value,
+                    selected_labels: [matchingOption.label],
+                    selected_values: [matchingOption.value],
+                },
+            };
         }
-    });
-});
-describe('parseInitArgs', () => {
-    it('parses all flags with space-separated values', () => {
+        return {
+            ok: true,
+            question_id: `q-${questions.length}`,
+            prompt: {
+                header: input.header,
+                question: input.question,
+                options: input.options,
+                allow_other: input.allow_other,
+                other_label: input.other_label ?? "Other",
+                multi_select: input.multi_select ?? false,
+                source: input.source,
+            },
+            answer: {
+                kind: "other",
+                value: next,
+                selected_labels: [input.other_label ?? "Other"],
+                selected_values: [next],
+                other_text: next,
+            },
+        };
+    };
+}
+describe("parseInitArgs", () => {
+    it("parses all flags with space-separated values", () => {
         const result = parseInitArgs([
-            '--topic', 'my topic',
-            '--evaluator', 'node eval.js',
-            '--keep-policy', 'pass_only',
-            '--slug', 'my-slug',
+            "--topic",
+            "my topic",
+            "--evaluator",
+            "node eval.js",
+            "--keep-policy",
+            "pass_only",
+            "--slug",
+            "my-slug",
         ]);
-        assert.equal(result.topic, 'my topic');
-        assert.equal(result.evaluatorCommand, 'node eval.js');
-        assert.equal(result.keepPolicy, 'pass_only');
-        assert.equal(result.slug, 'my-slug');
+        assert.equal(result.topic, "my topic");
+        assert.equal(result.evaluatorCommand, "node eval.js");
+        assert.equal(result.keepPolicy, "pass_only");
+        assert.equal(result.slug, "my-slug");
     });
-    it('parses all flags with = syntax', () => {
+    it("parses all flags with = syntax", () => {
         const result = parseInitArgs([
-            '--topic=my topic',
-            '--evaluator=node eval.js',
-            '--keep-policy=score_improvement',
-            '--slug=my-slug',
+            "--topic=my topic",
+            "--evaluator=node eval.js",
+            "--keep-policy=score_improvement",
+            "--slug=my-slug",
         ]);
-        assert.equal(result.topic, 'my topic');
-        assert.equal(result.evaluatorCommand, 'node eval.js');
-        assert.equal(result.keepPolicy, 'score_improvement');
-        assert.equal(result.slug, 'my-slug');
+        assert.equal(result.topic, "my topic");
+        assert.equal(result.evaluatorCommand, "node eval.js");
+        assert.equal(result.keepPolicy, "score_improvement");
+        assert.equal(result.slug, "my-slug");
     });
-    it('returns partial result when some flags are missing', () => {
-        const result = parseInitArgs(['--topic', 'my topic']);
-        assert.equal(result.topic, 'my topic');
+    it("returns partial result when some flags are missing", () => {
+        const result = parseInitArgs(["--topic", "my topic"]);
+        assert.equal(result.topic, "my topic");
         assert.equal(result.evaluatorCommand, undefined);
         assert.equal(result.keepPolicy, undefined);
         assert.equal(result.slug, undefined);
     });
-    it('throws on invalid keep-policy', () => {
-        assert.throws(() => parseInitArgs(['--keep-policy', 'invalid']), /must be one of/);
+    it("throws on invalid keep-policy", () => {
+        assert.throws(() => parseInitArgs(["--keep-policy", "invalid"]), /must be one of/);
     });
-    it('throws on unknown flags', () => {
-        assert.throws(() => parseInitArgs(['--unknown-flag', 'value']), /Unknown init flag: --unknown-flag/);
+    it("throws on unknown flags", () => {
+        assert.throws(() => parseInitArgs(["--unknown-flag", "value"]), /Unknown init flag: --unknown-flag/);
     });
-    it('sanitizes slug via slugifyMissionName', () => {
-        const result = parseInitArgs(['--slug', '../../etc/cron.d/omx']);
+    it("sanitizes slug via slugifyMissionName", () => {
+        const result = parseInitArgs(["--slug", "../../etc/cron.d/omx"]);
         assert.ok(result.slug);
         assert.doesNotMatch(result.slug, /\.\./);
         assert.doesNotMatch(result.slug, /\//);
     });
 });
-describe('checkTmuxAvailable', () => {
-    it('returns a boolean', () => {
-        const result = checkTmuxAvailable();
-        assert.equal(typeof result, 'boolean');
-    });
-    it('launches background tmux sessions with an absolute omx entry path even from a relative launcher', async () => {
-        const repo = await initRepo();
-        const fakeBin = await mkdtemp(join(tmpdir(), 'omx-autoresearch-guided-bin-'));
-        const startupCwd = await mkdtemp(join(tmpdir(), 'omx-autoresearch-guided-start-'));
-        const missionDir = join(repo, 'missions', 'demo');
-        const tmuxLog = join(repo, 'tmux.log');
-        const previousPath = process.env.PATH;
-        const previousEntryPath = process.env[OMX_ENTRY_PATH_ENV];
-        const previousStartupCwd = process.env[OMX_STARTUP_CWD_ENV];
-        try {
-            await mkdir(missionDir, { recursive: true });
-            const launcherDir = join(startupCwd, 'dist', 'cli');
-            const launcherPath = join(launcherDir, 'omx.js');
-            await mkdir(launcherDir, { recursive: true });
-            await writeFile(launcherPath, '#!/usr/bin/env node\n', 'utf-8');
-            const fakeTmuxPath = join(fakeBin, 'tmux');
-            await writeFile(fakeTmuxPath, `#!/bin/sh
-printf '%s\n' "$*" >>"${tmuxLog}"
-case "$1" in
-  -V)
-    exit 0
-    ;;
-  has-session)
-    exit 1
-    ;;
-  new-session)
-    exit 0
-    ;;
-  *)
-    exit 0
-    ;;
-esac
-`, 'utf-8');
-            execFileSync('chmod', ['+x', fakeTmuxPath], { stdio: 'ignore' });
-            process.env.PATH = `${fakeBin}:${previousPath || ''}`;
-            delete process.env[OMX_ENTRY_PATH_ENV];
-            process.env[OMX_STARTUP_CWD_ENV] = startupCwd;
-            const previousArgv = process.argv;
-            process.argv = [previousArgv[0] || 'node', 'dist/cli/omx.js'];
-            try {
-                spawnAutoresearchTmux(missionDir, 'demo');
-            }
-            finally {
-                process.argv = previousArgv;
-            }
-            const tmuxOutput = await readFile(tmuxLog, 'utf-8');
-            assert.match(tmuxOutput, /new-session -d -s omx-autoresearch-demo/);
-            assert.match(tmuxOutput, new RegExp(escapeRegExp(launcherPath)));
-            assert.doesNotMatch(tmuxOutput, /dist\/cli\/omx\.js autoresearch/);
-        }
-        finally {
-            if (typeof previousPath === 'string')
-                process.env.PATH = previousPath;
-            else
-                delete process.env.PATH;
-            if (typeof previousEntryPath === 'string')
-                process.env[OMX_ENTRY_PATH_ENV] = previousEntryPath;
-            else
-                delete process.env[OMX_ENTRY_PATH_ENV];
-            if (typeof previousStartupCwd === 'string')
-                process.env[OMX_STARTUP_CWD_ENV] = previousStartupCwd;
-            else
-                delete process.env[OMX_STARTUP_CWD_ENV];
-            await rm(repo, { recursive: true, force: true });
-            await rm(fakeBin, { recursive: true, force: true });
-            await rm(startupCwd, { recursive: true, force: true });
-        }
-    });
-});
-describe('autoresearch intake draft artifacts', () => {
-    it('writes a canonical deep-interview autoresearch draft artifact from vague input', async () => {
-        const repo = await initRepo();
+describe("autoresearch intake draft artifacts", () => {
+    it("writes a canonical deep-interview autoresearch draft artifact from vague input", async () => {
+        const repo = await initWorkspace();
         try {
             const artifact = await writeAutoresearchDraftArtifact({
                 repoRoot: repo,
-                topic: 'Improve onboarding for first-time contributors',
-                keepPolicy: 'score_improvement',
-                seedInputs: { topic: 'Improve onboarding for first-time contributors' },
+                topic: "Improve onboarding for first-time contributors",
+                keepPolicy: "score_improvement",
+                seedInputs: { topic: "Improve onboarding for first-time contributors" },
             });
             assert.match(artifact.path, /\.omx\/specs\/deep-interview-autoresearch-improve-onboarding-for-first-time-contributors\.md$/);
             assert.equal(artifact.launchReady, false);
@@ -265,48 +161,51 @@ describe('autoresearch intake draft artifacts', () => {
             await rm(repo, { recursive: true, force: true });
         }
     });
-    it('rejects placeholder evaluator commands and accepts concrete commands', () => {
-        assert.equal(isLaunchReadyEvaluatorCommand('TODO replace me'), false);
-        assert.equal(isLaunchReadyEvaluatorCommand('node scripts/eval.js'), true);
-        assert.equal(isLaunchReadyEvaluatorCommand('bash scripts/eval.sh'), true);
+    it("rejects placeholder evaluator commands and accepts concrete commands", () => {
+        assert.equal(isLaunchReadyEvaluatorCommand("TODO replace me"), false);
+        assert.equal(isLaunchReadyEvaluatorCommand("node scripts/eval.js"), true);
+        assert.equal(isLaunchReadyEvaluatorCommand("bash scripts/eval.sh"), true);
     });
-    it('writes launch-consumable mission/sandbox/result artifacts and resolves them back', async () => {
-        const repo = await initRepo();
+    it("writes launch-consumable mission/sandbox/result artifacts and resolves them back", async () => {
+        const repo = await initWorkspace();
         try {
             const artifacts = await writeAutoresearchDeepInterviewArtifacts({
                 repoRoot: repo,
-                topic: 'Measure onboarding friction',
-                evaluatorCommand: 'node scripts/eval.js',
-                keepPolicy: 'pass_only',
-                slug: 'onboarding-friction',
-                seedInputs: { topic: 'Measure onboarding friction' },
+                topic: "Measure onboarding friction",
+                evaluatorCommand: "node scripts/eval.js",
+                keepPolicy: "pass_only",
+                slug: "onboarding-friction",
+                seedInputs: { topic: "Measure onboarding friction" },
             });
             assert.match(artifacts.draftArtifactPath, /deep-interview-autoresearch-onboarding-friction\.md$/);
             assert.match(artifacts.missionArtifactPath, /autoresearch-onboarding-friction\/mission\.md$/);
             assert.match(artifacts.sandboxArtifactPath, /autoresearch-onboarding-friction\/sandbox\.md$/);
             assert.match(artifacts.resultPath, /autoresearch-onboarding-friction\/result\.json$/);
-            const resolved = await resolveAutoresearchDeepInterviewResult(repo, { slug: 'onboarding-friction' });
+            const resolved = await resolveAutoresearchDeepInterviewResult(repo, {
+                slug: "onboarding-friction",
+            });
             assert.ok(resolved);
-            assert.equal(resolved?.compileTarget.slug, 'onboarding-friction');
-            assert.equal(resolved?.compileTarget.keepPolicy, 'pass_only');
+            assert.equal(resolved?.compileTarget.slug, "onboarding-friction");
+            assert.equal(resolved?.compileTarget.keepPolicy, "pass_only");
             assert.equal(resolved?.launchReady, true);
-            assert.match(resolved?.missionContent || '', /Measure onboarding friction/);
-            assert.match(resolved?.sandboxContent || '', /command: node scripts\/eval\.js/);
+            assert.match(resolved?.missionContent || "", /Measure onboarding friction/);
+            assert.match(resolved?.sandboxContent || "", /command: node scripts\/eval\.js/);
         }
         finally {
             await rm(repo, { recursive: true, force: true });
         }
     });
 });
-describe('buildAutoresearchDeepInterviewPrompt', () => {
-    it('activates deep-interview --autoresearch and includes seed inputs', () => {
+describe("buildAutoresearchDeepInterviewPrompt", () => {
+    it("activates deep-interview --autoresearch and includes seed inputs", () => {
         const prompt = buildAutoresearchDeepInterviewPrompt({
-            topic: 'Investigate flaky tests',
-            evaluatorCommand: 'node scripts/eval.js',
-            keepPolicy: 'score_improvement',
-            slug: 'flaky-tests',
+            topic: "Investigate flaky tests",
+            evaluatorCommand: "node scripts/eval.js",
+            keepPolicy: "score_improvement",
+            slug: "flaky-tests",
         });
         assert.match(prompt, /\$deep-interview --autoresearch/);
+        assert.match(prompt, /Do not launch tmux or run `omx autoresearch` yourself/);
         assert.match(prompt, /deep-interview-autoresearch-\{slug\}\.md/);
         assert.match(prompt, /autoresearch-\{slug\}\/mission\.md/);
         assert.match(prompt, /- topic: Investigate flaky tests/);
@@ -315,29 +214,99 @@ describe('buildAutoresearchDeepInterviewPrompt', () => {
         assert.match(prompt, /- slug: flaky-tests/);
     });
 });
-describe('runAutoresearchNoviceBridge', () => {
-    it('loops through refine further before launching and writes draft + mission files', async () => {
-        const repo = await initRepo();
+describe("runAutoresearchNoviceBridge", () => {
+    it("falls back to plain terminal prompts when omx question is unavailable", async () => {
+        const repo = await initWorkspace();
         try {
             const result = await withMockedTty(() => runAutoresearchNoviceBridge(repo, {}, makeFakeIo([
-                'Improve evaluator UX',
-                'Make success measurable',
-                'TODO replace with evaluator command',
-                'score_improvement',
-                'ux-eval',
-                'refine further',
-                'Improve evaluator UX',
-                'Passing evaluator output',
-                'node scripts/eval.js',
-                'pass_only',
-                'ux-eval',
-                'launch',
+                "Improve evaluator UX",
+                "Passing evaluator output",
+                "node scripts/eval.js",
+                "pass_only",
+                "ux-eval",
+                "launch",
+            ]), async () => {
+                throw new Error("omx question requires tmux for OMX-owned question UI rendering in this session.");
+            }));
+            assert.equal(result.slug, "ux-eval");
+            assert.equal(result.resultPath, join(repo, ".omx", "specs", "autoresearch-ux-eval", "result.json"));
+        }
+        finally {
+            await rm(repo, { recursive: true, force: true });
+        }
+    });
+    it("does not fall back to plain prompts when question policy denies structured questions", async () => {
+        const repo = await initWorkspace();
+        try {
+            await mkdir(join(repo, ".omx", "state", "sessions", "sess-autoresearch"), {
+                recursive: true,
+            });
+            await writeFile(join(repo, ".omx", "state", "session.json"), JSON.stringify({ session_id: "sess-autoresearch" }));
+            await writeFile(join(repo, ".omx", "state", "sessions", "sess-autoresearch", "autoresearch-state.json"), JSON.stringify({ mode: "autoresearch", active: true }));
+            await assert.rejects(() => withMockedTty(() => runAutoresearchNoviceBridge(repo, {}, makeFakeIo([
+                "should not be used",
+                "should not be used",
+            ]), async () => {
+                throw new OmxQuestionError("active_execution_mode_blocked", "omx question is unavailable while auto-executing workflows are active: autoresearch.");
+            })), (error) => {
+                assert.ok(error instanceof OmxQuestionError);
+                assert.equal(error.code, "active_execution_mode_blocked");
+                return true;
+            });
+        }
+        finally {
+            await rm(repo, { recursive: true, force: true });
+        }
+    });
+    it("uses structured omx-question prompts and resumes from returned stdout answers", async () => {
+        const repo = await initWorkspace();
+        const askedQuestions = [];
+        try {
+            const result = await withMockedTty(() => runAutoresearchNoviceBridge(repo, {}, makeFakeIo([]), makeFakeStructuredQuestionAsker([
+                "Improve evaluator UX",
+                "Passing evaluator output",
+                "node scripts/eval.js",
+                "pass_only",
+                "ux-eval",
+                "launch",
+            ], askedQuestions)));
+            assert.equal(result.slug, "ux-eval");
+            assert.equal(result.resultPath, join(repo, ".omx", "specs", "autoresearch-ux-eval", "result.json"));
+            assert.equal(askedQuestions.length, 6);
+            assert.equal(askedQuestions[0]?.question, "Research topic/goal");
+            assert.deepEqual(askedQuestions[0]?.options, []);
+            assert.equal(askedQuestions[0]?.allowOther, true);
+            assert.match(askedQuestions[5]?.question || "", /Next step/);
+            assert.deepEqual(askedQuestions[5]?.options, ["launch", "refine"]);
+            assert.equal(askedQuestions[5]?.allowOther, false);
+        }
+        finally {
+            await rm(repo, { recursive: true, force: true });
+        }
+    });
+    it("loops through refine further before launching and writes canonical spec artifacts", async () => {
+        const repo = await initWorkspace();
+        try {
+            const result = await withMockedTty(() => runAutoresearchNoviceBridge(repo, {}, makeFakeIo([
+                "Improve evaluator UX",
+                "Make success measurable",
+                "TODO replace with evaluator command",
+                "score_improvement",
+                "ux-eval",
+                "refine further",
+                "Improve evaluator UX",
+                "Passing evaluator output",
+                "node scripts/eval.js",
+                "pass_only",
+                "ux-eval",
+                "launch",
             ])));
-            const draftContent = await readFile(join(repo, '.omx', 'specs', 'deep-interview-autoresearch-ux-eval.md'), 'utf-8');
-            const resultContent = await readFile(join(repo, '.omx', 'specs', 'autoresearch-ux-eval', 'result.json'), 'utf-8');
-            const missionContent = await readFile(join(result.missionDir, 'mission.md'), 'utf-8');
-            const sandboxContent = await readFile(join(result.missionDir, 'sandbox.md'), 'utf-8');
-            assert.equal(result.slug, 'ux-eval');
+            const draftContent = await readFile(join(repo, ".omx", "specs", "deep-interview-autoresearch-ux-eval.md"), "utf-8");
+            const resultContent = await readFile(result.resultPath, "utf-8");
+            const missionContent = await readFile(result.missionArtifactPath, "utf-8");
+            const sandboxContent = await readFile(result.sandboxArtifactPath, "utf-8");
+            assert.equal(result.artifactDir, join(repo, ".omx", "specs", "autoresearch-ux-eval"));
+            assert.equal(result.slug, "ux-eval");
             assert.match(draftContent, /Launch-ready: yes/);
             assert.match(resultContent, /"launchReady": true/);
             assert.match(missionContent, /Improve evaluator UX/);
@@ -348,24 +317,18 @@ describe('runAutoresearchNoviceBridge', () => {
             await rm(repo, { recursive: true, force: true });
         }
     });
-    it('uses seeded novice inputs while still requiring confirmation-driven launch', async () => {
-        const repo = await initRepo();
+    it("uses seeded novice inputs while still requiring confirmation-driven launch", async () => {
+        const repo = await initWorkspace();
         try {
             const result = await withMockedTty(() => runAutoresearchNoviceBridge(repo, {
-                topic: 'Seeded topic',
-                evaluatorCommand: 'node scripts/eval.js',
-                keepPolicy: 'score_improvement',
-                slug: 'seeded-topic',
-            }, makeFakeIo([
-                '',
-                '',
-                '',
-                '',
-                '',
-                'launch',
-            ])));
-            const draftContent = await readFile(join(repo, '.omx', 'specs', 'deep-interview-autoresearch-seeded-topic.md'), 'utf-8');
-            assert.equal(result.slug, 'seeded-topic');
+                topic: "Seeded topic",
+                evaluatorCommand: "node scripts/eval.js",
+                keepPolicy: "score_improvement",
+                slug: "seeded-topic",
+            }, makeFakeIo(["", "", "", "", "", "launch"])));
+            const draftContent = await readFile(join(repo, ".omx", "specs", "deep-interview-autoresearch-seeded-topic.md"), "utf-8");
+            assert.equal(result.resultPath, join(repo, ".omx", "specs", "autoresearch-seeded-topic", "result.json"));
+            assert.equal(result.slug, "seeded-topic");
             assert.match(draftContent, /- topic: Seeded topic/);
             assert.match(draftContent, /- evaluator: node scripts\/eval\.js/);
             assert.match(draftContent, /Launch-ready: yes/);