@fitlab-ai/agent-infra 0.9.6 → 0.9.8

package/dist/lib/server/process-state.js

@@ -11,7 +11,10 @@ export function parseLinuxProcessStat(raw) {
     if (typeof state !== 'string' || state.length !== 1 || !/^\d+$/.test(startTime ?? '')) {
         return null;
     }
-    return { state, startTime: startTime };
+    const numericStartTime = Number(startTime);
+    if (!Number.isSafeInteger(numericStartTime))
+        return null;
+    return { state, startTime: numericStartTime };
 }
 export function buildProcessStartTimeQuery(pid, platform) {
     if (platform === 'darwin') {
@@ -47,6 +50,17 @@ export function isProcessAlive(pid, platform = process.platform) {
         return error.code === 'EPERM';
     }
 }
+function parseDarwinStartTime(output) {
+    const match = output.trim().match(/^(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat) ([A-Z][a-z]{2}) (\d{1,2}) (\d{2}):(\d{2}):(\d{2}) (\d{4})$/);
+    if (!match)
+        return null;
+    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    const month = months.indexOf(match[1]);
+    if (month < 0)
+        return null;
+    const timestamp = Date.UTC(Number(match[6]), month, Number(match[2]), Number(match[3]), Number(match[4]), Number(match[5]));
+    return Number.isNaN(timestamp) ? null : timestamp;
+}
 export function getProcessStartTime(pid, platform = process.platform) {
     if (!Number.isInteger(pid) || pid <= 0)
         return null;
@@ -65,43 +79,114 @@ export function getProcessStartTime(pid, platform = process.platform) {
     if (query === null)
         return null;
     try {
-        const output = execFileSync(query.command, query.args, { encoding: 'utf8' }).trim();
+        const output = execFileSync(query.command, query.args, {
+            encoding: 'utf8',
+            env: platform === 'darwin' ? { ...process.env, LC_ALL: 'C', LANG: 'C', TZ: 'UTC' } : process.env
+        }).trim();
         if (output.length === 0)
             return null;
         if (platform === 'win32') {
             const timestamp = new Date(output);
-            return Number.isNaN(timestamp.getTime()) ? null : timestamp.toISOString();
+            return Number.isNaN(timestamp.getTime()) ? null : timestamp.getTime();
         }
-        return output;
+        if (platform === 'darwin')
+            return parseDarwinStartTime(output);
+        return null;
     }
     catch {
         return null;
     }
 }
+export function getProcessIdentityState(identity, platform = process.platform) {
+    if (!Number.isInteger(identity.pid) || identity.pid <= 0 || !Number.isSafeInteger(identity.startTime)) {
+        return 'dead';
+    }
+    if (platform === 'linux') {
+        try {
+            const stat = parseLinuxProcessStat(fs.readFileSync(`/proc/${identity.pid}/stat`, 'utf8'));
+            if (stat === null)
+                return 'unknown';
+            if (stat.state === 'Z')
+                return 'dead';
+            return stat.startTime === identity.startTime ? 'alive' : 'dead';
+        }
+        catch (error) {
+            return error.code === 'ENOENT' ? 'dead' : 'unknown';
+        }
+    }
+    try {
+        process.kill(identity.pid, 0);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ESRCH')
+            return 'dead';
+        if (code !== 'EPERM')
+            return 'unknown';
+    }
+    const query = buildProcessStartTimeQuery(identity.pid, platform);
+    if (query === null)
+        return 'unknown';
+    try {
+        const output = execFileSync(query.command, query.args, {
+            encoding: 'utf8',
+            env: platform === 'darwin' ? { ...process.env, LC_ALL: 'C', LANG: 'C', TZ: 'UTC' } : process.env
+        }).trim();
+        if (output.length === 0)
+            return 'unknown';
+        const startTime = platform === 'win32'
+            ? new Date(output).getTime()
+            : platform === 'darwin'
+                ? parseDarwinStartTime(output)
+                : null;
+        if (startTime === null || Number.isNaN(startTime))
+            return 'unknown';
+        return startTime === identity.startTime ? 'alive' : 'dead';
+    }
+    catch {
+        return 'unknown';
+    }
+}
 function parsePidRecord(raw) {
     const trimmed = raw.trim();
     if (/^[1-9]\d*$/.test(trimmed)) {
         const pid = Number(trimmed);
-        return Number.isSafeInteger(pid) ? { kind: 'legacy', pid } : { kind: 'invalid' };
+        return Number.isSafeInteger(pid)
+            ? { kind: 'legacy-pid-only', legacy: { pid, raw, format: 'pid-only' } }
+            : { kind: 'legacy-unknown', legacy: { raw, format: 'malformed' }, reason: 'pid is not a safe integer' };
     }
     try {
         const value = JSON.parse(trimmed);
+        const pidValue = value?.pid;
+        const startTimeValue = value?.startTime;
         if (value !== null &&
-            value.version === 1 &&
-            Number.isSafeInteger(value.pid) &&
-            (value.pid ?? 0) > 0 &&
-            typeof value.startTime === 'string' &&
-            value.startTime.length > 0) {
+            value.version === 2 &&
+            typeof pidValue === 'number' &&
+            Number.isSafeInteger(pidValue) &&
+            pidValue > 0 &&
+            typeof startTimeValue === 'number' &&
+            Number.isSafeInteger(startTimeValue) &&
+            startTimeValue >= 0) {
+            const startTime = startTimeValue;
             return {
                 kind: 'record',
-                record: { version: 1, pid: value.pid, startTime: value.startTime }
+                record: { version: 2, pid: pidValue, startTime }
             };
         }
+        if (value !== null &&
+            value.version === 1 &&
+            typeof pidValue === 'number' &&
+            Number.isSafeInteger(pidValue) &&
+            pidValue > 0 &&
+            typeof value.startTime === 'string' &&
+            value.startTime.length > 0) {
+            return { kind: 'legacy-json', legacy: { pid: pidValue, raw, format: 'json-v1' } };
+        }
+        return { kind: 'legacy-unknown', legacy: { raw, format: 'malformed' }, reason: 'unsupported PID record schema' };
     }
     catch {
-        // Invalid JSON is an invalid PID record.
+        return { kind: 'legacy-unknown', legacy: { raw, format: 'malformed' }, reason: 'invalid PID record JSON' };
     }
-    return { kind: 'invalid' };
 }
 export function readProcessState(pidFile) {
     let snapshot;
@@ -111,13 +196,15 @@ export function readProcessState(pidFile) {
     catch (error) {
         if (error.code === 'ENOENT')
             return { kind: 'missing', snapshot: null };
-        return { kind: 'invalid', snapshot: '' };
+        return { kind: 'legacy-unknown', snapshot: '', legacy: { raw: '', format: 'malformed' }, reason: 'PID record cannot be read' };
     }
     const parsed = parsePidRecord(snapshot);
-    if (parsed.kind === 'invalid')
-        return { kind: 'invalid', snapshot };
-    if (parsed.kind === 'legacy')
-        return { kind: 'legacy', snapshot, pid: parsed.pid };
+    if (parsed.kind === 'legacy-json')
+        return { kind: parsed.kind, snapshot, legacy: parsed.legacy };
+    if (parsed.kind === 'legacy-pid-only')
+        return { kind: parsed.kind, snapshot, legacy: parsed.legacy };
+    if (parsed.kind === 'legacy-unknown')
+        return { kind: parsed.kind, snapshot, legacy: parsed.legacy, reason: parsed.reason };
     const currentStartTime = getProcessStartTime(parsed.record.pid);
     if (currentStartTime === null || currentStartTime !== parsed.record.startTime) {
         return { kind: 'stale', snapshot, record: parsed.record };
@@ -162,7 +249,7 @@ export function removePidRecordIfMatches(pidFile, expected) {
         return false;
     return removePidFileIfMatches(pidFile, state.snapshot);
 }
-export function processIdentityMatches(record) {
-    return getProcessStartTime(record.pid) === record.startTime;
+export function processIdentityMatches(identity) {
+    return getProcessIdentityState(identity) === 'alive';
 }
 //# sourceMappingURL=process-state.js.map

package/dist/lib/task/activity-intent.js

@@ -5,6 +5,7 @@ import { locateActivityLog, appendActivityEntry } from './activity-log.js';
 import { assertWritableInventory, buildArtifactLinkSection, inspectTaskArtifacts, parseArtifactName } from './artifact-lifecycle.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
+import { allowsManualOverride } from './guard-override.js';
 const HEAD_RE = /^[0-9a-f]{40}$/;
 const REVIEW_ACTION_RE = /^Review PR \(Round ([1-9]\d*)\)( \[started\])?$/;
 const VERDICTS = new Set(['approved', 'changes-requested', 'commented']);
@@ -292,9 +293,11 @@ export function applyPrReviewActivityIntent(intent, options = {}) {
     const resolved = resolveTaskRef(intent.taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(intent, resolved.code, resolved.message, resolved.taskId);
-    if (resolved.state !== 'active') {
+    if (resolved.state !== 'active' && !allowsManualOverride(options.manualOverride, 'activity-intent', 'TASK_STATE_MISMATCH')) {
         return failed(intent, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
     }
+    if (options.lockAlreadyHeld)
+        return applyLocked(intent, validated.agent, { ...options, repoRoot: resolved.repoRoot });
     try {
         return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-activity:${intent.kind}`, () => applyLocked(intent, validated.agent, { ...options, repoRoot: resolved.repoRoot }), options.lockOptions);
     }

package/dist/lib/task/artifact-lifecycle.js

@@ -5,6 +5,7 @@ import { locateActivityLog } from './activity-log.js';
 import { parseImplementationInputs, selectPendingImplementationInput } from './implementation-inputs.js';
 import { parseVerdict } from './review-artifacts.js';
 import { extractSection, findSectionHeading } from './sections.js';
+import { receiptForOutput, sha256File } from './artifact-receipts.js';
 const artifactFamilyCatalog = [
     { family: 'analysis', sectionAliases: ['分析', 'Analysis'], heading: '分析', labels: ['需求分析报告', 'Requirements Analysis'] },
     { family: 'review-analysis', sectionAliases: ['审查反馈', 'Review Feedback'], heading: '审查反馈', labels: ['需求分析审查', 'Analysis Review'] },
@@ -151,11 +152,7 @@ function resolveReviewedInput(taskDir, review, expectedFamily, diagnostics) {
         diagnostics.push(diagnostic('BROKEN_REFERENCE', review.family, review.name, String(error)));
         return null;
     }
-    const lines = content.split(/\r?\n/);
-    const header = lines.findIndex((line) => /\*\*(?:审查输入|Review Input)\*\*[:：]/.test(line));
-    const referenceBlock = header >= 0 ? lines.slice(header, header + 12).join('\n') : '';
-    const candidates = [...referenceBlock.matchAll(/`([^`]+\.md)`/g)].map((match) => match[1]);
-    const parsed = candidates.map((name) => parseArtifactName(name)).find((item) => item?.family === expectedFamily);
+    const parsed = parseReviewedInputReference(content, expectedFamily);
     if (!parsed) {
         diagnostics.push(diagnostic('BROKEN_REFERENCE', review.family, review.name, `${review.name} does not reference a canonical ${expectedFamily} artifact`));
         return null;
@@ -165,9 +162,17 @@ function resolveReviewedInput(taskDir, review, expectedFamily, diagnostics) {
         const stat = fs.lstatSync(abs);
         if (!stat.isFile() || stat.isSymbolicLink())
             throw new Error('referenced input is not a regular file');
-        if (stat.mtimeMs > review.mtimeMs) {
-            diagnostics.push(diagnostic('BROKEN_REFERENCE', review.family, review.name, `${parsed.name} is newer than ${review.name}`));
-            return null;
+        const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+        const receipt = receiptForOutput(taskContent, review.name);
+        if (!receipt)
+            throw new Error(`receipt for ${review.name} is missing`);
+        const expectedEvent = reviewEventName(review.family);
+        if (receipt.event !== expectedEvent || receipt.input !== parsed.name) {
+            throw new Error(`receipt for ${review.name} does not match ${parsed.name}`);
+        }
+        const actualSha256 = sha256File(abs);
+        if (actualSha256 !== receipt.inputSha256) {
+            throw new Error(`${parsed.name} content digest does not match receipt`);
         }
         return { ...parsed, path: abs, size: stat.size, mtimeMs: stat.mtimeMs };
     }
@@ -176,6 +181,64 @@ function resolveReviewedInput(taskDir, review, expectedFamily, diagnostics) {
         return null;
     }
 }
+function parseReviewedInputReference(content, expectedFamily) {
+    const lines = content.split(/\r?\n/);
+    const header = lines.findIndex((line) => /\*\*(?:审查输入|Review Input)\*\*[:：]/.test(line));
+    const referenceBlock = header >= 0 ? lines.slice(header, header + 12).join('\n') : '';
+    const candidates = [...referenceBlock.matchAll(/`([^`]+\.md)`/g)].map((match) => match[1]);
+    return candidates
+        .map((name) => parseArtifactName(name))
+        .find((item) => item?.family === expectedFamily) ?? null;
+}
+function parseCodePlanInputReference(content) {
+    const lines = content.split(/\r?\n/);
+    const sectionStart = lines.findIndex((line) => /^##\s+(?:实现输入|Implementation Input)\s*$/.test(line.trim()));
+    if (sectionStart < 0)
+        return null;
+    const bodyLines = lines.slice(sectionStart + 1);
+    const nextSection = bodyLines.findIndex((line) => /^##\s+/.test(line.trim()));
+    const body = (nextSection < 0 ? bodyLines : bodyLines.slice(0, nextSection)).join('\n');
+    const match = body.match(/\*\*(?:方案输入|Plan Input)\*\*[:：]\s*`([^`]+\.md)`/);
+    if (!match)
+        return null;
+    const parsed = parseArtifactName(match[1]);
+    return parsed?.family === 'plan' ? { ...parsed, family: 'plan' } : null;
+}
+function reviewEventName(family) {
+    if (family === 'review-analysis')
+        return 'review-analysis.completed';
+    if (family === 'review-plan')
+        return 'review-plan.completed';
+    if (family === 'review-code')
+        return 'review-code.completed';
+    throw new Error(`unsupported review family '${family}'`);
+}
+function resolveCodeInputReceipt(taskDir, code) {
+    let taskContent;
+    try {
+        taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let receipt;
+    try {
+        receipt = receiptForOutput(taskContent, code.name);
+    }
+    catch {
+        return null;
+    }
+    if (!receipt || receipt.event !== 'code.completed')
+        return null;
+    const plan = inspectArtifactDirectory(taskDir, 'plan');
+    if (plan.status !== 'ready')
+        return null;
+    const input = plan.artifacts.find((artifact) => artifact.name === receipt.input);
+    return input ? { input, inputSha256: receipt.inputSha256 } : null;
+}
+function resolveCodePlanInput(taskDir, code) {
+    return resolveCodeInputReceipt(taskDir, code);
+}
 function assertWritableInventory(inventory) {
     if (inventory.status === 'failed')
         return inventory.error;
@@ -248,10 +311,18 @@ function resolveCodeContext(inventory, options) {
         }
         return withCodeMode(inventory, inputs, 'ready', 'init', codeMax, reviewMax, null, null, 'No prior code artifact. Starting initial implementation (round 1 -> code.md).');
     }
+    const codePlanInput = resolveCodePlanInput(inventory.taskDir, latestCode);
+    if (!codePlanInput) {
+        return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', `code completion receipt for ${latestCode.name} is missing or does not match the current plan`, latestCode.name);
+    }
+    if (reviewPlan.latest && !reviewPlan.reviewedInput) {
+        return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', `${reviewPlan.latest.name} has no valid reviewed input`, reviewPlan.latest.name);
+    }
     if (reviewPlan.latest && reviewPlan.reviewedInput?.name === plan.latest.name) {
         const verdict = parseVerdict(reviewPlan.latest.path);
-        if (verdict.ok && verdict.verdict === 'Approved' && reviewPlan.latest.mtimeMs > latestCode.mtimeMs) {
-            return withCodeMode(inventory, inputs, 'ready', 'init', codeMax, reviewMax, verdict.verdict, reviewPlan.latest.name, `Latest ${reviewPlan.latest.name} is approved and newer than the latest code artifact. Entering replan-driven init.`);
+        const reviewedPlanSha256 = sha256File(reviewPlan.reviewedInput.path);
+        if (verdict.ok && verdict.verdict === 'Approved' && (codePlanInput.input.name !== plan.latest.name || codePlanInput.inputSha256 !== reviewedPlanSha256)) {
+            return withCodeMode(inventory, inputs, 'ready', 'init', codeMax, reviewMax, verdict.verdict, reviewPlan.latest.name, `Latest ${reviewPlan.latest.name} approves plan content not captured by the latest code input receipt. Entering replan-driven init.`);
         }
     }
     if (reviewMax < codeMax) {
@@ -377,5 +448,5 @@ function buildArtifactLinkSection(content, artifact) {
     body = lines.join('\n').replace(/^\n+|\n+$/g, '');
     return { aliases, heading, body };
 }
-export { artifactFamilyCatalog, artifactName, parseArtifactName, familySpec, inspectTaskArtifacts, inspectArtifactDirectory, resolveArtifactContext, assertWritableInventory, validateCompletedArtifact, buildArtifactLinkSection };
+export { artifactFamilyCatalog, artifactName, parseArtifactName, familySpec, inspectTaskArtifacts, inspectArtifactDirectory, resolveArtifactContext, parseReviewedInputReference, parseCodePlanInputReference, resolveCodePlanInput, reviewEventName, assertWritableInventory, validateCompletedArtifact, buildArtifactLinkSection };
 //# sourceMappingURL=artifact-lifecycle.js.map

package/dist/lib/task/artifact-receipts.js

@@ -0,0 +1,128 @@
+import fs from 'node:fs';
+import { createHash } from 'node:crypto';
+import { extractSection, findSectionHeading, parseTable } from './sections.js';
+const RECEIPT_SECTION_ALIASES = ['产物生命周期收据', 'Artifact Lifecycle Receipts'];
+const RECEIPT_COLUMNS = ['event', 'output', 'input', 'input_sha256', 'completed_at'];
+const RECEIPT_EVENTS = new Set([
+    'review-analysis.completed',
+    'review-plan.completed',
+    'review-code.completed',
+    'code.completed'
+]);
+const SHA256_RE = /^[a-f0-9]{64}$/;
+const ARTIFACT_NAME_RE = /^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation|validation-run|pr-review)(?:-r([2-9]|[1-9]\d+))?\.md$/;
+const RECEIPT_SHAPES = {
+    'review-analysis.completed': { output: 'review-analysis', input: 'analysis' },
+    'review-plan.completed': { output: 'review-plan', input: 'plan' },
+    'review-code.completed': { output: 'review-code', input: 'code' },
+    'code.completed': { output: 'code', input: 'plan' }
+};
+class ArtifactReceiptError extends Error {
+    code = 'ARTIFACT_RECEIPT_INVALID';
+    constructor(message) {
+        super(message);
+        this.name = 'ArtifactReceiptError';
+    }
+}
+function sha256Bytes(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function sha256File(filePath) {
+    return sha256Bytes(fs.readFileSync(filePath));
+}
+function parseReceiptArtifactName(name) {
+    const match = ARTIFACT_NAME_RE.exec(name);
+    if (!match)
+        return null;
+    const roundText = match[2];
+    if (roundText !== undefined) {
+        const round = Number(roundText);
+        if (!Number.isSafeInteger(round) || String(round) !== roundText)
+            return null;
+    }
+    return { family: match[1] };
+}
+function validateReceiptShape(event, output, input) {
+    const outputIdentity = parseReceiptArtifactName(output);
+    const inputIdentity = parseReceiptArtifactName(input);
+    if (!outputIdentity || !inputIdentity)
+        throw new ArtifactReceiptError(`receipt artifact identity is invalid: ${output} -> ${input}`);
+    const shape = RECEIPT_SHAPES[event];
+    if (outputIdentity.family !== shape.output || inputIdentity.family !== shape.input) {
+        throw new ArtifactReceiptError(`receipt event '${event}' does not match ${output} -> ${input}`);
+    }
+}
+function parseArtifactReceipts(content) {
+    const section = extractSection(content, [...RECEIPT_SECTION_ALIASES]);
+    if (!section)
+        return { present: false, rows: [] };
+    let table;
+    try {
+        table = parseTable(content, {
+            sectionAliases: [...RECEIPT_SECTION_ALIASES],
+            columns: [...RECEIPT_COLUMNS],
+            keyColumn: 'output'
+        });
+    }
+    catch (error) {
+        throw new ArtifactReceiptError(error instanceof Error ? error.message : String(error));
+    }
+    if (!table)
+        throw new ArtifactReceiptError('receipt section has no receipt table');
+    const rows = table.rows.map((row) => {
+        const event = row.values.event ?? '';
+        const output = row.values.output ?? '';
+        const input = row.values.input ?? '';
+        const inputSha256 = row.values.input_sha256 ?? '';
+        const completedAt = row.values.completed_at ?? '';
+        if (!RECEIPT_EVENTS.has(event))
+            throw new ArtifactReceiptError(`unknown receipt event '${event}'`);
+        if (!output || !input)
+            throw new ArtifactReceiptError('receipt output and input are required');
+        validateReceiptShape(event, output, input);
+        if (!SHA256_RE.test(inputSha256))
+            throw new ArtifactReceiptError(`receipt digest for '${output}' is invalid`);
+        if (!completedAt || Number.isNaN(Date.parse(completedAt.replace(' ', 'T')))) {
+            throw new ArtifactReceiptError(`receipt completion time for '${output}' is invalid`);
+        }
+        return {
+            event: event,
+            output,
+            input,
+            inputSha256,
+            completedAt
+        };
+    });
+    return { present: true, rows };
+}
+function receiptForOutput(content, output) {
+    const parsed = parseArtifactReceipts(content);
+    return parsed.rows.find((row) => row.output === output) ?? null;
+}
+function upsertArtifactReceipt(content, receipt) {
+    if (!RECEIPT_EVENTS.has(receipt.event))
+        throw new ArtifactReceiptError(`unknown receipt event '${receipt.event}'`);
+    if (!receipt.output || !receipt.input)
+        throw new ArtifactReceiptError('receipt output and input are required');
+    validateReceiptShape(receipt.event, receipt.output, receipt.input);
+    if (!SHA256_RE.test(receipt.inputSha256))
+        throw new ArtifactReceiptError(`receipt digest for '${receipt.output}' is invalid`);
+    if (!receipt.completedAt || Number.isNaN(Date.parse(receipt.completedAt.replace(' ', 'T')))) {
+        throw new ArtifactReceiptError(`receipt completion time for '${receipt.output}' is invalid`);
+    }
+    const existing = parseArtifactReceipts(content).rows;
+    const previous = existing.find((row) => row.output === receipt.output);
+    if (previous && JSON.stringify(previous) !== JSON.stringify(receipt)) {
+        throw new ArtifactReceiptError(`receipt for '${receipt.output}' already exists with different evidence`);
+    }
+    const rows = previous ? existing : [...existing, receipt];
+    const heading = findSectionHeading(content, [...RECEIPT_SECTION_ALIASES]);
+    const body = [
+        `| ${RECEIPT_COLUMNS.join(' | ')} |`,
+        `| ${RECEIPT_COLUMNS.map(() => '---').join(' | ')} |`,
+        ...rows.map((row) => `| ${row.event} | ${row.output} | ${row.input} | ${row.inputSha256} | ${row.completedAt} |`)
+    ].join('\n');
+    return { aliases: [...RECEIPT_SECTION_ALIASES], heading, body };
+}
+export { ArtifactReceiptError, RECEIPT_SECTION_ALIASES, parseArtifactReceipts, receiptForOutput, sha256Bytes, sha256File, upsertArtifactReceipt };
+//# sourceMappingURL=artifact-receipts.js.map

package/dist/lib/task/codex-orchestration.js

@@ -1,6 +1,11 @@
+import fs from 'node:fs';
 import { preflightCodexLifecycleEvidence, resolveCodexSpawnedChild, resolveCodexTerminal, resolveCodexThread } from '../agent-clients/adapters/codex-lifecycle/app-server.js';
 import { createCodexLifecycleStore } from '../agent-clients/adapters/codex-lifecycle/store.js';
-import { activateMatchingOrchestrationDelegation, pauseMatchingOrchestrationDelegation, prepareOrchestrationDelegation, reconcileMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence } from './orchestration.js';
+import { createCodexCapabilityStore } from '../agent-clients/adapters/codex-lifecycle/capability-store.js';
+import { computeLifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.js';
+import { verifyCodexSandboxControllerContext } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.js';
+import { resolveTaskRef } from './resolve-ref.js';
+import { activateMatchingOrchestrationDelegation, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, pauseMatchingOrchestrationDelegation, prepareOrchestrationDelegation, reconcileMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence } from './orchestration.js';
 function coreOptions(options) {
     return { ...options.orchestrationOptions, repoRoot: options.repoRoot ?? options.orchestrationOptions?.repoRoot };
 }
@@ -21,19 +26,61 @@ function requiredStore(options) {
         throw new Error('Codex lifecycle store is required for orchestration bridge events');
     return options.store;
 }
+function controllerContext(taskId, repoRoot) {
+    const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
+    return contextPath
+        ? verifyCodexSandboxControllerContext(contextPath, taskId, { repoRoot })
+        : null;
+}
 async function prepareCodexOrchestrationDelegation(taskRef, input, options = {}) {
     if (input.client !== 'codex')
         return prepareOrchestrationDelegation(taskRef, input, coreOptions(options));
     try {
-        await (options.preflight ?? preflightCodexLifecycleEvidence)(options.repoRoot ?? process.cwd());
+        const repoRoot = options.repoRoot ?? process.cwd();
+        const resolved = resolveTaskRef(taskRef, { repoRoot });
+        if (!resolved.ok)
+            return bridgeFailure(resolved.code, resolved.message);
+        const preflight = await (options.preflight ?? preflightCodexLifecycleEvidence)(repoRoot);
+        if (!input.capabilityToken) {
+            return bridgeFailure('ORCHESTRATION_CODEX_CAPABILITY_REQUIRED', 'Codex prepare requires a current-session capability token');
+        }
+        const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
+        const controller = controllerContext(resolved.taskId, repoRoot);
+        const capabilityStore = options.capabilityStore ?? createCodexCapabilityStore();
+        const consumed = capabilityStore.consume(input.capabilityToken, {
+            taskId: resolved.taskId,
+            hookDefinitionHash: preflight.hookDefinitionHash,
+            buildIdentity,
+            ...(controller ? { controller: {
+                    instanceDigest: controller.controllerInstanceDigest,
+                    controlGeneration: controller.controlGeneration
+                } } : {})
+        });
+        return prepareOrchestrationDelegation(taskRef, {
+            ...input,
+            lifecycleProvenance: {
+                ...consumed.buildIdentity,
+                hookDefinitionHash: preflight.hookDefinitionHash,
+                ...preflight.hookProvenance,
+                capabilitySessionId: consumed.sessionId,
+                capabilityTurnId: consumed.turnId,
+                capabilityToolUseId: consumed.toolUseId,
+                controllerInstanceDigest: controller?.controllerInstanceDigest ?? null,
+                controlGeneration: controller?.controlGeneration ?? null
+            }
+        }, coreOptions(options));
     }
     catch (error) {
-        return bridgeFailure('ORCHESTRATION_CLIENT_PREFLIGHT_FAILED', error instanceof Error ? error.message : String(error));
+        return bridgeFailure(error instanceof Error && error.name.startsWith('CODEX_CAPABILITY_')
+            ? error.name
+            : 'ORCHESTRATION_CLIENT_PREFLIGHT_FAILED', error instanceof Error ? error.message : String(error));
     }
-    return prepareOrchestrationDelegation(taskRef, input, coreOptions(options));
 }
 async function activateCodexOrchestrationDelegation(childThreadId, options = {}) {
     try {
+        if (!hasActivatableOrchestrationDelegation('codex', childThreadId, coreOptions(options))) {
+            return bridgeFailure('ORCHESTRATION_DELEGATION_MISSING', 'No matching Codex delegation is active');
+        }
         const store = requiredStore(options);
         const resolved = await (options.resolveThread ?? resolveCodexThread)(childThreadId);
         store.apply(resolved.resolution.thread);
@@ -45,6 +92,23 @@ async function activateCodexOrchestrationDelegation(childThreadId, options = {})
         if (record.state.status !== 'start-ready' || !evidence) {
             return pauseBridge('ORCHESTRATION_CODEX_START_EVIDENCE_INVALID', 'Codex lifecycle start evidence is not ready', options);
         }
+        const repoRoot = options.repoRoot ?? process.cwd();
+        const preflight = await (options.preflight ?? preflightCodexLifecycleEvidence)(repoRoot, {
+            sessionId: evidence.parentThreadId,
+            turnId: evidence.parentTurnId,
+            toolUseId: evidence.spawnToolUseId
+        });
+        const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
+        const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
+        const contextTaskId = contextPath
+            ? JSON.parse(fs.readFileSync(contextPath, 'utf8')).taskId
+            : null;
+        if (contextPath && typeof contextTaskId !== 'string') {
+            throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+        }
+        const controller = contextPath
+            ? verifyCodexSandboxControllerContext(contextPath, contextTaskId, { repoRoot })
+            : null;
         return activateMatchingOrchestrationDelegation('codex', {
             nativeAgent: evidence.nativeAgent,
             childId: evidence.childThreadId,
@@ -57,9 +121,17 @@ async function activateCodexOrchestrationDelegation(childThreadId, options = {})
                 ? { reasoningEffortFallbackReason: evidence.reasoningEffortFallbackReason }
                 : {}),
             hostEvidence: {
-                kind: 'codex-lifecycle-v1',
+                kind: 'codex-lifecycle-v2',
                 hookDefinitionHash: evidence.hookDefinitionHash,
-                startRevision: record.revision
+                startRevision: record.revision,
+                ...buildIdentity,
+                ...preflight.hookProvenance,
+                capabilitySessionId: evidence.parentThreadId,
+                capabilityTurnId: evidence.parentTurnId,
+                spawnToolUseId: evidence.spawnToolUseId,
+                spawnObservedAt: record.spawnObservedAt ?? undefined,
+                controllerInstanceDigest: controller?.controllerInstanceDigest ?? null,
+                controlGeneration: controller?.controlGeneration ?? null
             }
         }, coreOptions(options));
     }
@@ -93,6 +165,9 @@ async function activateCodexSpawnDelegation(spawn, options = {}) {
 }
 async function sealCodexOrchestrationDelegation(childThreadId, options = {}) {
     try {
+        if (!hasSealableOrchestrationDelegation('codex', childThreadId, coreOptions(options))) {
+            return bridgeFailure('ORCHESTRATION_DELEGATION_MISSING', 'No matching Codex delegation is active');
+        }
         const store = requiredStore(options);
         const existing = store.read(childThreadId);
         if (!existing.consumer) {

package/dist/lib/task/commands/validate.js

@@ -168,7 +168,7 @@ function inplaceValidation(config, target, options) {
     const nonce = randomUUID();
     const issuedAt = Date.now();
     const lease = {
-        version: 1, generation: manifest.generation, nonce,
+        version: 2, generation: manifest.generation, nonce,
         owner: { pid: process.pid, startTime }, issuedAt,
         expiresAt: issuedAt + Math.min(options.timeoutMs + RECOVERY_GRACE_MS, MAX_TIMEOUT_MS + RECOVERY_GRACE_MS),
         taskId: target.workspace.mode === 'task-bound' ? target.workspace.taskId : null,

package/dist/lib/task/create.js

@@ -181,6 +181,13 @@ function assertRealDirectory(directory, code) {
     if (!stat.isDirectory() || stat.isSymbolicLink())
         throw new Error(code);
 }
+function ensureRealDirectory(directory, code) {
+    if (fs.existsSync(directory)) {
+        assertRealDirectory(directory, code);
+        return;
+    }
+    fs.mkdirSync(directory, { mode: 0o700 });
+}
 function withCreateLock(repoRoot, workspaceRoot, operation) {
     const lockRoot = path.join(workspaceRoot, '.task-create.lock');
     fs.mkdirSync(lockRoot, { recursive: true, mode: 0o700 });
@@ -254,8 +261,9 @@ function createLocalTask(value, options) {
     const repoRoot = fs.realpathSync.native(options.repoRoot);
     const workspaceRoot = path.join(repoRoot, '.agents', 'workspace');
     const activeRoot = path.join(workspaceRoot, 'active');
-    assertRealDirectory(workspaceRoot, 'TASK_CREATE_WORKSPACE_INVALID');
-    assertRealDirectory(activeRoot, 'TASK_CREATE_WORKSPACE_INVALID');
+    ensureRealDirectory(path.join(repoRoot, '.agents'), 'TASK_CREATE_WORKSPACE_INVALID');
+    ensureRealDirectory(workspaceRoot, 'TASK_CREATE_WORKSPACE_INVALID');
+    ensureRealDirectory(activeRoot, 'TASK_CREATE_WORKSPACE_INVALID');
     const project = readProject(repoRoot);
     const canonical = canonicalTaskCreateCandidate(candidate);
     const candidateDigest = sha256(canonical);