great-cto 3.47.0 → 3.48.0

package/board/scripts/work-task.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+/** Advanced operator contract behind `great-cto task work`; no new daily flow. */
+import { resolve } from 'node:path';
+import { listWorkTasks, readWorkTask } from './lib/work-tasks.mjs';
+import { approveWorkDecision, decisionCapabilities } from './lib/work-decisions.mjs';
+import { applyOutcome, readOutcomeEvidence } from './lib/work-outcomes.mjs';
+import { measureWork, compareWork } from './lib/work-metrics.mjs';
+const args = process.argv.slice(2), action = args.shift();
+try {
+  const supported = new Set(['--dir','--task','--decision','--revision','--operation','--evidence','--baseline']);
+  const opts = {};
+  for (let i = 0; i < args.length; i += 2) { if (!supported.has(args[i]) || !args[i+1] || args[i+1].startsWith('--') || opts[args[i]] !== undefined) throw Error('invalid or duplicate operator option'); opts[args[i]] = args[i+1]; }
+  const perAction = { metrics: ['--dir','--baseline'], decisions: ['--dir','--task'], approve: ['--dir','--task','--decision','--revision','--operation'], verify: ['--dir','--task','--revision','--operation','--evidence'], complete: ['--dir','--task','--revision','--operation'] };
+  if (perAction[action] && Object.keys(opts).some(k => !perAction[action].includes(k))) throw Error('option is not supported for this operation');
+  const root = resolve(opts['--dir'] || '.'), taskId = opts['--task'];
+  let result;
+  if (action === 'metrics') {
+    const listing = listWorkTasks(root); if (listing.state === 'degraded') throw Error('task source is degraded; measurements refused');
+    const current = measureWork(listing.tasks), baseline = opts['--baseline'] ? readOutcomeEvidence(root, opts['--baseline']).document : null;
+    result = { ...current, comparison: compareWork(current, baseline) };
+  } else if (action === 'decisions') result = decisionCapabilities(readWorkTask(taskId, { root }));
+  else if (action === 'approve') result = approveWorkDecision({ root, taskId, decisionId: opts['--decision'], expectedRevision: Number(opts['--revision']), operationId: opts['--operation'] });
+  else if (['verify','complete'].includes(action)) result = applyOutcome({ root, taskId, kind: action, expectedRevision: Number(opts['--revision']), operationId: opts['--operation'], evidenceFile: opts['--evidence'] });
+  else throw Error('usage: great-cto task work decisions|approve|verify|complete|metrics --dir PATH [--task UUID --revision N --operation UUID --decision ID --evidence EXTERNAL_FILE --baseline EXTERNAL_FILE]');
+  console.log(JSON.stringify(result, null, 2));
+} catch (e) { console.error('work-task: ' + e.message); process.exitCode = 2; }

package/dist/codex-host.js

