shift-ax 0.3.0

package/dist/platform/claude-code/scaffold/commands/onboarding.template.md

@@ -0,0 +1,43 @@
+---
+description: Capture or refresh the user's global Shift AX knowledge base.
+argument-hint: "[optional note]"
+---
+
+This command is the most important setup step.
+
+Start by saying:
+
+> This step matters most. Please invest 10 minutes so Shift AX can understand how you work.
+
+Then run a conversational interview that captures:
+
+1. primary role summary
+2. work types
+3. related repositories for each work type
+4. per-repository working methods
+5. company/domain language
+
+For each work type and repository:
+
+- ask which directories matter
+- inspect the repository when a path is available
+- infer likely workflow details from real files
+- present your inferred workflow back to the user
+- ask them to correct anything wrong or missing
+
+When you have enough information:
+
+1. write `.ax/onboarding-input.json`
+2. if `{{GLOBAL_CONTEXT_INDEX}}` or other global knowledge files already exist, ask whether to overwrite them first
+3. persist with:
+   - `shift-ax onboard-context --root "$PWD" --input .ax/onboarding-input.json`
+   - add `--overwrite` only if the user explicitly agreed
+
+Keep the top-level knowledge base in `~/.shift-ax/` with:
+
+- `index.md` listing only titles and linked pages
+- linked work type pages
+- linked repository/procedure pages
+- linked domain-language pages
+
+After completion, remind the user to share `~/.shift-ax/` with teammates who do similar work.

package/dist/platform/claude-code/scaffold/commands/request.template.md

@@ -0,0 +1,19 @@
+---
+description: Start a new Shift AX request-to-commit flow.
+argument-hint: "<request>"
+---
+
+Treat everything after this command as the raw request text.
+
+If no request text was provided, ask for it before doing anything else.
+
+Then:
+
+1. resolve context from `{{GLOBAL_CONTEXT_INDEX}}` first
+2. if the global index is missing, stop and tell the user onboarding should come first because accuracy will drop
+3. ask whether they want to continue anyway
+4. only if they explicitly agree, bootstrap with `shift-ax run-request --request "$ARGUMENTS" --allow-missing-global-context`
+5. otherwise bootstrap with `shift-ax run-request --request "$ARGUMENTS"`
+6. explain the resulting topic path and that the workflow pauses at human plan review
+
+Never skip context grounding or the planning/review gates.

package/dist/platform/claude-code/scaffold/commands/resume.template.md

@@ -0,0 +1,12 @@
+---
+description: Resume an approved Shift AX topic.
+argument-hint: "<topic-dir> [--verify-command <cmd> ...]"
+---
+
+Treat the first argument as the topic directory.
+
+Resume with:
+
+`shift-ax run-request --topic $ARGUMENTS --resume`
+
+Explain whether the topic is blocked by escalation or policy sync if resume cannot continue.

package/dist/platform/claude-code/scaffold/commands/review.template.md

@@ -0,0 +1,10 @@
+---
+description: Run structured Shift AX review for a topic.
+argument-hint: "<topic-dir>"
+---
+
+Run:
+
+`shift-ax review --topic $ARGUMENTS --run`
+
+Then summarize the review lanes, aggregate verdict, and remaining blockers.

package/dist/platform/claude-code/scaffold/commands/status.template.md

@@ -0,0 +1,14 @@
+---
+description: Show Shift AX status for one topic or the repo.
+argument-hint: "[<topic-dir>]"
+---
+
+If a topic directory is provided, run:
+
+`shift-ax topic-status --topic $ARGUMENTS`
+
+Otherwise run:
+
+`shift-ax topics-status`
+
+Summarize the current phase, review gate, execution status, and blockers.

package/dist/platform/claude-code/scaffold/commands/topics.template.md

@@ -0,0 +1,10 @@
+---
+description: List recent Shift AX topics for the current repository.
+argument-hint: "[--limit N]"
+---
+
+List recent topics with:
+
+`shift-ax topics-status $ARGUMENTS`
+
+If the user supplied a limit, include it.

