@fitlab-ai/agent-infra 0.9.11 → 0.9.12

package/dist/lib/platform/verification-required.js

@@ -5,6 +5,7 @@ import { hasPlatformCapability } from "./adapters.js";
 import { inspectRequiredChecks } from "./pr-checks.js";
 import { resolvePlatformContext } from "./context.js";
 import { resolveReviewedHeadRelation } from "./merged-pr-equivalence.js";
+import { readPrDeliveryFact } from "../task/pr-delivery-fact.js";
 const CHECK_TYPE = "required-checks";
 const SHA_PATTERN = /^[0-9a-f]{7,40}$/i;
 function validPrNumber(value) {
@@ -30,7 +31,13 @@ function readHead(repoRoot) {
 }
 export function evaluateRequiredChecks(context, shared) {
     const { metadata, localHead, inspection, prFlow } = context;
-    if (prFlow === "disabled" || metadata.pr_status === "skipped" || !validPrNumber(metadata.pr_number)) {
+    const factRead = readPrDeliveryFact(metadata);
+    if (factRead.status === "invalid") {
+        return shared.failResult(CHECK_TYPE, factRead.error.message, "check_failed");
+    }
+    const fact = factRead.status === "valid" ? factRead.fact : null;
+    const prNumber = fact?.state === "bound" ? fact.identity.number : null;
+    if (prFlow === "disabled" || fact?.state === "skipped" || !validPrNumber(prNumber)) {
         return shared.passResult(CHECK_TYPE, "Skipped: required checks are not applicable to this task");
     }
     const reviewedHead = String(metadata.last_reviewed_commit || "");
@@ -78,7 +85,11 @@ export function check({ taskDir }, shared) {
     if (!task.ok)
         return shared.failResult(CHECK_TYPE, task.message);
     const prFlow = readPrFlow(shared.repoRoot);
-    if (prFlow === "disabled" || task.metadata.pr_status === "skipped" || !validPrNumber(task.metadata.pr_number)) {
+    const factRead = readPrDeliveryFact(task.metadata);
+    if (factRead.status === "invalid")
+        return shared.failResult(CHECK_TYPE, factRead.error.message, "check_failed");
+    const bound = factRead.status === "valid" && factRead.fact.state === "bound";
+    if (prFlow === "disabled" || (factRead.status === "valid" && factRead.fact.state === "skipped") || !bound) {
         return evaluateRequiredChecks({ metadata: task.metadata, localHead: null, inspection: null, prFlow }, shared);
     }
     const platform = resolvePlatformContext({ cwd: shared.repoRoot });

package/dist/lib/platform/verification-sync.js

@@ -9,6 +9,7 @@ import { inspectGitHubIssueMetadata, requirementSectionAnchors } from "./issues.
 import { listRemoteComments } from "./issue-comments.js";
 import { taskTypeLabel } from "./metadata-labels.js";
 import { inspectGitHubPullRequest } from "./pull-requests.js";
+import { readPrDeliveryFact } from "../task/pr-delivery-fact.js";
 const CHECK_TYPE = "platform-sync";
 const VERSION_LINE_REGEX = /^[0-9]+\.[0-9]+\.x$/;
 const FRONTMATTER_FIELD_MAP = {
@@ -127,12 +128,16 @@ function buildSyncContext({ taskDir, config, artifactFile }) {
         return { earlyReturn: failResult(CHECK_TYPE, task.message) };
     }
     const issueNumber = parseIssueNumber(task.metadata.issue_number);
-    const prNumber = parsePrNumber(task.metadata.pr_number);
+    const fact = readPrDeliveryFact(task.metadata);
+    if (fact.status === "invalid") {
+        return { earlyReturn: failResult(CHECK_TYPE, fact.error.message, "check_failed") };
+    }
+    const prNumber = fact.status === "valid" && fact.fact.state === "bound" ? fact.fact.identity.number : null;
     if (config.when === "issue_number_exists" && !issueNumber) {
         return { earlyReturn: passResult(CHECK_TYPE, "Skipped: task has no issue_number") };
     }
-    if (config.when === "pr_number_exists" && !prNumber) {
-        return { earlyReturn: passResult(CHECK_TYPE, "Skipped: task has no pr_number") };
+    if (config.when === "pr_fact_bound" && !prNumber) {
+        return { earlyReturn: passResult(CHECK_TYPE, "Skipped: task has no verified bound pull request") };
     }
     if (!issueNumber) {
         return { earlyReturn: passResult(CHECK_TYPE, "Skipped: platform-sync not required for this task") };
@@ -276,7 +281,7 @@ function fetchRemoteData(context) {
     if (context.prMarker) {
         if (!context.prNumber) {
             return {
-                earlyReturn: failResult(CHECK_TYPE, "Expected a valid pr_number for PR comment verification", "check_failed")
+                earlyReturn: failResult(CHECK_TYPE, "Expected a verified bound pull request for PR comment verification", "check_failed")
             };
         }
         const prCommentsResult = listRemoteComments(githubClient, context.upstreamRepo, context.prNumber, context.taskDir);

package/dist/lib/pr-review/evidence-grading.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { parseTaskFrontmatter } from '../task/frontmatter.js';
+import { parseTypedTaskFrontmatter } from '../task/frontmatter.js';
+import { readPrDeliveryFact } from '../task/pr-delivery-fact.js';
 export class HostResolutionError extends Error {
     code;
     constructor(code, message) {
@@ -38,7 +39,7 @@ export function extractClosingIssueNumbers(body) {
 /**
  * Scan `.agents/workspace/active/{task-id}/task.md` files for tasks bound to the
  * PR number or to one of the PR's closing issues. A task is emitted at most once;
- * a direct `pr_number` hit takes priority over the issue-number reverse lookup.
+ * a verified fact identity hit takes priority over the issue-number reverse lookup.
  */
 export function collectHostCandidates(input) {
     const activeRoot = path.join(input.workspaceRoot, '.agents', 'workspace', 'active');
@@ -62,9 +63,16 @@ export function collectHostCandidates(input) {
         catch {
             continue;
         }
-        const frontmatter = parseTaskFrontmatter(content);
+        let frontmatter;
+        try {
+            frontmatter = parseTypedTaskFrontmatter(content);
+        }
+        catch {
+            continue;
+        }
         const issueNumber = toPositiveNumber(frontmatter.issue_number);
-        const prNumber = toPositiveNumber(frontmatter.pr_number);
+        const fact = readPrDeliveryFact(frontmatter);
+        const prNumber = fact.status === 'valid' && fact.fact.state === 'bound' ? fact.fact.identity.number : null;
         if (prNumber === input.prNumber) {
             candidates.push({ taskId: entry.name, taskDir, issueNumber, prNumber });
         }

package/dist/lib/sandbox/config.js

@@ -67,6 +67,7 @@ export function loadConfig({ platformFn = platform, writeStderr = (chunk) => pro
     const agentClients = normalizeAgentClients(airc);
     const defaults = cloneDefaults();
     const sandbox = airc.sandbox ?? {};
+    const delivery = airc.delivery ?? {};
     const engine = validateSandboxEngine(sandbox.engine ?? defaults.engine, { platformFn });
     const project = airc.project;
     if (!project || typeof project !== 'string') {
@@ -111,6 +112,10 @@ export function loadConfig({ platformFn = platform, writeStderr = (chunk) => pro
         tools,
         customTools,
         agentClientState: agentClients.state,
+        delivery: {
+            remote: typeof delivery.remote === 'string' ? delivery.remote : 'origin',
+            baseRef: typeof delivery.baseRef === 'string' ? delivery.baseRef : 'main'
+        },
         refreshIntervalDays: asNonNegativeIntegerOrDefault(sandbox.refreshIntervalDays, defaults.refreshIntervalDays),
         dockerfile,
         vm: {

package/dist/lib/sandbox/control/lifecycle.js

@@ -448,25 +448,27 @@ function readSandboxControlManifestValue(manifestPath) {
         'mode', 'processingDir', 'project', 'publicStatusDir', 'repoRoot', 'runtimeDir',
         'taskId', 'token', 'worktreeRoot'
     ];
-    if ('version' in candidate || typeof candidate.runtimeDir !== 'string'
-        || Object.keys(manifest).sort().join(',') !== expectedKeys.sort().join(',')) {
-        throw new Error('SANDBOX_CONTROL_MANIFEST_REBUILD_REQUIRED: container-only recreation/rebuild is required');
+    if (Object.keys(manifest).sort().join(',') !== expectedKeys.sort().join(',')) {
+        throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
     }
     if (typeof candidate.containerIdentity !== 'object' || candidate.containerIdentity === null
         || Array.isArray(candidate.containerIdentity))
         throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
     const containerIdentity = candidate.containerIdentity;
-    if (typeof candidate.engine !== 'string' || candidate.engine.length === 0
+    if (Object.keys(containerIdentity).sort().join(',') !== 'id,labels'
+        || typeof candidate.engine !== 'string' || candidate.engine.length === 0
         || typeof candidate.repoRoot !== 'string' || typeof candidate.worktreeRoot !== 'string'
         || typeof candidate.project !== 'string' || typeof candidate.container !== 'string'
         || typeof containerIdentity.id !== 'string' || containerIdentity.id.length === 0
         || typeof containerIdentity.labels !== 'object' || containerIdentity.labels === null
         || Array.isArray(containerIdentity.labels)
         || Object.values(containerIdentity.labels).some((value) => typeof value !== 'string')
-        || typeof candidate.branch !== 'string' || !['task-bound', 'branch-only'].includes(candidate.mode ?? '')
+        || typeof candidate.branch !== 'string'
+        || (candidate.mode !== 'task-bound' && candidate.mode !== 'branch-only')
         || (candidate.taskId !== null && typeof candidate.taskId !== 'string')
         || typeof candidate.channelDir !== 'string' || typeof candidate.publicStatusDir !== 'string'
-        || typeof candidate.processingDir !== 'string' || typeof candidate.token !== 'string'
+        || typeof candidate.processingDir !== 'string' || typeof candidate.runtimeDir !== 'string'
+        || typeof candidate.token !== 'string'
         || typeof candidate.generation !== 'string'
         || (candidate.mode === 'task-bound' && (typeof candidate.taskId !== 'string' || candidate.taskId.length === 0))
         || (candidate.mode === 'branch-only' && candidate.taskId !== null))
@@ -480,7 +482,27 @@ function readSandboxControlManifestValue(manifestPath) {
     if (path.resolve(candidate.runtimeDir) !== path.join(root, 'runtime')) {
         throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
     }
-    return candidate;
+    const normalized = {
+        engine: candidate.engine,
+        repoRoot: candidate.repoRoot,
+        worktreeRoot: candidate.worktreeRoot,
+        project: candidate.project,
+        container: candidate.container,
+        containerIdentity: {
+            id: containerIdentity.id,
+            labels: { ...containerIdentity.labels }
+        },
+        branch: candidate.branch,
+        mode: candidate.mode,
+        taskId: candidate.taskId,
+        token: candidate.token,
+        generation: candidate.generation,
+        channelDir: candidate.channelDir,
+        publicStatusDir: candidate.publicStatusDir,
+        processingDir: candidate.processingDir,
+        runtimeDir: candidate.runtimeDir
+    };
+    return normalized;
 }
 export function readSandboxControlManifest(manifestPath) {
     return readSandboxControlManifestValue(manifestPath);

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

@@ -50,8 +50,8 @@ 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})$/);
+export function parseDarwinStartTime(output) {
+    const match = output.trim().match(/^(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat) ([A-Z][a-z]{2})\s+(\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'];

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

@@ -429,9 +429,9 @@ function buildArtifactLinkSection(content, artifact) {
     const label = english
         ? `${spec.labels[1]} (Round ${artifact.round})`
         : `${spec.labels[0]}（Round ${artifact.round}）`;
-    const link = `[${label}](${artifact.name})`;
+    const link = `${label}：\`${artifact.name}\``;
     let body = extractSection(content, aliases);
-    if (body.includes(`](${artifact.name})`))
+    if (body.includes(link))
         return { aliases, heading, body };
     const placeholders = new Set([
         '[分析阶段的发现。哪些文件受影响？范围是什么？]',

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

@@ -0,0 +1,100 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+function intentRoot(repoRoot) {
+    return path.join(repoRoot, '.agents', 'workspace', '.task-commit-intents');
+}
+function intentPath(repoRoot, taskId) {
+    return path.join(intentRoot(repoRoot), `${taskId}.json`);
+}
+function checkpointIntentDigest(identity) {
+    return createHash('sha256').update(JSON.stringify({
+        taskId: identity.taskId,
+        branch: identity.branch,
+        mode: identity.mode,
+        expectedHead: identity.expectedHead,
+        expectedTree: identity.expectedTree,
+        paths: [...identity.paths],
+        message: identity.message,
+        round: identity.round
+    })).digest('hex');
+}
+function isIntent(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const intent = value;
+    return intent.version === 1
+        && typeof intent.taskId === 'string' && intent.taskId.length > 0
+        && typeof intent.branch === 'string' && intent.branch.length > 0
+        && intent.mode === 'local'
+        && typeof intent.expectedHead === 'string' && /^[a-f0-9]{40,64}$/.test(intent.expectedHead)
+        && typeof intent.expectedTree === 'string' && /^[a-f0-9]{40,64}$/.test(intent.expectedTree)
+        && Array.isArray(intent.paths) && intent.paths.every((item) => typeof item === 'string' && item.length > 0)
+        && typeof intent.message === 'string' && intent.message.length > 0
+        && Number.isSafeInteger(intent.round) && Number(intent.round) > 0
+        && typeof intent.digest === 'string' && /^[a-f0-9]{64}$/.test(intent.digest)
+        && ['prepared', 'committed', 'synced'].includes(String(intent.state))
+        && (intent.committedHead === null || (typeof intent.committedHead === 'string' && /^[a-f0-9]{40,64}$/.test(intent.committedHead)))
+        && typeof intent.createdAt === 'string' && intent.createdAt.length > 0
+        && typeof intent.updatedAt === 'string' && intent.updatedAt.length > 0
+        && intent.digest === checkpointIntentDigest(intent);
+}
+function readCheckpointIntent(repoRoot, taskId) {
+    const target = intentPath(repoRoot, taskId);
+    if (!fs.existsSync(target))
+        return null;
+    const value = JSON.parse(fs.readFileSync(target, 'utf8'));
+    if (!isIntent(value))
+        throw new Error('COMMIT_INTENT_INVALID: checkpoint intent schema is invalid');
+    return value;
+}
+function writeCheckpointIntent(repoRoot, value) {
+    if (!isIntent(value))
+        throw new Error('COMMIT_INTENT_INVALID: checkpoint intent schema is invalid');
+    const directory = intentRoot(repoRoot);
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const target = intentPath(repoRoot, value.taskId);
+    const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+    try {
+        fs.renameSync(temporary, target);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch { /* preserve primary error */ }
+        throw error;
+    }
+}
+function updateCheckpointIntent(value, patch) {
+    const next = { ...value, ...patch };
+    if (next.state === 'prepared' && next.committedHead !== null)
+        throw new Error('COMMIT_INTENT_INVALID: prepared intent cannot have a committed head');
+    if (next.state !== 'prepared' && !next.committedHead)
+        throw new Error('COMMIT_INTENT_INVALID: committed intent requires a committed head');
+    return next;
+}
+function removeCheckpointIntent(repoRoot, taskId) {
+    const target = intentPath(repoRoot, taskId);
+    try {
+        fs.unlinkSync(target);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
+function sameCheckpointIntent(left, right) {
+    return left.digest === checkpointIntentDigest(right)
+        && left.taskId === right.taskId
+        && left.branch === right.branch
+        && left.mode === right.mode
+        && left.expectedHead === right.expectedHead
+        && left.expectedTree === right.expectedTree
+        && left.message === right.message
+        && left.round === right.round
+        && JSON.stringify(left.paths) === JSON.stringify(right.paths);
+}
+export { checkpointIntentDigest, intentPath, intentRoot, isIntent, readCheckpointIntent, removeCheckpointIntent, sameCheckpointIntent, updateCheckpointIntent, writeCheckpointIntent };
+//# sourceMappingURL=commit-intent.js.map