@@ -6,8 +6,8 @@ import { spawnSync } from 'node:child_process';
 export function codexControllerCandidates(moduleUrl = import.meta.url) {
     const cliRoot = join(dirname(fileURLToPath(moduleUrl)), '..');
     return [
-        join(cliRoot, 'board', 'scripts', 'codex-pipeline.mjs'),
         join(cliRoot, '..', '..', 'scripts', 'codex-pipeline.mjs'),
+        join(cliRoot, 'board', 'scripts', 'codex-pipeline.mjs'),
     ];
 }
 export function runCodexHost(args, { exists = existsSync, spawn = spawnSync } = {}) {

package/dist/main.js

@@ -101,10 +101,12 @@ function parseArgs(argv) {
             args.noLlm = true;
         else if (a === "--host") {
             const v = argv[++i] ?? "";
+            args.hostInput = v;
             args.host = (v === "codex" || v === "claude-code") ? v : null;
         }
         else if (a.startsWith("--host=")) {
             const v = a.slice("--host=".length);
+            args.hostInput = v;
             args.host = (v === "codex" || v === "claude-code") ? v : null;
         }
         else if (a === "--bind")
@@ -158,11 +160,16 @@ function parseArgs(argv) {
             args.taskArgs = argv.slice(i + 1);
             break;
         }
+        else if (a === "run" || a === "status" || a === "resume") {
+            args.command = a;
+            args.taskArgs = argv.slice(i + 1);
+            break;
+        }
         // Slash-commands surfaced as CLI subcommands so users get a clear hint
         // instead of a confusing usage error. These work only in the chat plugin.
         else if (a === "start" || a === "audit" || a === "inbox" || a === "digest" ||
             a === "review" || a === "doctor" || a === "burn" || a === "save" ||
-            a === "resume" || a === "learn" || a === "agent" ||
+            a === "learn" || a === "agent" ||
             a === "rfc" || a === "release" || a === "ownership" ||
             a === "sec" || a === "poc" || a === "crystallize" ||
             a === "migrate") {
@@ -719,10 +726,34 @@ async function runUninstall(args) {
         warn(`${plan.keptVersions.length} plugin version(s) kept — a running session uses them; run uninstall again after closing it`);
     return r.failed.length ? 1 : 0;
 }
-function printHelp() {
+function printHelp(advanced = false) {
+    if (!advanced) {
+        log(`great-cto — describe the task, get a checked result
+
+Get started:
+  great-cto init
+
+Everyday use:
+  great-cto run "describe the task"
+  great-cto status
+  great-cto resume
+
+Default host: interactive Claude Code with the plugin loaded.
+For controlled Codex add --host codex; run also needs --allow src,tests,docs.
+Use --dir PATH to choose a project, --dry-run to preview, or run --help for options.
+Resume preserves pending decisions; it never approves them.
+
+Details:
+  great-cto board           Open the local dashboard
+  great-cto help --advanced All installation, runtime and operator commands`);
+        return;
+    }
     log(`${bold("great-cto")} — one-command install for the great_cto Claude Code plugin
 
 ${bold("Usage:")}
+  npx great-cto run "describe the task" [--host claude-code|codex] [--dir PATH]
+  npx great-cto status [RUN_UUID] [--host codex] [--json]
+  npx great-cto resume [RUN_UUID] [--host codex]
   npx great-cto install [options]    Same as init
   npx great-cto [init] [options]     Detect + bootstrap
   npx great-cto board [--port 3141] [--no-open]
@@ -731,6 +762,7 @@ ${bold("Usage:")}
   npx great-cto ci [path] [--no-archetype] [--no-budget]
   npx great-cto mcp [--sse --port N]
   npx great-cto adapt [--dry-run]
+  npx great-cto task work decisions|approve|verify|complete|metrics ...
   npx great-cto codex-host doctor|list|start|resume|status ...
   npx great-cto serve [--port 3142]
   npx great-cto upgrade [superpowers|beads]  Re-clone companions to latest tag + re-apply overlays
@@ -1528,7 +1560,7 @@ async function main() {
         await finish(exitCode);
     }
     if (args.command === "help") {
-        printHelp();
+        printHelp(rawArgv.includes('--advanced'));
         await finish(0);
     }
     if (args.command === "unknown") {
@@ -1622,6 +1654,10 @@ async function main() {
             await finish(2);
         }
     }
+    if (args.command === "task" && args.taskArgs?.[0] === "work") {
+        const { runWorkTask } = await import("./work-task.js");
+        await finish(runWorkTask(args.taskArgs.slice(1)));
+    }
     if (args.command === "task") {
         const { runTask } = await import("./worker.js");
         await finish(await runTask(args.taskArgs ?? []));
@@ -1634,6 +1670,11 @@ async function main() {
         const { runCodexHost } = await import('./codex-host.js');
         await finish(runCodexHost(args.taskArgs ?? []));
     }
+    if (args.command === "run" || args.command === "status" || args.command === "resume") {
+        const { runDaily } = await import('./run.js');
+        const dailyArgs = [...(args.hostInput !== undefined ? ['--host', args.hostInput] : []), ...(args.taskArgs ?? [])];
+        await finish(runDaily(args.command, dailyArgs, { cwd: args.dir }));
+    }
     if (args.command === "serve") {
         try {
             const { runServe } = await import("./serve.js");

package/dist/run.js

@@ -0,0 +1,321 @@
+/** Daily entry points. Adapters reuse host-owned state, checks and permissions. */
+import { randomUUID } from 'node:crypto';
+import { pathToFileURL } from 'node:url';
+import { existsSync } from 'node:fs';
+import { join, resolve, dirname } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { codexControllerCandidates } from './codex-host.js';
+const sharedTaskPath = codexControllerCandidates().map(p => join(dirname(p), 'lib', 'work-tasks.mjs')).find(existsSync);
+// Variable URL keeps one runtime implementation shared with hooks/controller/board.
+const sharedTasks = sharedTaskPath ? await import(pathToFileURL(sharedTaskPath).href) : null;
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const terminal = new Set(['done', 'cancelled']);
+export const dailyUsage = `great-cto run "describe the task" [--host claude-code|codex] [--dir PATH]
+great-cto status [--task TASK_UUID | RUN_UUID] [--host claude-code|codex] [--dir PATH] [--json]
+great-cto resume [--task TASK_UUID | RUN_UUID] [--host claude-code|codex] [--dir PATH]
+
+Default host: Claude Code (interactive /start and exact-session /resume).
+Status reads task metadata; it does not launch a model.
+Tasks persist goal, optional repeated --accept criteria and host links.
+Use --task UUID for exact task status/resume; --json works for either host.
+Use --operation UUID to replay a launch receipt without dispatching twice.
+Codex runs require --allow PATHS (comma-separated write scope).
+Codex resume selects the only unfinished run in this project; gates stay pending.
+Research tasks use --intent research; controlled scope is report-only.
+Advanced decisions/outcomes/measurements: great-cto task work.
+Use --dry-run to preview a launch without starting an agent.
+Advanced controller options remain available through great-cto codex-host.
+`;
+function parse(action, args, cwd) {
+    const out = { host: 'claude-code', dir: cwd, prompt: '', dryRun: false, json: false, help: false, acceptance: [], hostExplicit: false, intent: 'delivery', maxAttempts: 3 };
+    const positional = [];
+    let literal = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (literal) {
+            positional.push(arg);
+            continue;
+        }
+        if (arg === '--') {
+            literal = true;
+            continue;
+        }
+        if (arg === '--dry-run') {
+            out.dryRun = true;
+            continue;
+        }
+        if (arg === '--json') {
+            out.json = true;
+            continue;
+        }
+        if (arg === '--help' || arg === '-h') {
+            out.help = true;
+            continue;
+        }
+        const key = arg.split('=')[0];
+        if (['--host', '--dir', '--allow', '--accept', '--task', '--operation', '--revision', '--intent', '--max-attempts'].includes(key)) {
+            const value = arg.includes('=') ? arg.slice(arg.indexOf('=') + 1) : args[++i];
+            if (!value || value.startsWith('--'))
+                throw Error(`${key} requires a value`);
+            if (key === '--host') {
+                if (value !== 'codex' && value !== 'claude-code')
+                    throw Error('host must be claude-code or codex');
+                out.host = value;
+                out.hostExplicit = true;
+            }
+            else if (key === '--dir')
+                out.dir = resolve(cwd, value);
+            else if (key === '--allow')
+                out.allow = value;
+            else if (key === '--accept')
+                out.acceptance.push(value);
+            else if (key === '--intent') {
+                if (value !== 'delivery' && value !== 'research')
+                    throw Error('--intent must be delivery or research');
+                out.intent = value;
+            }
+            else if (key === '--max-attempts') {
+                out.maxAttempts = Number(value);
+                if (!Number.isInteger(out.maxAttempts) || out.maxAttempts < 1 || out.maxAttempts > 5)
+                    throw Error('--max-attempts must be 1..5');
+            }
+            else if (key === '--task') {
+                if (!uuid.test(value))
+                    throw Error('--task requires a task UUID');
+                out.taskId = value;
+            }
+            else if (key === '--operation') {
+                if (!uuid.test(value))
+                    throw Error('--operation requires an operation UUID');
+                out.operationId = value;
+            }
+            else {
+                out.revision = Number(value);
+                if (!Number.isInteger(out.revision) || out.revision < 1)
+                    throw Error('--revision requires a positive integer');
+            }
+        }
+        else if (arg.startsWith('-'))
+            throw Error(`unknown option: ${arg}`);
+        else
+            positional.push(arg);
+    }
+    if (out.help)
+        return out;
+    if (action === 'run') {
+        out.prompt = positional.join(' ').trim();
+        if (!out.prompt)
+            throw Error('describe the task: great-cto run "..."');
+    }
+    else {
+        if (positional.length > 1 || (positional[0] && !uuid.test(positional[0])))
+            throw Error('expected one run UUID');
+        out.id = positional[0];
+    }
+    if (out.allow && (action !== 'run' || out.host !== 'codex'))
+        throw Error('--allow is only supported for run --host codex');
+    if (out.json && action !== 'status')
+        throw Error('--json is only supported for status');
+    if (out.acceptance.length && action !== 'run')
+        throw Error('--accept is only supported for run');
+    if (out.taskId && action === 'run')
+        throw Error('--task is for existing task status/resume');
+    if (out.taskId && out.id)
+        throw Error('select task or run UUID, not both');
+    if (action !== 'run' && args.some(a => a === '--intent' || a.startsWith('--intent=') || a === '--max-attempts' || a.startsWith('--max-attempts=')))
+        throw Error('--intent and --max-attempts are start-only');
+    if (out.host === 'claude-code' && args.some(a => a === '--max-attempts' || a.startsWith('--max-attempts=')))
+        throw Error('native rework budget is host-owned');
+    if (out.operationId && action === 'status')
+        throw Error('--operation is for execution only');
+    if (out.revision && action !== 'resume')
+        throw Error('--revision is for resume only');
+    if (out.id && out.host !== 'codex')
+        throw Error('run UUIDs belong to the controlled host; use --host codex');
+    if (action === 'run' && out.host === 'codex' && (!out.allow || out.allow.split(',').some(p => !p.trim()))) {
+        throw Error('Codex requires explicit write scope: --allow src,tests,docs');
+    }
+    return out;
+}
+/** Selection never uses filesystem order or UUID order as a proxy for recency. */
+export function selectRun(runs, id) {
+    const candidates = id ? runs.filter(r => r.id === id) : runs.filter(r => !terminal.has(r.status));
+    if (!candidates.length)
+        throw Error(id ? 'run not found in this project' : 'no unfinished run in this project');
+    if (candidates.length !== 1)
+        throw Error('multiple unfinished runs; choose a UUID from great-cto status --host codex');
+    return candidates[0];
+}
+export function runDaily(action, args, { cwd = process.cwd(), exists = existsSync, spawn = spawnSync, write = (text) => { process.stdout.write(text); }, tasks = sharedTasks, taskStore = undefined, fail = (text) => { process.stderr.write(`great-cto: ${text}\n`); }, } = {}) {
+    let heldWork = null;
+    const release = () => { const lease = heldWork?.lease; heldWork = null; lease?.release(); };
+    try {
+        const options = parse(action, args, cwd);
+        if (options.help) {
+            write(dailyUsage);
+            return 0;
+        }
+        if (!exists(options.dir))
+            throw Error(`project directory does not exist: ${options.dir}`);
+        if (!tasks)
+            throw Error('shared task runtime missing; reinstall great-cto');
+        const storeOptions = taskStore ? { store: taskStore } : {};
+        // Dry runs stay pure; no metadata lookup is needed to preview an explicit host.
+        if (options.dryRun) {
+            write(JSON.stringify({ host: options.host, action, cwd: options.dir, dir: options.dir,
+                ...(options.host === 'claude-code' && action !== 'status' ? { command: 'claude', args: [action === 'run' ? `${options.intent === 'research' ? '/audit' : '/start'} ${options.prompt}` : '/resume'] } : {}),
+                intent: options.intent, maxAttempts: options.host === 'codex' ? options.maxAttempts : null,
+                taskId: options.taskId || null, id: options.id || 'project-scoped selection' }) + '\n');
+            return 0;
+        }
+        const taskListing = tasks.listWorkTasks(options.dir, storeOptions);
+        if (taskListing.state === 'degraded')
+            throw Error('task state is unreadable; selection is blocked');
+        let selectedTask = null;
+        if (options.taskId) {
+            selectedTask = taskListing.tasks.find((t) => t.taskId === options.taskId);
+            if (!selectedTask)
+                throw Error('task not found in this project');
+            if (options.hostExplicit && selectedTask.host !== options.host)
+                throw Error('task host cannot change during resume');
+            options.host = selectedTask.host;
+        }
+        if (action === 'run' && options.operationId && taskListing.tasks.some((t) => t.operations.some((o) => o.operationId === options.operationId))) {
+            const previous = tasks.beginWork({ root: options.dir, host: options.host, goal: options.prompt, acceptance: options.acceptance, intent: options.intent, maxAttempts: options.maxAttempts,
+                authority: options.host === 'codex' ? { mode: 'explicit-paths', writeScope: options.allow.split(',').map(p => p.trim()) } : { mode: 'native-interactive', writeScope: null },
+                operationId: options.operationId }, storeOptions);
+            write(JSON.stringify(tasks.publicWorkTask(previous.task)) + '\n');
+            return previous.operation.exitCode ?? 2;
+        }
+        if (action === 'resume' && options.operationId) {
+            const receiptTask = taskListing.tasks.find((t) => t.operations.some((o) => o.operationId === options.operationId));
+            if (receiptTask) {
+                if ((selectedTask && selectedTask.taskId !== receiptTask.taskId) || (options.id && !receiptTask.links.runs.includes(options.id))
+                    || (options.hostExplicit && options.host !== receiptTask.host))
+                    throw Error('idempotency key conflicts with another task');
+                const replay = tasks.beginWork({ root: options.dir, host: receiptTask.host, kind: 'resume', taskId: receiptTask.taskId,
+                    operationId: options.operationId, expectedRevision: options.revision ?? null }, storeOptions);
+                write(JSON.stringify(tasks.publicWorkTask(replay.task)) + '\n');
+                return replay.operation.exitCode ?? 2;
+            }
+        }
+        if (options.host === 'claude-code') {
+            if (action === 'status') {
+                const shown = selectedTask ? [selectedTask] : taskListing.tasks.filter((t) => t.host === 'claude-code');
+                if (options.json)
+                    write(JSON.stringify({ schemaVersion: 1, state: taskListing.state, tasks: shown.map(tasks.publicWorkTask) }, null, 2) + '\n');
+                else
+                    write(shown.length ? shown.map((t) => `${t.taskId}  ${t.phase}  ${t.goal}`).join('\n') + '\n' : 'No tracked Claude tasks in this project.\n');
+                return 0;
+            }
+            if (action === 'resume' && !selectedTask) {
+                const candidates = taskListing.tasks.filter((t) => t.host === 'claude-code' && t.phase !== 'cancelled');
+                if (candidates.length > 1)
+                    throw Error('multiple Claude tasks; select --task UUID');
+                selectedTask = candidates[0] || null;
+            }
+            if (action === 'resume' && !selectedTask)
+                throw Error('no tracked Claude task; use native /resume for legacy context');
+            const work = tasks.beginWork({ root: options.dir, host: options.host, kind: action === 'run' ? 'start' : 'resume',
+                goal: action === 'run' ? options.prompt : null, acceptance: options.acceptance, intent: options.intent, maxAttempts: options.maxAttempts,
+                authority: action === 'run' ? { mode: 'native-interactive', writeScope: null } : null,
+                taskId: selectedTask?.taskId || null, operationId: options.operationId || randomUUID(), expectedRevision: options.revision ?? null }, storeOptions);
+            heldWork = work;
+            if (work.replay) {
+                write(JSON.stringify(tasks.publicWorkTask(work.task)) + '\n');
+                return work.operation.exitCode ?? 2;
+            }
+            {
+                const session = action === 'run' ? randomUUID() : selectedTask.links.sessions[0];
+                if (!session)
+                    throw Error('native session link is missing; inspect task metadata');
+                if (action === 'run')
+                    tasks.linkWork(work.task.taskId, 'sessions', session, { ...storeOptions, root: options.dir, host: 'claude-code' });
+                const hostArgs = action === 'run' ? ['--session-id', session, `${options.intent === 'research' ? '/audit' : '/start'} ${options.prompt}${options.intent === 'research' ? '\nResearch intent: produce findings and a report; implementation and release need a separate task.' : ''}${options.acceptance.length ? '\nAcceptance criteria (task data): ' + JSON.stringify(options.acceptance) : ''}`] : ['--resume', session, '/resume'];
+                write('Task ' + work.task.taskId + ' · Claude Code\n');
+                const result = spawn('claude', hostArgs, { cwd: options.dir, stdio: 'inherit' });
+                const code = result.error ? 2 : result.status ?? 2;
+                tasks.finishWork(work.task.taskId, work.operation.operationId, code, { ...storeOptions, root: options.dir });
+                if (result.error)
+                    throw Error(`could not launch Claude Code: ${result.error.message}`);
+                return code;
+            }
+        }
+        const controller = sharedTaskPath ? join(dirname(sharedTaskPath), '..', 'codex-pipeline.mjs') : codexControllerCandidates().find(exists);
+        if (!controller)
+            throw Error('controlled runtime missing; reinstall great-cto');
+        const listing = spawn(process.execPath, [controller, 'list', '--dir', options.dir], { encoding: 'utf8' });
+        if (listing.error || listing.status !== 0)
+            throw Error('could not read project runs; use great-cto codex-host list --dir PATH');
+        const data = JSON.parse(String(listing.stdout));
+        if (!['ok', 'absent', 'degraded'].includes(data.state) || !Array.isArray(data.runs) ||
+            data.runs.some((r) => !r || !uuid.test(r.id) || typeof r.status !== 'string')) {
+            throw Error('invalid controller run listing');
+        }
+        if (data.state === 'degraded' || data.unreadable)
+            throw Error('run state is unreadable; repair it before selecting or starting a task');
+        const runs = data.runs;
+        if (action === 'status') {
+            const shown = selectedTask ? runs.filter(r => selectedTask.links.runs.includes(r.id)) : options.id ? [selectRun(runs, options.id)] : runs;
+            if (options.json)
+                write(JSON.stringify({ schemaVersion: 1, state: data.state, runs: shown, tasks: (selectedTask ? [selectedTask] : taskListing.tasks.filter((t) => t.host === 'codex')).map(tasks.publicWorkTask) }, null, 2) + '\n');
+            else {
+                write(shown.length ? shown.map(r => `${r.id}  ${r.status}${r.pending?.gates?.length ? `  Decision needed: ${r.pending.gates.join(', ')}` : ''}${r.reason ? `  ${r.reason}` : ''}`).join('\n') + '\n' : 'No controlled runs in this project.\n');
+            }
+            return 0;
+        }
+        let forwarded;
+        let work = null;
+        if (action === 'resume') {
+            if (selectedTask && selectedTask.links.runs.length !== 1)
+                throw Error('task run link is missing or ambiguous');
+            const selected = selectRun(runs, selectedTask?.links.runs[0] || options.id);
+            selectedTask ||= taskListing.tasks.find((t) => t.links.runs.includes(selected.id));
+            if (terminal.has(selected.status))
+                throw Error(`run is ${selected.status}; start a new task instead`);
+            if (selectedTask)
+                heldWork = work = tasks.beginWork({ root: options.dir, host: 'codex', kind: 'resume', taskId: selectedTask.taskId,
+                    operationId: options.operationId || randomUUID(), expectedRevision: options.revision ?? null }, storeOptions);
+            if (!selectedTask && (options.operationId || options.revision))
+                throw Error('legacy run has no task receipt; use advanced controller resume');
+            forwarded = ['resume', selected.id];
+        }
+        else {
+            if (runs.some(r => !terminal.has(r.status)))
+                throw Error('unfinished task exists; use great-cto resume --host codex or choose a run from status');
+            // Existing projects enter architecture; new projects enter product discovery.
+            const entry = options.intent === 'research' ? 'project-auditor' : exists(join(options.dir, '.great_cto', 'PROJECT.md')) ? 'architect' : 'product-owner';
+            heldWork = work = tasks.beginWork({ root: options.dir, host: 'codex', goal: options.prompt, acceptance: options.acceptance, intent: options.intent, maxAttempts: options.maxAttempts,
+                authority: { mode: 'explicit-paths', writeScope: options.allow.split(',').map(p => p.trim()) },
+                operationId: options.operationId || randomUUID() }, storeOptions);
+            forwarded = ['start', '--dir', options.dir, '--prompt', options.prompt, '--allow', options.allow, '--entry', entry, '--task-id', work.task.taskId];
+        }
+        if (work?.replay) {
+            write(JSON.stringify(tasks.publicWorkTask(work.task)) + '\n');
+            return work.operation.exitCode ?? 2;
+        }
+        {
+            const result = spawn(process.execPath, [controller, ...forwarded], { stdio: 'inherit',
+                env: { ...process.env, ...(taskStore ? { GREAT_CTO_TASKS_DIR: taskStore } : {}), ...(work ? { GREAT_CTO_WORK_LEASE: work.lease.token } : {}) } });
+            const code = result.error ? 2 : result.status ?? 2;
+            if (work)
+                tasks.finishWork(work.task.taskId, work.operation.operationId, code, { ...storeOptions, root: options.dir });
+            if (result.error)
+                throw Error(`could not launch controlled runtime: ${result.error.message}`);
+            return code;
+        }
+    }
+    catch (error) {
+        if (heldWork && !heldWork.replay) {
+            try {
+                tasks?.finishWork(heldWork.task.taskId, heldWork.operation.operationId, 2, taskStore ? { store: taskStore } : {});
+            }
+            catch { /* preserve the original failure; no dispatch retry */ }
+        }
+        fail(error.message);
+        return 2;
+    }
+    finally {
+        release();
+    }
+}

package/dist/work-task.js

@@ -0,0 +1,18 @@
+/** Advanced task operations share the same source/bundled runtime as daily entry. */
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { codexControllerCandidates } from './codex-host.js';
+export function runWorkTask(args) {
+    const script = codexControllerCandidates().map(p => join(dirname(p), 'work-task.mjs')).find(existsSync);
+    if (!script) {
+        process.stderr.write('great-cto: task operations runtime is missing; reinstall package\n');
+        return 2;
+    }
+    const result = spawnSync(process.execPath, [script, ...args], { stdio: 'inherit' });
+    if (result.error) {
+        process.stderr.write('great-cto: ' + result.error.message + '\n');
+        return 2;
+    }
+    return result.status ?? 2;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "great-cto",
-  "version": "3.47.0",
+  "version": "3.48.0",
   "description": "One command install for the great_cto Claude Code plugin. Auto-detects your stack, picks the right archetype, bootstraps PROJECT.md.",
   "keywords": [
     "claude-code",