package/dist/platform/claude-code/scaffold/hooks/shift-ax-session-start.template.md

@@ -0,0 +1,29 @@
+# Shift AX Claude Code SessionStart Bootstrap
+
+This build is expected to use SessionStart hook-driven context injection.
+
+## Hook Intent
+
+- SessionStart should inject Shift AX bootstrap context.
+- Before planning or implementation, resolve context from {{GLOBAL_CONTEXT_INDEX}}.
+- If the global index is missing, recommend `/onboard` before `/request`. Do not pretend the missing context does not matter.
+- Use `shift-ax doctor` when setup, launcher availability, or topic state looks unhealthy.
+- Use `shift-ax resolve-context` before answering when relevant documents may exist.
+- Use `shift-ax run-request` to create the request-scoped topic/worktree, run the planning interview, write brainstorming/spec/plan artifacts plus `execution-handoff.json`, and pause at the human planning-review gate.
+- Use `shift-ax approve-plan` after the human reviewer signs off.
+- If the reviewed plan requires shared policy or base-context doc changes, record them first with `shift-ax sync-policy-context --topic <dir> --summary "<what changed>" [--path <doc>]... [--entry "Label -> path"]...`.
+- Then resume with `shift-ax run-request --topic <dir> --resume` for automatic review and commit. Use `--no-auto-commit` only when a human explicitly wants the final commit step held back.
+- If downstream review or CI fails after the topic looked ready, use `shift-ax react-feedback --topic <dir> --kind <review-changes-requested|ci-failed> --summary "<text>"` to reopen implementation with a file-backed reaction trail.
+- Use `shift-ax launch-execution --platform claude-code --topic <dir> [--task-id <id>] [--dry-run]` when you need the concrete Claude or tmux launch commands from `execution-handoff.json`.
+- Use `shift-ax topic-status --topic <dir>` when you need a compact summary of phase, review gate, execution state, and last failure.
+- Use `shift-ax topics-status [--root DIR] [--limit N]` when you need a compact multi-topic view without leaving the CLI.
+- If a reviewed request hits a mandatory escalation trigger, persist that stop with `shift-ax run-request --topic <dir> --resume --escalation <kind>:<summary>` and resume only after human review with `--clear-escalations`.
+- Use `shift-ax worktree-plan` to inspect the preferred branch/worktree path for the topic.
+- Use `shift-ax worktree-create` before implementation begins and `shift-ax worktree-remove` when the topic worktree should be torn down.
+- Worktree runtime provenance is tracked in `platform/claude-code/upstream/worktree/provenance.md`.
+- Active imported worktree helpers currently include `getWorktreeRoot`, `createClaudeManagedWorktree`, and `removeClaudeManagedWorktree`.
+- Use `shift-ax review --run` before finalization and `shift-ax finalize-commit` only after the review gate allows commit.
+- Natural language is the primary user surface. Internal AX commands exist to support the flow, not replace the conversation.
+- In Shift AX Claude Code sessions, use `/onboard`, `/request <text>`, `/export-context`, `/doctor`, `/status`, `/topics`, `/resume <topic>`, `/review <topic>`, `/help` as the primary visible commands. `$...` aliases may mirror them when useful.
+- Native product-shell command files are installed under `.claude/commands/` for: `onboard`, `request`, `export-context`, `doctor`, `status`, `topics`, `resume`, and `review`.
+- Treat `$request <text>` as the explicit alias for starting a new request-to-commit flow inside the session.

package/dist/platform/claude-code/tmux.js

