@fitlab-ai/agent-infra 0.9.12 → 0.9.13

package/dist/lib/task/pr-delivery-fact.js

@@ -1,182 +1,183 @@
+import { isLegacyCompatibilityEnabled, legacyCompatibilityError, VERSION } from '../version.js';
+import { isResourceIdentity, parseResourceIdentity, resourceIdentityNumber, serializeResourceIdentity } from '../platform/resource-identity.js';
 const PR_DELIVERY_FACT_KEY = 'pr_delivery_fact';
 function factError(message) {
     return Object.assign(new Error(`PR_DELIVERY_FACT_INVALID: ${message}`), { code: 'PR_DELIVERY_FACT_INVALID' });
 }
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+function asFactError(error) {
+    if (error instanceof Error && typeof error.code === 'string')
+        return error;
+    return factError(error instanceof Error ? error.message : String(error));
 }
+function isRecord(value) { return Boolean(value) && typeof value === 'object' && !Array.isArray(value); }
 function exactKeys(value, keys, label) {
     const actual = Object.keys(value).sort();
     const expected = [...keys].sort();
-    if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
+    if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index]))
         throw factError(`${label} has an invalid field set`);
-    }
 }
-function text(value, label) {
-    if (typeof value !== 'string' || !value || value.trim() !== value)
-        throw factError(`${label} must be a non-empty string`);
+function text(value, label, allowEmpty = false) {
+    if (typeof value !== 'string' || (!allowEmpty && !value) || value.trim() !== value)
+        throw factError(`${label} must be a string`);
     return value;
 }
-function nullableText(value, label) {
-    return value === null ? null : text(value, label);
+function nullableText(value, label) { return value === null ? null : text(value, label); }
+function timestamp(value, label) {
+    const result = text(value, label);
+    if (Number.isNaN(Date.parse(result)))
+        throw factError(`${label} must be a valid timestamp`);
+    return new Date(result).toISOString();
 }
 function positiveNumber(value, label) {
     if (!Number.isSafeInteger(value) || value <= 0)
         throw factError(`${label} must be a positive integer`);
     return value;
 }
-function optionalTimestamp(value, label) {
-    const result = nullableText(value, label);
-    if (result !== null && Number.isNaN(Date.parse(result)))
-        throw factError(`${label} must be a valid timestamp`);
-    return result;
+function parseRef(value, label) {
+    if (!isRecord(value))
+        throw factError(`${label} must be an object`);
+    exactKeys(value, ['repository', 'ref', 'sha'], label);
+    return { repository: text(value.repository, `${label}.repository`), ref: text(value.ref, `${label}.ref`), sha: text(value.sha, `${label}.sha`) };
 }
-function parseIdentity(value) {
+function canonicalIdentity(value) {
     if (!isRecord(value))
         throw factError('identity must be an object');
-    exactKeys(value, ['repository', 'number', 'nodeId', 'url', 'head', 'base'], 'identity');
-    const head = parseRef(value.head, 'head');
-    const base = parseRef(value.base, 'base');
+    exactKeys(value, ['resource', 'repository', 'url', 'head', 'base'], 'identity');
     return {
+        resource: parseResourceIdentity(value.resource, 'identity.resource'),
         repository: text(value.repository, 'identity.repository'),
-        number: positiveNumber(value.number, 'identity.number'),
-        nodeId: text(value.nodeId, 'identity.nodeId'),
         url: text(value.url, 'identity.url'),
-        head,
-        base
+        head: parseRef(value.head, 'identity.head'),
+        base: parseRef(value.base, 'identity.base')
     };
 }
-function parseRef(value, label) {
+function decodeLegacyIdentity(value) {
     if (!isRecord(value))
-        throw factError(`${label} must be an object`);
-    exactKeys(value, ['repository', 'ref', 'sha'], label);
+        throw factError('legacy identity must be an object');
+    // TODO(compat): Remove the v1 identity decoder before the first stable v1.0.0 release.
+    exactKeys(value, ['repository', 'number', 'nodeId', 'url', 'head', 'base'], 'legacy identity');
+    const legacy = {
+        number: positiveNumber(value.number, 'legacy identity.number'),
+        repository: text(value.repository, 'identity.repository'),
+        nodeId: text(value.nodeId, 'legacy identity.nodeId'),
+        url: text(value.url, 'identity.url'),
+        head: parseRef(value.head, 'identity.head'),
+        base: parseRef(value.base, 'identity.base')
+    };
     return {
-        repository: text(value.repository, `${label}.repository`),
-        ref: text(value.ref, `${label}.ref`),
-        sha: text(value.sha, `${label}.sha`)
+        resource: { kind: 'number', value: legacy.number },
+        repository: legacy.repository,
+        url: legacy.url,
+        head: legacy.head,
+        base: legacy.base
     };
 }
-function parseFact(value) {
+function provenanceForSource(source) { return source === 'created' ? 'create-post' : source === 'reused' ? 'reuse' : source; }
+function parseFact(value, runtimeVersion = VERSION) {
     if (!isRecord(value))
         throw factError('fact must be an object');
-    if (value.version !== 1 || typeof value.state !== 'string')
+    if ((value.version !== 1 && value.version !== 2) || typeof value.state !== 'string')
         throw factError('version or state is invalid');
+    if (value.version === 1 && !isLegacyCompatibilityEnabled(runtimeVersion)) {
+        throw legacyCompatibilityError('v1 PR delivery fact', runtimeVersion);
+    }
     if (value.state === 'unbound') {
         exactKeys(value, ['version', 'state', 'reason'], 'unbound fact');
         if (value.reason !== 'initial')
             throw factError('unbound reason is invalid');
-        return { version: 1, state: 'unbound', reason: value.reason };
+        return { version: 2, state: 'unbound', reason: 'initial' };
     }
     if (value.state === 'skipped') {
         exactKeys(value, ['version', 'state', 'reason', 'decidedAt'], 'skipped fact');
         if (value.reason !== 'explicit')
             throw factError('skipped reason is invalid');
-        const decidedAt = text(value.decidedAt, 'skipped.decidedAt');
-        if (Number.isNaN(Date.parse(decidedAt)))
-            throw factError('skipped.decidedAt must be a valid timestamp');
-        return { version: 1, state: 'skipped', reason: 'explicit', decidedAt };
+        return { version: 2, state: 'skipped', reason: 'explicit', decidedAt: timestamp(value.decidedAt, 'skipped.decidedAt') };
     }
     if (value.state !== 'bound')
         throw factError('state is invalid');
+    if (value.version === 1) {
+        // TODO(compat): Remove this v1-to-v2 shape conversion before the first stable v1.0.0 release.
+        exactKeys(value, ['version', 'state', 'identity', 'binding', 'provenance'], 'legacy bound fact');
+        if (!isRecord(value.binding) || !isRecord(value.provenance))
+            throw factError('legacy binding or provenance is invalid');
+        exactKeys(value.binding, ['status', 'source', 'verifiedAt', 'issueNumber', 'remoteState', 'mergedAt', 'mergeCommitSha'], 'legacy binding');
+        const issueNumber = value.binding.issueNumber === null ? null : positiveNumber(value.binding.issueNumber, 'legacy binding.issueNumber');
+        return parseFact({
+            version: 2,
+            state: 'bound',
+            identity: decodeLegacyIdentity(value.identity),
+            binding: {
+                status: 'verified', source: value.binding.source, verifiedAt: timestamp(value.binding.verifiedAt, 'binding.verifiedAt'),
+                issueIdentity: issueNumber === null ? null : { kind: 'number', value: issueNumber }, remoteState: value.binding.remoteState,
+                mergedAt: value.binding.mergedAt === null ? null : timestamp(value.binding.mergedAt, 'binding.mergedAt'), mergeCommitSha: nullableText(value.binding.mergeCommitSha, 'binding.mergeCommitSha')
+            },
+            provenance: value.provenance
+        }, runtimeVersion);
+    }
     exactKeys(value, ['version', 'state', 'identity', 'binding', 'provenance'], 'bound fact');
-    if (!isRecord(value.binding))
-        throw factError('binding must be an object');
-    exactKeys(value.binding, ['status', 'source', 'verifiedAt', 'issueNumber', 'remoteState', 'mergedAt', 'mergeCommitSha'], 'binding');
+    if (!isRecord(value.binding) || !isRecord(value.provenance))
+        throw factError('binding or provenance is invalid');
+    exactKeys(value.binding, ['status', 'source', 'verifiedAt', 'issueIdentity', 'remoteState', 'mergedAt', 'mergeCommitSha'], 'binding');
     if (value.binding.status !== 'verified')
         throw factError('binding status is invalid');
     const sources = ['created', 'reused', 'explicit-bind', 'external-unique', 'external-explicit'];
     if (!sources.includes(value.binding.source))
         throw factError('binding source is invalid');
-    const verifiedAt = text(value.binding.verifiedAt, 'binding.verifiedAt');
-    if (Number.isNaN(Date.parse(verifiedAt)))
-        throw factError('binding.verifiedAt must be a valid timestamp');
-    const issueNumber = value.binding.issueNumber === null ? null : positiveNumber(value.binding.issueNumber, 'binding.issueNumber');
+    const issueIdentity = value.binding.issueIdentity === null ? null : parseResourceIdentity(value.binding.issueIdentity, 'binding.issueIdentity');
     if (value.binding.remoteState !== 'open' && value.binding.remoteState !== 'closed')
         throw factError('binding.remoteState is invalid');
-    const mergedAt = optionalTimestamp(value.binding.mergedAt, 'binding.mergedAt');
+    const mergedAt = value.binding.mergedAt === null ? null : timestamp(value.binding.mergedAt, 'binding.mergedAt');
     const mergeCommitSha = nullableText(value.binding.mergeCommitSha, 'binding.mergeCommitSha');
     if (Boolean(mergedAt) !== Boolean(mergeCommitSha))
         throw factError('mergedAt and mergeCommitSha must be paired');
-    if (!isRecord(value.provenance))
-        throw factError('provenance must be an object');
     exactKeys(value.provenance, ['establishedBy'], 'provenance');
-    const provenance = ['create-post', 'reuse', 'explicit-bind', 'external-unique', 'external-explicit'];
-    if (!provenance.includes(value.provenance.establishedBy))
+    const provenances = ['create-post', 'reuse', 'explicit-bind', 'external-unique', 'external-explicit'];
+    if (!provenances.includes(value.provenance.establishedBy))
         throw factError('provenance.establishedBy is invalid');
-    if (value.provenance.establishedBy !== provenanceForSource(value.binding.source)) {
+    if (value.provenance.establishedBy !== provenanceForSource(value.binding.source))
         throw factError('binding.source and provenance.establishedBy do not match');
-    }
     return {
-        version: 1,
-        state: 'bound',
-        identity: parseIdentity(value.identity),
-        binding: {
-            status: 'verified',
-            source: value.binding.source,
-            verifiedAt,
-            issueNumber,
-            remoteState: value.binding.remoteState,
-            mergedAt,
-            mergeCommitSha
-        },
+        version: 2, state: 'bound', identity: canonicalIdentity(value.identity),
+        binding: { status: 'verified', source: value.binding.source, verifiedAt: timestamp(value.binding.verifiedAt, 'binding.verifiedAt'), issueIdentity, remoteState: value.binding.remoteState, mergedAt, mergeCommitSha },
         provenance: { establishedBy: value.provenance.establishedBy }
     };
 }
-function decodePrDeliveryFact(value) {
+function decodePrDeliveryFact(value, runtimeVersion = VERSION) {
     if (typeof value === 'string') {
+        let decoded;
         try {
-            return parseFact(JSON.parse(value));
+            decoded = JSON.parse(value);
         }
-        catch (error) {
-            throw error instanceof Error && error.message.startsWith('PR_DELIVERY_FACT_INVALID:') ? error : factError('value is not valid JSON');
+        catch {
+            throw factError('value is not valid JSON');
         }
+        return parseFact(decoded, runtimeVersion);
     }
-    return parseFact(value);
+    return parseFact(value, runtimeVersion);
 }
-function encodePrDeliveryFact(fact) {
-    return JSON.stringify(parseFact(fact));
-}
-function readPrDeliveryFact(metadata) {
+function encodePrDeliveryFact(fact) { return JSON.stringify(parseFact(fact)); }
+function readPrDeliveryFact(metadata, runtimeVersion = VERSION) {
     if (!Object.hasOwn(metadata, PR_DELIVERY_FACT_KEY) || metadata[PR_DELIVERY_FACT_KEY] === '')
         return { status: 'missing', fact: null };
     try {
-        return { status: 'valid', fact: decodePrDeliveryFact(metadata[PR_DELIVERY_FACT_KEY]) };
+        return { status: 'valid', fact: decodePrDeliveryFact(metadata[PR_DELIVERY_FACT_KEY], runtimeVersion) };
     }
     catch (error) {
-        return { status: 'invalid', fact: null, error: error instanceof Error ? error : factError(String(error)) };
+        return { status: 'invalid', fact: null, error: asFactError(error) };
     }
 }
-function buildUnboundFact() {
-    return { version: 1, state: 'unbound', reason: 'initial' };
-}
-function buildSkippedFact(decidedAt) {
-    return parseFact({ version: 1, state: 'skipped', reason: 'explicit', decidedAt });
-}
-function provenanceForSource(source) {
-    return source === 'created' ? 'create-post' : source === 'reused' ? 'reuse' : source;
-}
+function buildUnboundFact() { return { version: 2, state: 'unbound', reason: 'initial' }; }
+function buildSkippedFact(decidedAt) { return parseFact({ version: 2, state: 'skipped', reason: 'explicit', decidedAt }); }
 function buildBoundFact(input) {
-    return parseFact({
-        version: 1,
-        state: 'bound',
-        identity: input.identity,
-        binding: {
-            status: 'verified',
-            source: input.source,
-            verifiedAt: input.verifiedAt,
-            issueNumber: input.issueNumber ?? null,
-            remoteState: input.remoteState,
-            mergedAt: input.mergedAt ?? null,
-            mergeCommitSha: input.mergeCommitSha ?? null
-        },
-        provenance: { establishedBy: provenanceForSource(input.source) }
-    });
-}
-function factFrontmatterMutation(fact) {
-    return { set: { [PR_DELIVERY_FACT_KEY]: encodePrDeliveryFact(fact) } };
+    return parseFact({ version: 2, state: 'bound', identity: input.identity, binding: {
+            status: 'verified', source: input.source, verifiedAt: input.verifiedAt,
+            issueIdentity: input.issueIdentity === undefined ? null : input.issueIdentity,
+            remoteState: input.remoteState, mergedAt: input.mergedAt ?? null, mergeCommitSha: input.mergeCommitSha ?? null
+        }, provenance: { establishedBy: provenanceForSource(input.source) } });
 }
+function factFrontmatterMutation(fact) { return { set: { [PR_DELIVERY_FACT_KEY]: encodePrDeliveryFact(fact) } }; }
 function identityFromPullRequest(pullRequest) {
-    return parseIdentity(pullRequest);
+    return canonicalIdentity(pullRequest);
 }
-export { PR_DELIVERY_FACT_KEY, buildBoundFact, buildSkippedFact, buildUnboundFact, decodePrDeliveryFact, encodePrDeliveryFact, factFrontmatterMutation, identityFromPullRequest, readPrDeliveryFact };
+export { PR_DELIVERY_FACT_KEY, buildBoundFact, buildSkippedFact, buildUnboundFact, decodePrDeliveryFact, encodePrDeliveryFact, factFrontmatterMutation, identityFromPullRequest, readPrDeliveryFact, serializeResourceIdentity };
 //# sourceMappingURL=pr-delivery-fact.js.map

package/dist/lib/task/review-fingerprint.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { artifactName, maxRound } from "./review-artifacts.js";
+import { invalidationBlocks, isArtifactInvalidated, parseInvalidationDocument } from "./invalidation.js";
 const REVIEWED_TREE_RE = /^[a-f0-9]{40,64}$/;
 export function parseReviewedGitTree(value) {
     return REVIEWED_TREE_RE.test(value) ? value : null;
@@ -30,14 +31,35 @@ export function findAuthoritativeReviewCodeArtifact(taskDir) {
     const entries = fs.existsSync(taskDir) ? fs.readdirSync(taskDir) : [];
     const round = maxRound(entries, "review-code");
     if (round === 0) {
-        return { ok: false, round: 0, fileName: null, path: null };
+        return { ok: false, round: 0, fileName: null, path: null, error: null };
     }
     const fileName = artifactName("review-code", round);
+    let taskContent;
+    try {
+        taskContent = fs.readFileSync(path.join(taskDir, "task.md"), "utf8");
+    }
+    catch (error) {
+        return {
+            ok: false, round, fileName, path: null,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+    const invalidation = parseInvalidationDocument(taskContent);
+    if (!invalidation.ok) {
+        return { ok: false, round, fileName, path: null, error: invalidation.message };
+    }
+    if (invalidationBlocks(invalidation.document)) {
+        return { ok: false, round, fileName, path: null, error: "artifact invalidation is incomplete; reconcile task.md before using review-code" };
+    }
+    if (isArtifactInvalidated(invalidation.document, "review-code", fileName)) {
+        return { ok: false, round, fileName, path: null, error: `${fileName} is invalidated; re-run review-code` };
+    }
     return {
         ok: true,
         round,
         fileName,
-        path: path.join(taskDir, fileName)
+        path: path.join(taskDir, fileName),
+        error: null
     };
 }
 export function extractReviewBaseline(content) {

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

@@ -0,0 +1,138 @@
+const REWORK_INTENT_HEADINGS = ['返工意图', 'Rework Intent'];
+const REWORK_INTENT_COLUMNS = [
+    'intent_id', 'finding_id', 'source_artifact', 'source_sha256', 'target',
+    'status', 'declared_at', 'consumed_at'
+];
+function cells(line) {
+    const first = line.indexOf('|');
+    const last = line.lastIndexOf('|');
+    if (first < 0 || first === last || line.slice(0, first).trim() || line.slice(last + 1).trim())
+        return null;
+    const inner = line.slice(first + 1, last);
+    const result = [];
+    let start = 0;
+    let escaped = false;
+    for (let index = 0; index < inner.length; index += 1) {
+        const char = inner[index];
+        if (char === '|' && !escaped) {
+            result.push(inner.slice(start, index));
+            start = index + 1;
+        }
+        escaped = char === '\\' && !escaped;
+        if (char !== '\\')
+            escaped = false;
+    }
+    result.push(inner.slice(start));
+    return result.map((cell) => cell.replace(/\\([\\|])/g, '$1').trim());
+}
+function sectionBody(content) {
+    const heading = REWORK_INTENT_HEADINGS.map((value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
+    const match = new RegExp(`^##\\s+(${heading})\\s*$`, 'm').exec(content);
+    if (!match)
+        return null;
+    const start = (match.index ?? 0) + match[0].length;
+    const rest = content.slice(start);
+    const end = rest.search(/^##\s+/m);
+    return rest.slice(0, end < 0 ? rest.length : end);
+}
+function parseReworkIntentDocument(content) {
+    const body = sectionBody(content);
+    if (body === null)
+        return { ok: true, present: false, intents: [] };
+    const lines = body.split(/\r?\n/).filter((line) => line.trim());
+    const header = lines[0] ? cells(lines[0]) : null;
+    const separator = lines[1] ? cells(lines[1]) : null;
+    if (!header || !separator || header.length !== REWORK_INTENT_COLUMNS.length || !header.every((value, index) => value === REWORK_INTENT_COLUMNS[index]) || !separator.every((value) => /^:?-{3,}:?$/.test(value))) {
+        return { ok: false, code: 'TASK_REWORK_INTENT_INVALID', message: 'rework intent section must contain its canonical table' };
+    }
+    try {
+        const intents = lines.slice(2).map((line) => {
+            const values = cells(line);
+            if (!values || values.length !== REWORK_INTENT_COLUMNS.length)
+                throw new Error('rework intent row has the wrong column count');
+            const row = Object.fromEntries(REWORK_INTENT_COLUMNS.map((column, index) => [column, values[index]]));
+            if (!/^RI-[1-9]\d*$/.test(row.intent_id))
+                throw new Error(`invalid intent id '${row.intent_id}'`);
+            if (!/^(AN|PL|CD)-[1-9]\d*$/.test(row.finding_id))
+                throw new Error(`invalid finding id '${row.finding_id}'`);
+            if (!['analysis', 'plan', 'code'].includes(row.target))
+                throw new Error(`invalid rework target '${row.target}'`);
+            if (!['pending', 'consumed', 'superseded'].includes(row.status))
+                throw new Error(`invalid rework status '${row.status}'`);
+            if (!/^[a-f0-9]{64}$/.test(row.source_sha256))
+                throw new Error(`invalid source hash for '${row.intent_id}'`);
+            if (!row.source_artifact || !row.declared_at)
+                throw new Error(`rework intent '${row.intent_id}' has invalid required fields`);
+            const terminal = row.status === 'consumed' || row.status === 'superseded';
+            if (terminal !== Boolean(row.consumed_at))
+                throw new Error(`rework intent '${row.intent_id}' has invalid consumed_at`);
+            return {
+                intentId: row.intent_id, findingId: row.finding_id, sourceArtifact: row.source_artifact,
+                sourceSha256: row.source_sha256, target: row.target,
+                status: row.status, declaredAt: row.declared_at, consumedAt: row.consumed_at
+            };
+        });
+        const ids = new Set();
+        for (const intent of intents) {
+            if (ids.has(intent.intentId))
+                throw new Error(`duplicate intent '${intent.intentId}'`);
+            ids.add(intent.intentId);
+        }
+        return { ok: true, present: true, intents };
+    }
+    catch (error) {
+        return { ok: false, code: 'TASK_REWORK_INTENT_INVALID', message: error instanceof Error ? error.message : String(error) };
+    }
+}
+function renderReworkIntents(intents) {
+    const escape = (value) => value.replace(/\\/g, '\\\\').replace(/\|/g, '\\|').replace(/[\r\n]/g, ' ');
+    return [
+        `| ${REWORK_INTENT_COLUMNS.join(' | ')} |`,
+        `| ${REWORK_INTENT_COLUMNS.map(() => '---').join(' | ')} |`,
+        ...intents.map((intent) => `| ${[
+            intent.intentId, intent.findingId, intent.sourceArtifact, intent.sourceSha256,
+            intent.target, intent.status, intent.declaredAt, intent.consumedAt
+        ].map(escape).join(' | ')} |`)
+    ].join('\n');
+}
+function upsertReworkIntent(intents, intent) {
+    const existing = intents.find((candidate) => candidate.intentId === intent.intentId);
+    if (!existing)
+        return { changed: true, intents: [...intents, intent] };
+    const identity = (value) => [value.intentId, value.findingId, value.sourceArtifact, value.sourceSha256, value.target];
+    if (JSON.stringify(identity(existing)) !== JSON.stringify(identity(intent)))
+        throw new Error(`intent '${intent.intentId}' identity conflicts with existing state`);
+    return { changed: false, intents };
+}
+function consumeReworkIntents(intents, target, sourceHashes, consumedAt) {
+    let changed = false;
+    const next = intents.map((intent) => {
+        if (intent.status !== 'pending'
+            || intent.target !== target
+            || sourceHashes[intent.sourceArtifact] !== intent.sourceSha256)
+            return intent;
+        changed = true;
+        return { ...intent, status: 'consumed', consumedAt };
+    });
+    return { changed, intents: next };
+}
+function supersedeReworkIntents(intents, sourceArtifact, sourceSha256, supersededAt) {
+    let changed = false;
+    const next = intents.map((intent) => {
+        if (intent.status !== 'pending' || intent.sourceArtifact !== sourceArtifact || intent.sourceSha256 === sourceSha256)
+            return intent;
+        changed = true;
+        return { ...intent, status: 'superseded', consumedAt: supersededAt };
+    });
+    return { changed, intents: next };
+}
+function reworkIntentMutation(content, intents) {
+    return {
+        kind: 'section',
+        aliases: REWORK_INTENT_HEADINGS,
+        heading: /^##\s+Rework Intent\s*$/m.test(content) ? REWORK_INTENT_HEADINGS[1] : REWORK_INTENT_HEADINGS[0],
+        body: renderReworkIntents(intents)
+    };
+}
+export { REWORK_INTENT_COLUMNS, REWORK_INTENT_HEADINGS, parseReworkIntentDocument, renderReworkIntents, reworkIntentMutation, consumeReworkIntents, supersedeReworkIntents, upsertReworkIntent };
+//# sourceMappingURL=rework-intent.js.map

package/dist/lib/task/skill-scope.js

@@ -0,0 +1,23 @@
+const TASK_SCOPE_SKILLS = new Set([
+    'analyze-task',
+    'block-task',
+    'cancel-task',
+    'check-task',
+    'code-task',
+    'commit',
+    'complete-manual-validation',
+    'complete-task',
+    'create-pr',
+    'plan-task',
+    'review-analysis',
+    'review-code',
+    'review-plan',
+    'run-manual-validation',
+    'run-task',
+    'watch-pr'
+]);
+function isTaskScopeSkill(skillName) {
+    return TASK_SCOPE_SKILLS.has(skillName);
+}
+export { TASK_SCOPE_SKILLS, isTaskScopeSkill };
+//# sourceMappingURL=skill-scope.js.map

package/dist/lib/task/task-execution-lock.js

@@ -160,6 +160,25 @@ function withTaskExecutionLock(repoRoot, taskId, ownerName, callback, options =
     };
     const serialized = `${JSON.stringify(owner)}\n`;
     let ownsFixed = false;
+    let deferRelease = false;
+    const release = () => {
+        try {
+            unlinkIfPresent(candidate);
+        }
+        catch {
+            // Candidate cleanup is best-effort and must not replace the primary result.
+        }
+        if (ownsFixed) {
+            try {
+                const current = parseOwner(fs.readFileSync(fixed, 'utf8'), key);
+                if (current.token === token)
+                    unlinkIfPresent(fixed);
+            }
+            catch {
+                // A missing or replaced fixed lock is not owned by this invocation.
+            }
+        }
+    };
     try {
         fs.mkdirSync(lockRoot, { recursive: true });
         cleanStaleCandidates(lockRoot, key, options.identityMatches ?? processIdentityMatches);
@@ -202,7 +221,12 @@ function withTaskExecutionLock(repoRoot, taskId, ownerName, callback, options =
             throw new TaskExecutionLockError('ORCHESTRATION_LOCK_BUSY', 'lifecycle task lock could not be acquired after stale recovery', { operation: 'acquire', errno: 'EEXIST', key });
         }
         unlinkIfPresent(candidate);
-        return callback();
+        const value = callback();
+        if (value && typeof value.then === 'function') {
+            deferRelease = true;
+            return value.finally(release);
+        }
+        return value;
     }
     catch (error) {
         if (error instanceof TaskExecutionLockError)
@@ -212,22 +236,8 @@ function withTaskExecutionLock(repoRoot, taskId, ownerName, callback, options =
         throw new TaskExecutionLockError('ORCHESTRATION_LOCK_FAILED', 'lifecycle task lock operation failed', { operation: ownsFixed ? 'callback' : 'acquire', errno: errno(error), key });
     }
     finally {
-        try {
-            unlinkIfPresent(candidate);
-        }
-        catch {
-            // Candidate cleanup is best-effort and must not replace the primary result.
-        }
-        if (ownsFixed) {
-            try {
-                const current = parseOwner(fs.readFileSync(fixed, 'utf8'), key);
-                if (current.token === token)
-                    unlinkIfPresent(fixed);
-            }
-            catch {
-                // A missing or replaced fixed lock is not owned by this invocation.
-            }
-        }
+        if (!deferRelease)
+            release();
     }
 }
 function withRepositoryMutationLock(repoRoot, callback, options = {}) {