@fitlab-ai/agent-infra 0.11.7 → 0.11.9

package/README.md

@@ -240,7 +240,7 @@ In-depth guides live under [`docs/en/`](./docs/en/README.md):
 - [Feishu Bridge](./docs/en/feishu-bridge.md) — configure the Feishu long-connection adapter, command routing, permissions, and TUI selection
 - [Built-in AI Skills](./docs/en/skills.md) — the full skill catalog by use case
 - [Custom Skills](./docs/en/custom-skills.md) — create and sync project-specific skills
-- [Custom TUI Configuration](./docs/en/custom-tui.md) — adapt agent-infra to non-built-in AI TUIs
+- [Custom Tool Invocations](./docs/en/custom-tool-invocations.md) — configure custom-tool next-step commands
 - [Prebuilt Workflows](./docs/en/workflows.md) — the gated delivery lifecycle and example flow
 - [Configuration Reference](./docs/en/configuration.md) — `.agents/.airc.json`, external sources, version management
 - [File Management Strategies](./docs/en/file-management.md) — managed / merged / ejected update strategies

package/README.zh-CN.md

@@ -239,7 +239,7 @@ my-project/
 - [飞书桥接](./docs/zh-CN/feishu-bridge.md) — 配置飞书长连接 adapter、命令路由、权限和 TUI 选择
 - [内置 AI Skills](./docs/zh-CN/skills.md) — 按使用场景分组的完整 skill 清单
 - [自定义 Skills](./docs/zh-CN/custom-skills.md) — 创建并同步项目专属 skill
-- [自定义 TUI 配置](./docs/zh-CN/custom-tui.md) — 适配非内置的 AI TUI
+- [自定义工具调用](./docs/zh-CN/custom-tool-invocations.md) — 配置自定义工具的下一步命令
 - [预置工作流](./docs/zh-CN/workflows.md) — 分阶段交付链路与示例流程
 - [配置参考](./docs/zh-CN/configuration.md) — `.agents/.airc.json`、外部源、版本管理
 - [文件管理策略](./docs/zh-CN/file-management.md) — managed / merged / ejected 更新策略

package/dist/bin/internal-cli.js

@@ -15,6 +15,7 @@ const taskWorkflowCommand = command === 'task-artifact'
     || command === 'task-ledger'
     || command === 'task-invalidation'
     || command === 'task-warning';