@@ -0,0 +1,35 @@
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readImportedUpstreamSlice } from '../upstream-imports.js';
+import { buildClaudeWorkerSessionName } from './upstream/tmux/imported/session-name.js';
+import { createClaudeDetachedSession, killClaudeDetachedSession, } from './upstream/tmux/imported/detached-session.js';
+const HERE = dirname(fileURLToPath(import.meta.url));
+export function getClaudeCodeTmuxRuntime(rootDir) {
+    return {
+        support: 'imported-helpers',
+        multiplexer: 'tmux',
+        workspace_mode: 'detached-sessions',
+        naming: {
+            session_prefix: 'omc-team',
+            imported_helpers: ['sanitizeClaudeSessionNamePart', 'buildClaudeWorkerSessionName'],
+        },
+        upstream_boundary: {
+            import_root: join(rootDir, 'platform', 'claude-code', 'upstream', 'tmux'),
+            provenance_doc: join(rootDir, 'platform', 'claude-code', 'upstream', 'tmux', 'provenance.md'),
+            planned_upstream_modules: ['oh-my-claudecode/src/team/tmux-session.ts'],
+            active_imports: [
+                readImportedUpstreamSlice(join(HERE, 'upstream', 'tmux', 'imported', 'provenance.json')),
+                readImportedUpstreamSlice(join(HERE, 'upstream', 'tmux', 'imported', 'detached-session.provenance.json')),
+            ],
+        },
+    };
+}
+export function buildClaudeWorkerSessionIdentity(teamName, workerName) {
+    return buildClaudeWorkerSessionName(teamName, workerName);
+}
+export function createClaudeDetachedWorkerSession(teamName, workerName, workingDirectory) {
+    return createClaudeDetachedSession(teamName, workerName, workingDirectory);
+}
+export function killClaudeDetachedWorkerSession(teamName, workerName) {
+    killClaudeDetachedSession(teamName, workerName);
+}

package/dist/platform/claude-code/upstream/tmux/imported/detached-session.js

@@ -0,0 +1,40 @@
+import { execFileSync } from 'node:child_process';
+import { buildClaudeWorkerSessionName } from './session-name.js';
+/**
+ * Imported from oh-my-claudecode.
+ * Source: oh-my-claudecode/src/team/tmux-session.ts
+ * Commit: 2487d3878f8d25e60802940b020d5ee8774d135e
+ */
+export function createClaudeDetachedSession(teamName, workerName, workingDirectory) {
+    const name = buildClaudeWorkerSessionName(teamName, workerName);
+    try {
+        execFileSync('tmux', ['kill-session', '-t', name], {
+            stdio: 'pipe',
+            timeout: 5000,
+        });
+    }
+    catch {
+        // ignore stale session misses
+    }
+    const args = ['new-session', '-d', '-s', name, '-x', '200', '-y', '50'];
+    if (workingDirectory) {
+        args.push('-c', workingDirectory);
+    }
+    execFileSync('tmux', args, {
+        stdio: 'pipe',
+        timeout: 5000,
+    });
+    return name;
+}
+export function killClaudeDetachedSession(teamName, workerName) {
+    const name = buildClaudeWorkerSessionName(teamName, workerName);
+    try {
+        execFileSync('tmux', ['kill-session', '-t', name], {
+            stdio: 'pipe',
+            timeout: 5000,
+        });
+    }
+    catch {
+        // ignore absent session
+    }
+}

package/dist/platform/claude-code/upstream/tmux/imported/session-name.js

@@ -0,0 +1,19 @@
+const TMUX_SESSION_PREFIX = 'omc-team';
+/**
+ * Imported from oh-my-claudecode.
+ * Source: oh-my-claudecode/src/team/tmux-session.ts
+ * Commit: 2487d3878f8d25e60802940b020d5ee8774d135e
+ */
+export function sanitizeClaudeSessionNamePart(name) {
+    const sanitized = name.replace(/[^a-zA-Z0-9-]/g, '');
+    if (sanitized.length === 0) {
+        throw new Error(`Invalid name: "${name}" contains no valid characters (alphanumeric or hyphen)`);
+    }
+    if (sanitized.length < 2) {
+        throw new Error(`Invalid name: "${name}" too short after sanitization (minimum 2 characters)`);
+    }
+    return sanitized.slice(0, 50);
+}
+export function buildClaudeWorkerSessionName(teamName, workerName) {
+    return `${TMUX_SESSION_PREFIX}-${sanitizeClaudeSessionNamePart(teamName)}-${sanitizeClaudeSessionNamePart(workerName)}`;
+}

