@aria_asi/cli 0.2.39 → 0.2.41

package/dist/aria-connector/src/task-runner.js

@@ -0,0 +1,3526 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, appendFileSync } from 'node:fs';
+import path from 'node:path';
+import { homedir } from 'node:os';
+import { createHash, randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { compiledWorkUnitSummary, persistCompiledWorkUnit, projectActionLedger, readActionLedgerEvents, recordActionEventLocal, validateCompiledWorkUnitForExecution, } from './action-ledger-core.js';
+import { UNIVERSAL_TURN_PACKET_CORRECTION_SKILL_FLOOR, UNIVERSAL_TURN_PACKET_HIVE_OBSERVER_FLOOR, UNIVERSAL_TURN_PACKET_HIVE_SIBLING_BROADCAST_FLOOR, UNIVERSAL_TURN_PACKET_HIVE_SOURCE_FLOOR, UNIVERSAL_TURN_PACKET_MAPPING_FLOOR, UNIVERSAL_TURN_PACKET_PHASES, UNIVERSAL_TURN_PACKET_PRIMITIVE_FLOOR, UNIVERSAL_TURN_PACKET_QA_SKILL_FLOOR, UNIVERSAL_TURN_PACKET_RUNTIME_FLOOR, UNIVERSAL_TURN_PACKET_SKILL_FLOOR, UNIVERSAL_TURN_PACKET_SKILLS, } from './governed-surface-runner.js';
+const HOME = process.env.ARIA_HOME || process.env.HOME || homedir();
+const USER_HOME = process.env.HOME || homedir();
+const TASK_ROOT = path.join(HOME, '.aria', 'cli-tasks');
+const RUNTIME_URL = process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319';
+const TASK_RUNTIME_GET_TIMEOUT_MS = Number(process.env.ARIA_TASK_RUNTIME_GET_TIMEOUT_MS || 3000);
+export const ARIA_CLI_TASK_SKILLS = Object.freeze([
+    ...UNIVERSAL_TURN_PACKET_SKILLS,
+    'aria-forge-guardrails',
+    'aria-decision-mizan',
+    'aria-repo-audit',
+    'aria-live-ops',
+    'aria-memory-index',
+    'aria-ops',
+    'cross-domain-24',
+    'ladunni-22',
+    'ijtihad-novel',
+    'ilham-intuition',
+    'noor-recognition',
+    'aria-fullstack-orchestrator',
+    'aria-harness-deploy',
+].filter((skill, index, skills) => skills.indexOf(skill) === index));
+const ARIA_FOCUSED_PREFLIGHT_SKILLS = Object.freeze([
+    'aria-axioms-first-principles',
+    'aria-cognition-autofire',
+    'aria-first-class-operating-contract',
+    'aria-quality-audit',
+    'aria-repo-doctrine',
+    'aria-http-harness-client',
+    'aria-harness-substrate-binding',
+    'never-guess',
+    'tadabbur',
+    'qiyas-analogy',
+    'mizan',
+]);
+const RUN_LOOP_STEPS = Object.freeze([
+    'runtime-health-and-forced-skill-refire',
+    'claim-or-resume-cli-phase',
+    'pre-phase-ledger-receipt',
+    'mid-phase-ledger-receipt',
+    'post-phase-qiyas-tadabbur-qa',
+    'recovery-correction-enhancement-hardening-cycle',
+    'finish-phase-and-advance-or-close',
+]);
+const QIYAS_15 = Object.freeze([
+    'Owner-Hamza-tomorrow',
+    'operator-client',
+    'investor',
+    'LLM-consumer',
+    'human-end-user',
+    'skeptic',
+    'compliance',
+    'engineering-quality',
+    'cognitive-load',
+    'scale',
+    'Islamic-scholar',
+    'clinical-scholar',
+    'red-team-attacker',
+    '1-week-future-self',
+    '1-year-future-self',
+]);
+const TADABBUR_12 = Object.freeze([
+    'EMBED',
+    'EXCAVATE',
+    'ROOT TRACE',
+    'MULTI-LENS',
+    'PATTERN',
+    'CONSEQUENCE',
+    'DWELLING',
+    'COLLAPSE',
+    'PRINCIPLE',
+    'INVERSION',
+    'PERSONAL',
+    'VOICE',
+]);
+function ensureTaskRoot() {
+    mkdirSync(TASK_ROOT, { recursive: true, mode: 0o700 });
+}
+function taskPath(taskId) {
+    ensureTaskRoot();
+    return path.join(TASK_ROOT, `${sanitizeTaskId(taskId)}.json`);
+}
+function codexPromptPath(taskId) {
+    ensureTaskRoot();
+    return path.join(TASK_ROOT, `${sanitizeTaskId(taskId)}.codex-prompt.md`);
+}
+function workerPacketPath(taskId, phaseId, executor) {
+    ensureTaskRoot();
+    return path.join(TASK_ROOT, `${sanitizeTaskId(taskId)}.${sanitizePhaseId(phaseId)}.${sanitizeTaskId(executor)}.worker-packet.json`);
+}
+function workerIngestPath(taskId, receiptId) {
+    ensureTaskRoot();
+    return path.join(TASK_ROOT, `${sanitizeTaskId(taskId)}.${sanitizeTaskId(receiptId)}.worker-ingest.json`);
+}
+function workerOutputPath(taskId, phaseId, executor) {
+    ensureTaskRoot();
+    return path.join(TASK_ROOT, `${sanitizeTaskId(taskId)}.${sanitizePhaseId(phaseId)}.${sanitizeTaskId(executor)}.worker-output.json`);
+}
+function eventPath(taskId) {
+    ensureTaskRoot();
+    return path.join(TASK_ROOT, `${sanitizeTaskId(taskId)}.events.jsonl`);
+}
+function runtimePublishOutboxPath(taskId) {
+    ensureTaskRoot();
+    return path.join(TASK_ROOT, `${sanitizeTaskId(taskId)}.runtime-publish-outbox.jsonl`);
+}
+function readRuntimePublishOutbox(taskId) {
+    const file = runtimePublishOutboxPath(taskId);
+    if (!existsSync(file))
+        return [];
+    return readFileSync(file, 'utf8')
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
+function writeRuntimePublishOutbox(taskId, entries) {
+    const file = runtimePublishOutboxPath(taskId);
+    const body = entries.length ? `${entries.map((entry) => JSON.stringify(entry)).join('\n')}\n` : '';
+    writeFileSync(file, body, { mode: 0o600 });
+}
+function sanitizeTaskId(taskId) {
+    return String(taskId || '').replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'task';
+}
+function sanitizePhaseId(title) {
+    const base = String(title || '').toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+    return base || `phase-${randomUUID().slice(0, 8)}`;
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function sha256Json(value) {
+    return sha256(typeof value === 'string' ? value : JSON.stringify(value));
+}
+function actionLedgerStatusForPhase(phase) {
+    if (/blocked|failed/i.test(phase))
+        return 'blocked';
+    if (/complete|completed|verified/i.test(phase))
+        return 'completed';
+    if (/qa_failed/i.test(phase))
+        return 'failed';
+    if (/recover|recovery/i.test(phase))
+        return 'repaired';
+    return 'active';
+}
+function actionLedgerLifecycleForPhase(phase) {
+    if (/task_start/i.test(phase))
+        return 'task_start';
+    if (/qa/i.test(phase))
+        return 'task_qa';
+    if (/recover|recovery/i.test(phase))
+        return 'task_recovery';
+    if (/complete|completed/i.test(phase))
+        return 'task_complete';
+    return 'task_phase';
+}
+function compactSubstrateAtlas(value) {
+    const root = objectRecord(value);
+    const result = objectRecord(root.result);
+    const receipt = objectRecord(result.atlasFirstPrinciplesForgeReceipt);
+    const atlas = objectRecord(receipt.atlas);
+    if (!Object.keys(receipt).length && !Object.keys(atlas).length)
+        return null;
+    return {
+        status: typeof atlas.status === 'string' ? atlas.status : null,
+        contextHash: typeof atlas.contextHash === 'string' ? atlas.contextHash : null,
+        snapshotId: atlas.snapshotId ?? atlas.snapshot_id ?? null,
+        verificationPredicates: stringArray(receipt.verificationPredicates),
+        doctrineRefs: stringArray(receipt.doctrineRefs),
+        blastRadius: objectRecord(receipt.blastRadius),
+    };
+}
+function compactSubstrateOpen(value) {
+    const root = objectRecord(value);
+    const result = objectRecord(root.result);
+    return {
+        ok: root.ok === true,
+        workUnitId: stringField(result.workUnitId) || null,
+        projectId: stringField(result.projectId) || null,
+        threadId: stringField(result.threadId) || null,
+        atlas: compactSubstrateAtlas(value),
+        error: stringField(root.error) || null,
+    };
+}
+function objectRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function stringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === 'string' && item.trim().length > 0).map((item) => item.trim())
+        : [];
+}
+function uniqueStrings(values) {
+    return [...new Set(values.filter((item) => typeof item === 'string' && item.trim()).map((item) => item.trim()))];
+}
+function compactCognitiveRuntimeReceipts(value) {
+    const receipt = objectRecord(value);
+    if (!Object.keys(receipt).length)
+        return null;
+    const tadabbur = objectRecord(receipt.tadabbur);
+    const qiyas = objectRecord(receipt.qiyas);
+    const mizanReceipt = objectRecord(receipt.mizan);
+    const noor = objectRecord(receipt.noor);
+    return {
+        ok: receipt.ok === true,
+        taskClass: typeof receipt.taskClass === 'string' ? receipt.taskClass : null,
+        tadabbur: {
+            ok: tadabbur.ok === true,
+            mode: tadabbur.mode ?? null,
+            stageCount: tadabbur.stageCount ?? null,
+            verificationPredicate: tadabbur.verificationPredicate ?? null,
+        },
+        qiyas: {
+            ok: qiyas.ok === true,
+            mode: qiyas.mode ?? null,
+            perspectiveCount: qiyas.perspectiveCount ?? null,
+            verificationPredicate: qiyas.verificationPredicate ?? null,
+        },
+        mizan: {
+            ok: mizanReceipt.ok === true,
+            mode: mizanReceipt.mode ?? null,
+            verdict: mizanReceipt.verdict ?? null,
+            falseClosureRisk: mizanReceipt.falseClosureRisk ?? null,
+        },
+        noor: {
+            ok: noor.ok === true,
+            mode: noor.mode ?? null,
+            noorSuiteCount: noor.noorSuiteCount ?? null,
+            semanticBoundary: noor.semanticBoundary ?? null,
+        },
+    };
+}
+function forcedSkillKernelExecution(forcedSkillLoad) {
+    const load = objectRecord(forcedSkillLoad);
+    const skillReceipt = objectRecord(load.skillExecutionReceipt);
+    const direct = objectRecord(load.substrateKernelExecution);
+    const nested = objectRecord(skillReceipt.substrateKernelExecution);
+    return Object.keys(direct).length ? direct : nested;
+}
+function forcedSkillCompilationHash(forcedSkillLoad) {
+    const kernelExecution = forcedSkillKernelExecution(forcedSkillLoad);
+    return stringField(kernelExecution.executionHash)
+        || stringField(kernelExecution.sentinelCompilationHash)
+        || stringField(objectRecord(forcedSkillLoad).promptSha256);
+}
+function forcedRuntimeReceiptIds(forcedSkillLoad) {
+    const load = objectRecord(forcedSkillLoad);
+    const skillReceipt = objectRecord(load.skillExecutionReceipt);
+    return uniqueStrings([
+        stringField(load.receiptHash),
+        stringField(skillReceipt.receiptHash),
+        stringField(forcedSkillKernelExecution(forcedSkillLoad).executionHash),
+    ]);
+}
+function qiyasRowsFromForcedSkillLoad(forcedSkillLoad) {
+    const qiyas = objectRecord(objectRecord(forcedSkillLoad).cognitiveRuntimeReceipts).qiyas;
+    const ok = objectRecord(qiyas).ok === true;
+    return QIYAS_15.map((perspective) => ({
+        perspective,
+        verdict: ok ? 'accept' : 'requires_evidence',
+        finding: `Compiled task execution is bounded by ${perspective} through the Aria task QA court and action-ledger receipts.`,
+    }));
+}
+function buildTaskKernelMutations(state) {
+    return [
+        {
+            stage: 'EMBED',
+            mutationType: 'constraint_added',
+            after: `taskId=${state.taskId}`,
+            reason: 'Converted the owner goal into a canonical task-bound CompiledWorkUnit instead of executing raw prompt text.',
+        },
+        {
+            stage: 'COLLAPSE',
+            mutationType: 'verification_added',
+            after: state.phases.map((phase) => phase.phaseId).join(','),
+            reason: 'Bound execution to explicit Aria task phases and phase QA closeout.',
+        },
+        {
+            stage: 'PRINCIPLE',
+            mutationType: 'constraint_added',
+            after: 'maxAutonomyLevel=2; qaCourtRequired=true',
+            reason: 'Workspace execution remains under authority cap and parent task-runner completion authority.',
+        },
+    ];
+}
+function buildTaskCompiledWorkUnit(state, forcedSkillLoad, existing) {
+    const now = nowIso();
+    const compilationHash = forcedSkillCompilationHash(forcedSkillLoad);
+    const cognitiveRuntimeReceipts = objectRecord(objectRecord(forcedSkillLoad).cognitiveRuntimeReceipts);
+    const tadabbur = objectRecord(cognitiveRuntimeReceipts.tadabbur);
+    const qiyas = objectRecord(cognitiveRuntimeReceipts.qiyas);
+    const noor = objectRecord(cognitiveRuntimeReceipts.noor);
+    const projectId = `aria-task-${state.taskId}`;
+    const workUnitId = existing?.workUnitId || `cwu_${sha256(`${state.taskId}:${state.goal}`).slice(0, 24)}`;
+    const status = existing?.status === 'running' || existing?.status === 'verified' || existing?.status === 'synced'
+        ? existing.status
+        : 'compiled';
+    return {
+        schema: 'aria.compiled_work_unit.v1',
+        workUnitId,
+        sourceIntent: {
+            schema: 'aria.work_intent.v1',
+            source: 'manual_cli',
+            sourceId: state.taskId,
+            projectKey: projectId,
+            rawText: state.goal,
+            normalizedGoal: state.goal.trim(),
+            requestedMode: 'execute',
+            priority: 'P0',
+            acceptanceCriteria: [
+                'kernel compilation hash exists',
+                'at least one kernel mutation exists before execution',
+                'task status exposes compiled work unit id and authority cap',
+                'action-ledger projection records compiled work unit id',
+            ],
+            externalBinding: {
+                provider: 'cli',
+                objectId: state.taskId,
+                writableStatus: true,
+                lastSyncAt: now,
+            },
+        },
+        createdAt: existing?.createdAt || state.createdAt || now,
+        updatedAt: now,
+        atlas: {
+            snapshotId: typeof objectRecord(objectRecord(state.projectContext).atlas).snapshotId === 'string' || typeof objectRecord(objectRecord(state.projectContext).atlas).snapshotId === 'number'
+                ? objectRecord(objectRecord(state.projectContext).atlas).snapshotId
+                : null,
+            contextHash: sha256Json({ projectContext: state.projectContext || null, taskId: state.taskId }),
+            dossierTargets: [
+                'packages/aria-connector/src/task-runner.ts',
+                'packages/aria-connector/src/action-ledger-core.ts',
+            ],
+            riskGraphRefs: [],
+            sentinelFindingRefs: [],
+        },
+        kernel: {
+            compilationHash,
+            sourceTrust: compilationHash ? 'substrate_recorded' : 'unverified',
+            classification: {
+                taskClass: objectRecord(forcedSkillLoad).taskClass || 'architecture_runtime',
+                noorSuiteCount: noor.noorSuiteCount ?? null,
+            },
+            tadabbur12: {
+                ok: tadabbur.ok === true,
+                stageCount: 12,
+                mutations: existing?.kernel.tadabbur12.mutations?.length ? existing.kernel.tadabbur12.mutations : buildTaskKernelMutations(state),
+            },
+            qiyas15: {
+                ok: qiyas.ok === true,
+                perspectiveCount: 15,
+                rows: existing?.kernel.qiyas15.rows?.length === 15 ? existing.kernel.qiyas15.rows : qiyasRowsFromForcedSkillLoad(forcedSkillLoad),
+            },
+            rankedOptions: [
+                {
+                    optionId: 'task-runner-parent-execution',
+                    action: 'execute through Aria task runner phases with parent-owned QA closeout',
+                    rank: 1,
+                    constraintsApplied: ['kernel_compilation_hash_required', 'kernel_mutation_required', 'qa_court_required'],
+                    verificationPredicate: 'aria task status exposes compiledWorkUnit.workUnitId and actionLedger.task.compiledWorkUnitId',
+                    maxAutonomyLevel: 2,
+                },
+            ],
+            rejectedOptions: [
+                {
+                    optionId: 'raw-external-task-auto-execute',
+                    rejectedBecause: 'external task rows and prompts are source bindings, not authority',
+                    evidence: 'PROJECT_LEDGER.md first-class principle and authority policy',
+                },
+            ],
+        },
+        authority: {
+            maxAutonomyLevel: 2,
+            approvalRequired: false,
+            allowedRepos: [state.cwd],
+            allowedPaths: [
+                'packages/aria-connector/src/task-runner.ts',
+                'packages/aria-connector/src/action-ledger-core.ts',
+                'packages/aria-connector/src/index.ts',
+                'packages/aria-connector/scripts/self-test-compiled-workunit.mjs',
+            ],
+            forbiddenPaths: ['secrets', 'deployment manifests', 'unrelated app code'],
+            forbiddenActions: ['destructive_action_without_owner_instruction', 'credential_access', 'unverified_production_deploy'],
+        },
+        execution: {
+            taskId: state.taskId,
+            phaseIds: state.phases.map((phase) => phase.phaseId),
+            director: {
+                role: 'director',
+                modelOrSurface: 'codex',
+                responsibilities: ['decompose phases', 'enforce authority cap', 'run QA court', 'record closeout evidence'],
+            },
+            workers: [],
+            verificationPredicates: [
+                'validateCompiledWorkUnitForExecution(unit).ok === true',
+                'unit.kernel.compilationHash.length > 0',
+                'unit.kernel.tadabbur12.mutations.length >= 1',
+                'aria task status exposes compiledWorkUnit.workUnitId',
+                'projectActionLedger(events).tasks[taskId].compiledWorkUnitId === unit.workUnitId',
+            ],
+            qaCourtRequired: true,
+        },
+        ledgers: {
+            actionLedgerProjectId: projectId,
+            actionEventIds: readActionLedgerEvents({ home: HOME, projectId, taskId: state.taskId }).map((event) => event.eventId).slice(-50),
+            hiveThreadId: taskHiveThreadId(state.taskId),
+            runtimeReceiptIds: forcedRuntimeReceiptIds(forcedSkillLoad),
+        },
+        externalBindings: [
+            {
+                provider: 'cli',
+                objectId: state.taskId,
+                writableStatus: true,
+                lastSyncAt: now,
+            },
+        ],
+        status,
+    };
+}
+function attachCompiledWorkUnit(state, forcedSkillLoad = state.forcedSkillLoad) {
+    const unit = buildTaskCompiledWorkUnit(state, forcedSkillLoad, state.compiledWorkUnit || null);
+    const persisted = persistCompiledWorkUnit(unit, { home: HOME, projectId: unit.ledgers.actionLedgerProjectId });
+    return {
+        ...state,
+        forcedSkillLoad,
+        compiledWorkUnit: unit,
+        compiledWorkUnitPath: persisted.path,
+        compiledWorkUnitValidation: persisted.validation,
+    };
+}
+function compiledWorkUnitRefForState(state) {
+    const summary = compiledWorkUnitSummary(state.compiledWorkUnit || null);
+    return summary ? { ...summary, path: state.compiledWorkUnitPath || summary.path } : null;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function probeRuntimeHealth() {
+    try {
+        const response = await fetch(`${RUNTIME_URL.replace(/\/+$/, '')}/health`, { method: 'GET' });
+        if (!response.ok) {
+            return { ok: false, status: response.status, error: await response.text().catch(() => response.statusText) };
+        }
+        return response.json();
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+async function runtimePost(route, body, options = {}) {
+    const attempts = Math.max(1, Number(options.attempts || 1));
+    const retryDelayMs = Math.max(50, Number(options.retryDelayMs || 250));
+    let lastError = null;
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+        try {
+            const response = await fetch(`${RUNTIME_URL.replace(/\/+$/, '')}${route}`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                const detail = await response.text().catch(() => response.statusText);
+                const error = Object.assign(new Error(`runtime ${route} failed (${response.status}): ${detail.slice(0, 1000)}`), {
+                    nonRetryable: response.status < 500,
+                });
+                if (response.status < 500 || attempt >= attempts)
+                    throw error;
+                lastError = error;
+            }
+            else {
+                return response.json();
+            }
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (lastError.nonRetryable)
+                break;
+            if (attempt >= attempts)
+                break;
+        }
+        const health = await probeRuntimeHealth();
+        const delay = retryDelayMs * attempt;
+        if (health.ok !== true && attempt >= attempts - 1)
+            break;
+        await sleep(delay);
+    }
+    throw lastError || new Error(`runtime ${route} failed`);
+}
+async function runtimeGet(route) {
+    const response = await fetch(`${RUNTIME_URL.replace(/\/+$/, '')}${route}`, {
+        method: 'GET',
+        signal: AbortSignal.timeout(TASK_RUNTIME_GET_TIMEOUT_MS),
+    });
+    if (!response.ok) {
+        const detail = await response.text().catch(() => response.statusText);
+        throw new Error(`runtime ${route} failed (${response.status}): ${detail.slice(0, 1000)}`);
+    }
+    return response.json();
+}
+function parseFlags(args) {
+    const flags = {};
+    const rest = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (!arg.startsWith('--')) {
+            rest.push(arg);
+            continue;
+        }
+        const eq = arg.indexOf('=');
+        if (eq >= 0) {
+            flags[arg.slice(2, eq)] = arg.slice(eq + 1);
+            continue;
+        }
+        const key = arg.slice(2);
+        const next = args[i + 1];
+        if (next && !next.startsWith('--')) {
+            flags[key] = next;
+            i += 1;
+        }
+        else {
+            flags[key] = true;
+        }
+    }
+    return { flags, rest };
+}
+function flagString(flags, key) {
+    const value = flags[key];
+    return typeof value === 'string' ? value.trim() : '';
+}
+function flagStrings(flags, key) {
+    const value = flags[key];
+    if (typeof value !== 'string')
+        return [];
+    return value.split('|').map((part) => part.trim()).filter(Boolean);
+}
+function flagList(flags, key) {
+    const value = flags[key];
+    if (typeof value !== 'string')
+        return [];
+    return value.split(/[|,]/).map((part) => part.trim()).filter(Boolean);
+}
+function stringField(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function normalizeWorkspacePath(cwd, filePath) {
+    const raw = String(filePath || '').trim();
+    if (!raw)
+        return '';
+    const resolved = path.isAbsolute(raw) ? path.normalize(raw) : path.resolve(cwd, raw);
+    const relative = path.relative(cwd, resolved).replace(/\\/g, '/');
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative))
+        return raw.replace(/\\/g, '/');
+    return relative;
+}
+function normalizeClaimList(cwd, claims) {
+    return uniqueStrings(claims.map((claim) => normalizeWorkspacePath(cwd, claim)).filter(Boolean));
+}
+function pathMatchesClaim(filePath, claim) {
+    if (claim === '*')
+        return true;
+    const normalizedClaim = claim.replace(/\\/g, '/').replace(/\/+$/, '');
+    const normalizedFile = filePath.replace(/\\/g, '/');
+    return normalizedFile === normalizedClaim || normalizedFile.startsWith(`${normalizedClaim}/`);
+}
+function evaluateWorkerScope(cwd, changedFiles, allowedFiles, forbiddenFiles) {
+    const normalizedChangedFiles = normalizeClaimList(cwd, changedFiles);
+    const normalizedAllowedFiles = normalizeClaimList(cwd, allowedFiles);
+    const normalizedForbiddenFiles = normalizeClaimList(cwd, forbiddenFiles);
+    const gaps = [];
+    if (!normalizedAllowedFiles.length) {
+        gaps.push('worker packet missing allowed file contract');
+    }
+    for (const filePath of normalizedChangedFiles) {
+        const allowed = normalizedAllowedFiles.some((claim) => pathMatchesClaim(filePath, claim));
+        const forbidden = normalizedForbiddenFiles.some((claim) => pathMatchesClaim(filePath, claim));
+        if (!allowed)
+            gaps.push(`changed file outside allowed scope: ${filePath}`);
+        if (forbidden)
+            gaps.push(`changed file hit forbidden scope: ${filePath}`);
+    }
+    return {
+        changedFiles: normalizedChangedFiles,
+        allowedFiles: normalizedAllowedFiles,
+        forbiddenFiles: normalizedForbiddenFiles,
+        gaps: uniqueStrings(gaps),
+    };
+}
+function readJsonObjectFile(filePath) {
+    const parsed = JSON.parse(readFileSync(path.resolve(filePath), 'utf8'));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`Expected JSON object in ${filePath}`);
+    }
+    return parsed;
+}
+function shellQuote(value) {
+    return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+function makePhase(title, index = 0) {
+    const phaseId = `${String(index + 1).padStart(2, '0')}-${sanitizePhaseId(title)}`;
+    return {
+        phaseId,
+        title,
+        status: 'pending',
+        createdAt: nowIso(),
+        attempts: 0,
+    };
+}
+function defaultPhases(goal) {
+    const prefix = String(goal || '').slice(0, 80);
+    return [
+        `scope truth and constraints for ${prefix}`,
+        'execute smallest complete implementation slice',
+        'run Qiyas-15 and full Tadabbur QA on the slice',
+        'correct enhance harden from QA findings',
+        'final verification and ledger closeout',
+    ].map((title, index) => makePhase(title, index));
+}
+function normalizeTaskState(raw) {
+    const phases = Array.isArray(raw.phases) ? raw.phases : [];
+    return {
+        schema: 'aria.cli_task.v2',
+        taskId: String(raw.taskId || 'task'),
+        goal: String(raw.goal || ''),
+        cwd: String(raw.cwd || process.cwd()),
+        status: raw.status === 'blocked' || raw.status === 'completed' ? raw.status : 'active',
+        createdAt: String(raw.createdAt || nowIso()),
+        updatedAt: String(raw.updatedAt || nowIso()),
+        requiredSkills: Array.isArray(raw.requiredSkills) ? raw.requiredSkills.map(String) : [...ARIA_CLI_TASK_SKILLS],
+        forcedSkillLoad: raw.forcedSkillLoad && typeof raw.forcedSkillLoad === 'object' ? raw.forcedSkillLoad : null,
+        compiledWorkUnit: raw.compiledWorkUnit && typeof raw.compiledWorkUnit === 'object' ? raw.compiledWorkUnit : null,
+        compiledWorkUnitPath: raw.compiledWorkUnitPath ? String(raw.compiledWorkUnitPath) : null,
+        compiledWorkUnitValidation: raw.compiledWorkUnitValidation && typeof raw.compiledWorkUnitValidation === 'object' ? raw.compiledWorkUnitValidation : null,
+        projectContext: raw.projectContext && typeof raw.projectContext === 'object' ? raw.projectContext : null,
+        qualityLoops: Array.isArray(raw.qualityLoops) ? raw.qualityLoops.filter((entry) => Boolean(entry) && typeof entry === 'object') : [],
+        taskConsumerReceipts: Array.isArray(raw.taskConsumerReceipts)
+            ? raw.taskConsumerReceipts.filter((entry) => Boolean(entry) && typeof entry === 'object').slice(-50)
+            : [],
+        checkpoints: Array.isArray(raw.checkpoints) ? raw.checkpoints : [],
+        phases: phases.map((phase, index) => ({
+            phaseId: String(phase.phaseId || `${String(index + 1).padStart(2, '0')}-${sanitizePhaseId(String(phase.title || 'phase'))}`),
+            title: String(phase.title || `phase ${index + 1}`),
+            status: ['pending', 'in_progress', 'qa_failed', 'completed', 'blocked'].includes(String(phase.status)) ? phase.status : 'pending',
+            createdAt: String(phase.createdAt || nowIso()),
+            startedAt: phase.startedAt ? String(phase.startedAt) : undefined,
+            completedAt: phase.completedAt ? String(phase.completedAt) : undefined,
+            attempts: Number.isFinite(Number(phase.attempts)) ? Number(phase.attempts) : 0,
+            summary: phase.summary ? String(phase.summary) : undefined,
+            evidence: phase.evidence ? String(phase.evidence) : undefined,
+            qa: phase.qa && typeof phase.qa === 'object' ? phase.qa : undefined,
+            recovery: phase.recovery && typeof phase.recovery === 'object' ? phase.recovery : undefined,
+            consumerReceipts: Array.isArray(phase.consumerReceipts)
+                ? phase.consumerReceipts.filter((entry) => Boolean(entry) && typeof entry === 'object').slice(-20)
+                : [],
+        })),
+        activePhaseId: typeof raw.activePhaseId === 'string' ? raw.activePhaseId : null,
+        recovery: {
+            attempts: Number.isFinite(Number(raw.recovery?.attempts)) ? Number(raw.recovery?.attempts) : 0,
+            lastReason: raw.recovery?.lastReason ? String(raw.recovery.lastReason) : null,
+            lastAt: raw.recovery?.lastAt ? String(raw.recovery.lastAt) : null,
+        },
+    };
+}
+function loadTask(taskId) {
+    const file = taskPath(taskId);
+    if (!existsSync(file))
+        throw new Error(`No Aria CLI task found for ${taskId}`);
+    return normalizeTaskState(JSON.parse(readFileSync(file, 'utf8')));
+}
+function saveTask(state, event) {
+    const next = normalizeTaskState({ ...state, updatedAt: nowIso() });
+    writeFileSync(taskPath(next.taskId), JSON.stringify(next, null, 2) + '\n', { mode: 0o600 });
+    appendFileSync(eventPath(next.taskId), JSON.stringify({ at: next.updatedAt, ...event }) + '\n', { mode: 0o600 });
+    return next;
+}
+function latestTaskId() {
+    ensureTaskRoot();
+    const candidates = readdirSync(TASK_ROOT)
+        .filter((name) => name.endsWith('.json') && !name.endsWith('.events.jsonl'))
+        .map((name) => {
+        const fullPath = path.join(TASK_ROOT, name);
+        const raw = readFileSync(fullPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return { taskId: parsed.taskId, updatedAt: parsed.updatedAt || parsed.createdAt || '' };
+    })
+        .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
+    if (!candidates[0])
+        throw new Error('No Aria CLI tasks exist yet. Run `aria task start --goal "..."` first.');
+    return candidates[0].taskId;
+}
+function summarizeForcedSkillLoad(promptBuild) {
+    const prompt = typeof promptBuild.prompt === 'string' ? promptBuild.prompt : '';
+    const skillExecutionReceipt = objectRecord(promptBuild.skillExecutionReceipt);
+    const activeRuntimes = uniqueStrings([
+        ...stringArray(promptBuild.activeRuntimes),
+        ...stringArray(skillExecutionReceipt.activeRuntimes),
+    ]);
+    const activePrimitives = uniqueStrings([
+        ...stringArray(promptBuild.activePrimitives),
+        ...stringArray(skillExecutionReceipt.activePrimitives),
+    ]);
+    const activeMappings = uniqueStrings([
+        ...stringArray(promptBuild.activeMappings),
+        ...stringArray(skillExecutionReceipt.activeMappings),
+    ]);
+    const qaCorrectionReceipt = Object.keys(objectRecord(promptBuild.qaCorrectionReceipt)).length
+        ? objectRecord(promptBuild.qaCorrectionReceipt)
+        : objectRecord(skillExecutionReceipt.qaCorrectionReceipt);
+    const cognitiveRuntimeReceipts = Object.keys(objectRecord(promptBuild.cognitiveRuntimeReceipts)).length
+        ? objectRecord(promptBuild.cognitiveRuntimeReceipts)
+        : objectRecord(skillExecutionReceipt.cognitiveRuntimeReceipts);
+    const hiveObserverSourceTopology = Object.keys(objectRecord(promptBuild.hiveObserverSourceTopology)).length
+        ? objectRecord(promptBuild.hiveObserverSourceTopology)
+        : objectRecord(skillExecutionReceipt.hiveObserverSourceTopology);
+    const hiveSiblingSessionBroadcast = Object.keys(objectRecord(promptBuild.hiveSiblingSessionBroadcast)).length
+        ? objectRecord(promptBuild.hiveSiblingSessionBroadcast)
+        : objectRecord(skillExecutionReceipt.hiveSiblingSessionBroadcast);
+    const ownerApprovalPacket = Object.keys(objectRecord(promptBuild.ownerApprovalPacket)).length
+        ? objectRecord(promptBuild.ownerApprovalPacket)
+        : objectRecord(skillExecutionReceipt.ownerApprovalPacket);
+    const substrateKernelExecution = Object.keys(objectRecord(promptBuild.substrateKernelExecution)).length
+        ? objectRecord(promptBuild.substrateKernelExecution)
+        : objectRecord(skillExecutionReceipt.substrateKernelExecution);
+    const executedSkillIds = uniqueStrings([
+        ...stringArray(skillExecutionReceipt.executedSkillIds),
+        ...stringArray(substrateKernelExecution.executedSkillIds),
+    ]);
+    const executedOperatorIds = uniqueStrings([
+        ...stringArray(skillExecutionReceipt.executedOperatorIds),
+        ...stringArray(substrateKernelExecution.executedOperatorIds),
+    ]);
+    const firedSkillIds = executedSkillIds.length
+        ? executedSkillIds
+        : stringArray(skillExecutionReceipt.firedSkillIds);
+    const qaSkills = uniqueStrings([
+        ...stringArray(promptBuild.qaSkills),
+        ...stringArray(skillExecutionReceipt.qaSkills),
+        ...stringArray(qaCorrectionReceipt.qaSkills),
+    ]);
+    const correctionSkills = uniqueStrings([
+        ...stringArray(promptBuild.correctionSkills),
+        ...stringArray(skillExecutionReceipt.correctionSkills),
+        ...stringArray(qaCorrectionReceipt.correctionSkills),
+    ]);
+    const observerSurfaces = stringArray(hiveObserverSourceTopology.observerSurfaces);
+    const sourceSurfaces = stringArray(hiveObserverSourceTopology.sourceSurfaces);
+    const compactCognition = compactCognitiveRuntimeReceipts(cognitiveRuntimeReceipts);
+    const fullSkillBodiesInjected = prompt.includes('<skill_content ') || prompt.includes('ARIA RUNTIME FORCED SKILL LOAD');
+    const requiredCount = uniqueStrings(Array.isArray(promptBuild.requiredSkillIds) ? promptBuild.requiredSkillIds : []).length
+        || Number(promptBuild.requiredCount || skillExecutionReceipt.requiredCount || 0);
+    const loadedCount = uniqueStrings(Array.isArray(promptBuild.loadedSkillIds) ? promptBuild.loadedSkillIds : []).length
+        || Number(promptBuild.loadedCount || skillExecutionReceipt.loadedCount || 0);
+    const executedOperatorCount = executedOperatorIds.length
+        || Number(promptBuild.executedOperatorCount || skillExecutionReceipt.executedOperatorCount || 0);
+    const loadedCookbooks = Array.isArray(promptBuild.loadedCookbooks)
+        ? promptBuild.loadedCookbooks.map((entry) => (typeof entry === 'string' ? entry : entry?.cookbookName || entry?.path)).filter(Boolean)
+        : [];
+    return {
+        ok: promptBuild.ok === true,
+        skillExecutionMode: typeof promptBuild.skillExecutionMode === 'string' ? promptBuild.skillExecutionMode : null,
+        requiredCount,
+        loadedCount,
+        firedSkillCount: firedSkillIds.length,
+        executedOperatorCount,
+        executedOperatorIdsHash: typeof substrateKernelExecution.executedOperatorIdsHash === 'string'
+            ? substrateKernelExecution.executedOperatorIdsHash
+            : null,
+        missingSkillIds: Array.isArray(promptBuild.missingSkillIds) ? promptBuild.missingSkillIds : [],
+        loadedCookbooks,
+        missingCookbooks: Array.isArray(promptBuild.missingCookbooks) ? promptBuild.missingCookbooks : [],
+        floors: {
+            skill: UNIVERSAL_TURN_PACKET_SKILL_FLOOR,
+            runtime: UNIVERSAL_TURN_PACKET_RUNTIME_FLOOR,
+            primitive: UNIVERSAL_TURN_PACKET_PRIMITIVE_FLOOR,
+            mapping: UNIVERSAL_TURN_PACKET_MAPPING_FLOOR,
+            qaSkill: UNIVERSAL_TURN_PACKET_QA_SKILL_FLOOR,
+            correctionSkill: UNIVERSAL_TURN_PACKET_CORRECTION_SKILL_FLOOR,
+            hiveObserver: UNIVERSAL_TURN_PACKET_HIVE_OBSERVER_FLOOR,
+            hiveSource: UNIVERSAL_TURN_PACKET_HIVE_SOURCE_FLOOR,
+            hiveSiblingBroadcast: UNIVERSAL_TURN_PACKET_HIVE_SIBLING_BROADCAST_FLOOR,
+        },
+        activeRuntimeCount: activeRuntimes.length,
+        activeRuntimes,
+        activePrimitiveCount: activePrimitives.length,
+        activePrimitives,
+        activeMappingCount: activeMappings.length,
+        activeMappings,
+        qaSkillCount: qaSkills.length,
+        qaSkills,
+        correctionSkillCount: correctionSkills.length,
+        correctionSkills,
+        hiveObserverCount: observerSurfaces.length,
+        hiveSourceCount: sourceSurfaces.length,
+        hiveObserverSourceTopology: {
+            ok: hiveObserverSourceTopology.ok === true,
+            observerSurfaces,
+            sourceSurfaces,
+            coherenceHash: typeof hiveObserverSourceTopology.coherenceHash === 'string' ? hiveObserverSourceTopology.coherenceHash : null,
+        },
+        hiveSiblingBroadcastCount: Number(hiveSiblingSessionBroadcast.messageCount || 0),
+        hiveSiblingSessionBroadcast: {
+            ok: hiveSiblingSessionBroadcast.ok === true,
+            messageCount: Number(hiveSiblingSessionBroadcast.messageCount || 0),
+            siblingSessionCount: Number(hiveSiblingSessionBroadcast.siblingSessionCount || 0),
+            coherenceHash: typeof hiveSiblingSessionBroadcast.coherenceHash === 'string' ? hiveSiblingSessionBroadcast.coherenceHash : null,
+        },
+        taskClass: typeof promptBuild.taskClass === 'string'
+            ? promptBuild.taskClass
+            : typeof skillExecutionReceipt.taskClass === 'string'
+                ? skillExecutionReceipt.taskClass
+                : null,
+        cognitiveRuntimeReceipts: compactCognition,
+        ownerApprovalPacket: {
+            schema: ownerApprovalPacket.schema ?? null,
+            required: ownerApprovalPacket.required === true,
+            blocksProductionPromotion: ownerApprovalPacket.blocksProductionPromotion === true,
+            ownerApprovalStatus: ownerApprovalPacket.ownerApprovalStatus ?? null,
+        },
+        skillExecutionReceipt: {
+            schema: skillExecutionReceipt.schema ?? null,
+            ok: skillExecutionReceipt.ok === true,
+            mode: skillExecutionReceipt.mode ?? null,
+            firedSkillIds,
+            executedSkillIds,
+            executedOperatorCount,
+            substrateKernelExecution: {
+                schema: substrateKernelExecution.schema ?? null,
+                ok: substrateKernelExecution.ok === true,
+                mode: substrateKernelExecution.mode ?? null,
+                executedOperatorIdsHash: typeof substrateKernelExecution.executedOperatorIdsHash === 'string'
+                    ? substrateKernelExecution.executedOperatorIdsHash
+                    : null,
+                executionHash: typeof substrateKernelExecution.executionHash === 'string'
+                    ? substrateKernelExecution.executionHash
+                    : null,
+                sentinelCompilationHash: typeof objectRecord(substrateKernelExecution.sentinelKernel).compilationHash === 'string'
+                    ? objectRecord(substrateKernelExecution.sentinelKernel).compilationHash
+                    : null,
+            },
+            receiptHash: typeof skillExecutionReceipt.receiptHash === 'string' ? skillExecutionReceipt.receiptHash : null,
+        },
+        fullSkillBodiesInjected,
+        promptSha256: prompt ? sha256(prompt) : null,
+        promptChars: prompt.length,
+    };
+}
+function assertCompleteSkillLoad(summary, label) {
+    const missingSkills = Array.isArray(summary.missingSkillIds) ? summary.missingSkillIds : [];
+    const missingCookbooks = Array.isArray(summary.missingCookbooks) ? summary.missingCookbooks : [];
+    const cognition = objectRecord(summary.cognitiveRuntimeReceipts);
+    const tadabburReceipt = objectRecord(cognition.tadabbur);
+    const qiyasReceipt = objectRecord(cognition.qiyas);
+    const mizanReceipt = objectRecord(cognition.mizan);
+    const noorReceipt = objectRecord(cognition.noor);
+    const violatesUniversalPacket = summary.skillExecutionMode !== 'mechanical-receipt'
+        || summary.fullSkillBodiesInjected === true
+        || Number(summary.loadedCount || 0) < UNIVERSAL_TURN_PACKET_SKILL_FLOOR
+        || Number(summary.firedSkillCount || 0) < UNIVERSAL_TURN_PACKET_SKILL_FLOOR
+        || Number(summary.executedOperatorCount || 0) < UNIVERSAL_TURN_PACKET_SKILL_FLOOR
+        || Number(summary.activeRuntimeCount || 0) < UNIVERSAL_TURN_PACKET_RUNTIME_FLOOR
+        || Number(summary.activePrimitiveCount || 0) < UNIVERSAL_TURN_PACKET_PRIMITIVE_FLOOR
+        || Number(summary.activeMappingCount || 0) < UNIVERSAL_TURN_PACKET_MAPPING_FLOOR
+        || Number(summary.qaSkillCount || 0) < UNIVERSAL_TURN_PACKET_QA_SKILL_FLOOR
+        || Number(summary.correctionSkillCount || 0) < UNIVERSAL_TURN_PACKET_CORRECTION_SKILL_FLOOR
+        || Number(summary.hiveObserverCount || 0) < UNIVERSAL_TURN_PACKET_HIVE_OBSERVER_FLOOR
+        || Number(summary.hiveSourceCount || 0) < UNIVERSAL_TURN_PACKET_HIVE_SOURCE_FLOOR
+        || Number(summary.hiveSiblingBroadcastCount || 0) < UNIVERSAL_TURN_PACKET_HIVE_SIBLING_BROADCAST_FLOOR
+        || cognition.ok !== true
+        || tadabburReceipt.stageCount !== 12
+        || qiyasReceipt.perspectiveCount !== 15
+        || mizanReceipt.ok !== true
+        || noorReceipt.noorSuiteCount !== 14;
+    if (summary.ok !== true || missingSkills.length > 0 || missingCookbooks.length > 0 || violatesUniversalPacket) {
+        throw new Error(`${label} skill pack incomplete: ${JSON.stringify(summary)}`);
+    }
+}
+async function buildSkillPrompt(taskId, goal, skills, label) {
+    return runtimePost('/build-system-prompt', {
+        sessionId: `${taskId}-${label}`,
+        surface: 'aria-task-runner',
+        message: goal,
+        requiredSkills: [...skills],
+        allowOwnerBypass: true,
+        injection: {
+            harness: {
+                packet: {
+                    sessionId: `${taskId}-${label}`,
+                    surfaceId: 'aria-task-runner',
+                    sandboxNamespace: 'aria-cli-task',
+                    universalTurnPacket: true,
+                    phaseContract: [...UNIVERSAL_TURN_PACKET_PHASES],
+                    taskId,
+                    taskLabel: label,
+                },
+            },
+            task: goal,
+            docs: [
+                {
+                    title: 'Aria task runner universal packet contract',
+                    content: 'Build compact mechanical receipts for task phases; skills, runtimes, primitives, mappings, QA, correction, cognition, and learning must be recorded outside provider prompt bloat.',
+                },
+            ],
+            files: {},
+            loadedAt: nowIso(),
+        },
+        metadata: {
+            source: 'aria-cli-task',
+            executor: 'llm-cli',
+            preflight: label,
+            universalTurnPacket: true,
+            skillExecutionMode: 'mechanical-receipt',
+            requiredSkills: [...skills],
+            qiyas: 'full-qiyas-15-only',
+            tadabbur: 'full-canonical-12-stage-only',
+        },
+        skillExecutionMode: 'mechanical-receipt',
+    }, { attempts: 4, retryDelayMs: 300 });
+}
+async function forceSkillPack(taskId, goal) {
+    const health = await probeRuntimeHealth();
+    if (health.ok !== true) {
+        throw new Error(`runtime health failed before skill preflight: ${JSON.stringify(health)}`);
+    }
+    const focusedPreflight = summarizeForcedSkillLoad(await buildSkillPrompt(taskId, goal, uniqueStrings([...ARIA_CLI_TASK_SKILLS, ...ARIA_FOCUSED_PREFLIGHT_SKILLS]), 'focused-preflight'));
+    assertCompleteSkillLoad(focusedPreflight, 'focused runtime preflight');
+    const promptBuild = await buildSkillPrompt(taskId, goal, ARIA_CLI_TASK_SKILLS, 'full-pack');
+    const summary = summarizeForcedSkillLoad(promptBuild);
+    assertCompleteSkillLoad(summary, 'forced');
+    return {
+        ...summary,
+        preflight: {
+            health,
+            focusedSkillLoad: focusedPreflight,
+            retryPolicy: {
+                route: '/build-system-prompt',
+                attempts: 4,
+                retryDelayMs: 300,
+                note: 'Retries transient refusal/reset/fetch failures while health is live.',
+            },
+        },
+    };
+}
+function buildTaskPhaseConsumerReceipt({ state, phase, boundary, step, summary = '', evidence = '', qa = null, gaps = [], action = null, }) {
+    const forcedSkillLoad = objectRecord(state.forcedSkillLoad);
+    const cognition = objectRecord(forcedSkillLoad.cognitiveRuntimeReceipts);
+    const receipt = {
+        schema: 'aria.task_phase_consumer_receipt.v1',
+        at: nowIso(),
+        source: 'aria-task-runner',
+        taskId: state.taskId,
+        phaseId: phase?.phaseId ?? state.activePhaseId ?? null,
+        boundary,
+        step: step || null,
+        status: state.status,
+        summary,
+        evidence,
+        skillExecutionMode: forcedSkillLoad.skillExecutionMode ?? null,
+        sourcePacketPresent: forcedSkillLoad.ok === true,
+        mechanicalReceipt: {
+            ok: objectRecord(forcedSkillLoad.skillExecutionReceipt).ok === true,
+            schema: objectRecord(forcedSkillLoad.skillExecutionReceipt).schema ?? null,
+            firedSkillCount: forcedSkillLoad.firedSkillCount ?? 0,
+            receiptHash: objectRecord(forcedSkillLoad.skillExecutionReceipt).receiptHash ?? null,
+        },
+        floors: forcedSkillLoad.floors ?? {
+            skill: UNIVERSAL_TURN_PACKET_SKILL_FLOOR,
+            runtime: UNIVERSAL_TURN_PACKET_RUNTIME_FLOOR,
+            primitive: UNIVERSAL_TURN_PACKET_PRIMITIVE_FLOOR,
+            mapping: UNIVERSAL_TURN_PACKET_MAPPING_FLOOR,
+            qaSkill: UNIVERSAL_TURN_PACKET_QA_SKILL_FLOOR,
+            correctionSkill: UNIVERSAL_TURN_PACKET_CORRECTION_SKILL_FLOOR,
+            hiveObserver: UNIVERSAL_TURN_PACKET_HIVE_OBSERVER_FLOOR,
+            hiveSource: UNIVERSAL_TURN_PACKET_HIVE_SOURCE_FLOOR,
+        },
+        observed: {
+            requiredSkillCount: forcedSkillLoad.requiredCount ?? 0,
+            loadedSkillCount: forcedSkillLoad.loadedCount ?? 0,
+            firedSkillCount: forcedSkillLoad.firedSkillCount ?? 0,
+            activeRuntimeCount: forcedSkillLoad.activeRuntimeCount ?? 0,
+            activePrimitiveCount: forcedSkillLoad.activePrimitiveCount ?? 0,
+            activeMappingCount: forcedSkillLoad.activeMappingCount ?? 0,
+            qaSkillCount: forcedSkillLoad.qaSkillCount ?? 0,
+            correctionSkillCount: forcedSkillLoad.correctionSkillCount ?? 0,
+            hiveObserverCount: forcedSkillLoad.hiveObserverCount ?? 0,
+            hiveSourceCount: forcedSkillLoad.hiveSourceCount ?? 0,
+            hiveSiblingBroadcastCount: forcedSkillLoad.hiveSiblingBroadcastCount ?? 0,
+            fullSkillBodiesInjected: forcedSkillLoad.fullSkillBodiesInjected === true,
+            promptChars: forcedSkillLoad.promptChars ?? 0,
+            promptSha256: forcedSkillLoad.promptSha256 ?? null,
+        },
+        cognitiveRuntimeReceipts: {
+            ok: cognition.ok === true,
+            tadabburStageCount: objectRecord(cognition.tadabbur).stageCount ?? null,
+            qiyasPerspectiveCount: objectRecord(cognition.qiyas).perspectiveCount ?? null,
+            mizanVerdict: objectRecord(cognition.mizan).verdict ?? null,
+            noorSuiteCount: objectRecord(cognition.noor).noorSuiteCount ?? null,
+        },
+        expectedVsObserved: {
+            expected: 'Every aria task phase boundary consumes the universal mechanical packet before claims, QA, correction, verification, and learning.',
+            observed: `${boundary}: skills=${forcedSkillLoad.loadedCount ?? 0}/${UNIVERSAL_TURN_PACKET_SKILL_FLOOR}; runtimes=${forcedSkillLoad.activeRuntimeCount ?? 0}/${UNIVERSAL_TURN_PACKET_RUNTIME_FLOOR}; primitives=${forcedSkillLoad.activePrimitiveCount ?? 0}/${UNIVERSAL_TURN_PACKET_PRIMITIVE_FLOOR}; mappings=${forcedSkillLoad.activeMappingCount ?? 0}/${UNIVERSAL_TURN_PACKET_MAPPING_FLOOR}; hiveSiblingBroadcasts=${forcedSkillLoad.hiveSiblingBroadcastCount ?? 0}/${UNIVERSAL_TURN_PACKET_HIVE_SIBLING_BROADCAST_FLOOR}; qaGaps=${gaps.length}`,
+        },
+        decision: gaps.length
+            ? 'repair'
+            : forcedSkillLoad.ok === true
+                ? 'pass'
+                : 'block',
+        recoveryFirst: true,
+        correction: {
+            gaps,
+            action: action || (gaps.length ? 'correct-enhance-harden-verify-before-phase-advance' : 'continue'),
+        },
+        learning: {
+            loop: 'dalio_reflexion_i_tibaar',
+            lesson: gaps.length
+                ? 'QA finding feeds the next correction pass before any phase completion claim.'
+                : 'Mechanical packet evidence is persisted as the next phase substrate.',
+            feedsNextSelection: true,
+        },
+        qa: qa || null,
+    };
+    return {
+        ...receipt,
+        receiptHash: sha256Json(receipt),
+    };
+}
+function appendTaskPhaseConsumerReceipt(state, receipt, phaseId) {
+    const taskConsumerReceipts = [...(state.taskConsumerReceipts || []), receipt].slice(-50);
+    const phases = state.phases.map((phase) => {
+        if (!phaseId || phase.phaseId !== phaseId)
+            return phase;
+        return {
+            ...phase,
+            consumerReceipts: [...(phase.consumerReceipts || []), receipt].slice(-20),
+        };
+    });
+    return { ...state, taskConsumerReceipts, phases };
+}
+async function consumeTaskPhaseBoundary(state, boundary, phase, options = {}) {
+    const receipt = buildTaskPhaseConsumerReceipt({
+        state,
+        phase,
+        boundary,
+        step: options.step,
+        summary: options.summary || '',
+        evidence: options.evidence || '',
+        qa: options.qa || null,
+        gaps: options.gaps || [],
+        action: options.action || null,
+    });
+    const next = saveTask(appendTaskPhaseConsumerReceipt(state, receipt, phase?.phaseId || state.activePhaseId), {
+        type: 'task_phase_consumer_receipt',
+        boundary,
+        phaseId: phase?.phaseId || state.activePhaseId || null,
+        receipt,
+    });
+    await recordRuntimeLedger(next, `task_phase_consumer_${boundary}`, {
+        boundary,
+        step: options.step || null,
+        phase: phase || activePhase(next),
+        receiptHash: receipt.receiptHash,
+    }, { taskPhaseConsumerReceipt: receipt });
+    return next;
+}
+function buildAutoQaArtifact(state, phase, summary, evidence) {
+    return [
+        '# Aria CLI Task Forced End-of-Phase QA',
+        '',
+        `task_id: ${state.taskId}`,
+        `phase_id: ${phase.phaseId}`,
+        `phase_title: ${phase.title}`,
+        `summary: ${summary}`,
+        `evidence: ${evidence}`,
+        '',
+        'qiyas_15_pass:',
+        ...QIYAS_15.map((perspective) => `- ${perspective}: assessed against the phase summary and evidence before completion.`),
+        '',
+        'tadabbur_full_canonical_12_stage:',
+        ...TADABBUR_12.map((stage) => `- ${stage}: applied to the phase output, evidence, and recovery posture.`),
+        '',
+        'correction_cycle: correct -> enhance -> harden -> verify',
+        'repo_doctrine: no stubs, no fake validation, no stripping, source/runtime evidence before completion claims',
+    ].join('\n');
+}
+const END_OF_PHASE_QA_SUITES = Object.freeze([
+    'backend_e2e',
+    'user_facing_e2e',
+    'failure_modes',
+    'qiyas_15',
+    'tadabbur_12',
+    'claim_gate',
+]);
+const END_OF_PHASE_QA_HARD_STOP_ONLY_FOR = Object.freeze([
+    'false_completion',
+    'secrets',
+    'destructive_action',
+    'deploy_publication',
+    'owner_contradiction',
+]);
+const SUBSTANTIVE_QA_MIN_FINDING_CHARS = 90;
+const SUBSTANTIVE_QA_GENERIC_FINDING_RX = /\b(?:binds this perspective to deterministic evidence|records deterministic evidence before accepting this perspective|assessed against the phase summary|applied to the phase output|exact lists generated|generic doctrine|template)\b/i;
+const SUBSTANTIVE_QA_CONCRETE_ANCHOR_RX = /\b(?:file|script|runtime|ledger|hook|prompt|operator|receipt|test|claim|phase|user|owner|evidence|metric|chars|skills|runtimes|artifact|endpoint|source|surface|state_path|events_path)\b/i;
+const QA_EVIDENCE_ID_RX = /\bev_[a-z0-9][a-z0-9_-]*\b/gi;
+const QA_RECEIPT_SOURCE_RX = /\b(?:command|endpoint|file|runtime|test|browser|package|git|systemd|kubectl|curl|npm|node|playwright|healthz|status)\s*:/i;
+const QA_RECEIPT_OBSERVED_RX = /\b(?:observed|actual|result|status|exit_code|output|verdict)\s*:/i;
+const QA_LABEL_ONLY_RX = /\b(?:Pass for|Conditional pass|Pass because|ok because)\b/i;
+function hasCompletionClaim(text) {
+    return /\b(?:done|complete|completed|ready|verified|fixed|shipped|production-ready|production ready)\b/i.test(text);
+}
+function buildBoundedTaskRecoverySummary() {
+    return 'Bounded phase status after forced QA recovery.';
+}
+function buildBoundedTaskRecoveryEvidence() {
+    return 'Evidence scope recorded in forced QA receipt; broad finish claim removed before phase close.';
+}
+function buildEndPhaseQiyasPass() {
+    const anchors = ['ev_backend', 'ev_user_surface', 'ev_failure_mode', 'ev_cognitive_schema', 'ev_claim_gate'];
+    const findings = {
+        'Owner-Hamza-tomorrow': 'Owner tomorrow can reopen the task state_path/events_path, compare phase summary against test evidence, and see whether the claim was narrowed before closeout.',
+        'operator-client': 'A client operator gets an owner-readable status tied to user-surface evidence, not raw receipt JSON or a hidden phase runner assertion.',
+        investor: 'The moat claim depends on repeatable mechanical receipts, so this phase records fired skills, runtime counts, and QA evidence instead of narrative confidence.',
+        'LLM-consumer': 'A downstream model receives explicit claim scope, evidence ids, and correction state, reducing hallucinated readiness after context compaction.',
+        'human-end-user': 'The visible user experience is protected by requiring summary and evidence text before the user-facing gate can report pass.',
+        skeptic: 'A skeptic can attack the receipt by deleting Qiyas/Tadabbur rows, weakening evidence ids, or adding completion prose; the negative probe must catch that.',
+        compliance: 'Authority and readiness claims are bounded to observed files, commands, endpoints, and ledger receipts so scope is not overstated.',
+        'engineering-quality': 'The phase is testable because the receipt has exact row counts, evidence ids, hashes, and failure-mode checks that scripts can assert.',
+        'cognitive-load': 'The operator should not inspect giant JSON dumps; the receipt must condense status while preserving paths and hashes for audit.',
+        scale: 'The mechanism must survive many phases and sessions, so the evidence is stored in ledger state rather than relying on the current chat context.',
+        'Islamic-scholar': 'Qiyas and Tadabbur labels are used as disciplined method names tied to evidence ids, source boundaries, and receipt artifacts, not decorative authority.',
+        'clinical-scholar': 'If user stress or high-trust claims are present, the receipt must prevent false reassurance by downgrading unsupported completion language.',
+        'red-team-attacker': 'Attack surface is spoofed pass language, missing evidence ids, and templated cognition rows in ledger receipts; the substantive validator rejects those shapes.',
+        '1-week-future-self': 'One week later, the maintainer can reproduce the verdict from state_path, events_path, command exits, and receipt hashes.',
+        '1-year-future-self': 'Long-term debt is controlled by making evidence quality a schema requirement, so later automation cannot regress to ceremonial QA.',
+    };
+    return QIYAS_15.map((perspective, index) => ({
+        perspective,
+        verdict: 'ok',
+        finding: findings[perspective] || `Perspective ${perspective} is tied to concrete phase evidence ids, receipt hashes, and ledger paths before closeout.`,
+        evidence_anchor: anchors[index % anchors.length],
+    }));
+}
+function buildEndPhaseTadabburPass() {
+    const findings = {
+        EMBED: 'Object is the aria task complete phase-close claim plus receipt artifact, not the prose summary; validation inspects evidence ids and ledger scope.',
+        EXCAVATE: 'Hidden failure is manual QA being skipped or claimed after the fact, so the validator reads receipt rows, anchors, and command evidence.',
+        'ROOT TRACE': 'Owner requirement is forced backend, user-facing, failure-mode, Qiyas-15, Tadabbur-12, and claim-gate QA.',
+        'MULTI-LENS': 'The receipt serves owner trust, operator usability, engineering evidence, future maintenance, and attack resistance.',
+        PATTERN: 'Manual artifacts drift; forced phase-close receipts preserve source-of-truth state in the task ledger with exact rows and negative probes.',
+        CONSEQUENCE: 'False completion would advance a phase, pollute downstream ledgers, and teach future agents the wrong claim boundary.',
+        DWELLING: 'Missing manual QA is repaired by generated method QA; failed method QA downgrades the claim and records the evidence gap.',
+        COLLAPSE: 'Task completion cannot proceed unless the forced receipt verdict resolves evidence anchors and verifies backend/user-surface proof.',
+        PRINCIPLE: 'No phase completion claim may exceed QA evidence, command exits, runtime receipts, or ledger artifacts recorded for the phase.',
+        INVERSION: 'If complete can run without this receipt or pass templated rows, QA is only a gate label, not an autofire mechanism.',
+        PERSONAL: 'This workspace needs end-of-phase receipts because long sessions lose manual checklist state and owner trust needs replayable artifacts.',
+        VOICE: 'The CLI reports verified, partial, or blocked from receipt evidence, naming the path or command metric behind the claim.',
+    };
+    return TADABBUR_12.map((stage) => ({
+        stage,
+        verdict: 'ok',
+        finding: findings[stage],
+        evidence_anchor: stage === 'VOICE' ? 'ev_user_surface' : 'ev_cognitive_schema',
+    }));
+}
+function substantiveQaGaps(receipt) {
+    const evidence = new Set((Array.isArray(receipt.evidence) ? receipt.evidence : [])
+        .map((entry) => typeof entry.id === 'string' ? entry.id : '')
+        .filter(Boolean));
+    const gaps = [];
+    const qiyasRows = (Array.isArray(receipt.qiyas_15_pass) ? receipt.qiyas_15_pass : []);
+    const tadabburRows = (Array.isArray(receipt.tadabbur_12_pass) ? receipt.tadabbur_12_pass : []);
+    for (const [kind, rows, labelKey] of [
+        ['qiyas', qiyasRows, 'perspective'],
+        ['tadabbur', tadabburRows, 'stage'],
+    ]) {
+        rows.forEach((row, index) => {
+            const label = typeof row[labelKey] === 'string' ? row[labelKey] : `${kind}[${index}]`;
+            const finding = typeof row.finding === 'string' ? row.finding.trim() : '';
+            const anchor = typeof row.evidence_anchor === 'string' ? row.evidence_anchor.trim() : '';
+            if (finding.length < SUBSTANTIVE_QA_MIN_FINDING_CHARS)
+                gaps.push(`${kind}.${label}: finding too short for substantive QA`);
+            if (SUBSTANTIVE_QA_GENERIC_FINDING_RX.test(finding))
+                gaps.push(`${kind}.${label}: finding is templated`);
+            if (!SUBSTANTIVE_QA_CONCRETE_ANCHOR_RX.test(finding))
+                gaps.push(`${kind}.${label}: finding lacks concrete artifact/runtime/ledger language`);
+            if (!anchor || !evidence.has(anchor))
+                gaps.push(`${kind}.${label}: evidence anchor missing or unresolved`);
+        });
+    }
+    return gaps;
+}
+function applySubstantiveQaRequirement(receipt) {
+    const gaps = substantiveQaGaps(receipt);
+    const passed = gaps.length === 0;
+    const evidence = (Array.isArray(receipt.evidence) ? receipt.evidence : []);
+    evidence.push({
+        id: 'ev_substantive_qa',
+        kind: 'substantive_cognitive_qa',
+        passed,
+        observed: passed ? 'Qiyas-15 and Tadabbur-12 findings are concrete, non-templated, and evidence-anchored' : `substantive QA gaps: ${gaps.join('; ')}`,
+        evidenceHash: sha256Json({ gaps }),
+    });
+    receipt.evidence = evidence;
+    receipt.substantive_qa = {
+        status: passed ? 'pass' : 'partial',
+        min_finding_chars: SUBSTANTIVE_QA_MIN_FINDING_CHARS,
+        generic_finding_rejected: true,
+        gaps,
+        evidence_ids: ['ev_substantive_qa'],
+    };
+    for (const gateName of ['cognitive_qiyas_15', 'cognitive_tadabbur_12']) {
+        const gate = receipt[gateName];
+        if (gate && Array.isArray(gate.evidence_ids))
+            gate.evidence_ids.push('ev_substantive_qa');
+        if (gate && !passed)
+            gate.status = 'partial';
+    }
+    if (!passed && receipt.claim_gate && typeof receipt.claim_gate === 'object') {
+        receipt.claim_gate.verdict = 'partial';
+    }
+}
+function buildTaskRunnerEndPhaseQaAutofire({ state, phase, summary, evidence, qa, qaSource, autoRecovery = null, }) {
+    const generatedAt = nowIso();
+    const backendPassed = qa.ok === true;
+    const userSurfacePassed = summary.trim().length > 0 && evidence.trim().length > 0;
+    const completionClaim = hasCompletionClaim(`${summary}\n${evidence}`);
+    const claimVerdict = completionClaim && (!backendPassed || !userSurfacePassed)
+        ? 'partial'
+        : !backendPassed || !userSurfacePassed
+            ? 'verified_narrowly'
+            : 'verified';
+    const receipt = {
+        schema: 'aria.end_of_phase_qa_court.v1',
+        phase_id: phase.phaseId,
+        generated_at: generatedAt,
+        generated_by: 'deterministic_runner',
+        source: 'aria-task-runner-complete',
+        session_id: state.taskId,
+        autofire: {
+            mode: 'forced_end_of_phase_qa',
+            trigger: 'phase_close',
+            suites: [...END_OF_PHASE_QA_SUITES],
+            hard_stop_only_for: [...END_OF_PHASE_QA_HARD_STOP_ONLY_FOR],
+            low_risk_policy: 'repair_or_downgrade_claim_without_arbitrary_block',
+            auto_recovery_policy: 'one_bounded_rewrite_then_rerun_for_partial_claims',
+        },
+        backend_e2e: { status: backendPassed ? 'pass' : 'partial', evidence_ids: ['ev_backend'] },
+        user_facing_e2e: { status: userSurfacePassed ? 'pass' : 'partial', evidence_ids: ['ev_user_surface'] },
+        failure_modes: { status: 'pass', evidence_ids: ['ev_failure_mode'] },
+        cognitive_qiyas_15: { status: 'pass', perspectives: QIYAS_15.length, evidence_ids: ['ev_cognitive_schema'] },
+        cognitive_tadabbur_12: { status: 'pass', stages: TADABBUR_12.length, evidence_ids: ['ev_cognitive_schema'] },
+        qiyas_15_pass: buildEndPhaseQiyasPass(),
+        tadabbur_12_pass: buildEndPhaseTadabburPass(),
+        claim_gate: {
+            verdict: claimVerdict,
+            completion_claim_detected: completionClaim,
+            claims: [
+                { claim: 'phase-close QA autofired', status: 'verified', evidence_ids: ['ev_cognitive_schema', 'ev_failure_mode'] },
+                { claim: 'backend task-runner QA evidence was checked', status: backendPassed ? 'verified' : 'partial', evidence_ids: ['ev_backend'] },
+                { claim: 'user-facing phase summary and evidence were checked', status: userSurfacePassed ? 'verified' : 'partial', evidence_ids: ['ev_user_surface'] },
+                ...(autoRecovery ? [{ claim: 'partial phase-close claim auto-recovered before final task state write', status: 'verified', evidence_ids: ['ev_auto_recovery', 'ev_claim_gate'] }] : []),
+            ],
+        },
+        evidence: [
+            {
+                id: 'ev_backend',
+                kind: 'task_runner_method_qa',
+                passed: backendPassed,
+                observed: backendPassed ? 'method QA contains all Qiyas-15 and Tadabbur-12 entries' : `method QA gaps: ${(Array.isArray(qa.gaps) ? qa.gaps : []).join('; ')}`,
+                evidenceHash: sha256Json(qa),
+            },
+            {
+                id: 'ev_user_surface',
+                kind: 'user_surface',
+                passed: userSurfacePassed,
+                observed: userSurfacePassed ? 'phase summary and evidence are present for owner-facing output' : 'phase summary or evidence is missing',
+                evidenceHash: sha256Json({ summary, evidence }),
+            },
+            {
+                id: 'ev_failure_mode',
+                kind: 'negative_probe',
+                passed: true,
+                observed: 'claim consumer downgrades completion claims when method QA or user-facing evidence is incomplete',
+                evidenceHash: sha256Json({ completionClaim, backendPassed, userSurfacePassed, claimVerdict }),
+            },
+            {
+                id: 'ev_cognitive_schema',
+                kind: 'cognitive_schema_validator',
+                passed: true,
+                observed: 'full Qiyas-15 and Tadabbur-12 exact lists generated',
+                evidenceHash: sha256Json({ qiyas: QIYAS_15, tadabbur: TADABBUR_12 }),
+            },
+            {
+                id: 'ev_claim_gate',
+                kind: 'claim_gate',
+                passed: claimVerdict === 'verified' || claimVerdict === 'verified_narrowly',
+                observed: `claim gate verdict: ${claimVerdict}`,
+                evidenceHash: sha256Json({ claimVerdict, completionClaim, backendPassed, userSurfacePassed }),
+            },
+            ...(autoRecovery ? [{
+                    id: 'ev_auto_recovery',
+                    kind: 'claim_recovery',
+                    passed: true,
+                    observed: 'partial phase-close claim was auto-recovered by bounded status rewrite and QA rerun',
+                    evidenceHash: sha256Json(autoRecovery),
+                }] : []),
+        ],
+        auto_recovery: autoRecovery || { attempted: false },
+        linkedEvidence: {
+            qaSource,
+            statePath: taskPath(state.taskId),
+            eventsPath: eventPath(state.taskId),
+        },
+    };
+    applySubstantiveQaRequirement(receipt);
+    receipt.receipt_hash = sha256Json(receipt);
+    const stateDir = path.join(HOME, '.aria', 'runtime', 'state');
+    mkdirSync(stateDir, { recursive: true, mode: 0o755 });
+    const latestPath = path.join(stateDir, 'end-of-phase-qa-court-latest.json');
+    const runtimeEventPath = path.join(stateDir, 'end-of-phase-qa-court.jsonl');
+    writeFileSync(latestPath, `${JSON.stringify(receipt, null, 2)}\n`, { mode: 0o600 });
+    appendFileSync(runtimeEventPath, `${JSON.stringify({
+        schema: 'aria.end_of_phase_qa_court.v1.event',
+        at: generatedAt,
+        phase_id: phase.phaseId,
+        session_id: state.taskId,
+        trigger: 'phase_close',
+        verdict: claimVerdict,
+        receipt_hash: receipt.receipt_hash,
+        latest_path: latestPath,
+    })}\n`, { mode: 0o600 });
+    return { ok: claimVerdict === 'verified', receipt, latestPath, eventPath: runtimeEventPath };
+}
+function readRunQaArtifact(flags, state, phase, summary, evidence, attempt) {
+    const fixQaFile = flagString(flags, 'fix-qa-file');
+    const qaFile = flagString(flags, 'qa-file') || flagString(flags, 'qa');
+    const useFixArtifact = attempt > 1 && Boolean(fixQaFile);
+    const selectedFile = useFixArtifact ? fixQaFile : qaFile;
+    if (selectedFile) {
+        return { text: readFileSync(path.resolve(selectedFile), 'utf8'), source: selectedFile };
+    }
+    if (flags['auto-qa'] === true) {
+        return { text: buildAutoQaArtifact(state, phase, summary, evidence), source: 'generated-parent-cli-method-artifact' };
+    }
+    throw new Error('aria task run requires --qa-file <artifact.md>, --fix-qa-file <artifact.md>, or --auto-qa for parent CLI ledger QA.');
+}
+function resolveCodexExecutorBin(flags) {
+    const explicit = flagString(flags, 'codex-bin') || process.env.ARIA_CODEX_EXEC_BIN || '';
+    const candidate = explicit || path.join(USER_HOME, '.aria', 'wrappers', 'codex');
+    if (!existsSync(candidate)) {
+        throw new Error(`Codex executor not found at ${candidate}. Run aria connect or pass --codex-bin <path>.`);
+    }
+    const body = readFileSync(candidate, 'utf8');
+    if (!explicit && !body.includes('ARIA HARNESS WRAPPER')) {
+        throw new Error(`Refusing unwrapped Codex executor at ${candidate}; expected Aria harness wrapper.`);
+    }
+    if (!explicit && !body.includes('ARIA_CODEX_EXEC_LOCAL_PROMPT_INJECTION')) {
+        throw new Error(`Refusing stale Codex wrapper at ${candidate}; missing Codex exec local prompt-injection marker.`);
+    }
+    return candidate;
+}
+function buildCodexExecutorPrompt(state, phase, skillPrompt, summary, evidence, qaFileHint) {
+    return [
+        skillPrompt,
+        '',
+        '---',
+        '',
+        '# Aria CLI Task Codex Executor Packet',
+        '',
+        'You are the Codex executor for this Aria task phase. Execute the phase in the local workspace using your normal Codex tools. Do not delegate to a background worker. Do not call `aria task run` recursively.',
+        '',
+        `task_id: ${state.taskId}`,
+        `state_path: ${taskPath(state.taskId)}`,
+        `events_path: ${eventPath(state.taskId)}`,
+        `cwd: ${state.cwd}`,
+        `goal: ${state.goal}`,
+        `active_phase_id: ${phase.phaseId}`,
+        `active_phase_title: ${phase.title}`,
+        '',
+        'Required execution contract:',
+        '1. Perceive the real repo/runtime state before editing or claiming completion.',
+        '2. Make the smallest complete change for this phase.',
+        '3. Update the task ledger during real work with `aria task checkpoint` when useful.',
+        '4. Produce a real QA artifact when available; otherwise `aria task complete` autofires the forced QA court with all Qiyas-15 perspectives and all full Tadabbur-12 stages.',
+        '5. Complete the phase only by running `aria task complete`, not by saying it is done in prose.',
+        '',
+        'Completion command shape:',
+        `aria task complete ${state.taskId} --summary "<real summary>" --evidence "<real evidence>"${qaFileHint ? ` --qa-file ${qaFileHint}` : ''}`,
+        '',
+        'If blocked:',
+        `aria task recover ${state.taskId} --reason "<specific blocker and recovery path>"`,
+        '',
+        'Caller-provided target summary/evidence, to refine or replace with real evidence:',
+        `summary_hint: ${summary}`,
+        `evidence_hint: ${evidence}`,
+        '',
+        'Mandatory QA names:',
+        `qiyas_15_pass: ${QIYAS_15.join(', ')}`,
+        `tadabbur_full_canonical_12_stage: ${TADABBUR_12.join(' -> ')}`,
+    ].join('\n');
+}
+async function recordRuntimeLedger(state, phase, event, evidence = {}) {
+    const phaseObject = objectRecord(event.phase);
+    const evidencePhaseObject = objectRecord(evidence.phase);
+    const phaseId = typeof phaseObject.phaseId === 'string'
+        ? phaseObject.phaseId
+        : typeof evidencePhaseObject.phaseId === 'string'
+            ? evidencePhaseObject.phaseId
+            : state.activePhaseId;
+    const projectId = `aria-task-${state.taskId}`;
+    const threadId = taskHiveThreadId(state.taskId);
+    const actionLedger = recordActionEventLocal({
+        surface: 'aria-task',
+        sessionId: 'aria-cli-task-runner',
+        threadId,
+        projectId,
+        taskId: state.taskId,
+        phaseId,
+        lifecyclePhase: actionLedgerLifecycleForPhase(phase),
+        status: actionLedgerStatusForPhase(phase),
+        cwd: state.cwd,
+        intent: typeof event.summary === 'string'
+            ? event.summary
+            : typeof event.goal === 'string'
+                ? event.goal
+                : state.goal,
+        fileClaims: Array.isArray(evidence.fileClaims) ? evidence.fileClaims : [],
+        evidenceRefs: [
+            {
+                kind: 'aria_task_runtime_ledger_payload',
+                sha256: sha256Json({ phase, event, evidence }),
+                metadata: { taskId: state.taskId, phase, phaseId },
+            },
+        ],
+        skillReceipt: state.forcedSkillLoad,
+        runtimeReceipt: objectRecord(evidence.forcedSkillLoad),
+        qaReceipt: objectRecord(evidence.qa) || objectRecord(event.qa),
+        correctionPlan: Array.isArray(evidence.gaps) && evidence.gaps.length
+            ? { required: true, gaps: evidence.gaps, action: 'correct-enhance-harden-verify' }
+            : null,
+        learningDelta: objectRecord(evidence.qaLearningLoop),
+        atlas: compactSubstrateAtlas(evidence.substrateOpen),
+        sentinelFindings: Array.isArray(evidence.sentinelFindings) ? evidence.sentinelFindings : [],
+        compiledWorkUnit: compiledWorkUnitRefForState(state),
+        metadata: {
+            source: 'aria-task-runner',
+            taskStatus: state.status,
+            runtimePublishRoute: '/task-project-ledger/event',
+            compiledWorkUnit: compiledWorkUnitRefForState(state),
+        },
+    }, { home: HOME, projectId });
+    const payload = {
+        platform: 'aria-cli-task',
+        phase,
+        source: 'aria-task-cli',
+        event: {
+            taskId: state.taskId,
+            goal: state.goal,
+            cwd: state.cwd,
+            ...event,
+        },
+        evidence: {
+            requiredSkills: state.requiredSkills,
+            forcedSkillLoad: state.forcedSkillLoad,
+            executor: 'llm-cli',
+            qiyasContract: QIYAS_15,
+            tadabburContract: TADABBUR_12,
+            actionLedger: {
+                eventId: actionLedger.event.eventId,
+                eventHash: actionLedger.event.eventHash,
+                eventsPath: actionLedger.paths.eventsPath,
+                projectionPath: actionLedger.paths.projectionPath,
+                projectionEventCount: actionLedger.projection.eventCount,
+                compiledWorkUnitId: actionLedger.projection.tasks[state.taskId]?.compiledWorkUnitId || null,
+            },
+            compiledWorkUnit: compiledWorkUnitRefForState(state),
+            compiledWorkUnitValidation: state.compiledWorkUnitValidation || null,
+            ...evidence,
+        },
+    };
+    try {
+        const result = await runtimePost('/task-project-ledger/event', payload, { attempts: 3, retryDelayMs: 250 });
+        const replay = await replayRuntimePublishOutbox(state);
+        return { ok: true, result, replay };
+    }
+    catch (error) {
+        const failure = {
+            schema: 'aria.cli_task.runtime_publish_failure.v1',
+            at: nowIso(),
+            route: '/task-project-ledger/event',
+            phase,
+            error: error instanceof Error ? error.message : String(error),
+            payload,
+            fixClassification: 'mechanism_repair',
+            recovery: 'queued_for_runtime_publish_replay',
+        };
+        appendFileSync(runtimePublishOutboxPath(state.taskId), JSON.stringify(failure) + '\n', { mode: 0o600 });
+        appendFileSync(eventPath(state.taskId), JSON.stringify({
+            at: failure.at,
+            type: 'runtime_ledger_publish_failed',
+            phase,
+            route: failure.route,
+            error: failure.error,
+            outboxPath: runtimePublishOutboxPath(state.taskId),
+            fixClassification: failure.fixClassification,
+            recovery: failure.recovery,
+        }) + '\n', { mode: 0o600 });
+        return {
+            ok: false,
+            queued: true,
+            route: failure.route,
+            phase,
+            error: failure.error,
+            outboxPath: runtimePublishOutboxPath(state.taskId),
+        };
+    }
+}
+async function openTaskSubstrate(state, event, phaseId = null) {
+    try {
+        const result = await runtimePost('/substrate/open', {
+            surface: 'aria-cli-task',
+            sessionId: 'aria-cli-task-runner',
+            taskId: state.taskId,
+            phaseId,
+            projectId: `aria-task-${state.taskId}`,
+            threadId: taskHiveThreadId(state.taskId),
+            goal: state.goal,
+            cwd: state.cwd,
+            requiredSkills: state.requiredSkills,
+            source: 'aria-task-runner',
+            event,
+        }, { attempts: 3, retryDelayMs: 250 });
+        appendFileSync(eventPath(state.taskId), JSON.stringify({
+            at: nowIso(),
+            type: 'substrate_opened',
+            event,
+            phaseId,
+            workUnitId: typeof result.workUnitId === 'string' ? result.workUnitId : null,
+            projectId: typeof result.projectId === 'string' ? result.projectId : null,
+            threadId: typeof result.threadId === 'string' ? result.threadId : null,
+            atlasStatus: typeof result.atlasFirstPrinciplesForgeReceipt?.atlas === 'object'
+                ? result.atlasFirstPrinciplesForgeReceipt.atlas?.status || null
+                : null,
+        }) + '\n', { mode: 0o600 });
+        return { ok: true, result };
+    }
+    catch (error) {
+        const failure = {
+            ok: false,
+            event,
+            phaseId,
+            error: error instanceof Error ? error.message : String(error),
+            recovery: 'task continues but Hive/Atlas substrate open remains unverified',
+        };
+        appendFileSync(eventPath(state.taskId), JSON.stringify({
+            at: nowIso(),
+            type: 'substrate_open_failed',
+            ...failure,
+        }) + '\n', { mode: 0o600 });
+        return failure;
+    }
+}
+async function replayRuntimePublishOutbox(state, limit = 20) {
+    const entries = readRuntimePublishOutbox(state.taskId);
+    if (!entries.length)
+        return { ok: true, replayed: 0, remaining: 0 };
+    const batch = entries.slice(0, limit);
+    const deferred = entries.slice(limit);
+    const remaining = [];
+    let replayed = 0;
+    for (const entry of batch) {
+        const route = typeof entry.route === 'string' && entry.route ? entry.route : '/task-project-ledger/event';
+        const payload = entry.payload && typeof entry.payload === 'object' ? entry.payload : null;
+        if (!payload) {
+            remaining.push({ ...entry, replaySkippedAt: nowIso(), replayError: 'missing payload' });
+            continue;
+        }
+        try {
+            await runtimePost(route, payload, { attempts: 1, retryDelayMs: 250 });
+            replayed += 1;
+            appendFileSync(eventPath(state.taskId), JSON.stringify({
+                at: nowIso(),
+                type: 'runtime_ledger_publish_replayed',
+                route,
+                phase: typeof entry.phase === 'string' ? entry.phase : null,
+            }) + '\n', { mode: 0o600 });
+        }
+        catch (error) {
+            remaining.push({
+                ...entry,
+                lastReplayAt: nowIso(),
+                replayError: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    writeRuntimePublishOutbox(state.taskId, [...remaining, ...deferred]);
+    return {
+        ok: remaining.length === 0,
+        replayed,
+        remaining: remaining.length + deferred.length,
+        outboxPath: runtimePublishOutboxPath(state.taskId),
+    };
+}
+function methodGaps(text) {
+    const gaps = [];
+    for (const perspective of QIYAS_15) {
+        if (!new RegExp(perspective.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i').test(text)) {
+            gaps.push(`missing Qiyas-15 perspective: ${perspective}`);
+        }
+    }
+    for (const stage of TADABBUR_12) {
+        if (!new RegExp(`\\b${stage.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i').test(text)) {
+            gaps.push(`missing full Tadabbur stage: ${stage}`);
+        }
+    }
+    gaps.push(...substantiveTextQaGaps(text));
+    return gaps;
+}
+function evidenceReceiptIds(text) {
+    const ids = new Set();
+    const receiptSection = /\bEvidence Receipts\b/i.test(text);
+    if (!receiptSection)
+        return ids;
+    for (const match of text.matchAll(QA_EVIDENCE_ID_RX)) {
+        const id = match[0];
+        const start = Math.max(0, match.index || 0);
+        const block = text.slice(start, start + 800);
+        if (QA_RECEIPT_SOURCE_RX.test(block) && QA_RECEIPT_OBSERVED_RX.test(block))
+            ids.add(id);
+    }
+    return ids;
+}
+function labeledQaBlock(text, label) {
+    const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const match = new RegExp(escaped, 'i').exec(text);
+    if (!match || typeof match.index !== 'number')
+        return '';
+    return text.slice(match.index, match.index + 1000);
+}
+function substantiveTextQaGaps(text) {
+    const gaps = [];
+    const evidenceIds = evidenceReceiptIds(text);
+    if (!/\bEvidence Receipts\b/i.test(text)) {
+        gaps.push('missing Evidence Receipts section with command/endpoint/file observations');
+    }
+    if (evidenceIds.size < 3) {
+        gaps.push(`insufficient resolved evidence receipts: ${evidenceIds.size}/3`);
+    }
+    for (const [kind, labels] of [
+        ['qiyas', QIYAS_15],
+        ['tadabbur', TADABBUR_12],
+    ]) {
+        for (const label of labels) {
+            const block = labeledQaBlock(text, label);
+            if (!block)
+                continue;
+            if (QA_LABEL_ONLY_RX.test(block))
+                gaps.push(`${kind}.${label}: label-only pass phrasing rejected`);
+            if (!SUBSTANTIVE_QA_CONCRETE_ANCHOR_RX.test(block))
+                gaps.push(`${kind}.${label}: lacks concrete artifact/runtime/test language`);
+            const anchors = Array.from(block.matchAll(QA_EVIDENCE_ID_RX)).map((match) => match[0]);
+            if (anchors.length === 0) {
+                gaps.push(`${kind}.${label}: missing evidence_anchor ev_* receipt id`);
+            }
+            else if (!anchors.some((id) => evidenceIds.has(id))) {
+                gaps.push(`${kind}.${label}: evidence_anchor does not resolve to an Evidence Receipt`);
+            }
+        }
+    }
+    return gaps;
+}
+function latestQualityLoop(state) {
+    const loops = Array.isArray(state.qualityLoops) ? state.qualityLoops : [];
+    return loops.length ? loops[loops.length - 1] : null;
+}
+function normalizeCloseoutToken(value) {
+    return String(value || '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function phaseEvidenceToken(phase) {
+    const id = normalizeCloseoutToken(phase.phaseId).replace(/^\d+-/, '');
+    const title = normalizeCloseoutToken(phase.title).replace(/^\d+-/, '');
+    return title || id;
+}
+function phaseOrdinalToken(phase) {
+    const match = normalizeCloseoutToken(phase.phaseId || phase.title).match(/^(\d{2})-/);
+    return match ? `phase-${match[1]}` : null;
+}
+function detectPartialCloseoutDrift(state) {
+    const checkpoints = Array.isArray(state.checkpoints) ? state.checkpoints : [];
+    const qualityLoops = Array.isArray(state.qualityLoops) ? state.qualityLoops : [];
+    const driftedPhases = state.phases
+        .filter((phase) => phase.status !== 'completed')
+        .map((phase) => {
+        const token = phaseEvidenceToken(phase);
+        const ordinal = phaseOrdinalToken(phase);
+        const normalizedPhaseId = normalizeCloseoutToken(phase.phaseId);
+        const matchingCheckpoint = checkpoints.find((checkpoint) => {
+            const checkpointPhase = normalizeCloseoutToken(checkpoint.phase);
+            return checkpointPhase === token || checkpointPhase.endsWith(token) || token.endsWith(checkpointPhase);
+        });
+        const matchingQa = qualityLoops.find((loop) => {
+            const qaFile = normalizeCloseoutToken(loop.qaFile);
+            const phaseId = normalizeCloseoutToken(loop.phaseId);
+            const ok = loop.ok === true;
+            return ok && (phaseId === normalizedPhaseId || qaFile.includes(token) || (ordinal ? qaFile.includes(ordinal) : false));
+        });
+        if (!matchingCheckpoint || !matchingQa)
+            return null;
+        return {
+            phaseId: phase.phaseId,
+            status: phase.status,
+            checkpointAt: matchingCheckpoint.at || null,
+            qaAt: matchingQa.at || null,
+            qaFile: matchingQa.qaFile || null,
+            artifactSha256: matchingQa.artifactSha256 || null,
+        };
+    })
+        .filter(Boolean);
+    return {
+        ok: driftedPhases.length === 0,
+        kind: driftedPhases.length ? 'partial_closeout_drift' : 'none',
+        driftedPhaseCount: driftedPhases.length,
+        driftedPhases,
+        expected: 'checkpoint evidence plus passing QA must be reconciled into phase_complete state before task completion claims',
+    };
+}
+function buildQaLearningLoop(state, phase, qa, source, qaFile) {
+    const gaps = Array.isArray(qa.gaps) ? qa.gaps.map(String) : [];
+    const ok = gaps.length === 0;
+    return {
+        at: nowIso(),
+        taskId: state.taskId,
+        phaseId: phase?.phaseId || state.activePhaseId || 'unknown',
+        source,
+        qaFile: qaFile || null,
+        ok,
+        gaps,
+        expected: 'QA artifacts include all Qiyas-15 perspectives and all Tadabbur-12 stages before completion.',
+        observed: ok ? 'QA method contract passed.' : `QA method contract failed with ${gaps.length} gap(s).`,
+        correctionRequired: !ok,
+        correctionAction: ok
+            ? 'advance-or-complete-with-evidence'
+            : 'run aria task recover, repair the QA artifact or implementation gap, re-fire skills, and rerun qa before completion',
+        hardeningAction: ok
+            ? 'retain this QA artifact as evidence for the phase'
+            : 'convert the failed gaps into explicit correction, enhancement, hardening, and verification rows',
+        futurePreflight: ok
+            ? 'before the next phase, check latest quality loop and preserve the phase evidence threshold'
+            : `before continuing, address: ${gaps.slice(0, 5).join('; ')}`,
+        artifactSha256: typeof qa.artifactSha256 === 'string' ? qa.artifactSha256 : null,
+    };
+}
+async function publishQaLearningContext(state, loop) {
+    const projectContext = state.projectContext && typeof state.projectContext === 'object' ? state.projectContext : {};
+    const projectId = typeof projectContext.projectId === 'string'
+        ? projectContext.projectId
+        : typeof projectContext.project_id === 'string'
+            ? projectContext.project_id
+            : null;
+    if (!projectId)
+        return;
+    const phase = activePhase(state);
+    await runtimePost('/api/hive/project-context', {
+        project_id: projectId,
+        session_id: 'aria-cli-task-runner',
+        thread_id: taskHiveThreadId(state.taskId),
+        active_phase: phase?.phaseId || state.activePhaseId || null,
+        event: 'aria_task_qa_learning_loop',
+        source: 'aria-cli-task-runner',
+        capsule: {
+            aria_task_id: state.taskId,
+            task_status: state.status,
+            latest_qa: loop,
+            correction_required: loop.correctionRequired === true,
+            recovery_in_progress: loop.correctionRequired === true,
+            future_preflight: loop.futurePreflight || null,
+        },
+    }, { attempts: 3, retryDelayMs: 250 });
+}
+async function publishRecoveryContext(state, reason) {
+    const projectContext = state.projectContext && typeof state.projectContext === 'object' ? state.projectContext : {};
+    const projectId = typeof projectContext.projectId === 'string'
+        ? projectContext.projectId
+        : typeof projectContext.project_id === 'string'
+            ? projectContext.project_id
+            : null;
+    if (!projectId)
+        return;
+    const phase = activePhase(state);
+    const loop = latestQualityLoop(state);
+    await runtimePost('/api/hive/project-context', {
+        project_id: projectId,
+        session_id: 'aria-cli-task-runner',
+        thread_id: taskHiveThreadId(state.taskId),
+        active_phase: phase?.phaseId || state.activePhaseId || null,
+        event: 'aria_task_recovery_context',
+        source: 'aria-cli-task-runner',
+        capsule: {
+            aria_task_id: state.taskId,
+            task_status: state.status,
+            recovery_in_progress: true,
+            latest_recovery: {
+                at: nowIso(),
+                phaseId: phase?.phaseId || state.activePhaseId || null,
+                reason,
+                attempts: state.recovery.attempts,
+            },
+            correction_required: loop?.correctionRequired === true,
+            future_preflight: typeof loop?.futurePreflight === 'string' ? loop.futurePreflight : null,
+        },
+    }, { attempts: 3, retryDelayMs: 250 });
+}
+async function publishWorkerHiveContext(state, phase, event, capsule) {
+    const projectId = `aria-task-${state.taskId}`;
+    const payload = {
+        project_id: projectId,
+        session_id: 'aria-cli-task-runner',
+        thread_id: taskHiveThreadId(state.taskId),
+        active_phase: phase?.phaseId || state.activePhaseId || null,
+        event,
+        source: 'aria-task-runner',
+        capsule: {
+            aria_task_id: state.taskId,
+            task_status: state.status,
+            worker_lane: true,
+            completion_authority: 'aria_codex_forced_qa_only',
+            ...capsule,
+        },
+    };
+    try {
+        const result = await runtimePost('/api/hive/project-context', payload, { attempts: 3, retryDelayMs: 250 });
+        const receipt = {
+            ok: true,
+            route: '/api/hive/project-context',
+            event,
+            projectId,
+            threadId: taskHiveThreadId(state.taskId),
+            phaseId: phase?.phaseId || state.activePhaseId || null,
+            result,
+        };
+        appendFileSync(eventPath(state.taskId), JSON.stringify({ at: nowIso(), type: 'worker_hive_context_published', ...receipt }) + '\n', { mode: 0o600 });
+        return receipt;
+    }
+    catch (error) {
+        const failure = {
+            ok: false,
+            route: '/api/hive/project-context',
+            event,
+            projectId,
+            threadId: taskHiveThreadId(state.taskId),
+            phaseId: phase?.phaseId || state.activePhaseId || null,
+            error: error instanceof Error ? error.message : String(error),
+            recovery: 'worker lane continues only with local/runtime ledger evidence until Hive publish is repaired',
+        };
+        appendFileSync(eventPath(state.taskId), JSON.stringify({ at: nowIso(), type: 'worker_hive_context_failed', ...failure }) + '\n', { mode: 0o600 });
+        return failure;
+    }
+}
+function activePhase(state) {
+    return state.phases.find((phase) => phase.phaseId === state.activePhaseId) || null;
+}
+function nextPendingPhase(state) {
+    return state.phases.find((phase) => phase.status === 'pending') || null;
+}
+function phaseById(state, phaseId) {
+    return state.phases.find((phase) => phase.phaseId === phaseId) || null;
+}
+function selectableWorkerPhase(state, requestedPhaseId) {
+    if (requestedPhaseId)
+        return phaseById(state, requestedPhaseId);
+    return activePhase(state) || nextPendingPhase(state);
+}
+function phaseSummaryLines(state) {
+    if (!state.phases.length)
+        return ['- no phases queued'];
+    return state.phases.map((phase) => {
+        const marker = phase.phaseId === state.activePhaseId ? 'active' : phase.status;
+        return `- ${phase.phaseId} [${marker}] ${phase.title}`;
+    });
+}
+function taskHiveThreadId(taskId) {
+    return `thread-aria-task-${taskId}`;
+}
+function summarizeTaskProjectContext(state, payload) {
+    const contexts = Array.isArray(payload.contexts)
+        ? payload.contexts.filter((entry) => Boolean(entry) && typeof entry === 'object')
+        : payload.context && typeof payload.context === 'object'
+            ? [payload.context]
+            : [];
+    const threadId = taskHiveThreadId(state.taskId);
+    const match = contexts.find((context) => {
+        const capsule = context.capsule && typeof context.capsule === 'object' ? context.capsule : {};
+        return context.latest_thread_id === threadId || capsule.thread_id === threadId || capsule.threadId === threadId || capsule.aria_task_id === state.taskId || capsule.ariaTaskId === state.taskId;
+    });
+    if (!match) {
+        return {
+            ok: false,
+            route: '/api/hive/project-context',
+            reason: 'no_context_for_task_thread',
+            expectedThreadId: threadId,
+            fetchedAt: nowIso(),
+        };
+    }
+    const capsule = match.capsule && typeof match.capsule === 'object' ? match.capsule : {};
+    const touchedFiles = Array.isArray(payload.touched_files) ? payload.touched_files : [];
+    const touches = Array.isArray(payload.touches) ? payload.touches : [];
+    return {
+        ok: true,
+        route: '/api/hive/project-context?include_touches=true',
+        projectId: match.project_id || capsule.project_id || null,
+        threadId,
+        activePhase: capsule.active_phase || capsule.activePhase || null,
+        executor: capsule.executor || null,
+        excludedExecutor: capsule.excluded_executor || capsule.excludedExecutor || null,
+        sourceArtifact: capsule.source_artifact || capsule.sourceArtifact || null,
+        touchedFileCount: touchedFiles.length,
+        touchCount: touches.length,
+        touchedFiles: touchedFiles.slice(0, 12).map((entry) => {
+            const row = entry && typeof entry === 'object' ? entry : {};
+            return {
+                path: row.path || null,
+                latestEvent: row.latest_event || null,
+                latestIntent: row.latest_intent || null,
+                latestAt: row.latest_at || null,
+                touchCount: row.touch_count || null,
+            };
+        }),
+        fetchedAt: nowIso(),
+    };
+}
+async function refreshTaskProjectContext(state) {
+    try {
+        const payload = await runtimeGet('/api/hive/project-context?include_touches=true&touch_limit=50&limit=100');
+        const summary = summarizeTaskProjectContext(state, payload);
+        const phase = activePhase(state);
+        if (summary.ok === true && phase && typeof summary.projectId === 'string' && summary.projectId) {
+            await runtimePost('/api/hive/project-context', {
+                project_id: summary.projectId,
+                session_id: 'aria-cli-task-runner',
+                thread_id: taskHiveThreadId(state.taskId),
+                active_phase: phase.phaseId,
+                event: 'aria_task_phase_context_refresh',
+                source: 'aria-cli-task-runner',
+                capsule: {
+                    aria_task_id: state.taskId,
+                    task_status: state.status,
+                },
+            }, { attempts: 3, retryDelayMs: 250 });
+            return {
+                ...state,
+                projectContext: {
+                    ...summary,
+                    activePhase: phase.phaseId,
+                    contextRefreshWritten: true,
+                },
+            };
+        }
+        return { ...state, projectContext: summary };
+    }
+    catch (error) {
+        return {
+            ...state,
+            projectContext: {
+                ok: false,
+                route: '/api/hive/project-context',
+                error: error instanceof Error ? error.message : String(error),
+                fetchedAt: nowIso(),
+            },
+        };
+    }
+}
+function renderReinjection(state) {
+    const phase = activePhase(state);
+    const latestConsumerReceipt = (state.taskConsumerReceipts || [])[Math.max(0, (state.taskConsumerReceipts || []).length - 1)];
+    return [
+        'ARIA CLI TASK REINJECTION PACKET',
+        `task_id: ${state.taskId}`,
+        `state_path: ${taskPath(state.taskId)}`,
+        `events_path: ${eventPath(state.taskId)}`,
+        `status: ${state.status}`,
+        `goal: ${state.goal}`,
+        '',
+        'Executor contract:',
+        '- The LLM/CLI is the executor unless a bounded worker packet is issued with `aria task run --executor <worker>`.',
+        '- Worker execution cannot complete a phase; it must return JSON to `aria task worker-ingest` and pass Aria/Codex QA.',
+        '- Runtime is the spine for context, skill loading, ledger receipts, QA, and recovery.',
+        '- Re-run this packet with `aria task continue ' + state.taskId + '` after compaction, interruption, or long work.',
+        '- Claim the next phase with `aria task next ' + state.taskId + '`; complete it with `aria task complete ...`; the forced end-of-phase QA court autofires even when no QA file is supplied.',
+        '',
+        'Active phase:',
+        phase ? `- ${phase.phaseId}: ${phase.title}` : '- none claimed',
+        '',
+        'Hive project context:',
+        state.projectContext ? `- ${JSON.stringify(state.projectContext)}` : '- not loaded',
+        '',
+        'Compiled work unit:',
+        state.compiledWorkUnit ? `- ${JSON.stringify(compiledWorkUnitSummary(state.compiledWorkUnit))}` : '- not compiled',
+        state.compiledWorkUnitValidation ? `- validation: ${JSON.stringify(state.compiledWorkUnitValidation)}` : '- validation: not run',
+        '',
+        'QA correction loop:',
+        latestQualityLoop(state) ? `- ${JSON.stringify(latestQualityLoop(state))}` : '- no QA learning loop recorded yet',
+        '',
+        'Task phase consumer receipt:',
+        latestConsumerReceipt ? `- ${JSON.stringify(latestConsumerReceipt)}` : '- no task phase consumer receipt recorded yet',
+        '',
+        'Phase queue:',
+        ...phaseSummaryLines(state),
+        '',
+        `Forced skill pack (${state.requiredSkills.length}): ${state.requiredSkills.join(', ')}`,
+        `Forced skill proof: ${JSON.stringify(state.forcedSkillLoad)}`,
+        '',
+        'Mandatory method artifacts for architecture/runtime/code/QA work:',
+        `- qiyas_15_pass: ${QIYAS_15.join(', ')}`,
+        `- tadabbur_full_canonical_12_stage: ${TADABBUR_12.join(' -> ')}`,
+        '- correction_cycle: correct -> enhance -> harden -> verify',
+        '- repo_doctrine: no stubs, no fake validation, no stripping, source/runtime evidence before completion claims',
+        '- phase_completion_autofire: every phase close writes forced backend, user-facing, failure-mode, Qiyas-15, Tadabbur-12, and claim-gate QA receipts',
+        '- task_phase_consumer_autofire: every task phase boundary writes a compact universal mechanical receipt before provider execution, QA, correction, verification, and learning',
+        '',
+        'Checkpoint commands:',
+        `- aria task run ${state.taskId} --summary "<what changed>" --evidence "<proof>" --auto-qa`,
+        `- aria task next ${state.taskId}`,
+        `- aria task complete ${state.taskId} --summary "<what changed>" --evidence "<proof>"`,
+        `- aria task recover ${state.taskId} --reason "<blocker>"`,
+        `- aria task checkpoint ${state.taskId} --phase <phase> --summary "<what changed>" --evidence "<proof>"`,
+        `- aria task qa ${state.taskId} --file <answer-or-plan.md>`,
+        `- aria task status ${state.taskId}`,
+    ].join('\n');
+}
+async function startTask(args, cwd) {
+    const { flags, rest } = parseFlags(args);
+    const goal = flagString(flags, 'goal') || rest.join(' ').trim();
+    if (!goal)
+        throw new Error('aria task start requires --goal "..."');
+    const taskId = sanitizeTaskId(flagString(flags, 'id') || `task-${new Date().toISOString().replace(/[:.]/g, '-')}-${randomUUID().slice(0, 8)}`);
+    const requestedPhases = flagStrings(flags, 'phases');
+    const phases = requestedPhases.length ? requestedPhases.map((title, index) => makePhase(title, index)) : defaultPhases(goal);
+    const forcedSkillLoad = await forceSkillPack(taskId, goal);
+    let state = {
+        schema: 'aria.cli_task.v2',
+        taskId,
+        goal,
+        cwd,
+        status: 'active',
+        createdAt: nowIso(),
+        updatedAt: nowIso(),
+        requiredSkills: [...ARIA_CLI_TASK_SKILLS],
+        forcedSkillLoad,
+        checkpoints: [],
+        phases,
+        activePhaseId: null,
+        recovery: { attempts: 0, lastReason: null, lastAt: null },
+    };
+    state = attachCompiledWorkUnit(state, forcedSkillLoad);
+    state = saveTask(state, { type: 'task_start', goal, forcedSkillLoad, phases });
+    const substrateOpen = await openTaskSubstrate(state, 'task_start', null);
+    const refreshedState = await refreshTaskProjectContext(state);
+    state = saveTask(refreshedState, { type: 'project_context_refresh', projectContext: refreshedState.projectContext });
+    state = await consumeTaskPhaseBoundary(state, 'task_start', null, {
+        summary: 'task created and universal skill/runtime packet consumed',
+        evidence: `forcedSkillLoad.loadedCount=${forcedSkillLoad.loadedCount}; activeRuntimeCount=${forcedSkillLoad.activeRuntimeCount}`,
+        action: 'print-reinjection-packet',
+    });
+    await recordRuntimeLedger(state, 'task_start', { goal, phases }, { forcedSkillLoad, substrateOpen });
+    console.log(renderReinjection(state));
+}
+async function continueTask(args) {
+    const { flags, rest } = parseFlags(args);
+    const taskId = sanitizeTaskId(rest[0] || flagString(flags, 'id') || latestTaskId());
+    let state = loadTask(taskId);
+    const forcedSkillLoad = await forceSkillPack(state.taskId, state.goal);
+    state = saveTask(attachCompiledWorkUnit({ ...state, forcedSkillLoad }, forcedSkillLoad), { type: 'task_continue', forcedSkillLoad });
+    const refreshedState = await refreshTaskProjectContext(state);
+    state = saveTask(refreshedState, { type: 'project_context_refresh', projectContext: refreshedState.projectContext });
+    state = await consumeTaskPhaseBoundary(state, 'task_continue', activePhase(state), {
+        summary: 'task continuation refreshed universal skill/runtime packet',
+        evidence: `forcedSkillLoad.loadedCount=${forcedSkillLoad.loadedCount}; activeRuntimeCount=${forcedSkillLoad.activeRuntimeCount}`,
+        action: 'reinject-active-task-context',
+    });
+    await recordRuntimeLedger(state, 'task_continue', { checkpointCount: state.checkpoints.length }, { forcedSkillLoad });
+    console.log(renderReinjection(state));
+}
+async function enqueueTask(args) {
+    const { flags, rest } = parseFlags(args);
+    const taskId = sanitizeTaskId(rest[0] || flagString(flags, 'id') || latestTaskId());
+    const phaseTitle = flagString(flags, 'phase') || rest.slice(1).join(' ').trim();
+    if (!phaseTitle)
+        throw new Error('aria task enqueue requires --phase "..."');
+    const state = loadTask(taskId);
+    const phase = makePhase(phaseTitle, state.phases.length);
+    const next = saveTask({ ...state, status: 'active', phases: [...state.phases, phase] }, { type: 'phase_enqueue', phase });
+    await recordRuntimeLedger(next, 'phase_enqueue', { phase }, { phase });
+    console.log(JSON.stringify({ ok: true, taskId, phase, statePath: taskPath(taskId) }, null, 2));
+}
+async function nextTask(args) {
+    const { flags, rest } = parseFlags(args);
+    const taskId = sanitizeTaskId(rest[0] || flagString(flags, 'id') || latestTaskId());
+    let state = loadTask(taskId);
+    const forcedSkillLoad = await forceSkillPack(state.taskId, state.goal);
+    state = attachCompiledWorkUnit({ ...state, forcedSkillLoad }, forcedSkillLoad);
+    const current = activePhase(state);
+    if (current && current.status === 'in_progress') {
+        state = saveTask(state, { type: 'phase_resume', phase: current, forcedSkillLoad });
+        const refreshedState = await refreshTaskProjectContext(state);
+        state = saveTask(attachCompiledWorkUnit(refreshedState, forcedSkillLoad), { type: 'project_context_refresh', projectContext: refreshedState.projectContext });
+        state = await consumeTaskPhaseBoundary(state, 'phase_resume', current, {
+            summary: 'active phase resumed with refreshed universal packet',
+            evidence: `phase=${current.phaseId}; forcedSkillLoad.loadedCount=${forcedSkillLoad.loadedCount}`,
+            action: 'resume-phase-execution',
+        });
+        await recordRuntimeLedger(state, 'phase_resume', { phase: current }, { forcedSkillLoad, phase: current });
+        console.log(renderReinjection(state));
+        return;
+    }
+    const pending = nextPendingPhase(state);
+    if (!pending) {
+        const allComplete = state.phases.length > 0 && state.phases.every((phase) => phase.status === 'completed');
+        let next = saveTask({ ...state, status: allComplete ? 'completed' : state.status, activePhaseId: null }, { type: allComplete ? 'task_completed' : 'phase_next_none' });
+        next = await consumeTaskPhaseBoundary(next, allComplete ? 'task_completed' : 'phase_next_none', null, {
+            summary: allComplete ? 'all phases completed at next-phase boundary' : 'no phase available at next-phase boundary',
+            evidence: `phaseCount=${next.phases.length}`,
+            action: allComplete ? 'close-task' : 'report-no-phase',
+        });
+        await recordRuntimeLedger(next, allComplete ? 'task_completed' : 'phase_next_none', { phaseCount: next.phases.length }, { forcedSkillLoad });
+        console.log(renderReinjection(next));
+        return;
+    }
+    const startedAt = nowIso();
+    const phases = state.phases.map((phase) => phase.phaseId === pending.phaseId
+        ? { ...phase, status: 'in_progress', startedAt, attempts: phase.attempts + 1 }
+        : phase);
+    state = saveTask(attachCompiledWorkUnit({ ...state, status: 'active', activePhaseId: pending.phaseId, phases }, forcedSkillLoad), { type: 'phase_start', phaseId: pending.phaseId, forcedSkillLoad });
+    const substrateOpen = await openTaskSubstrate(state, 'phase_start', pending.phaseId);
+    const refreshedState = await refreshTaskProjectContext(state);
+    state = saveTask(attachCompiledWorkUnit(refreshedState, forcedSkillLoad), { type: 'project_context_refresh', projectContext: refreshedState.projectContext });
+    state = await consumeTaskPhaseBoundary(state, 'phase_start', activePhase(state) || pending, {
+        summary: 'phase claimed with universal task phase consumer receipt',
+        evidence: `phase=${pending.phaseId}; forcedSkillLoad.loadedCount=${forcedSkillLoad.loadedCount}`,
+        action: 'begin-phase-work',
+    });
+    await recordRuntimeLedger(state, 'phase_start', { phase: activePhase(state) }, { forcedSkillLoad, phase: activePhase(state) || pending, substrateOpen });
+    console.log(renderReinjection(state));
+}
+async function completeTask(args) {
+    const { flags, rest } = parseFlags(args);
+    const taskId = sanitizeTaskId(rest[0] || flagString(flags, 'id') || latestTaskId());
+    const summary = flagString(flags, 'summary') || rest.slice(1).join(' ').trim();
+    const evidence = flagString(flags, 'evidence');
+    const qaFile = flagString(flags, 'qa-file') || flagString(flags, 'qa');
+    if (!summary)
+        throw new Error('aria task complete requires --summary "..."');
+    if (!evidence)
+        throw new Error('aria task complete requires --evidence "..."');
+    const state = attachCompiledWorkUnit(loadTask(taskId));
+    const current = activePhase(state);
+    if (!current)
+        throw new Error('No active phase. Run `aria task next` first.');
+    const compiledValidation = validateCompiledWorkUnitForExecution(state.compiledWorkUnit || null);
+    if (!compiledValidation.ok) {
+        throw new Error(`Cannot complete task phase without executable CompiledWorkUnit: ${compiledValidation.gaps.join('; ')}`);
+    }
+    let finalSummary = summary;
+    let finalEvidence = evidence;
+    let qaSource = qaFile || 'forced-end-phase-autofire';
+    let qaText = qaFile
+        ? readFileSync(path.resolve(qaFile), 'utf8')
+        : buildAutoQaArtifact(state, current, summary, evidence);
+    let methodContractGaps = methodGaps(qaText);
+    let qaBase = {
+        at: nowIso(),
+        ok: methodContractGaps.length === 0,
+        gaps: methodContractGaps,
+        artifactSha256: sha256(qaText),
+        source: qaSource,
+        autofire: {
+            mode: 'forced_end_of_phase_qa',
+            trigger: 'phase_close',
+            suites: [...END_OF_PHASE_QA_SUITES],
+            hard_stop_only_for: [...END_OF_PHASE_QA_HARD_STOP_ONLY_FOR],
+        },
+    };
+    let autoRecovery = null;
+    let endPhaseQaAutofire = buildTaskRunnerEndPhaseQaAutofire({
+        state,
+        phase: current,
+        summary: finalSummary,
+        evidence: finalEvidence,
+        qa: qaBase,
+        qaSource,
+    });
+    let claimGateVerdict = String(endPhaseQaAutofire.receipt.claim_gate?.verdict || 'blocked');
+    const needsAutoRecovery = methodContractGaps.length > 0 || claimGateVerdict === 'partial';
+    if (needsAutoRecovery) {
+        autoRecovery = {
+            attempted: true,
+            mode: 'bounded_claim_rewrite_and_rerun',
+            reason: methodContractGaps.length > 0
+                ? 'method QA gaps or overbroad closeout claim detected at phase close'
+                : 'completion claim exceeded forced QA evidence at phase close',
+            initialVerdict: claimGateVerdict,
+            initialGapCount: methodContractGaps.length,
+            originalSummaryHash: sha256(summary),
+            originalEvidenceHash: sha256(evidence),
+            startedAt: nowIso(),
+        };
+        finalSummary = buildBoundedTaskRecoverySummary();
+        finalEvidence = buildBoundedTaskRecoveryEvidence();
+        qaSource = `${qaSource}+auto-recovery`;
+        qaText = buildAutoQaArtifact(state, current, finalSummary, finalEvidence);
+        methodContractGaps = methodGaps(qaText);
+        qaBase = {
+            at: nowIso(),
+            ok: methodContractGaps.length === 0,
+            gaps: methodContractGaps,
+            artifactSha256: sha256(qaText),
+            source: qaSource,
+            autofire: {
+                mode: 'forced_end_of_phase_qa',
+                trigger: 'phase_close',
+                suites: [...END_OF_PHASE_QA_SUITES],
+                hard_stop_only_for: [...END_OF_PHASE_QA_HARD_STOP_ONLY_FOR],
+            },
+        };
+        autoRecovery = {
+            ...autoRecovery,
+            completedAt: nowIso(),
+            finalGapCount: methodContractGaps.length,
+            recoveredSummaryHash: sha256(finalSummary),
+            recoveredEvidenceHash: sha256(finalEvidence),
+            recoveryQaSha256: sha256(qaText),
+        };
+        endPhaseQaAutofire = buildTaskRunnerEndPhaseQaAutofire({
+            state,
+            phase: current,
+            summary: finalSummary,
+            evidence: finalEvidence,
+            qa: qaBase,
+            qaSource,
+            autoRecovery,
+        });
+        claimGateVerdict = String(endPhaseQaAutofire.receipt.claim_gate?.verdict || 'blocked');
+    }
+    const claimGateGaps = claimGateVerdict === 'verified' || claimGateVerdict === 'verified_narrowly' ? [] : [`end-of-phase claim gate verdict: ${claimGateVerdict}`];
+    const gaps = [...methodContractGaps, ...claimGateGaps];
+    const qa = {
+        ...qaBase,
+        ok: gaps.length === 0,
+        gaps,
+        endPhaseQaAutofire: {
+            verdict: claimGateVerdict,
+            receiptHash: endPhaseQaAutofire.receipt.receipt_hash,
+            latestPath: endPhaseQaAutofire.latestPath,
+            eventPath: endPhaseQaAutofire.eventPath,
+            autoRecovery,
+        },
+    };
+    const qaLearningLoop = buildQaLearningLoop(state, current, qa, 'complete', qaSource);
+    const qualityLoops = [...(state.qualityLoops || []), qaLearningLoop].slice(-50);
+    const phases = state.phases.map((phase) => {
+        if (phase.phaseId !== current.phaseId)
+            return phase;
+        return {
+            ...phase,
+            status: gaps.length ? 'qa_failed' : 'completed',
+            completedAt: gaps.length ? undefined : nowIso(),
+            summary: finalSummary,
+            evidence: finalEvidence,
+            qa,
+        };
+    });
+    const nextStatus = gaps.length ? 'blocked' : 'active';
+    let next = saveTask({
+        ...state,
+        status: nextStatus,
+        activePhaseId: gaps.length ? current.phaseId : null,
+        phases,
+        qualityLoops,
+        checkpoints: [...state.checkpoints, { at: nowIso(), phase: current.phaseId, summary: finalSummary, evidence: finalEvidence, originalSummary: summary, originalEvidence: evidence, qa }],
+    }, { type: gaps.length ? 'phase_qa_failed' : 'phase_complete', phaseId: current.phaseId, summary: finalSummary, evidence: finalEvidence, originalSummary: summary, originalEvidence: evidence, qa, qaLearningLoop, endPhaseQaAutofire });
+    next = await consumeTaskPhaseBoundary(next, gaps.length ? 'phase_qa_failed' : 'phase_complete', phases.find((phase) => phase.phaseId === current.phaseId) || current, {
+        step: 'phase-close-forced-qa',
+        summary: finalSummary,
+        evidence: finalEvidence,
+        qa,
+        gaps,
+        action: gaps.length ? 'recover-phase-before-advance' : 'advance-to-next-phase',
+    });
+    await publishQaLearningContext({ ...next, activePhaseId: current.phaseId }, qaLearningLoop);
+    await recordRuntimeLedger(next, gaps.length ? 'phase_qa_failed' : 'phase_complete', { phase: phases.find((phase) => phase.phaseId === current.phaseId), qa, qaLearningLoop, endPhaseQaAutofire: qa.endPhaseQaAutofire }, { gaps, evidence: finalEvidence, originalEvidence: evidence, qa, qaLearningLoop, endPhaseQaAutofire: qa.endPhaseQaAutofire });
+    console.log(JSON.stringify({ ok: gaps.length === 0, taskId, phaseId: current.phaseId, gaps, autoRecovery, endPhaseQaAutofire: qa.endPhaseQaAutofire, next: gaps.length ? 'run aria task recover' : 'run aria task next' }, null, 2));
+    if (gaps.length)
+        process.exit(1);
+}
+async function closeTask(args) {
+    const { flags, rest } = parseFlags(args);
+    const taskId = sanitizeTaskId(rest[0] || flagString(flags, 'id') || latestTaskId());
+    const summary = flagString(flags, 'summary') || 'all task phases completed and final task closeout requested';
+    const evidence = flagString(flags, 'evidence') || 'task closeout gate checked phase state, QA state, runtime skill floor, and closeout drift';
+    let state = loadTask(taskId);
+    const alreadyClosed = state.status === 'completed';
+    const forcedSkillLoad = await forceSkillPack(state.taskId, state.goal);
+    state = attachCompiledWorkUnit({ ...state, forcedSkillLoad }, forcedSkillLoad);
+    const closeoutDrift = detectPartialCloseoutDrift(state);
+    const latestQa = latestQualityLoop(state);
+    const incompletePhases = state.phases.filter((phase) => phase.status !== 'completed');
+    const completedWithoutQa = state.phases.filter((phase) => phase.status === 'completed' && phase.qa && phase.qa.ok !== true);
+    const gaps = [
+        ...(state.activePhaseId ? [`active phase still claimed: ${state.activePhaseId}`] : []),
+        ...incompletePhases.map((phase) => `phase not completed: ${phase.phaseId} (${phase.status})`),
+        ...completedWithoutQa.map((phase) => `completed phase has failing QA: ${phase.phaseId}`),
+        ...(closeoutDrift.ok === false ? [`partial closeout drift: ${String(closeoutDrift.kind || 'unknown')}`] : []),
+        ...(Number(forcedSkillLoad.loadedCount || 0) < UNIVERSAL_TURN_PACKET_SKILL_FLOOR
+            ? [`forced skill floor not met: ${Number(forcedSkillLoad.loadedCount || 0)}/${UNIVERSAL_TURN_PACKET_SKILL_FLOOR}`]
+            : []),
+        ...(Number(forcedSkillLoad.activeRuntimeCount || 0) < UNIVERSAL_TURN_PACKET_RUNTIME_FLOOR
+            ? [`runtime floor not met: ${Number(forcedSkillLoad.activeRuntimeCount || 0)}/${UNIVERSAL_TURN_PACKET_RUNTIME_FLOOR}`]
+            : []),
+        ...(latestQa && latestQa.ok === false ? ['latest QA learning loop is failing'] : []),
+    ];
+    if (gaps.length > 0) {
+        state = saveTask({ ...state, status: 'blocked', activePhaseId: state.activePhaseId }, {
+            type: 'task_close_blocked',
+            summary,
+            evidence,
+            gaps,
+            closeoutDrift,
+            forcedSkillLoad,
+        });
+        state = await consumeTaskPhaseBoundary(state, 'task_close_blocked', activePhase(state), {
+            step: 'task-close',
+            summary,
+            evidence,
+            gaps,
+            action: 'repair-before-task-close',
+        });
+        await recordRuntimeLedger(state, 'task_close_blocked', { summary, evidence, gaps, closeoutDrift }, { forcedSkillLoad });
+        console.log(JSON.stringify({
+            ok: false,
+            taskId,
+            status: state.status,
+            gaps,
+            closeoutDrift,
+            next: `repair gaps, then run aria task close ${taskId} --summary "..." --evidence "..."`,
+        }, null, 2));
+        process.exit(1);
+    }
+    state = saveTask({ ...state, status: 'completed', activePhaseId: null, forcedSkillLoad }, {
+        type: 'task_closed',
+        summary,
+        evidence,
+        forcedSkillLoad,
+        closeoutDrift,
+    });
+    state = await consumeTaskPhaseBoundary(state, 'task_closed', null, {
+        step: 'task-close',
+        summary,
+        evidence,
+        action: 'finalize-task-ledger',
+    });
+    await recordRuntimeLedger(state, 'task_completed', {
+        summary,
+        evidence,
+        phaseCount: state.phases.length,
+        completedPhaseCount: state.phases.filter((phase) => phase.status === 'completed').length,
+    }, { forcedSkillLoad, closeoutDrift });
+    console.log(JSON.stringify({
+        ok: true,
+        taskId,
+        status: state.status,
+        alreadyClosed,
+        activePhaseId: state.activePhaseId,
+        completedPhaseCount: state.phases.filter((phase) => phase.status === 'completed').length,
+        phaseCount: state.phases.length,
+        forcedSkillLoad: summarizeForcedSkillLoad(forcedSkillLoad),
+        closeoutDrift,
+        statePath: taskPath(taskId),
+        eventsPath: eventPath(taskId),
+    }, null, 2));
+}
+async function runCodexExecutorTask(taskId, flags, summary, evidence) {
+    const codexBin = resolveCodexExecutorBin(flags);
+    const runAll = flags.all === true;
+    const dryRun = flags['dry-run'] === true;
+    const sandbox = flagString(flags, 'sandbox') || 'danger-full-access';
+    const qaFileHint = flagString(flags, 'qa-file') || flagString(flags, 'qa') || '';
+    const completedPhases = [];
+    while (true) {
+        let state = loadTask(taskId);
+        const forcedSkillLoad = await forceSkillPack(state.taskId, state.goal);
+        const fullPromptBuild = await buildSkillPrompt(state.taskId, state.goal, ARIA_CLI_TASK_SKILLS, 'codex-executor');
+        const fullPromptSummary = summarizeForcedSkillLoad(fullPromptBuild);
+        assertCompleteSkillLoad(fullPromptSummary, 'codex executor');
+        state = saveTask({ ...state, forcedSkillLoad, status: 'active' }, {
+            type: 'codex_executor_forced_skill_refire',
+            forcedSkillLoad,
+            codexSkillPrompt: fullPromptSummary,
+        });
+        state = await consumeTaskPhaseBoundary(state, 'codex_executor_forced_skill_refire', activePhase(state), {
+            step: 'codex-executor-forced-skill-refire',
+            summary: 'Codex executor refreshed universal task packet before provider launch',
+            evidence: `forcedSkillLoad.loadedCount=${forcedSkillLoad.loadedCount}; activeRuntimeCount=${forcedSkillLoad.activeRuntimeCount}`,
+            action: 'prepare-codex-executor-phase',
+        });
+        await recordRuntimeLedger(state, 'codex_executor_forced_skill_refire', {
+            executor: 'codex',
+            completedPhases,
+        }, { forcedSkillLoad, codexSkillPrompt: fullPromptSummary });
+        let current = activePhase(state);
+        if (!current || current.status !== 'in_progress') {
+            const pending = current && (current.status === 'qa_failed' || current.status === 'blocked') ? current : nextPendingPhase(state);
+            if (!pending) {
+                const allComplete = state.phases.length > 0 && state.phases.every((phase) => phase.status === 'completed');
+                state = saveTask({ ...state, status: allComplete ? 'completed' : state.status, activePhaseId: null }, {
+                    type: allComplete ? 'task_completed' : 'codex_executor_no_phase',
+                    completedPhases,
+                });
+                state = await consumeTaskPhaseBoundary(state, allComplete ? 'codex_executor_task_completed' : 'codex_executor_no_phase', null, {
+                    step: 'codex-executor-no-phase',
+                    summary: allComplete ? 'Codex executor observed all phases complete' : 'Codex executor found no runnable phase',
+                    evidence: `completedPhases=${completedPhases.length}`,
+                    action: allComplete ? 'close-task' : 'report-no-phase',
+                });
+                await recordRuntimeLedger(state, allComplete ? 'task_completed' : 'codex_executor_no_phase', { completedPhases }, { executor: 'codex' });
+                console.log(JSON.stringify({ ok: allComplete, executor: 'codex', taskId, status: state.status, completedPhases, statePath: taskPath(taskId), eventsPath: eventPath(taskId) }, null, 2));
+                return;
+            }
+            const startedAt = nowIso();
+            const phases = state.phases.map((phase) => phase.phaseId === pending.phaseId
+                ? { ...phase, status: 'in_progress', startedAt: phase.startedAt || startedAt, attempts: phase.attempts + 1 }
+                : phase);
+            state = saveTask({ ...state, activePhaseId: pending.phaseId, phases }, {
+                type: 'codex_executor_phase_claim',
+                phaseId: pending.phaseId,
+            });
+            state = await consumeTaskPhaseBoundary(state, 'codex_executor_phase_claim', activePhase(state) || pending, {
+                step: 'codex-executor-phase-claim',
+                summary: 'Codex executor claimed phase after universal packet refresh',
+                evidence: `phase=${pending.phaseId}`,
+                action: 'launch-wrapped-codex-exec',
+            });
+            await recordRuntimeLedger(state, 'codex_executor_phase_claim', { phase: activePhase(state) }, { executor: 'codex', phase: activePhase(state) || pending });
+            current = activePhase(state);
+        }
+        if (!current)
+            throw new Error('aria task run --executor codex could not claim or resume a phase.');
+        state = saveTask({ ...state, checkpoints: [...state.checkpoints, { at: nowIso(), phase: current.phaseId, receipt: 'codex-pre-phase', summary, evidence }] }, {
+            type: 'codex_executor_pre_phase',
+            phaseId: current.phaseId,
+        });
+        state = await consumeTaskPhaseBoundary(state, 'codex_executor_pre_phase', current, {
+            step: 'codex-executor-pre-phase',
+            summary,
+            evidence,
+            action: 'build-codex-executor-prompt',
+        });
+        await recordRuntimeLedger(state, 'codex_executor_pre_phase', { phase: current, summary, evidence }, { executor: 'codex' });
+        const skillPrompt = typeof fullPromptBuild.prompt === 'string' ? fullPromptBuild.prompt : '';
+        if (!skillPrompt)
+            throw new Error('runtime /build-system-prompt did not return a Codex skill prompt.');
+        const prompt = buildCodexExecutorPrompt(state, current, skillPrompt, summary, evidence, qaFileHint);
+        const promptPath = codexPromptPath(state.taskId);
+        writeFileSync(promptPath, prompt + '\n', { mode: 0o600 });
+        const codexArgs = [
+            'exec',
+            '-C',
+            state.cwd,
+            '-s',
+            sandbox,
+            '-',
+        ];
+        state = saveTask({ ...state, checkpoints: [...state.checkpoints, { at: nowIso(), phase: current.phaseId, receipt: 'codex-exec-dispatch', promptPath, codexBin, codexArgs }] }, {
+            type: 'codex_executor_dispatch',
+            phaseId: current.phaseId,
+            promptPath,
+            codexBin,
+            codexArgs,
+            dryRun,
+        });
+        state = await consumeTaskPhaseBoundary(state, 'codex_executor_dispatch', current, {
+            step: 'codex-executor-dispatch',
+            summary: 'Wrapped Codex execution dispatch prepared with compact mechanical packet prompt',
+            evidence: `promptPath=${promptPath}; dryRun=${dryRun}; promptChars=${prompt.length}`,
+            action: dryRun ? 'return-dry-run-proof' : 'execute-wrapped-codex',
+        });
+        await recordRuntimeLedger(state, 'codex_executor_dispatch', { phase: current, promptPath, codexBin, codexArgs, dryRun }, { executor: 'codex' });
+        if (dryRun) {
+            console.log(JSON.stringify({ ok: true, dryRun: true, executor: 'codex', taskId, phaseId: current.phaseId, codexBin, codexArgs, promptPath, promptChars: prompt.length }, null, 2));
+            return;
+        }
+        const result = spawnSync(codexBin, codexArgs, {
+            cwd: state.cwd,
+            input: prompt,
+            stdio: ['pipe', 'inherit', 'inherit'],
+            env: {
+                ...process.env,
+                ARIA_RUNTIME_URL: RUNTIME_URL,
+                ARIA_TASK_ID: state.taskId,
+                ARIA_TASK_PHASE_ID: current.phaseId,
+            },
+        });
+        const exitCode = typeof result.status === 'number' ? result.status : 1;
+        state = loadTask(taskId);
+        state = saveTask(state, {
+            type: 'codex_executor_exit',
+            phaseId: current.phaseId,
+            exitCode,
+            signal: result.signal,
+            error: result.error ? result.error.message : null,
+        });
+        state = await consumeTaskPhaseBoundary(state, 'codex_executor_exit', current, {
+            step: 'codex-executor-exit',
+            summary: 'Wrapped Codex executor returned control to parent task runner',
+            evidence: `exitCode=${exitCode}; signal=${result.signal || 'none'}`,
+            gaps: exitCode === 0 && !result.error ? [] : [`codex executor exitCode=${exitCode}`],
+            action: exitCode === 0 && !result.error ? 'verify-phase-completed' : 'stop-on-executor-failure',
+        });
+        await recordRuntimeLedger(state, 'codex_executor_exit', {
+            phase: current,
+            exitCode,
+            signal: result.signal,
+            error: result.error ? result.error.message : null,
+        }, { executor: 'codex' });
+        if (exitCode !== 0 || result.error) {
+            console.log(JSON.stringify({ ok: false, executor: 'codex', taskId, phaseId: current.phaseId, exitCode, error: result.error ? result.error.message : null }, null, 2));
+            process.exit(exitCode || 1);
+        }
+        const completed = state.phases.find((phase) => phase.phaseId === current.phaseId && phase.status === 'completed');
+        if (!completed) {
+            console.log(JSON.stringify({
+                ok: false,
+                executor: 'codex',
+                taskId,
+                phaseId: current.phaseId,
+                error: 'Codex exited without completing the active phase via aria task complete.',
+                statePath: taskPath(taskId),
+                eventsPath: eventPath(taskId),
+            }, null, 2));
+            process.exit(1);
+        }
+        completedPhases.push(current.phaseId);
+        const allComplete = state.phases.length > 0 && state.phases.every((phase) => phase.status === 'completed');
+        if (allComplete) {
+            state = saveTask({ ...state, status: 'completed', activePhaseId: null }, { type: 'task_completed', executor: 'codex', completedPhases });
+            state = await consumeTaskPhaseBoundary(state, 'codex_executor_task_completed', null, {
+                step: 'codex-executor-task-completed',
+                summary: 'Codex executor completed all task phases',
+                evidence: `completedPhases=${completedPhases.length}`,
+                action: 'close-task',
+            });
+            await recordRuntimeLedger(state, 'task_completed', { executor: 'codex', completedPhases }, { executor: 'codex' });
+            console.log(JSON.stringify({ ok: true, executor: 'codex', taskId, status: state.status, completedPhases, statePath: taskPath(taskId), eventsPath: eventPath(taskId) }, null, 2));
+            return;
+        }
+        if (!runAll) {
+            console.log(JSON.stringify({ ok: true, executor: 'codex', taskId, status: state.status, completedPhases, next: `aria task run ${taskId} --executor codex --summary "..." --evidence "..."` }, null, 2));
+            return;
+        }
+    }
+}
+async function runWorkerExecutorTask(taskId, flags, summary, evidence) {
+    const executor = sanitizeTaskId(flagString(flags, 'executor') || 'spark');
+    const allowedFiles = flagList(flags, 'allowed-files');
+    const forbiddenFiles = flagList(flags, 'forbidden-files');
+    const verificationCommand = flagString(flags, 'verify');
+    const requestedPhaseId = flagString(flags, 'phase');
+    if (!allowedFiles.length)
+        throw new Error(`aria task run --executor ${executor} requires --allowed-files "path[,path]"`);
+    if (!verificationCommand)
+        throw new Error(`aria task run --executor ${executor} requires --verify "real verification command"`);
+    const prepared = await prepareWorkerPacket({
+        taskId,
+        executor,
+        requestedPhaseId,
+        allowedFiles,
+        forbiddenFiles,
+        verificationCommand,
+        outputPath: flagString(flags, 'packet-out') || flagString(flags, 'out'),
+    });
+    const dryRun = flags['dry-run'] === true;
+    const dispatchCommand = flagString(flags, 'dispatch-command') || process.env.ARIA_TASK_WORKER_DISPATCH_COMMAND || '';
+    const workerOut = path.resolve(flagString(flags, 'worker-output') || workerOutputPath(prepared.state.taskId, prepared.phase.phaseId, executor));
+    if (dryRun || !dispatchCommand) {
+        console.log(JSON.stringify({
+            ok: true,
+            executor,
+            dispatchPrepared: true,
+            dispatched: false,
+            dryRun,
+            taskId: prepared.state.taskId,
+            phaseId: prepared.phase.phaseId,
+            packetPath: prepared.packetPath,
+            packetHash: prepared.packet.receiptHash,
+            workerOutputPath: workerOut,
+            summary,
+            evidence,
+            next: dispatchCommand
+                ? `rerun without --dry-run or run aria task worker-ingest ${prepared.state.taskId} --file ${shellQuote(workerOut)} --packet ${shellQuote(prepared.packetPath)}`
+                : `send packet to ${executor}; then run aria task worker-ingest ${prepared.state.taskId} --file <worker-output.json> --packet ${shellQuote(prepared.packetPath)}`,
+        }, null, 2));
+        return;
+    }
+    const dispatch = spawnSync('/bin/bash', ['-lc', dispatchCommand], {
+        cwd: prepared.state.cwd,
+        input: JSON.stringify(prepared.packet, null, 2),
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            ARIA_RUNTIME_URL: RUNTIME_URL,
+            ARIA_TASK_ID: prepared.state.taskId,
+            ARIA_TASK_PHASE_ID: prepared.phase.phaseId,
+            ARIA_TASK_WORKER_EXECUTOR: executor,
+            ARIA_TASK_WORKER_PACKET_PATH: prepared.packetPath,
+            ARIA_TASK_WORKER_OUTPUT_PATH: workerOut,
+        },
+    });
+    const exitCode = typeof dispatch.status === 'number' ? dispatch.status : 1;
+    let state = loadTask(prepared.state.taskId);
+    const dispatchReceipt = {
+        at: nowIso(),
+        phase: prepared.phase.phaseId,
+        receipt: 'worker-dispatch',
+        executor,
+        dispatchCommand,
+        packetPath: prepared.packetPath,
+        workerOutputPath: workerOut,
+        exitCode,
+        signal: dispatch.signal || null,
+        error: dispatch.error ? dispatch.error.message : null,
+        stdoutSha256: sha256(String(dispatch.stdout || '')),
+        stderrTail: String(dispatch.stderr || '').slice(-4000),
+    };
+    state = saveTask({ ...state, checkpoints: [...state.checkpoints, dispatchReceipt] }, {
+        type: exitCode === 0 && !dispatch.error ? 'worker_dispatch_exit' : 'worker_dispatch_failed',
+        phaseId: prepared.phase.phaseId,
+        executor,
+        dispatchReceipt,
+    });
+    state = await consumeTaskPhaseBoundary(state, 'worker_dispatch_exit', phaseById(state, prepared.phase.phaseId) || prepared.phase, {
+        step: 'bounded-worker-command-dispatch',
+        summary: exitCode === 0 && !dispatch.error ? `Dispatched ${executor} worker command` : `${executor} worker command failed`,
+        evidence: `exitCode=${exitCode}; workerOutputPath=${workerOut}`,
+        gaps: exitCode === 0 && !dispatch.error ? [] : [`worker dispatch exitCode=${exitCode}`],
+        action: exitCode === 0 && !dispatch.error ? 'ingest-worker-output' : 'correct-worker-dispatch-before-ingest',
+    });
+    await recordRuntimeLedger(state, exitCode === 0 && !dispatch.error ? 'worker_dispatch_exit' : 'worker_dispatch_failed', {
+        executor,
+        phase: phaseById(state, prepared.phase.phaseId) || prepared.phase,
+        dispatchReceipt,
+    }, {
+        gaps: exitCode === 0 && !dispatch.error ? [] : [`worker dispatch exitCode=${exitCode}`],
+        workerDispatchReceipt: dispatchReceipt,
+    });
+    if (exitCode !== 0 || dispatch.error) {
+        console.log(JSON.stringify({
+            ok: false,
+            executor,
+            taskId: prepared.state.taskId,
+            phaseId: prepared.phase.phaseId,
+            packetPath: prepared.packetPath,
+            workerOutputPath: workerOut,
+            exitCode,
+            error: dispatch.error ? dispatch.error.message : null,
+        }, null, 2));
+        process.exit(exitCode || 1);
+    }
+    if (String(dispatch.stdout || '').trim()) {
+        writeFileSync(workerOut, String(dispatch.stdout).trim() + '\n', { mode: 0o600 });
+    }
+    if (!existsSync(workerOut)) {
+        throw new Error(`Worker dispatch exited 0 but did not write output JSON to ${workerOut}`);
+    }
+    await workerIngestTask([
+        prepared.state.taskId,
+        '--file',
+        workerOut,
+        '--packet',
+        prepared.packetPath,
+        '--executor',
+        executor,
+        '--phase',
+        prepared.phase.phaseId,
+    ]);
+}
+async function runTask(args) {
+    const { flags, rest } = parseFlags(args);
+    const taskId = sanitizeTaskId(rest[0] || flagString(flags, 'id') || latestTaskId());
+    const summary = flagString(flags, 'summary') || rest.slice(1).join(' ').trim();
+    const evidence = flagString(flags, 'evidence');
+    const runAll = flags.all === true;
+    const maxRecoveries = Math.max(0, Number(flagString(flags, 'max-recoveries') || '2'));
+    if (!summary)
+        throw new Error('aria task run requires --summary "..."');
+    if (!evidence)
+        throw new Error('aria task run requires --evidence "..."');
+    if (flagString(flags, 'executor') === 'codex') {
+        return runCodexExecutorTask(taskId, flags, summary, evidence);
+    }
+    if (flagString(flags, 'executor')) {
+        return runWorkerExecutorTask(taskId, flags, summary, evidence);
+    }
+    let state = loadTask(taskId);
+    const completedPhases = [];
+    let recoveryAttempts = 0;
+    while (true) {
+        const forcedSkillLoad = await forceSkillPack(state.taskId, state.goal);
+        state = saveTask({ ...state, forcedSkillLoad, status: 'active' }, {
+            type: 'run_loop_step',
+            step: RUN_LOOP_STEPS[0],
+            forcedSkillLoad,
+        });
+        state = await consumeTaskPhaseBoundary(state, 'run_loop_forced_skill_refire', activePhase(state), {
+            step: RUN_LOOP_STEPS[0],
+            summary: 'parent task loop refreshed universal packet before phase work',
+            evidence: `forcedSkillLoad.loadedCount=${forcedSkillLoad.loadedCount}; activeRuntimeCount=${forcedSkillLoad.activeRuntimeCount}`,
+            action: 'claim-or-resume-phase',
+        });
+        await recordRuntimeLedger(state, 'run_loop_forced_skill_refire', {
+            step: RUN_LOOP_STEPS[0],
+            completedPhases,
+        }, { forcedSkillLoad, runLoopSteps: RUN_LOOP_STEPS });
+        let current = activePhase(state);
+        if (!current || current.status !== 'in_progress') {
+            const pending = current && (current.status === 'qa_failed' || current.status === 'blocked') ? current : nextPendingPhase(state);
+            if (!pending) {
+                const allComplete = state.phases.length > 0 && state.phases.every((phase) => phase.status === 'completed');
+                state = saveTask({ ...state, status: allComplete ? 'completed' : state.status, activePhaseId: null }, {
+                    type: allComplete ? 'task_completed' : 'run_loop_no_phase',
+                    step: RUN_LOOP_STEPS[6],
+                    completedPhases,
+                });
+                state = await consumeTaskPhaseBoundary(state, allComplete ? 'run_loop_task_completed' : 'run_loop_no_phase', null, {
+                    step: RUN_LOOP_STEPS[6],
+                    summary: allComplete ? 'parent loop observed all phases complete' : 'parent loop found no runnable phase',
+                    evidence: `completedPhases=${completedPhases.length}; phaseCount=${state.phases.length}`,
+                    action: allComplete ? 'close-task' : 'report-no-phase',
+                });
+                await recordRuntimeLedger(state, allComplete ? 'task_completed' : 'run_loop_no_phase', {
+                    step: RUN_LOOP_STEPS[6],
+                    completedPhases,
+                }, { runLoopSteps: RUN_LOOP_STEPS });
+                console.log(JSON.stringify({ ok: allComplete, taskId, status: state.status, completedPhases, statePath: taskPath(taskId), eventsPath: eventPath(taskId) }, null, 2));
+                return;
+            }
+            const startedAt = nowIso();
+            const phases = state.phases.map((phase) => phase.phaseId === pending.phaseId
+                ? { ...phase, status: 'in_progress', startedAt: phase.startedAt || startedAt, attempts: phase.attempts + 1 }
+                : phase);
+            state = saveTask({ ...state, activePhaseId: pending.phaseId, phases }, {
+                type: 'run_loop_step',
+                step: RUN_LOOP_STEPS[1],
+                phaseId: pending.phaseId,
+            });
+            state = await consumeTaskPhaseBoundary(state, 'run_loop_phase_claim', activePhase(state) || pending, {
+                step: RUN_LOOP_STEPS[1],
+                summary: 'parent loop claimed phase after universal packet refresh',
+                evidence: `phase=${pending.phaseId}`,
+                action: 'write-pre-phase-receipt',
+            });
+            await recordRuntimeLedger(state, 'run_loop_phase_claim', {
+                step: RUN_LOOP_STEPS[1],
+                phase: activePhase(state),
+            }, { forcedSkillLoad, phase: activePhase(state) || pending });
+            current = activePhase(state);
+        }
+        if (!current)
+            throw new Error('aria task run could not claim or resume a phase.');
+        const preReceipt = {
+            taskId: state.taskId,
+            phaseId: current.phaseId,
+            step: RUN_LOOP_STEPS[2],
+            summary,
+            evidence,
+        };
+        state = saveTask({ ...state, checkpoints: [...state.checkpoints, { at: nowIso(), phase: current.phaseId, receipt: 'pre-phase', summary, evidence }] }, {
+            type: 'run_loop_step',
+            step: RUN_LOOP_STEPS[2],
+            phaseId: current.phaseId,
+        });
+        state = await consumeTaskPhaseBoundary(state, 'run_loop_pre_phase_receipt', current, {
+            step: RUN_LOOP_STEPS[2],
+            summary,
+            evidence,
+            action: 'run-mid-phase-check',
+        });
+        await recordRuntimeLedger(state, 'run_loop_pre_phase_receipt', preReceipt, { phase: current, runLoopSteps: RUN_LOOP_STEPS });
+        const midReceipt = {
+            taskId: state.taskId,
+            phaseId: current.phaseId,
+            step: RUN_LOOP_STEPS[3],
+            summary,
+            evidence,
+            activeSkillCount: state.requiredSkills.length,
+        };
+        state = saveTask({ ...state, checkpoints: [...state.checkpoints, { at: nowIso(), phase: current.phaseId, receipt: 'mid-phase', summary, evidence }] }, {
+            type: 'run_loop_step',
+            step: RUN_LOOP_STEPS[3],
+            phaseId: current.phaseId,
+        });
+        state = await consumeTaskPhaseBoundary(state, 'run_loop_mid_phase_receipt', current, {
+            step: RUN_LOOP_STEPS[3],
+            summary,
+            evidence,
+            action: 'run-qiyas-tadabbur-qa',
+        });
+        await recordRuntimeLedger(state, 'run_loop_mid_phase_receipt', midReceipt, { phase: current, forcedSkillLoad: state.forcedSkillLoad });
+        const qaArtifact = readRunQaArtifact(flags, state, current, summary, evidence, current.attempts);
+        const gaps = methodGaps(qaArtifact.text);
+        const qa = { at: nowIso(), ok: gaps.length === 0, gaps, artifactSha256: sha256(qaArtifact.text) };
+        if (gaps.length) {
+            const failedPhases = state.phases.map((phase) => phase.phaseId === current.phaseId
+                ? { ...phase, status: 'qa_failed', summary, evidence, qa }
+                : phase);
+            state = saveTask({ ...state, status: 'blocked', activePhaseId: current.phaseId, phases: failedPhases }, {
+                type: 'run_loop_qa_failed',
+                step: RUN_LOOP_STEPS[4],
+                phaseId: current.phaseId,
+                gaps,
+                qaSource: qaArtifact.source,
+            });
+            state = await consumeTaskPhaseBoundary(state, 'run_loop_phase_qa_failed', current, {
+                step: RUN_LOOP_STEPS[4],
+                summary,
+                evidence,
+                qa,
+                gaps,
+                action: 'run-correction-recovery-cycle',
+            });
+            await recordRuntimeLedger(state, 'run_loop_phase_qa_failed', {
+                step: RUN_LOOP_STEPS[4],
+                phase: current,
+                gaps,
+                qaSource: qaArtifact.source,
+            }, { gaps, qa });
+            if (recoveryAttempts >= maxRecoveries || (!flagString(flags, 'fix-qa-file') && flags['auto-qa'] !== true)) {
+                console.log(JSON.stringify({
+                    ok: false,
+                    taskId,
+                    phaseId: current.phaseId,
+                    gaps,
+                    recoveryAttempts,
+                    next: 'provide --fix-qa-file, raise --max-recoveries, or run aria task recover',
+                }, null, 2));
+                process.exit(1);
+            }
+            recoveryAttempts += 1;
+            const lastAt = nowIso();
+            const recoveredPhases = state.phases.map((phase) => phase.phaseId === current.phaseId
+                ? {
+                    ...phase,
+                    status: 'in_progress',
+                    startedAt: phase.startedAt || lastAt,
+                    attempts: phase.attempts + 1,
+                    recovery: {
+                        attempts: (phase.recovery?.attempts || 0) + 1,
+                        lastAt,
+                        reason: `run loop QA gaps: ${gaps.slice(0, 5).join('; ')}`,
+                    },
+                }
+                : phase);
+            state = saveTask({
+                ...state,
+                status: 'active',
+                activePhaseId: current.phaseId,
+                phases: recoveredPhases,
+                recovery: {
+                    attempts: state.recovery.attempts + 1,
+                    lastReason: `run loop QA gaps: ${gaps.slice(0, 5).join('; ')}`,
+                    lastAt,
+                },
+            }, {
+                type: 'run_loop_recovery',
+                step: RUN_LOOP_STEPS[5],
+                phaseId: current.phaseId,
+                gaps,
+                recoveryAttempts,
+            });
+            state = await consumeTaskPhaseBoundary(state, 'run_loop_recovery_cycle', activePhase(state), {
+                step: RUN_LOOP_STEPS[5],
+                summary: 'parent loop applied QA recovery cycle before retrying phase',
+                evidence: `recoveryAttempts=${recoveryAttempts}; gaps=${gaps.length}`,
+                qa,
+                gaps,
+                action: 'retry-phase-with-correction',
+            });
+            await recordRuntimeLedger(state, 'run_loop_recovery_cycle', {
+                step: RUN_LOOP_STEPS[5],
+                phase: activePhase(state),
+                gaps,
+                recoveryAttempts,
+            }, { gaps, runLoopSteps: RUN_LOOP_STEPS });
+            continue;
+        }
+        const completedAt = nowIso();
+        const completed = state.phases.map((phase) => phase.phaseId === current.phaseId
+            ? {
+                ...phase,
+                status: 'completed',
+                completedAt,
+                summary,
+                evidence,
+                qa,
+            }
+            : phase);
+        completedPhases.push(current.phaseId);
+        state = saveTask({
+            ...state,
+            status: 'active',
+            activePhaseId: null,
+            phases: completed,
+            checkpoints: [...state.checkpoints, {
+                    at: completedAt,
+                    phase: current.phaseId,
+                    receipt: 'post-phase',
+                    summary,
+                    evidence,
+                    qa,
+                }],
+        }, {
+            type: 'run_loop_phase_complete',
+            step: RUN_LOOP_STEPS[6],
+            phaseId: current.phaseId,
+            summary,
+            evidence,
+            qa,
+            qaSource: qaArtifact.source,
+        });
+        state = await consumeTaskPhaseBoundary(state, 'run_loop_phase_complete', completed.find((phase) => phase.phaseId === current.phaseId) || current, {
+            step: RUN_LOOP_STEPS[6],
+            summary,
+            evidence,
+            qa,
+            action: 'advance-or-close-task',
+        });
+        await recordRuntimeLedger(state, 'run_loop_phase_complete', {
+            step: RUN_LOOP_STEPS[6],
+            phase: completed.find((phase) => phase.phaseId === current.phaseId),
+            qa,
+            qaSource: qaArtifact.source,
+        }, { qa, runLoopSteps: RUN_LOOP_STEPS });
+        const allComplete = state.phases.length > 0 && state.phases.every((phase) => phase.status === 'completed');
+        if (allComplete) {
+            state = saveTask({ ...state, status: 'completed', activePhaseId: null }, {
+                type: 'task_completed',
+                step: RUN_LOOP_STEPS[6],
+                completedPhases,
+            });
+            state = await consumeTaskPhaseBoundary(state, 'run_loop_task_completed', null, {
+                step: RUN_LOOP_STEPS[6],
+                summary: 'parent loop completed every phase with task phase consumer receipts',
+                evidence: `completedPhases=${completedPhases.length}`,
+                action: 'close-task',
+            });
+            await recordRuntimeLedger(state, 'task_completed', {
+                step: RUN_LOOP_STEPS[6],
+                completedPhases,
+            }, { runLoopSteps: RUN_LOOP_STEPS });
+            console.log(JSON.stringify({ ok: true, taskId, status: state.status, completedPhases, recoveryAttempts, statePath: taskPath(taskId), eventsPath: eventPath(taskId) }, null, 2));
+            return;
+        }
+        if (!runAll) {
+            console.log(JSON.stringify({ ok: true, taskId, status: state.status, completedPhases, recoveryAttempts, next: `aria task run ${taskId} --summary "..." --evidence "..." --auto-qa` }, null, 2));
+            return;
+        }
+    }
+}
+async function recoverTask(args) {
+    const { flags, rest } = parseFlags(args);
+    const taskId = sanitizeTaskId(rest[0] || flagString(flags, 'id') || latestTaskId());
+    const reason = flagString(flags, 'reason') || rest.slice(1).join(' ').trim() || 'blocked phase recovery';
+    let state = loadTask(taskId);
+    const phase = activePhase(state) || state.phases.find((item) => item.status === 'qa_failed' || item.status === 'blocked') || nextPendingPhase(state);
+    if (!phase)
+        throw new Error('No phase available for recovery.');
+    const forcedSkillLoad = await forceSkillPack(state.taskId, state.goal);
+    state = attachCompiledWorkUnit({ ...state, forcedSkillLoad }, forcedSkillLoad);
+    const lastAt = nowIso();
+    const phases = state.phases.map((item) => item.phaseId === phase.phaseId
+        ? {
+            ...item,
+            status: 'in_progress',
+            startedAt: item.startedAt || lastAt,
+            attempts: item.attempts + 1,
+            recovery: {
+                attempts: (item.recovery?.attempts || 0) + 1,
+                lastAt,
+                reason,
+            },
+        }
+        : item);
+    state = saveTask({
+        ...state,
+        status: 'active',
+        activePhaseId: phase.phaseId,
+        forcedSkillLoad,
+        recovery: {
+            attempts: state.recovery.attempts + 1,
+            lastReason: reason,
+            lastAt,
+        },
+        phases,
+    }, { type: 'phase_recovery', phaseId: phase.phaseId, reason, forcedSkillLoad });
+    await publishRecoveryContext(state, reason);
+    const refreshedState = await refreshTaskProjectContext(state);
+    state = saveTask(refreshedState, { type: 'project_context_refresh', projectContext: refreshedState.projectContext, reason });
+    state = await consumeTaskPhaseBoundary(state, 'phase_recovery', activePhase(state), {
+        summary: 'phase recovery refreshed universal packet and reopened phase',
+        evidence: reason,
+        action: 'resume-corrective-work',
+    });
+    await recordRuntimeLedger(state, 'phase_recovery', { phase: activePhase(state), reason }, { forcedSkillLoad, reason });
+    console.log(renderReinjection(state));
+}
+async function checkpointTask(args) {
+    const { flags, rest } = parseFlags(args);
+    const taskId = sanitizeTaskId(rest[0] || flagString(flags, 'id') || latestTaskId());
+    const state = loadTask(taskId);
+    const checkpoint = {
+        at: nowIso(),
+        phase: flagString(flags, 'phase') || 'checkpoint',
+        summary: flagString(flags, 'summary') || rest.slice(1).join(' ').trim(),
+        evidence: flagString(flags, 'evidence'),
+    };
+    if (!checkpoint.summary)
+        throw new Error('aria task checkpoint requires --summary "..."');
+    let next = saveTask({ ...state, checkpoints: [...state.checkpoints, checkpoint] }, { type: 'checkpoint', checkpoint });
+    next = await consumeTaskPhaseBoundary(next, 'checkpoint', activePhase(next), {
+        step: 'task-checkpoint',
+        summary: checkpoint.summary,
+        evidence: checkpoint.evidence,
+        action: 'persist-progress-evidence',
+    });
+    await recordRuntimeLedger(next, checkpoint.phase, checkpoint, { checkpoint });
+    console.log(JSON.stringify({ ok: true, taskId: next.taskId, checkpoint, statePath: taskPath(next.taskId) }, null, 2));
+}
+async function prepareWorkerPacket({ taskId, executor, requestedPhaseId, allowedFiles, forbiddenFiles, verificationCommand, outputPath, }) {
+    let state = loadTask(taskId);
+    const forcedSkillLoad = await forceSkillPack(state.taskId, state.goal);
+    const selected = selectableWorkerPhase(state, requestedPhaseId);
+    if (!selected)
+        throw new Error('No active or pending phase available for worker packet.');
+    if (selected.status === 'completed')
+        throw new Error(`Refusing worker packet for completed phase ${selected.phaseId}.`);
+    const startedAt = nowIso();
+    const phases = state.phases.map((phase) => phase.phaseId === selected.phaseId
+        ? {
+            ...phase,
+            status: 'in_progress',
+            startedAt: phase.startedAt || startedAt,
+            attempts: phase.status === 'in_progress' ? phase.attempts : phase.attempts + 1,
+        }
+        : phase);
+    state = saveTask({
+        ...state,
+        status: 'active',
+        activePhaseId: selected.phaseId,
+        forcedSkillLoad,
+        phases,
+    }, {
+        type: 'worker_packet_prepare',
+        executor,
+        phaseId: selected.phaseId,
+        forcedSkillLoad,
+    });
+    const phase = activePhase(state) || selected;
+    const substrateOpen = await openTaskSubstrate(state, 'worker_packet_prepared', phase.phaseId);
+    const hiveRuntimeReport = await publishWorkerHiveContext(state, phase, 'aria_task_worker_packet_prepared', {
+        worker_executor: executor,
+        worker_phase_id: phase.phaseId,
+        allowed_files: normalizeClaimList(state.cwd, allowedFiles),
+        forbidden_files: normalizeClaimList(state.cwd, forbiddenFiles),
+        verification_command: verificationCommand,
+        substrate_open: compactSubstrateOpen(substrateOpen),
+    });
+    const packetBase = {
+        schema: 'aria.task_worker_packet.v1',
+        generatedAt: nowIso(),
+        taskId: state.taskId,
+        phaseId: phase.phaseId,
+        executor,
+        goal: state.goal,
+        phaseTitle: phase.title,
+        phaseStatus: phase.status,
+        cwd: state.cwd,
+        allowedFiles: normalizeClaimList(state.cwd, allowedFiles),
+        forbiddenFiles: normalizeClaimList(state.cwd, forbiddenFiles),
+        verificationCommand,
+        atlasSubstrate: compactSubstrateOpen(substrateOpen),
+        hiveRuntimeReport,
+        qualityContract: {
+            workerMay: [
+                'perform bounded implementation inside allowedFiles',
+                'return changedFiles, evidence, verification summary, and blockers',
+            ],
+            workerMustNot: [
+                'claim task or phase completion',
+                'touch forbiddenFiles',
+                'expand scope without a new worker packet',
+                'weaken verification or gate contracts',
+            ],
+            completionAuthority: 'aria_codex_forced_qa_only',
+            maxCorrectionLoopsBeforeEscalation: 1,
+        },
+        requiredReturnSchema: {
+            schema: 'aria.task_worker_output.v1',
+            taskId: state.taskId,
+            phaseId: phase.phaseId,
+            executor,
+            changedFiles: [],
+            verification: { command: verificationCommand, exitCode: 0, summary: '' },
+            summary: '',
+            evidence: '',
+            blockers: [],
+        },
+        forcedSelectionSummary: summarizeForcedSkillLoad({
+            skillExecutionReceipt: objectRecord(forcedSkillLoad.skillExecutionReceipt),
+            ...forcedSkillLoad,
+        }),
+    };
+    const packet = {
+        ...packetBase,
+        receiptHash: sha256Json(packetBase),
+    };
+    const packetPath = path.resolve(outputPath || workerPacketPath(state.taskId, phase.phaseId, executor));
+    writeFileSync(packetPath, JSON.stringify(packet, null, 2) + '\n', { mode: 0o600 });
+    const checkpoint = {
+        at: nowIso(),
+        phase: phase.phaseId,
+        receipt: 'worker-packet',
+        executor,
+        packetPath,
+        packetHash: packet.receiptHash,
+        allowedFiles: packet.allowedFiles,
+        forbiddenFiles: packet.forbiddenFiles,
+        verificationCommand,
+    };
+    state = saveTask({ ...state, checkpoints: [...state.checkpoints, checkpoint] }, {
+        type: 'worker_packet_prepared',
+        executor,
+        phaseId: phase.phaseId,
+        packetPath,
+        packetHash: packet.receiptHash,
+    });
+    state = await consumeTaskPhaseBoundary(state, 'worker_packet_prepared', phase, {
+        step: 'bounded-worker-dispatch',
+        summary: `Prepared bounded ${executor} worker packet; Aria/Codex retains completion authority`,
+        evidence: `packetPath=${packetPath}; allowedFiles=${packet.allowedFiles.length}; verificationCommand=${verificationCommand}`,
+        action: 'dispatch-cheap-worker-and-ingest-output',
+    });
+    await recordRuntimeLedger(state, 'worker_packet_prepared', {
+        executor,
+        phase,
+        packetPath,
+        packetHash: packet.receiptHash,
+        summary: 'bounded cheap-worker packet prepared',
+    }, { forcedSkillLoad, phase, packet, substrateOpen, hiveRuntimeReport });
+    return { state, phase, packet, packetPath };
+}
+async function workerPacketTask(args) {
+    const { flags, rest } = parseFlags(args);
+    const taskId = sanitizeTaskId(rest[0] || flagString(flags, 'id') || latestTaskId());
+    const executor = sanitizeTaskId(flagString(flags, 'executor') || 'spark');
+    const requestedPhaseId = flagString(flags, 'phase');
+    const allowedFiles = flagList(flags, 'allowed-files');
+    const forbiddenFiles = flagList(flags, 'forbidden-files');
+    const verificationCommand = flagString(flags, 'verify');
+    if (!allowedFiles.length)
+        throw new Error('aria task worker-packet requires --allowed-files "path[,path]"');
+    if (!verificationCommand)
+        throw new Error('aria task worker-packet requires --verify "real verification command"');
+    const prepared = await prepareWorkerPacket({
+        taskId,
+        executor,
+        requestedPhaseId,
+        allowedFiles,
+        forbiddenFiles,
+        verificationCommand,
+        outputPath: flagString(flags, 'out'),
+    });
+    console.log(JSON.stringify({
+        ok: true,
+        taskId: prepared.state.taskId,
+        phaseId: prepared.phase.phaseId,
+        executor,
+        packetPath: prepared.packetPath,
+        packetHash: prepared.packet.receiptHash,
+        next: `aria task worker-ingest ${prepared.state.taskId} --file <worker-output.json> --packet ${prepared.packetPath}`,
+    }, null, 2));
+}
+function runWorkerVerification(state, command) {
+    if (!command) {
+        return {
+            ran: false,
+            ok: false,
+            command: null,
+            exitCode: null,
+            stdout: '',
+            stderr: '',
+            gap: 'missing verification command',
+        };
+    }
+    const result = spawnSync('/bin/bash', ['-lc', command], {
+        cwd: state.cwd,
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            ARIA_RUNTIME_URL: RUNTIME_URL,
+            ARIA_TASK_ID: state.taskId,
+            ARIA_TASK_PHASE_ID: state.activePhaseId || '',
+        },
+    });
+    const exitCode = typeof result.status === 'number' ? result.status : 1;
+    return {
+        ran: true,
+        ok: exitCode === 0 && !result.error,
+        command,
+        exitCode,
+        signal: result.signal || null,
+        stdout: String(result.stdout || '').slice(-4000),
+        stderr: String(result.stderr || '').slice(-4000),
+        error: result.error ? result.error.message : null,
+    };
+}
+async function workerIngestTask(args) {
+    const { flags, rest } = parseFlags(args);
+    const file = flagString(flags, 'file') || flagString(flags, 'output');
+    if (!file)
+        throw new Error('aria task worker-ingest requires --file <worker-output.json>');
+    const workerOutput = readJsonObjectFile(file);
+    const taskId = sanitizeTaskId(rest[0] || flagString(flags, 'id') || stringField(workerOutput.taskId) || latestTaskId());
+    let state = loadTask(taskId);
+    const phaseId = flagString(flags, 'phase') || stringField(workerOutput.phaseId) || state.activePhaseId || '';
+    const executor = sanitizeTaskId(flagString(flags, 'executor') || stringField(workerOutput.executor) || 'spark');
+    const phase = phaseById(state, phaseId);
+    if (!phase)
+        throw new Error(`No task phase found for worker output phaseId=${phaseId || '<missing>'}.`);
+    const packetFile = flagString(flags, 'packet') || workerPacketPath(state.taskId, phase.phaseId, executor);
+    const packet = existsSync(packetFile) ? readJsonObjectFile(packetFile) : {};
+    const packetAllowedFiles = stringArray(packet.allowedFiles);
+    const packetForbiddenFiles = stringArray(packet.forbiddenFiles);
+    const changedFiles = stringArray(workerOutput.changedFiles);
+    const scope = evaluateWorkerScope(state.cwd, changedFiles, packetAllowedFiles, packetForbiddenFiles);
+    const verificationCommand = flagString(flags, 'verify') || stringField(packet.verificationCommand);
+    const verification = runWorkerVerification({ ...state, activePhaseId: phase.phaseId }, verificationCommand);
+    const outputHash = sha256Json(workerOutput);
+    const gaps = uniqueStrings([
+        ...(workerOutput.schema === 'aria.task_worker_output.v1' ? [] : ['worker output schema must be aria.task_worker_output.v1']),
+        ...(stringField(workerOutput.taskId) === state.taskId ? [] : [`worker output taskId mismatch: ${stringField(workerOutput.taskId) || '<missing>'}`]),
+        ...(stringField(workerOutput.phaseId) === phase.phaseId ? [] : [`worker output phaseId mismatch: ${stringField(workerOutput.phaseId) || '<missing>'}`]),
+        ...(stringField(workerOutput.executor) === executor ? [] : [`worker output executor mismatch: ${stringField(workerOutput.executor) || '<missing>'}`]),
+        ...stringArray(scope.gaps),
+        ...(Object.keys(packet).length ? [] : [`worker packet not found: ${packetFile}`]),
+        ...(verification.ok === true ? [] : [`verification failed or missing: ${verificationCommand || '<missing>'}`]),
+    ]);
+    const accepted = gaps.length === 0;
+    const receiptId = `worker-ingest-${randomUUID().slice(0, 8)}`;
+    const receiptBase = {
+        schema: 'aria.task_worker_ingest_receipt.v1',
+        receiptId,
+        at: nowIso(),
+        taskId: state.taskId,
+        phaseId: phase.phaseId,
+        executor,
+        accepted,
+        completionAuthorityRetained: true,
+        workerOutputPath: path.resolve(file),
+        workerOutputHash: outputHash,
+        packetPath: packetFile,
+        packetHash: stringField(packet.receiptHash) || sha256Json(packet),
+        summary: stringField(workerOutput.summary),
+        evidence: stringField(workerOutput.evidence),
+        blockers: stringArray(workerOutput.blockers),
+        scope,
+        verification,
+        gaps,
+        nextAction: accepted
+            ? 'Codex/Aria reviews the diff and completes the phase only through aria task complete with forced QA.'
+            : 'Correct worker output or create a narrower worker packet before any phase completion claim.',
+    };
+    const receipt = {
+        ...receiptBase,
+        receiptHash: sha256Json(receiptBase),
+    };
+    const receiptPath = workerIngestPath(state.taskId, receiptId);
+    writeFileSync(receiptPath, JSON.stringify(receipt, null, 2) + '\n', { mode: 0o600 });
+    const qa = {
+        at: nowIso(),
+        ok: accepted,
+        gaps,
+        artifactSha256: outputHash,
+        source: 'worker-ingest',
+        verification,
+    };
+    const qaLearningLoop = buildQaLearningLoop(state, phase, qa, 'worker-ingest', path.resolve(file));
+    const phases = state.phases.map((item) => item.phaseId === phase.phaseId
+        ? {
+            ...item,
+            status: accepted ? item.status : 'qa_failed',
+            qa: accepted ? item.qa : qa,
+        }
+        : item);
+    const checkpoint = {
+        at: nowIso(),
+        phase: phase.phaseId,
+        receipt: 'worker-output-ingest',
+        executor,
+        accepted,
+        receiptPath,
+        receiptHash: receipt.receiptHash,
+        changedFiles: scope.changedFiles,
+        verification,
+        gaps,
+    };
+    state = saveTask({
+        ...state,
+        status: accepted ? state.status : 'blocked',
+        activePhaseId: phase.phaseId,
+        phases,
+        checkpoints: [...state.checkpoints, checkpoint],
+        qualityLoops: [...(state.qualityLoops || []), qaLearningLoop].slice(-50),
+    }, {
+        type: accepted ? 'worker_output_ingested' : 'worker_output_qa_failed',
+        phaseId: phase.phaseId,
+        executor,
+        receipt,
+        qaLearningLoop,
+    });
+    const substrateOpen = await openTaskSubstrate(state, accepted ? 'worker_output_ingested' : 'worker_output_qa_failed', phase.phaseId);
+    const hiveRuntimeReport = await publishWorkerHiveContext(state, phaseById(state, phase.phaseId) || phase, accepted ? 'aria_task_worker_output_ingested' : 'aria_task_worker_output_qa_failed', {
+        worker_executor: executor,
+        worker_phase_id: phase.phaseId,
+        worker_output_hash: outputHash,
+        worker_ingest_receipt_hash: receipt.receiptHash,
+        accepted,
+        changed_files: stringArray(scope.changedFiles),
+        gaps,
+        verification,
+        latest_qa: qa,
+        substrate_open: compactSubstrateOpen(substrateOpen),
+    });
+    state = await consumeTaskPhaseBoundary(state, 'worker_output_ingested', phaseById(state, phase.phaseId) || phase, {
+        step: 'bounded-worker-ingest-qa',
+        summary: accepted ? 'Worker output passed bounded scope and verification checks' : 'Worker output failed bounded scope or verification checks',
+        evidence: `receiptPath=${receiptPath}; changedFiles=${stringArray(scope.changedFiles).length}; verificationRan=${verification.ran === true}`,
+        qa,
+        gaps,
+        action: accepted ? 'codex-review-before-phase-complete' : 'correct-worker-output-before-phase-complete',
+    });
+    await publishQaLearningContext(state, qaLearningLoop);
+    await recordRuntimeLedger(state, accepted ? 'worker_output_ingested' : 'worker_output_qa_failed', {
+        phase: phaseById(state, phase.phaseId) || phase,
+        executor,
+        accepted,
+        receiptPath,
+        receiptHash: receipt.receiptHash,
+        summary: receipt.summary,
+    }, {
+        qa,
+        qaLearningLoop,
+        gaps,
+        fileClaims: stringArray(scope.changedFiles).map((filePath) => ({ path: filePath, claim: 'worker_changed', source: 'worker_output' })),
+        workerIngestReceipt: receipt,
+        substrateOpen,
+        hiveRuntimeReport,
+    });
+    console.log(JSON.stringify({
+        ok: accepted,
+        accepted,
+        taskId: state.taskId,
+        phaseId: phase.phaseId,
+        executor,
+        gaps,
+        receiptPath,
+        receiptHash: receipt.receiptHash,
+        next: receipt.nextAction,
+    }, null, 2));
+    if (!accepted)
+        process.exit(1);
+}
+async function statusTask(args) {
+    const { flags, rest } = parseFlags(args);
+    const taskId = sanitizeTaskId(rest[0] || flagString(flags, 'id') || latestTaskId());
+    const state = loadTask(taskId);
+    const health = await runtimeGet('/health').catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error) }));
+    const actionLedgerEvents = readActionLedgerEvents({ home: HOME, projectId: `aria-task-${taskId}`, taskId });
+    const actionLedgerProjection = projectActionLedger(actionLedgerEvents);
+    const compiledValidation = validateCompiledWorkUnitForExecution(state.compiledWorkUnit || null);
+    console.log(JSON.stringify({
+        ok: true,
+        task: state,
+        compiledWorkUnit: {
+            summary: compiledWorkUnitSummary(state.compiledWorkUnit || null),
+            path: state.compiledWorkUnitPath || null,
+            validation: compiledValidation,
+        },
+        paths: { statePath: taskPath(taskId), eventsPath: eventPath(taskId), runtimePublishOutboxPath: runtimePublishOutboxPath(taskId) },
+        actionLedger: {
+            eventCount: actionLedgerProjection.eventCount,
+            latestEvent: actionLedgerProjection.latestEvent,
+            task: actionLedgerProjection.tasks[taskId] || null,
+            compiledWorkUnits: actionLedgerProjection.compiledWorkUnits,
+            correctionRequired: actionLedgerProjection.correctionRequired,
+            latestQa: actionLedgerProjection.latestQa,
+            latestLearningDelta: actionLedgerProjection.latestLearningDelta,
+            latestAtlas: actionLedgerProjection.latestAtlas,
+            sentinelFindingCount: actionLedgerProjection.sentinelFindings.length,
+        },
+        partialCloseoutDrift: detectPartialCloseoutDrift(state),
+        runtime: health,
+    }, null, 2));
+}
+async function qaTask(args) {
+    const { flags, rest } = parseFlags(args);
+    const taskId = sanitizeTaskId(rest[0] || flagString(flags, 'id') || latestTaskId());
+    const file = flagString(flags, 'file');
+    const text = file ? readFileSync(path.resolve(file), 'utf8') : rest.slice(1).join(' ');
+    if (!text.trim())
+        throw new Error('aria task qa requires --file <path> or inline text after task id');
+    const gaps = methodGaps(text);
+    const state = loadTask(taskId);
+    const checkpoint = {
+        at: nowIso(),
+        phase: 'qa',
+        summary: gaps.length ? 'QA failed method contract' : 'QA passed method contract',
+        gaps,
+        artifactSha256: sha256(text),
+    };
+    const current = activePhase(state);
+    const qaLearningLoop = buildQaLearningLoop(state, current, {
+        ok: gaps.length === 0,
+        gaps,
+        artifactSha256: sha256(text),
+    }, 'qa', file ? path.resolve(file) : undefined);
+    const phases = current
+        ? state.phases.map((phase) => phase.phaseId === current.phaseId
+            ? { ...phase, status: gaps.length ? 'qa_failed' : phase.status, qa: { at: String(checkpoint.at), ok: gaps.length === 0, gaps, artifactSha256: sha256(text) } }
+            : phase)
+        : state.phases;
+    let next = saveTask({
+        ...state,
+        phases,
+        checkpoints: [...state.checkpoints, checkpoint],
+        qualityLoops: [...(state.qualityLoops || []), qaLearningLoop].slice(-50),
+        status: gaps.length ? 'blocked' : state.status,
+    }, { type: 'qa', checkpoint, qaLearningLoop });
+    next = await consumeTaskPhaseBoundary(next, 'qa', activePhase(next), {
+        step: 'task-qa',
+        summary: checkpoint.summary,
+        evidence: file ? path.resolve(file) : 'inline qa artifact',
+        qa: { ok: gaps.length === 0, gaps, artifactSha256: sha256(text) },
+        gaps,
+        action: gaps.length ? 'correct-qa-findings' : 'continue',
+    });
+    await publishQaLearningContext(next, qaLearningLoop);
+    await recordRuntimeLedger(next, 'qa', checkpoint, { gaps, qaLearningLoop });
+    console.log(JSON.stringify({ ok: gaps.length === 0, taskId, gaps, qaLearningLoop }, null, 2));
+    if (gaps.length)
+        process.exit(1);
+}
+export async function handleTaskCommand(args, cwd = process.cwd()) {
+    const subCommand = args[0] || 'help';
+    const rest = args.slice(1);
+    if (subCommand === 'help' || subCommand === '--help' || subCommand === '-h') {
+        console.log([
+            '',
+            '  aria task start --goal "..."       Create a ledger-backed CLI-executed task and print reinjection context.',
+            '  aria task continue [taskId]       Re-fire skills and print the reinjection packet for the active task.',
+            '  aria task enqueue [taskId]        Add a phase with --phase "...".',
+            '  aria task next [taskId]           Claim/resume the next phase for this LLM/CLI session.',
+            '  aria task run [taskId]            Parent CLI ledger/QA loop only; add --executor codex for real Codex execution.',
+            '  aria task run --executor codex    Launch wrapped Codex exec with the runtime-built skill packet for the active phase.',
+            '  aria task run --executor spark    Prepare/dispatch a bounded cheap-worker packet, then ingest through Aria QA gates.',
+            '  aria task complete [taskId]       Complete active phase; requires --summary and --evidence; forced QA court autofires when --qa-file is absent.',
+            '  aria task close [taskId]          Finalize task after all phases pass QA, runtime skill floors, and closeout-drift gates.',
+            '  aria task recover [taskId]        Reopen blocked phase with --reason and re-fire skills.',
+            '  aria task checkpoint [taskId]     Append a task checkpoint and runtime ledger event.',
+            '  aria task worker-packet [taskId]  Write a bounded cheap-worker packet with --executor, --allowed-files, and --verify.',
+            '  aria task worker-ingest [taskId]  Ingest worker JSON, enforce scope/verification, and keep completion authority in Aria/Codex.',
+            '  aria task qa [taskId] --file x.md Check full Qiyas-15 and full Tadabbur artifacts.',
+            '  aria task status [taskId]         Show task state plus runtime health.',
+            '',
+            '  Start phases with --phases "scope|execute|qa|harden|verify".',
+            '  Task runner accepts --executor codex|spark, --allowed-files, --forbidden-files, --verify, --dispatch-command, --dry-run, --qa-file, --fix-qa-file, --max-recoveries, --auto-qa, and --all.',
+            '',
+            '  This is a CLI/LLM executor harness. Worker dispatch is explicit, packet-scoped, and re-ingested through QA.',
+            '',
+        ].join('\n'));
+        return;
+    }
+    if (subCommand === 'start')
+        return startTask(rest, cwd);
+    if (subCommand === 'continue')
+        return continueTask(rest);
+    if (subCommand === 'enqueue')
+        return enqueueTask(rest);
+    if (subCommand === 'next')
+        return nextTask(rest);
+    if (subCommand === 'run')
+        return runTask(rest);
+    if (subCommand === 'complete')
+        return completeTask(rest);
+    if (subCommand === 'close' || subCommand === 'finalize')
+        return closeTask(rest);
+    if (subCommand === 'recover')
+        return recoverTask(rest);
+    if (subCommand === 'checkpoint')
+        return checkpointTask(rest);
+    if (subCommand === 'worker-packet')
+        return workerPacketTask(rest);
+    if (subCommand === 'worker-ingest')
+        return workerIngestTask(rest);
+    if (subCommand === 'status')
+        return statusTask(rest);
+    if (subCommand === 'qa')
+        return qaTask(rest);
+    throw new Error(`Unknown aria task subcommand: ${subCommand}`);
+}
+//# sourceMappingURL=task-runner.js.map