+const taskPlatformRecoveryCommand = command === 'task-platform-recovery';
 const manualValidationWorkflowCommand = command === 'manual-validation';
 const taskControlMarkers = [
     'AGENT_INFRA_TASK_ID', 'AGENT_INFRA_CONTROL_TOKEN', 'AGENT_INFRA_CONTROL_GENERATION',
@@ -48,9 +49,9 @@ function taskControlTransportFailure(message, code = 'TASK_CONTROL_TRANSPORT_INV
     process.exit(1);
 }
 let controlRouted = false;
-if (!taskViewGuardFailed && !markerlessHelp && (taskControlCommand || taskWorkflowCommand || manualValidationWorkflowCommand)) {
+if (!taskViewGuardFailed && !markerlessHelp && (taskControlCommand || taskWorkflowCommand || manualValidationWorkflowCommand || taskPlatformRecoveryCommand)) {
     const transport = resolveSandboxControlTransport(process.env, {
-        localWorkflow: command === 'task-orchestration' || command === 'task-finalization' || taskWorkflowCommand || manualValidationWorkflowCommand
+        localWorkflow: command === 'task-orchestration' || command === 'task-finalization' || taskWorkflowCommand || manualValidationWorkflowCommand || taskPlatformRecoveryCommand
     });
     switch (transport.kind) {
         case 'fail-closed': {
@@ -90,6 +91,11 @@ if (!controlRouted && !taskViewGuardFailed && internalRouteRegistered)
             await taskFinalization(process.argv.slice(3));
             break;
         }
+        case 'task-platform-recovery': {
+            const { taskPlatformRecovery } = await import('../lib/internal/task-platform-recovery.js');
+            await taskPlatformRecovery(process.argv.slice(3));
+            break;
+        }
         case 'task-create': {
             const { taskCreate } = await import('../lib/internal/task-create.js');
             await taskCreate(process.argv.slice(3));

package/dist/lib/agent-clients/adapters/codex.js

@@ -50,7 +50,7 @@ const codexAdapter = defineAgentClientAdapter({
             containerMount: '/home/devuser/.codex',
             versionCmd: 'codex --version',
             setupHint: 'Run codex once inside the container and choose Device Code login if needed.',
-            tmpfs: { size: '512m', seed: ['config.toml', 'model-catalogs'] },
+            tmpfs: { size: '512m', seed: ['config.toml', 'model-catalogs'], exec: true },
             hostLiveMounts: [
                 {
                     hostPath: hostJoin(home, '.codex', 'auth.json'),

package/dist/lib/agent-clients/config.js

@@ -114,10 +114,18 @@ function normalizeAgentClients(input) {
     if (hasOwn(input, 'tuis'))
         fail('INVALID_AGENT_CLIENTS', 'tuis');
     const sandbox = isRecord(input.sandbox) ? input.sandbox : undefined;
-    if (Array.isArray(sandbox?.tools)) {
-        for (const [index, tool] of sandbox.tools.entries()) {
+    if (sandbox && hasOwn(sandbox, 'customTools')) {
+        fail('INVALID_AGENT_CLIENTS', 'sandbox.customTools');
+    }
+    if (sandbox && hasOwn(sandbox, 'tools')) {
+        if (!isRecord(sandbox.tools))
+            fail('INVALID_AGENT_CLIENTS', 'sandbox.tools');
+        const tools = sandbox.tools;
+        if (!Array.isArray(tools.ids))
+            fail('INVALID_AGENT_CLIENTS', 'sandbox.tools.ids');
+        for (const [index, tool] of tools.ids.entries()) {
             if (isAgentClientId(tool)) {
-                fail('INVALID_AGENT_CLIENTS', `sandbox.tools[${index}]`);
+                fail('INVALID_AGENT_CLIENTS', `sandbox.tools.ids[${index}]`);
             }
         }
     }

package/dist/lib/agent-clients/custom-tool-invocations.js

@@ -0,0 +1,92 @@
+const ALLOWED_PLACEHOLDERS = Object.freeze(['skillName', 'projectName']);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNonEmptySingleLine(value) {
+    return typeof value === 'string'
+        && value.trim() !== ''
+        && !/[\r\n]/.test(value);
+}
+function hasValidPlaceholders(invocation) {
+    const placeholders = [
+        ...invocation.matchAll(/\$\{([^}]+)\}/g)
+    ].map((match) => match[1]);
+    return placeholders.includes('skillName')
+        && placeholders.every((placeholder) => ALLOWED_PLACEHOLDERS.includes(placeholder))
+        && !invocation
+            .replaceAll('${skillName}', '')
+            .replaceAll('${projectName}', '')
+            .includes('${');
+}
+function normalizeCustomToolInvocations(config) {
+    const items = [];
+    const diagnostics = [];
+    const root = isRecord(config) ? config : {};
+    const sandbox = isRecord(root.sandbox) ? root.sandbox : {};
+    const sandboxTools = isRecord(sandbox.tools) ? sandbox.tools : { ids: ['agent-infra'] };
+    const definitions = sandboxTools.definitions ?? {};
+    const selectedIds = sandboxTools.ids;
+    if (!Array.isArray(selectedIds)) {
+        return Object.freeze({
+            items: Object.freeze([]),
+            diagnostics: Object.freeze([
+                Object.freeze({
+                    code: 'INVALID_CUSTOM_TOOL_CONFIG',
+                    path: 'sandbox.tools.ids'
+                })
+            ])
+        });
+    }
+    if (!isRecord(definitions)) {
+        return Object.freeze({
+            items: Object.freeze([]),
+            diagnostics: Object.freeze([
+                Object.freeze({
+                    code: 'INVALID_CUSTOM_TOOL_CONFIG',
+                    path: 'sandbox.tools.definitions'
+                })
+            ])
+        });
+    }
+    for (const [index, id] of selectedIds.entries()) {
+        if (typeof id !== 'string') {
+            diagnostics.push({
+                code: 'INVALID_CUSTOM_TOOL_INVOCATION',
+                path: `sandbox.tools.ids[${index}]`
+            });
+            continue;
+        }
+        const candidate = definitions[id];
+        if (!isRecord(candidate))
+            continue;
+        if (candidate.invoke === undefined)
+            continue;
+        const base = `sandbox.tools.definitions.${id}`;
+        const name = candidate.name === undefined ? id : candidate.name;
+        if (!isNonEmptySingleLine(name)) {
+            diagnostics.push({ code: 'INVALID_CUSTOM_TOOL_INVOCATION', path: `${base}.name` });
+            continue;
+        }
+        if (!isNonEmptySingleLine(candidate.invoke)) {
+            diagnostics.push({ code: 'INVALID_CUSTOM_TOOL_INVOCATION', path: `${base}.invoke` });
+            continue;
+        }
+        if (!hasValidPlaceholders(candidate.invoke)) {
+            diagnostics.push({
+                code: 'INVALID_CUSTOM_TOOL_INVOCATION_PLACEHOLDER',
+                path: `${base}.invoke`
+            });
+            continue;
+        }
+        items.push(Object.freeze({
+            name,
+            invocation: candidate.invoke
+        }));
+    }
+    return Object.freeze({
+        items: Object.freeze(items),
+        diagnostics: Object.freeze(diagnostics.map((diagnostic) => Object.freeze(diagnostic)))
+    });
+}
+export { normalizeCustomToolInvocations };
+//# sourceMappingURL=custom-tool-invocations.js.map

package/dist/lib/agent-clients/next-steps.js

@@ -37,7 +37,7 @@ function renderNextStepCommands(input) {
             args
         })
     }));
-    const custom = input.customTUIs.map((tool) => Object.freeze({
+    const custom = input.customToolInvocations.map((tool) => Object.freeze({
         source: 'custom',
         displayName: tool.name,
         command: renderAgentClientInvocation(tool.invocation, {

package/dist/lib/agent-clients/reconcile.js

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import defaults from '../defaults.json' with { type: 'json' };
 import { normalizeAgentClients, serializeAgentClients } from './config.js';
-import { normalizeCustomTUIs } from './custom-tuis.js';
+import { normalizeCustomToolInvocations } from './custom-tool-invocations.js';
 import { renderNextStepCommands } from './next-steps.js';
 import { planAgentClientProjectAssets } from './project-assets.js';
 import { listAgentClientAdapters, listEnabledAgentClientAdapters } from './registry.js';
@@ -141,11 +141,11 @@ function planAgentClientReconciliation(input) {
     if (Object.keys(baselines).length === 0) {
         delete nextConfig.files.managedBaselines;
     }
-    const custom = normalizeCustomTUIs(input.projectRoot, input.config.customTUIs ?? []);
+    const custom = normalizeCustomToolInvocations(input.config);
     const nextSteps = renderNextStepCommands({
         projectName,
         state: desired,
-        customTUIs: custom.items,
+        customToolInvocations: custom.items,
         skillName: 'update-agent-infra'
     });
     const actionableSeed = seedOperations.some((operation) => operation.kind === 'write' || operation.kind === 'remove');

package/dist/lib/agent-clients/schema.js

@@ -38,16 +38,24 @@ const AGENT_CLIENTS_SCHEMA = {
                 }
             }))
         },
-        customTUIs: {
-            type: 'array',
-            items: {
-                type: 'object',
-                additionalProperties: true,
-                required: ['name', 'dir', 'invoke'],
-                properties: {
-                    name: { type: 'string' },
-                    dir: { type: 'string' },
-                    invoke: { type: 'string' }
+        sandbox: {
+            type: 'object',
+            properties: {
+                tools: {
+                    type: 'object',
+                    properties: {
+                        ids: { type: 'array', items: { type: 'string' } },
+                        definitions: {
+                            type: 'object',
+                            additionalProperties: {
+                                type: 'object',
+                                properties: {
+                                    name: { type: 'string' },
+                                    invoke: { type: 'string' }
+                                }
+                            }
+                        }
+                    }
                 }
             }
         }

package/dist/lib/defaults.json

@@ -34,9 +34,12 @@
     "runtimes": [
       "node22"
     ],
-    "tools": [
-      "agent-infra"
-    ],
+    "tools": {
+      "ids": [
+        "agent-infra"
+      ],
+      "definitions": {}
+    },
     "refreshIntervalDays": 7,
     "dockerfile": null,
     "vm": {

package/dist/lib/init.js

@@ -228,8 +228,8 @@ async function cmdInit() {
     console.log('    npm install -g @fitlab-ai/agent-infra');
     console.log('');
     if (workflowPlan.nextSteps.length === 0) {
-        console.log('  No Agent Client project integration enabled.');
-        console.log(`  Configure "customTUIs" in ${configPath} before running update-agent-infra.`);
+        console.log('  No Agent Client or sandbox custom tool integration enabled.');
+        console.log(`  Configure a custom tool in "sandbox.tools.definitions" and select it in "sandbox.tools.ids" in ${configPath}.`);
         console.log('');
     }
     else {

package/dist/lib/internal/agent-client.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { AgentClientConfigError, normalizeAgentClients } from '../agent-clients/config.js';
-import { normalizeCustomTUIs } from '../agent-clients/custom-tuis.js';
+import { normalizeCustomToolInvocations } from '../agent-clients/custom-tool-invocations.js';
 import { renderNextStepCommands } from '../agent-clients/next-steps.js';
 import { getAgentClientModelSelection } from '../agent-clients/registry.js';
 import { isAgentClientId } from '../agent-clients/types.js';
@@ -139,11 +139,11 @@ function agentClient(args = []) {
     }
     try {
         const clients = normalizeAgentClients(config);
-        const custom = normalizeCustomTUIs(process.cwd(), config.customTUIs ?? []);
+        const custom = normalizeCustomToolInvocations(config);
         const commands = renderNextStepCommands({
             projectName: String(config.project ?? ''),
             state: clients.state,
-            customTUIs: custom.items,
+            customToolInvocations: custom.items,
             skillName: parsed.skillName,
             ...(parsed.taskRef ? { taskRef: parsed.taskRef } : {}),
             ...(parsed.version ? { version: parsed.version } : {})

package/dist/lib/internal/cli-route-inventory.js

@@ -60,6 +60,7 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
     'task-invalidation': ['reconcile'],
     'task-lifecycle': ['intent'],
     'task-finalization': ['complete'],
+    'task-platform-recovery': ['inspect', 'recover'],
     'task-short-id': ['list', 'list-verify', 'alloc', 'release', 'resolve'],
     'task-snapshot': ['snapshot'],
     'task-verify': ['event'],
@@ -88,6 +89,8 @@ export function internalRouteSelector(command, args) {
         return args[1] ? 'intent' : '';
     if (command === 'task-finalization')
         return args[1] === 'complete' ? 'complete' : '';
+    if (command === 'task-platform-recovery')
+        return args[1] ?? '';
     if (command === 'task-event')
         return args[1] ? 'event' : '';
     if (command === 'task-verify')

package/dist/lib/internal/platform-pr-review.js

@@ -3,12 +3,13 @@ import path from 'node:path';
 import { inspectPlatformPullRequestByNumber } from '../platform/pull-requests.js';
 import { listPrReviews, publishPrReview } from '../platform/pr-review.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 const USAGE = `Usage: agent-infra-internal platform-pr-review inspect --pr <token> [--cwd <path>]
        agent-infra-internal platform-pr-review list --pr <token> [--cwd <path>]
-       agent-infra-internal platform-pr-review publish --pr <token> --scope <taskId|pr{N}> --round <N> --commit <sha> --event <COMMENT|APPROVE|REQUEST_CHANGES> --body-file <path|-> [--dry-run] [--cwd <path>]
+       agent-infra-internal platform-pr-review publish --pr <token> --scope <taskId|pr{N}> --round <N> --commit <sha> --event <COMMENT|APPROVE|REQUEST_CHANGES> --body-file <path|-> [--artifact <pr-review-artifact>] [--agent <agent>] [--dry-run] [--cwd <path>]
 `;
 const BOOLEAN_FLAGS = new Set(['--dry-run']);
-const VALUE_FLAGS = new Set(['--cwd', '--pr', '--scope', '--round', '--commit', '--event', '--body-file']);
+const VALUE_FLAGS = new Set(['--cwd', '--pr', '--scope', '--round', '--commit', '--event', '--body-file', '--artifact', '--agent']);
 function key(flag) {
     return flag.slice(2).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
 }
@@ -74,7 +75,7 @@ async function platformPrReview(args = []) {
     const allowed = {
         inspect: ['cwd', 'pr'],
         list: ['cwd', 'pr'],
-        publish: ['cwd', 'pr', 'scope', 'round', 'commit', 'event', 'bodyFile', 'dryRun']
+        publish: ['cwd', 'pr', 'scope', 'round', 'commit', 'event', 'bodyFile', 'artifact', 'agent', 'dryRun']
     };
     const unexpected = Object.keys(values).find((name) => !allowed[operation].includes(name));
     if (unexpected) {
@@ -99,6 +100,8 @@ async function platformPrReview(args = []) {
     const round = Number(values.round);
     const commit = typeof values.commit === 'string' ? values.commit : '';
     const event = values.event;
+    const rawAgent = typeof values.agent === 'string' ? values.agent : '';
+    const agent = rawAgent ? normalizeAgentToken(rawAgent) : null;
     if (!scope || !/^(?:pr\d+|TASK-\d{8}-\d{6})$/.test(scope)) {
         fail('publish requires --scope <taskId|pr{N}>');
         return;
@@ -124,6 +127,18 @@ async function platformPrReview(args = []) {
         fail('publish requires --body-file');
         return;
     }
+    if (/^TASK-\d{8}-\d{6}$/u.test(scope) && typeof values.artifact !== 'string') {
+        fail('task-scoped publish requires --artifact <pr-review-artifact>');
+        return;
+    }
+    if (/^TASK-\d{8}-\d{6}$/u.test(scope) && !agent) {
+        fail(`task-scoped publish requires --agent <agent>${rawAgent ? `: invalid '${rawAgent}'` : ''}: ${AGENT_USAGE_HINT}`);
+        return;
+    }
+    if (rawAgent && !agent) {
+        fail(`invalid --agent '${rawAgent}': ${AGENT_USAGE_HINT}`);
+        return;
+    }
     let body;
     try {
         body = readBodyFile(values.bodyFile, cwd);
@@ -138,6 +153,8 @@ async function platformPrReview(args = []) {
         identity: { scope, round, commitSha: commit },
         event: event,
         body,
+        ...(typeof values.artifact === 'string' ? { recoveryArtifact: values.artifact } : {}),
+        ...(agent ? { agent } : {}),
         dryRun: values.dryRun === true
     }));
 }

package/dist/lib/internal/task-operation-registry.js

@@ -105,6 +105,8 @@ function internalTaskRoutes() {
         descriptor('internal', 'task-invalidation', 'reconcile', 'task-bound', 'progress'),
         descriptor('internal', 'task-lifecycle', 'intent', 'task-bound', 'progress'),
         descriptor('internal', 'task-finalization', 'complete', 'task-bound', 'progress'),
+        descriptor('internal', 'task-platform-recovery', 'inspect', 'task-bound', 'diagnostic'),
+        descriptor('internal', 'task-platform-recovery', 'recover', 'task-bound', 'recovery'),
         descriptor('internal', 'task-short-id', 'list', 'conditional', 'diagnostic'),
         descriptor('internal', 'task-short-id', 'list-verify', 'conditional', 'diagnostic'),
         descriptor('internal', 'task-short-id', 'alloc', 'task-bound', 'progress'),
@@ -178,7 +180,7 @@ export const INTERNAL_DISPATCHER_ROUTES = Object.freeze([
     'platform-comment', 'platform-issue', 'platform-pr', 'platform-pr-review', 'pr-review-grade',
     'platform-checks', 'task-context', 'task-ledger', 'task-warning', 'task-activity', 'task-artifact',
     'task-orchestration', 'task-review', 'task-event', 'task-invalidation', 'task-lifecycle',
-    'task-finalization', 'task-short-id', 'task-snapshot', 'task-verify', 'task-validate', 'manual-validation'
+    'task-finalization', 'task-platform-recovery', 'task-short-id', 'task-snapshot', 'task-verify', 'task-validate', 'manual-validation'
 ]);
 export const PUBLIC_DISPATCHER_ROUTES = Object.freeze([
     'agent-client', 'cp', 'data', 'decide', 'help', 'init', 'merge', 'run', 'sandbox', 'server', 'task', 'sync', 'update', 'version'

package/dist/lib/internal/task-platform-recovery.js

@@ -0,0 +1,56 @@
+import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
+import { readPlatformOperationJournal } from '../task/platform-operation-journal.js';
+import { recoverPlatformOperations } from '../task/platform-operation-recovery.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
+const USAGE = 'Usage: agent-infra-internal task-platform-recovery <N | TASK-id> <inspect | recover> [--agent <agent>] [--selection required|deferred|all]\n';
+function option(args, name) {
+    const index = args.indexOf(name);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+async function taskPlatformRecovery(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    if (!ensureInternalHandlerRoute('task-platform-recovery', args))
+        return;
+    const action = args[1];
+    const registered = action === 'inspect'
+        ? internalHandlerRoute('task-platform-recovery', 'inspect', action)
+        : action === 'recover' && internalHandlerRoute('task-platform-recovery', 'recover', action);
+    if (!registered)
+        return;
+    const repoRoot = detectRepoRoot();
+    const task = resolveTaskRef(args[0] ?? '', { repoRoot });
+    if (!task.ok) {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: task.code, message: task.message } })}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    if (action === 'inspect') {
+        try {
+            const journal = readPlatformOperationJournal(task.taskId, repoRoot);
+            process.stdout.write(`${JSON.stringify({ status: 'ready', changed: false, taskId: task.taskId, journal })}\n`);
+        }
+        catch (error) {
+            const value = error;
+            process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error) } })}\n`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    const agent = option(args, '--agent');
+    const selection = option(args, '--selection') ?? 'all';
+    if (!agent || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u.test(agent)
+        || !['required', 'deferred', 'all'].includes(selection)) {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'PLATFORM_OPERATION_RECOVERY_PAYLOAD_INVALID', message: 'recover requires a valid --agent and --selection' } })}\n`);
+        process.stderr.write(USAGE);
+        process.exitCode = 1;
+        return;
+    }
+    const result = await recoverPlatformOperations(task.taskId, selection, { agent, cwd: repoRoot });
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    process.exitCode = result.status === 'applied' || result.status === 'no-op' ? 0 : result.status === 'blocked' ? 2 : 1;
+}
+export { taskPlatformRecovery };
+//# sourceMappingURL=task-platform-recovery.js.map

package/dist/lib/merge.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { removeDirRecursive } from './remove-dir.js';
@@ -305,6 +306,23 @@ function formatBackupTimestamp(date) {
         String(date.getDate()).padStart(2, '0')
     ].join('') + `-${String(date.getHours()).padStart(2, '0')}${String(date.getMinutes()).padStart(2, '0')}${String(date.getSeconds()).padStart(2, '0')}`;
 }
+function resolveRecoveryProjectKey(repoRoot) {
+    let projectKey;
+    try {
+        const config = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
+        if (typeof config.project === 'string' && config.project.trim() !== '') {
+            projectKey = config.project.trim();
+        }
+    }
+    catch {
+        // Fall back to the repository directory when project config is unavailable.
+    }
+    projectKey ??= path.basename(repoRoot);
+    if (!/^[A-Za-z0-9_.@-]+$/.test(projectKey) || projectKey === '.' || projectKey === '..') {
+        throw new Error(`Invalid project name for recovery backups: ${projectKey}`);
+    }
+    return projectKey;
+}
 function toPosixPath(relativePath) {
     return relativePath.split(path.sep).join('/');
 }
@@ -400,7 +418,7 @@ function buildWorkspaceIndex(workspaceDir) {
 function backupTaskDir(backupRoot, section, taskDir, taskId) {
     const backupDir = path.join(backupRoot, section, taskId);
     fs.mkdirSync(path.dirname(backupDir), { recursive: true });
-    fs.cpSync(taskDir, backupDir, { recursive: true });
+    fs.cpSync(taskDir, backupDir, { recursive: true, verbatimSymlinks: true });
     return backupDir;
 }
 function copyTaskToSection(sourceTask, workspaceDir) {
@@ -872,12 +890,14 @@ async function cmdMerge(args) {
     if (!fs.lstatSync(resolvedSource).isDirectory()) {
         throw new Error(`Source path is not a directory: ${sourcePath}`);
     }
-    const workspaceDir = path.join(process.cwd(), '.agents', 'workspace');
+    const repoRoot = process.cwd();
+    const workspaceDir = path.join(repoRoot, '.agents', 'workspace');
     const archiveDir = path.join(workspaceDir, 'archive');
     const backupStamp = formatBackupTimestamp(new Date());
-    const backupRootRelative = `.agents/workspace/.merge-backup/${backupStamp}/`;
-    const backupRoot = path.join(workspaceDir, '.merge-backup', backupStamp);
-    const report = createReport(resolvedSource, backupRootRelative);
+    const projectKey = resolveRecoveryProjectKey(repoRoot);
+    const recoveryRoot = path.join(os.homedir(), '.agent-infra', 'recovery-backups', projectKey, 'workspace-merge');
+    const backupRoot = path.join(recoveryRoot, backupStamp);
+    const report = createReport(resolvedSource, backupRoot);
     detectSourceMode(resolvedSource);
     validateSourceWorkspace(resolvedSource);
     validateArchiveSection(workspaceDir, new Map());

package/dist/lib/platform/completion-backfill.js

@@ -19,7 +19,7 @@ function referencedBackfillArtifact(taskDir, message) {
     if (names.length !== 1)
         return { status: 'ignored', artifact: null, error: null };
     const parsed = parseArtifactName(names[0]);
-    if (!parsed || (parsed.family !== 'pr-review' && !COMPLETION_BACKFILL_FAMILIES.includes(parsed.family))) {
+    if (!parsed || !COMPLETION_BACKFILL_FAMILIES.includes(parsed.family)) {
         return { status: 'ignored', artifact: null, error: null };
     }
     const artifactPath = path.join(taskDir, parsed.name);
@@ -112,6 +112,7 @@ async function backfillCompletionComments(taskRef, options) {
             artifact: artifact.name,
             agent: options.agent,
             backfill: true,
+            dependency: 'required',
             cwd: resolved.repoRoot,
             client: options.client
         });

package/dist/lib/platform/in-label-sync.js

@@ -1,4 +1,5 @@
 import { computeInLabels } from './metadata-labels.js';
+import { createHash } from 'node:crypto';
 function inLabels(labels) {
     return [...new Set(labels.filter((label) => label.startsWith('in:')))].sort();
 }
@@ -26,6 +27,16 @@ function validateInLabelMapping(value) {
     }
     return { ok: true, value: normalized };
 }
+function inLabelMappingDigest(value) {
+    const mapping = validateInLabelMapping(value);
+    if (!mapping.ok)
+        return mapping;
+    const canonical = Object.fromEntries(Object.keys(mapping.value).sort().map((name) => [
+        name,
+        [...new Set(mapping.value[name])].sort()
+    ]));
+    return { ok: true, digest: createHash('sha256').update(JSON.stringify(canonical)).digest('hex') };
+}
 function repositoryLabelPages(value) {
     if (!Array.isArray(value))
         return null;
@@ -139,5 +150,5 @@ function extractPullRequestFileNames(value) {
 function resourceSnapshot(kind, number, labels) {
     return { kind, number, labels: [...labels].sort() };
 }
-export { extractPullRequestFileNames, extractRepositoryLabelNames, flattenPages, inLabels, labelDelta, mergeInLabels, planInLabelUpdate, resourceSnapshot, syncLabelDelta, validateInLabelMapping, validateRepositoryLabelPayload };
+export { extractPullRequestFileNames, extractRepositoryLabelNames, flattenPages, inLabels, inLabelMappingDigest, labelDelta, mergeInLabels, planInLabelUpdate, resourceSnapshot, syncLabelDelta, validateInLabelMapping, validateRepositoryLabelPayload };
 //# sourceMappingURL=in-label-sync.js.map