package/dist/platform/claude-code/upstream/worktree/imported/get-worktree-root.js

@@ -0,0 +1,39 @@
+import { execSync } from 'node:child_process';
+/**
+ * Imported from oh-my-claudecode.
+ * Source: oh-my-claudecode/src/lib/worktree-paths.ts
+ * Commit: 2487d3878f8d25e60802940b020d5ee8774d135e
+ */
+const MAX_WORKTREE_CACHE_SIZE = 8;
+const worktreeCacheMap = new Map();
+export function clearClaudeCodeWorktreeRootCache() {
+    worktreeCacheMap.clear();
+}
+export function getClaudeCodeWorktreeRoot(cwd) {
+    const effectiveCwd = cwd || process.cwd();
+    if (worktreeCacheMap.has(effectiveCwd)) {
+        const root = worktreeCacheMap.get(effectiveCwd);
+        worktreeCacheMap.delete(effectiveCwd);
+        worktreeCacheMap.set(effectiveCwd, root);
+        return root || null;
+    }
+    try {
+        const root = execSync('git rev-parse --show-toplevel', {
+            cwd: effectiveCwd,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 5000,
+        }).trim();
+        if (worktreeCacheMap.size >= MAX_WORKTREE_CACHE_SIZE) {
+            const oldest = worktreeCacheMap.keys().next().value;
+            if (oldest !== undefined) {
+                worktreeCacheMap.delete(oldest);
+            }
+        }
+        worktreeCacheMap.set(effectiveCwd, root);
+        return root;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/platform/claude-code/upstream/worktree/imported/managed-worktree.js

@@ -0,0 +1,77 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+export function createClaudeManagedWorktree(plan) {
+    try {
+        execFileSync('git', ['worktree', 'prune'], {
+            cwd: plan.repoRoot,
+            stdio: 'pipe',
+        });
+    }
+    catch {
+        // best effort only
+    }
+    if (existsSync(plan.worktreePath)) {
+        try {
+            execFileSync('git', ['worktree', 'remove', '--force', plan.worktreePath], {
+                cwd: plan.repoRoot,
+                stdio: 'pipe',
+            });
+        }
+        catch {
+            // best effort only
+        }
+    }
+    try {
+        execFileSync('git', ['branch', '-D', plan.branchName], {
+            cwd: plan.repoRoot,
+            stdio: 'pipe',
+        });
+    }
+    catch {
+        // branch may not exist
+    }
+    mkdirSync(dirname(plan.worktreePath), { recursive: true });
+    const args = ['worktree', 'add', '-b', plan.branchName, plan.worktreePath];
+    if (plan.baseBranch) {
+        args.push(plan.baseBranch);
+    }
+    execFileSync('git', args, {
+        cwd: plan.repoRoot,
+        stdio: 'pipe',
+    });
+    return {
+        path: plan.worktreePath,
+        branch: plan.branchName,
+        createdAt: new Date().toISOString(),
+    };
+}
+export function removeClaudeManagedWorktree(target) {
+    try {
+        execFileSync('git', ['worktree', 'remove', '--force', target.worktreePath], {
+            cwd: target.repoRoot,
+            stdio: 'pipe',
+        });
+    }
+    catch {
+        // worktree may already be absent
+    }
+    try {
+        execFileSync('git', ['worktree', 'prune'], {
+            cwd: target.repoRoot,
+            stdio: 'pipe',
+        });
+    }
+    catch {
+        // best effort only
+    }
+    try {
+        execFileSync('git', ['branch', '-D', target.branchName], {
+            cwd: target.repoRoot,
+            stdio: 'pipe',
+        });
+    }
+    catch {
+        // branch may already be absent
+    }
+}

package/dist/platform/claude-code/worktree.js

@@ -0,0 +1,79 @@
+import { dirname, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { planTopicWorktree, recordTopicWorktreeCreate, recordTopicWorktreeRemove, resolveTopicWorktreeTarget, } from '../../core/topics/worktree-runtime.js';
+import { readImportedUpstreamSlice } from '../upstream-imports.js';
+import { createClaudeManagedWorktree, removeClaudeManagedWorktree, } from './upstream/worktree/imported/managed-worktree.js';
+const HERE = dirname(fileURLToPath(import.meta.url));
+function command(name) {
+    return ['shift-ax', name];
+}
+export function getClaudeCodeWorktreeRuntime(rootDir) {
+    const importRoot = join(rootDir, 'platform', 'claude-code', 'upstream', 'worktree');
+    return {
+        support: 'available',
+        entrypoint_style: 'cli',
+        topic_artifacts: {
+            plan: 'worktree-plan.json',
+            state: 'worktree-state.json',
+        },
+        operations: {
+            plan: {
+                command: command('worktree-plan'),
+                topic_flag: '--topic',
+            },
+            create: {
+                command: command('worktree-create'),
+                topic_flag: '--topic',
+                additional_flags: ['--base'],
+            },
+            remove: {
+                command: command('worktree-remove'),
+                topic_flag: '--topic',
+            },
+        },
+        upstream_boundary: {
+            import_root: importRoot,
+            provenance_doc: join(rootDir, 'platform', 'claude-code', 'upstream', 'worktree', 'provenance.md'),
+            planned_upstream_modules: [
+                'oh-my-claudecode/src/team/git-worktree.ts',
+                'oh-my-claudecode/src/lib/worktree-paths.ts',
+            ],
+            active_imports: [
+                readImportedUpstreamSlice(join(HERE, 'upstream', 'worktree', 'imported', 'provenance.json')),
+                readImportedUpstreamSlice(join(HERE, 'upstream', 'worktree', 'imported', 'managed-worktree.provenance.json')),
+            ],
+        },
+    };
+}
+export async function planClaudeCodeTopicWorktree(input) {
+    return planTopicWorktree(input);
+}
+export async function createClaudeCodeTopicWorktree(input) {
+    const target = await resolveTopicWorktreeTarget(input);
+    if (existsSync(target.worktreePath)) {
+        return recordTopicWorktreeCreate(target, {
+            created: false,
+            reused: true,
+        });
+    }
+    createClaudeManagedWorktree({
+        repoRoot: target.rootDir,
+        worktreePath: target.worktreePath,
+        branchName: target.branchName,
+        baseBranch: target.baseBranch,
+    });
+    return recordTopicWorktreeCreate(target, {
+        created: true,
+        reused: false,
+    });
+}
+export async function removeClaudeCodeTopicWorktree(input) {
+    const target = await resolveTopicWorktreeTarget(input);
+    removeClaudeManagedWorktree({
+        repoRoot: target.rootDir,
+        worktreePath: target.worktreePath,
+        branchName: target.branchName,
+    });
+    return recordTopicWorktreeRemove(target, !existsSync(target.worktreePath));
+}

package/dist/platform/codex/bootstrap.js

@@ -0,0 +1,69 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { buildProductShellAssets, SHIFT_AX_PRODUCT_SHELL_COMMANDS } from '../product-shell-commands.js';
+import { getGlobalContextHome } from '../../core/settings/global-context-home.js';
+const HERE = dirname(fileURLToPath(import.meta.url));
+const TEMPLATE_FILES = [
+    'platform/codex/scaffold/AGENTS.template.md',
+    'platform/codex/scaffold/prompts/shift-ax-bootstrap.template.md',
+    ...SHIFT_AX_PRODUCT_SHELL_COMMANDS.map((name) => `platform/codex/scaffold/skills/${name}/SKILL.template.md`),
+];
+function templatePath(relativePath) {
+    return join(HERE, 'scaffold', relativePath.split('/').slice(3).join('/'));
+}
+function localePrelude(locale) {
+    return locale === 'ko'
+        ? '선호 사용자 언어: 한국어. 사용자가 명시적으로 바꾸라고 하지 않으면 한국어로 응답하세요.'
+        : 'Preferred user language: English. Respond in English unless the user explicitly asks to switch.';
+}
+function injectLocalePrelude(raw, locale) {
+    const prelude = localePrelude(locale);
+    if (raw.startsWith('---\n')) {
+        const closing = raw.indexOf('\n---\n', 4);
+        if (closing !== -1) {
+            const frontmatter = raw.slice(0, closing + 5);
+            const rest = raw.slice(closing + 5);
+            return `${frontmatter}\n${prelude}\n\n${rest}`;
+        }
+    }
+    return `${prelude}\n\n${raw}`;
+}
+function renderTemplate(relativePath, rootDir, locale) {
+    const raw = readFileSync(templatePath(relativePath), 'utf8');
+    return injectLocalePrelude(raw
+        .replaceAll('{{BASE_CONTEXT_INDEX}}', `${rootDir}/docs/base-context/index.md`)
+        .replaceAll('{{GLOBAL_CONTEXT_INDEX}}', getGlobalContextHome().indexPath), locale);
+}
+export function codexScaffoldTemplateFiles() {
+    return [...TEMPLATE_FILES];
+}
+export function renderCodexAgentsBootstrap(rootDir, locale = 'en') {
+    return renderTemplate('platform/codex/scaffold/AGENTS.template.md', rootDir, locale);
+}
+export function renderCodexPromptBootstrap(rootDir, locale = 'en') {
+    return renderTemplate('platform/codex/scaffold/prompts/shift-ax-bootstrap.template.md', rootDir, locale);
+}
+export function getCodexBootstrapAssets(rootDir, locale = 'en') {
+    const commandAssets = buildProductShellAssets({
+        platform: 'codex',
+        commandBasePath: '.codex/skills',
+        renderTemplate: (name) => renderTemplate(`platform/codex/scaffold/skills/${name}/SKILL.template.md`, rootDir, locale),
+    });
+    return [
+        {
+            path: 'AGENTS.md',
+            description: 'Top-level AGENTS bootstrap for Codex builds.',
+            content: renderCodexAgentsBootstrap(rootDir, locale),
+        },
+        {
+            path: '.codex/prompts/shift-ax-bootstrap.md',
+            description: 'Codex bootstrap prompt fragment.',
+            content: renderCodexPromptBootstrap(rootDir, locale),
+        },
+        ...commandAssets.map((asset) => ({
+            ...asset,
+            path: asset.path.replace(/\.codex\/skills\/([^/]+)\.md$/, '.codex/skills/$1/SKILL.md'),
+        })),
+    ];
+}

package/dist/platform/codex/execution.js

@@ -0,0 +1,163 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { materializeExecutionPrompts } from '../../core/planning/execution-launch.js';
+import { sanitizeCodexTeamName } from './upstream/tmux/imported/sanitize-team-name.js';
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function buildCodexTmuxSessionName(topicSlug, taskId) {
+    const topicPart = sanitizeCodexTeamName(topicSlug).slice(0, 18).replace(/-$/, '');
+    const taskPart = sanitizeCodexTeamName(taskId).slice(0, 8).replace(/-$/, '');
+    return `axexec-${topicPart}-${taskPart}`;
+}
+function buildCodexExecShellCommand(plan) {
+    return `codex exec --full-auto -C ${shellQuote(plan.working_directory)} -o ${shellQuote(plan.output_path)} \"$(cat ${shellQuote(plan.prompt_path)})\"`;
+}
+function formatProcessError(error) {
+    const failure = error;
+    const stdout = typeof failure.stdout === 'string'
+        ? failure.stdout
+        : failure.stdout instanceof Buffer
+            ? failure.stdout.toString('utf8')
+            : '';
+    const stderr = typeof failure.stderr === 'string'
+        ? failure.stderr
+        : failure.stderr instanceof Buffer
+            ? failure.stderr.toString('utf8')
+            : '';
+    return [failure.message ?? 'process failed', stdout.trim(), stderr.trim()]
+        .filter(Boolean)
+        .join('\n');
+}
+function codexExecutionTimeoutMs() {
+    const parsed = Number(process.env.SHIFT_AX_CODEX_EXEC_TIMEOUT_MS || '180000');
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 180_000;
+}
+function clearExistingTmuxSession(sessionName) {
+    try {
+        execFileSync('tmux', ['has-session', '-t', sessionName], {
+            stdio: 'pipe',
+        });
+        execFileSync('tmux', ['kill-session', '-t', sessionName], {
+            stdio: 'pipe',
+        });
+    }
+    catch {
+        // no existing session to clear
+    }
+}
+export function getCodexExecutionRuntime() {
+    return {
+        support: 'available',
+        entrypoint_style: 'cli',
+        execution_handoff_artifact: 'execution-handoff.json',
+        operations: {
+            launch: {
+                command: ['shift-ax', 'launch-execution'],
+                topic_flag: '--topic',
+                additional_flags: ['--platform', '--task-id', '--dry-run'],
+            },
+        },
+        hosts: {
+            subagent_cli: 'codex',
+            tmux_cli: 'tmux',
+        },
+    };
+}
+export async function planCodexExecutionLaunch({ topicDir, taskId, }) {
+    const artifacts = await materializeExecutionPrompts(topicDir, taskId);
+    const tasks = artifacts.map((artifact) => {
+        const basePlan = {
+            task_id: artifact.task.id,
+            source_text: artifact.task.source_text,
+            execution_mode: artifact.task.execution_mode,
+            working_directory: artifact.worktreePath,
+            prompt_path: artifact.promptPath,
+            output_path: artifact.outputPath,
+        };
+        if (artifact.task.execution_mode === 'tmux') {
+            const sessionName = buildCodexTmuxSessionName(topicDir.split('/').pop() || 'topic', artifact.task.id);
+            const shellCommand = buildCodexExecShellCommand({
+                ...basePlan,
+                command: [],
+                shell_command: '',
+            });
+            return {
+                ...basePlan,
+                command: [
+                    'tmux',
+                    'new-session',
+                    '-d',
+                    '-s',
+                    sessionName,
+                    '-c',
+                    artifact.worktreePath,
+                    shellCommand,
+                ],
+                shell_command: shellCommand,
+                session_name: sessionName,
+            };
+        }
+        const shellCommand = buildCodexExecShellCommand({
+            ...basePlan,
+            command: [],
+            shell_command: '',
+        });
+        return {
+            ...basePlan,
+            command: [
+                'codex',
+                'exec',
+                '--full-auto',
+                '-C',
+                artifact.worktreePath,
+                '-o',
+                artifact.outputPath,
+                '-',
+            ],
+            shell_command: shellCommand,
+        };
+    });
+    return {
+        platform: 'codex',
+        launched: false,
+        topic_dir: topicDir,
+        tasks,
+    };
+}
+export async function launchCodexExecution({ topicDir, taskId, }) {
+    const plan = await planCodexExecutionLaunch({ topicDir, taskId });
+    for (const task of plan.tasks) {
+        if (task.execution_mode === 'tmux') {
+            if (task.session_name) {
+                clearExistingTmuxSession(task.session_name);
+            }
+            execFileSync(task.command[0], task.command.slice(1), {
+                stdio: 'pipe',
+            });
+            continue;
+        }
+        try {
+            execFileSync('codex', [
+                'exec',
+                '--full-auto',
+                '-C',
+                task.working_directory,
+                '-o',
+                task.output_path,
+                readFileSync(task.prompt_path, 'utf8'),
+            ], {
+                cwd: task.working_directory,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                timeout: codexExecutionTimeoutMs(),
+            });
+        }
+        catch (error) {
+            throw new Error(`Codex execution failed for ${task.task_id}: ${formatProcessError(error)}`);
+        }
+    }
+    return {
+        ...plan,
+        launched: true,
+    };
+}