shift-ax 0.3.0

package/dist/core/review/run-lanes.js

@@ -0,0 +1,376 @@
+import { execFileSync } from 'node:child_process';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { readProjectProfile } from '../policies/project-profile.js';
+import { readPlanReviewArtifact, verifyApprovedPlanFingerprint } from '../planning/plan-review.js';
+import { getRootDirFromTopicDir } from '../topics/topic-artifacts.js';
+function containsPlaceholder(content) {
+    return /Shift AX placeholder/i.test(content);
+}
+async function readMaybe(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function verdictBase(lane, status, summary, issues = []) {
+    return {
+        version: 1,
+        lane,
+        status,
+        checked_at: new Date().toISOString(),
+        summary,
+        ...(issues.length > 0 ? { issues } : {}),
+    };
+}
+function tokenizeReviewWords(value) {
+    return String(value || '')
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 4)
+        .filter((token) => !['that', 'this', 'with', 'from', 'into', 'when', 'then', 'keep'].includes(token));
+}
+function parseMarkdownSections(content) {
+    const lines = String(content || '').split(/\r?\n/);
+    const sections = new Map();
+    let current = null;
+    const buffer = [];
+    const flush = () => {
+        if (current) {
+            sections.set(current, buffer.join('\n').trim());
+            buffer.length = 0;
+        }
+    };
+    for (const line of lines) {
+        const match = line.match(/^##\s+(.+)$/);
+        if (match) {
+            flush();
+            current = match[1].trim();
+            continue;
+        }
+        if (current) {
+            buffer.push(line);
+        }
+    }
+    flush();
+    return sections;
+}
+function hasTokenOverlap(content, reference) {
+    const haystack = String(content || '').toLowerCase();
+    return tokenizeReviewWords(reference).some((token) => haystack.includes(token));
+}
+async function readWorkflowStateMaybe(topicDir) {
+    const raw = await readMaybe(join(topicDir, 'workflow-state.json'));
+    if (!raw)
+        return null;
+    return JSON.parse(raw);
+}
+async function readExecutionStateMaybe(topicDir) {
+    const raw = await readMaybe(join(topicDir, 'execution-state.json'));
+    if (!raw)
+        return null;
+    return JSON.parse(raw);
+}
+async function readExecutionResultArtifacts(topicDir) {
+    const executionState = await readExecutionStateMaybe(topicDir);
+    const outputPaths = (executionState?.tasks ?? [])
+        .map((task) => task.output_path)
+        .filter((path) => Boolean(path));
+    return Promise.all(outputPaths.map(async (path) => {
+        const resolved = path.startsWith('/') ? path : join(topicDir, path);
+        return readMaybe(resolved);
+    }));
+}
+function extractMentionedFilesFromExecutionResults(results) {
+    const mentioned = new Set();
+    for (const result of results) {
+        if (!result.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(result);
+            for (const file of parsed.changed_files ?? []) {
+                if (file)
+                    mentioned.add(file);
+            }
+            const summary = parsed.summary ?? '';
+            const summaryMatches = summary.match(/[A-Za-z0-9_./-]+\.[A-Za-z0-9]+/g) ?? [];
+            for (const file of summaryMatches) {
+                mentioned.add(file);
+            }
+            continue;
+        }
+        catch {
+            const matches = result.match(/[A-Za-z0-9_./-]+\.[A-Za-z0-9]+/g) ?? [];
+            for (const file of matches) {
+                mentioned.add(file);
+            }
+        }
+    }
+    return [...mentioned];
+}
+function listChangedFiles(worktreePath) {
+    const output = execFileSync('git', ['status', '--porcelain', '--untracked-files=all'], {
+        cwd: worktreePath,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return output
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => line.replace(/^[A-Z?]{1,2}\s+/, ''))
+        .filter(Boolean);
+}
+function isTestFile(path) {
+    return /(^|\/)(tests?|__tests__)\//i.test(path) || /\.(test|spec)\.[cm]?[jt]sx?$/i.test(path);
+}
+function strategyPattern(value) {
+    const normalized = value.toLowerCase();
+    if (normalized === 'tdd') {
+        return /\btdd\b|test[- ]driven/i;
+    }
+    return new RegExp(normalized.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&').replace(/-/g, '[- ]?'), 'i');
+}
+async function readProjectProfileForTopic(topicDir) {
+    try {
+        return await readProjectProfile(getRootDirFromTopicDir(topicDir));
+    }
+    catch {
+        return readProjectProfile(topicDir);
+    }
+}
+function architecturePattern(value) {
+    const normalized = value.toLowerCase();
+    if (normalized === 'clean-boundaries') {
+        return /\b(boundary|boundaries|architecture)\b/i;
+    }
+    if (normalized === 'layered-boundaries') {
+        return /\b(layered|boundary|boundaries|architecture)\b/i;
+    }
+    return new RegExp(normalized.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&').replace(/-/g, '[- ]?'), 'i');
+}
+async function runDomainPolicyLane(topicDir) {
+    const raw = await readMaybe(join(topicDir, 'resolved-context.json'));
+    if (!raw) {
+        return verdictBase('domain-policy', 'changes_requested', 'Resolved context artifact is missing.', [
+            { severity: 'high', message: 'resolved-context.json is required before review.' },
+        ]);
+    }
+    const parsed = JSON.parse(raw);
+    const unresolved = parsed.unresolved_paths ?? [];
+    if (unresolved.length > 0) {
+        return verdictBase('domain-policy', 'changes_requested', 'Some base-context paths could not be resolved.', unresolved.map((path) => ({
+            severity: 'high',
+            message: `Unresolved base-context path: ${path}`,
+        })));
+    }
+    return verdictBase('domain-policy', 'approved', parsed.matches && parsed.matches.length > 0
+        ? 'Relevant base-context documents were resolved and no unresolved paths were recorded.'
+        : 'No relevant base-context documents matched this topic, and no unresolved paths were recorded.');
+}
+async function runSpecConformanceLane(topicDir) {
+    const spec = await readMaybe(join(topicDir, 'spec.md'));
+    const plan = await readMaybe(join(topicDir, 'implementation-plan.md'));
+    const planReview = await readPlanReviewArtifact(topicDir);
+    const workflow = await readWorkflowStateMaybe(topicDir);
+    if (planReview.status !== 'approved') {
+        return verdictBase('spec-conformance', 'changes_requested', 'Human plan review has not approved the current implementation plan yet.', [
+            {
+                severity: 'high',
+                message: 'Approve plan-review.json before review can pass.',
+            },
+        ]);
+    }
+    const fingerprint = await verifyApprovedPlanFingerprint({ topicDir });
+    if (!fingerprint.matches) {
+        return verdictBase('spec-conformance', 'changes_requested', 'The implementation plan changed after approval and needs re-review.', [
+            {
+                severity: 'high',
+                message: fingerprint.reason ?? 'Approved plan fingerprint no longer matches.',
+            },
+        ]);
+    }
+    if (containsPlaceholder(spec) || containsPlaceholder(plan)) {
+        return verdictBase('spec-conformance', 'changes_requested', 'Spec or implementation plan still contains placeholders.', [
+            {
+                severity: 'high',
+                message: 'Replace placeholder content in spec.md and implementation-plan.md before review can pass.',
+            },
+        ]);
+    }
+    const worktreePath = workflow?.worktree?.worktree_path;
+    if (worktreePath) {
+        const changedFiles = listChangedFiles(worktreePath);
+        const executionState = await readExecutionStateMaybe(topicDir);
+        const outOfScopeContent = parseMarkdownSections(spec).get('Out of Scope') ??
+            parseMarkdownSections(await readMaybe(join(topicDir, 'brainstorm.md'))).get('Out of Scope') ??
+            '';
+        if (changedFiles.length > 0 && executionState && executionState.overall_status !== 'completed') {
+            return verdictBase('spec-conformance', 'changes_requested', 'Execution state is not completed for the current changed files.', [
+                {
+                    severity: 'high',
+                    message: `execution-state.json reports ${executionState.overall_status ?? 'unknown'} instead of completed.`,
+                },
+            ]);
+        }
+        const outOfScopeTouched = changedFiles.find((file) => hasTokenOverlap(file, outOfScopeContent));
+        if (outOfScopeTouched) {
+            return verdictBase('spec-conformance', 'changes_requested', 'Changed files touch an area that is explicitly out of scope for the reviewed plan.', [
+                {
+                    severity: 'high',
+                    message: `Out-of-scope file changed: ${outOfScopeTouched}`,
+                },
+            ]);
+        }
+    }
+    return verdictBase('spec-conformance', 'approved', 'Spec and implementation plan are approved, fingerprint-matched, and free of unresolved placeholders.');
+}
+async function runTestAdequacyLane(topicDir) {
+    const plan = await readMaybe(join(topicDir, 'implementation-plan.md'));
+    const workflow = await readWorkflowStateMaybe(topicDir);
+    const worktreePath = workflow?.worktree?.worktree_path;
+    if (worktreePath) {
+        const successfulTestCommand = (workflow?.verification ?? []).some((item) => item.exit_code === 0 && /\b(test|jest|vitest|pytest|go test|cargo test|phpunit|rspec)\b/i.test(item.command));
+        if (!successfulTestCommand) {
+            return verdictBase('test-adequacy', 'changes_requested', 'Verification evidence does not include a successful test command.', [
+                {
+                    severity: 'high',
+                    message: 'Run a passing automated test command before review can approve test adequacy.',
+                },
+            ]);
+        }
+        const changedFiles = listChangedFiles(worktreePath);
+        const changedCodeFiles = changedFiles.filter((file) => !isTestFile(file));
+        const changedTestFiles = changedFiles.filter((file) => isTestFile(file));
+        if (changedCodeFiles.length > 0 && changedTestFiles.length === 0) {
+            return verdictBase('test-adequacy', 'changes_requested', 'Code changed in the worktree, but no corresponding test file changes were found.', [
+                {
+                    severity: 'high',
+                    message: 'Add or update tests for changed implementation files before review can pass.',
+                },
+            ]);
+        }
+        if (changedTestFiles.length > 0) {
+            const [spec, brainstorm, resolvedContext] = await Promise.all([
+                readMaybe(join(topicDir, 'spec.md')),
+                readMaybe(join(topicDir, 'brainstorm.md')),
+                readMaybe(join(topicDir, 'resolved-context.json')),
+            ]);
+            const contextLabels = (() => {
+                try {
+                    const parsed = JSON.parse(resolvedContext);
+                    return (parsed.matches ?? []).map((item) => item.label).filter(Boolean).join('\n');
+                }
+                catch {
+                    return '';
+                }
+            })();
+            const desiredCoverage = [spec, brainstorm, contextLabels].join('\n');
+            const testContents = await Promise.all(changedTestFiles.map((file) => readMaybe(join(worktreePath, file))));
+            const hasRelevantCoverage = testContents.some((content) => hasTokenOverlap(content, desiredCoverage));
+            if (!hasRelevantCoverage) {
+                return verdictBase('test-adequacy', 'changes_requested', 'Changed tests do not clearly reflect the spec, brainstorm, or domain-policy language yet.', [
+                    {
+                        severity: 'medium',
+                        message: 'Make the changed tests reference the agreed outcome, constraints, or domain-policy terms more explicitly.',
+                    },
+                ]);
+            }
+        }
+    }
+    if (!/\b(test|tdd)\b/i.test(plan) || containsPlaceholder(plan)) {
+        return verdictBase('test-adequacy', 'changes_requested', 'Implementation plan does not yet provide reviewable test evidence expectations.', [
+            {
+                severity: 'medium',
+                message: 'Implementation plan should explicitly reference tests or TDD expectations.',
+            },
+        ]);
+    }
+    return verdictBase('test-adequacy', 'approved', 'Implementation plan explicitly references test or TDD expectations.');
+}
+async function runEngineeringDisciplineLane(topicDir) {
+    const plan = await readMaybe(join(topicDir, 'implementation-plan.md'));
+    const profile = await readProjectProfileForTopic(topicDir);
+    const requiredTestStrategy = profile?.engineering_defaults.test_strategy ?? 'tdd';
+    const requiredArchitecture = profile?.engineering_defaults.architecture ?? 'clean-boundaries';
+    const hasTdd = strategyPattern(requiredTestStrategy).test(plan);
+    const hasArchitecture = architecturePattern(requiredArchitecture).test(plan);
+    if (containsPlaceholder(plan) || !hasTdd || !hasArchitecture) {
+        return verdictBase('engineering-discipline', 'changes_requested', 'Engineering-discipline expectations are not yet explicit enough.', [
+            {
+                severity: 'medium',
+                message: `Implementation plan should explicitly reference ${requiredTestStrategy} and ${requiredArchitecture}.`,
+            },
+        ]);
+    }
+    return verdictBase('engineering-discipline', 'approved', 'Implementation plan references the configured engineering-method guardrails.');
+}
+async function runConversationTraceLane(topicDir) {
+    const request = await readMaybe(join(topicDir, 'request.md'));
+    const summary = await readMaybe(join(topicDir, 'request-summary.md'));
+    const spec = await readMaybe(join(topicDir, 'spec.md'));
+    const brainstorm = await readMaybe(join(topicDir, 'brainstorm.md'));
+    const plan = await readMaybe(join(topicDir, 'implementation-plan.md'));
+    const workflow = await readWorkflowStateMaybe(topicDir);
+    if (!request.trim() || !summary.trim() || !brainstorm.trim() || containsPlaceholder(spec)) {
+        return verdictBase('conversation-trace', 'changes_requested', 'Request artifacts exist, but the spec is not yet traceable enough to the original request.', [
+            {
+                severity: 'medium',
+                message: 'A reviewable brainstorm + spec must exist before conversation trace can pass.',
+            },
+        ]);
+    }
+    const brainstormSections = parseMarkdownSections(brainstorm);
+    const missingSpecSections = ['Clarified Outcome', 'Constraints', 'Out of Scope'].filter((section) => {
+        const content = brainstormSections.get(section);
+        return content && !hasTokenOverlap(spec, content);
+    });
+    const missingPlanSections = ['Verification Expectations', 'Implementation Areas', 'Long-running Work'].filter((section) => {
+        const content = brainstormSections.get(section);
+        return content && !hasTokenOverlap(plan, content);
+    });
+    if (missingSpecSections.length > 0 || missingPlanSections.length > 0) {
+        return verdictBase('conversation-trace', 'changes_requested', 'The spec or implementation plan does not yet reflect all of the clarified brainstorming details.', [
+            ...missingSpecSections.map((section) => ({
+                severity: 'medium',
+                message: `Spec is missing clarified brainstorming details from section: ${section}.`,
+            })),
+            ...missingPlanSections.map((section) => ({
+                severity: 'medium',
+                message: `Implementation plan is missing clarified brainstorming details from section: ${section}.`,
+            })),
+        ]);
+    }
+    const worktreePath = workflow?.worktree?.worktree_path;
+    if (worktreePath) {
+        const changedFiles = listChangedFiles(worktreePath);
+        if (changedFiles.length > 0) {
+            const executionResults = await readExecutionResultArtifacts(topicDir);
+            const mentionedFiles = extractMentionedFilesFromExecutionResults(executionResults);
+            const unmentionedChangedFile = changedFiles.find((file) => !mentionedFiles.includes(file));
+            if (unmentionedChangedFile) {
+                return verdictBase('conversation-trace', 'changes_requested', 'Execution results do not describe all of the changed files yet.', [
+                    {
+                        severity: 'medium',
+                        message: `Changed file is missing from execution result artifacts: ${unmentionedChangedFile}.`,
+                    },
+                ]);
+            }
+        }
+    }
+    return verdictBase('conversation-trace', 'approved', 'Request, summary, brainstorm, and spec artifacts are traceable to the original request.');
+}
+export async function runReviewLanes({ topicDir, }) {
+    const verdicts = await Promise.all([
+        runDomainPolicyLane(topicDir),
+        runSpecConformanceLane(topicDir),
+        runTestAdequacyLane(topicDir),
+        runEngineeringDisciplineLane(topicDir),
+        runConversationTraceLane(topicDir),
+    ]);
+    await Promise.all(verdicts.map((verdict) => writeFile(join(topicDir, 'review', `${verdict.lane}.json`), `${JSON.stringify(verdict, null, 2)}\n`, 'utf8')));
+    return verdicts;
+}

package/dist/core/settings/global-context-home.js

@@ -0,0 +1,28 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export function resolveGlobalContextRoot({ env = process.env, homeDir = homedir(), } = {}) {
+    const override = env.SHIFT_AX_HOME?.trim();
+    if (override)
+        return override;
+    return join(homeDir, '.shift-ax');
+}
+export function getGlobalContextHome(options = {}) {
+    const root = resolveGlobalContextRoot(options);
+    return {
+        root,
+        indexPath: join(root, 'index.md'),
+        workTypesDir: join(root, 'work-types'),
+        reposDir: join(root, 'repos'),
+        proceduresDir: join(root, 'procedures'),
+        domainLanguageDir: join(root, 'domain-language'),
+        backupsDir: join(root, 'backups'),
+        profilePath: join(root, 'profile.json'),
+        settingsPath: join(root, 'settings.json'),
+    };
+}
+export function toGlobalRelativePath(absolutePath, home = getGlobalContextHome()) {
+    if (!absolutePath.startsWith(home.root)) {
+        return absolutePath;
+    }
+    return absolutePath.slice(home.root.length + 1);
+}

package/dist/core/settings/project-settings.js

@@ -0,0 +1,37 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { getGlobalContextHome } from './global-context-home.js';
+export function getProjectSettingsPath(rootDir) {
+    return getGlobalContextHome().settingsPath;
+}
+export async function readProjectSettings(rootDir) {
+    try {
+        const raw = JSON.parse(await readFile(getProjectSettingsPath(rootDir), 'utf8'));
+        const locale = raw.locale ??
+            (raw.preferred_language === 'korean'
+                ? 'ko'
+                : raw.preferred_language === 'english'
+                    ? 'en'
+                    : undefined);
+        if (!locale)
+            return null;
+        return {
+            version: 1,
+            updated_at: raw.updated_at ?? new Date(0).toISOString(),
+            locale,
+            preferred_language: raw.preferred_language ?? (locale === 'ko' ? 'korean' : 'english'),
+            ...(typeof raw.default_full_auto === 'boolean' ? { default_full_auto: raw.default_full_auto } : {}),
+            ...(raw.preferred_platform ? { preferred_platform: raw.preferred_platform } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeProjectSettings({ rootDir, settings, }) {
+    const path = getProjectSettingsPath(rootDir);
+    await mkdir(getGlobalContextHome().root, { recursive: true });
+    await writeFile(path, `${JSON.stringify({
+        ...settings,
+        preferred_language: settings.preferred_language ?? (settings.locale === 'ko' ? 'korean' : 'english'),
+    }, null, 2)}\n`, 'utf8');
+}

package/dist/core/shell/platform-shell.js

@@ -0,0 +1,144 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline/promises';
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { stdin, stdout } from 'node:process';
+import { getPlatformBootstrapAssets } from '../../platform/index.js';
+import { readProjectProfile } from '../policies/project-profile.js';
+import { readProjectSettings, writeProjectSettings, } from '../settings/project-settings.js';
+import { getGlobalContextHome } from '../settings/global-context-home.js';
+const SHELL_COPY = {
+    en: {
+        chooseLanguage: 'Choose language:\n1. English (default)\n2. Korean\n> ',
+        chooseFullAuto: 'Enable full-auto mode by default?\n1. No (default)\n2. Yes\n> ',
+        localeRule: 'Preferred user language: English. Respond in English unless the user explicitly asks to switch.',
+    },
+    ko: {
+        chooseLanguage: '언어를 선택하세요:\n1. English (default)\n2. Korean\n> ',
+        chooseFullAuto: '기본으로 full-auto 모드를 켤까요?\n1. 아니오 (기본값)\n2. 예\n> ',
+        localeRule: '선호 사용자 언어: 한국어. 사용자가 명시적으로 바꾸라고 하지 않으면 한국어로 응답하세요.',
+    },
+};
+let nonTtyAnswerLinesPromise = null;
+let nonTtyAnswerIndex = 0;
+async function readNonTtyAnswers() {
+    if (!nonTtyAnswerLinesPromise) {
+        nonTtyAnswerLinesPromise = new Promise((resolve, reject) => {
+            let raw = '';
+            stdin.setEncoding('utf8');
+            stdin.on('data', (chunk) => {
+                raw += chunk;
+            });
+            stdin.on('end', () => resolve(raw.split(/\r?\n/)));
+            stdin.on('error', reject);
+            stdin.resume();
+        });
+    }
+    return nonTtyAnswerLinesPromise;
+}
+async function promptChoice({ question, fallback, }) {
+    if (stdin.isTTY) {
+        const rl = createInterface({ input: stdin, output: stdout });
+        try {
+            return (await rl.question(question)).trim() || fallback;
+        }
+        finally {
+            rl.close();
+        }
+    }
+    const answers = await readNonTtyAnswers().catch(() => []);
+    const answer = answers[nonTtyAnswerIndex] ?? '';
+    nonTtyAnswerIndex += 1;
+    return answer.trim() || fallback;
+}
+async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isProjectOnboarded(rootDir) {
+    const home = getGlobalContextHome();
+    return (await pathExists(home.indexPath)) && (await readProjectProfile(rootDir)) !== null;
+}
+export async function resolveShellLocale({ rootDir, requestedLocale, }) {
+    if (requestedLocale)
+        return requestedLocale;
+    const settings = await readProjectSettings(rootDir);
+    if (settings?.locale)
+        return settings.locale;
+    const answer = await promptChoice({
+        question: SHELL_COPY.en.chooseLanguage,
+        fallback: '1',
+    });
+    return answer === '2' ? 'ko' : 'en';
+}
+export async function resolveShellPlatform({ rootDir, requestedPlatform, locale, }) {
+    if (requestedPlatform)
+        return requestedPlatform;
+    const settings = await readProjectSettings(rootDir);
+    if (settings?.preferred_platform)
+        return settings.preferred_platform;
+    return 'codex';
+}
+export async function resolveShellDefaultFullAuto({ rootDir, locale, }) {
+    const settings = await readProjectSettings(rootDir);
+    if (typeof settings?.default_full_auto === 'boolean') {
+        return settings.default_full_auto;
+    }
+    const answer = await promptChoice({
+        question: SHELL_COPY[locale].chooseFullAuto,
+        fallback: '1',
+    });
+    return answer === '2';
+}
+export async function persistShellSettings({ rootDir, locale, defaultFullAuto, platform, }) {
+    const existing = (await readProjectSettings(rootDir));
+    await writeProjectSettings({
+        rootDir,
+        settings: {
+            ...(existing ?? {}),
+            version: 1,
+            updated_at: new Date().toISOString(),
+            locale,
+            preferred_language: locale === 'ko' ? 'korean' : 'english',
+            ...(typeof defaultFullAuto === 'boolean'
+                ? { default_full_auto: defaultFullAuto }
+                : typeof existing?.default_full_auto === 'boolean'
+                    ? { default_full_auto: existing.default_full_auto }
+                    : {}),
+            preferred_platform: platform,
+        },
+    });
+}
+export async function launchPlatformShell({ rootDir, platform, fullAuto = false, initialPrompt, }) {
+    const locale = (await readProjectSettings(rootDir))?.locale ?? 'en';
+    await ensurePlatformShellAssets({ platform, rootDir, locale });
+    const args = platform === 'codex'
+        ? [...(fullAuto ? ['--yolo'] : []), '-C', rootDir, ...(initialPrompt?.trim() ? [initialPrompt.trim()] : [])]
+        : [...(fullAuto ? ['--dangerously-skip-permissions'] : []), ...(initialPrompt?.trim() ? [initialPrompt.trim()] : [])];
+    const child = platform === 'codex'
+        ? spawn('codex', args, { stdio: 'inherit' })
+        : spawn('claude', args, { cwd: rootDir, stdio: 'inherit' });
+    return await new Promise((resolve, reject) => {
+        child.on('error', reject);
+        child.on('exit', (code) => resolve(code ?? 0));
+    });
+}
+async function ensurePlatformShellAssets({ platform, rootDir, locale, }) {
+    const assets = getPlatformBootstrapAssets(platform, rootDir, locale);
+    await Promise.all(assets.map(async (asset) => {
+        const absolutePath = join(rootDir, asset.path);
+        const current = await readFile(absolutePath, 'utf8').catch(() => '');
+        const isTopLevelBootstrap = asset.path === 'AGENTS.md' || asset.path === 'CLAUDE.md';
+        if (isTopLevelBootstrap && current.trim() && !current.includes('Shift AX')) {
+            return;
+        }
+        await mkdir(dirname(absolutePath), { recursive: true });
+        await writeFile(absolutePath, asset.content, 'utf8');
+    }));
+}