@fitlab-ai/agent-infra 0.11.14 → 0.12.0

package/templates/.agents/skills/watch-pr/SKILL.zh-CN.md

@@ -5,7 +5,7 @@ description: >
   当需要持续监控 PR 直到门禁通过且明确可合入时使用。
 ---
 
-# 监控 Pull Request
+# 监控拉取请求
 
 在 `create-pr` 之后持续监控同一 PR head 的全部 checks 与 mergeability。只有全部 checks 通过且平台明确可合入才进入成功出口；check 失败走既有修复，合并冲突走受限 rebase 自愈，未知或无法安全闭环时 fail-closed。
 
@@ -40,7 +40,7 @@ description: >
 按以下确定性分支解析出目标 PR 号 `{pr#}` 与可选 `{task-id}`：
 
 - 场景 A（省略入参）：从当前分支反查 active task；定位后读取其 verified `pr_delivery_fact.identity.number`。
-- 场景 B（省略 task ref 或 `--task/-t`，**任务锚定主路径**）：按「任务上下文解析」取得完整 `{task-id}`。读 `.agents/workspace/active/{task-id}/task.md` 取 verified `pr_delivery_fact.identity.number` 作为 `{pr#}`；fact 未绑定时按「错误处理」提示先 `create-pr`，停止。
+- 场景 B（省略 task ref 或 `--task/-t`，**任务锚定主路径**）：按「任务上下文解析」取得完整 `{task-id}`。读 `<task-workspace>/active/{task-id}/task.md` 取 verified `pr_delivery_fact.identity.number` 作为 `{pr#}`；fact 未绑定时按「错误处理」提示先 `create-pr`，停止。
 - 场景 C（`--pr <number>` 或 PR URL）：直接取该 PR 号为 `{pr#}`；随后按「反查任务」确定 `{task-id}`。
 - 反查任务（场景 A / C）：通过任务上下文/任务查询取得与 `{pr#}` 唯一绑定的 active task。未命中时停止并提示先绑定 PR；typed checks intent 不建立第二套无任务状态机。
 
@@ -48,7 +48,22 @@ description: >
 
 执行此步骤前，先读取 `reference/monitor-and-heal.md` 与 `.agents/rules/pr-checks-commands.md`。
 
-进入本轮时初始化 `repairCommits=[]` 与 `rebaseAttempts=0`。每轮 readiness 前先调用 `platform-pr summary-context`，按共享 PR change-report contract 以当前权威 PR head 重建任务绑定的 `pr-change-report.json`，再用含唯一 `<!-- canonical-pr-change-report -->` 占位符的正文调用 `summary-sync --change-report-file ... --result no_op --strict` 刷新同一条摘要。`--strict` 将报告或摘要刷新失败保留为 `failed/blocked`，不得把 warning 当作成功；刷新失败时不得进入 ready/complete 出口，按步骤 4 记录阻塞。刷新完成后调用 `agent-infra-internal platform-checks watch {task-id} --interval-seconds 30 --deadline-seconds 1800`，只按结构化 `readiness.state` 分流：`ready` 进入步骤 7，`conflicting` 或 `checks-failed` 进入步骤 3，`pending|timed-out|cancelled` 进入步骤 4。
+进入本轮时初始化 `repairCommits=[]` 与 `rebaseAttempts=0`。每次覆盖当前报告前，先用 core 导出的 reader 验证并暂存现有报告的身份与 head；文件不存在或验证失败即记为无上一 head：
+
+```bash
+node --experimental-strip-types --input-type=module -e '
+import { readPrChangeReport } from "./lib/platform/pr-change-report.ts";
+const report = readPrChangeReport(`<task-workspace>/active/${process.argv[1]}/pr-change-report.json`);
+const previous = report.ok
+  ? { repository: report.value.identity.repository, resource: report.value.identity.resource, head: report.value.identity.head.sha }
+  : { status: "unavailable" };
+process.stdout.write(`${JSON.stringify(previous)}\n`);
+' {task-id}
+```
+
+随后调用 `platform-pr summary-context`，比较暂存的 repository/resource identity 与当前权威 snapshot；不匹配时丢弃旧 head 并标记增量未确认。按共享 PR change-report contract 用当前权威 PR head 重建任务绑定的 `pr-change-report.json`，再用含唯一 `<!-- canonical-pr-change-report -->` 占位符的正文调用 `summary-sync --change-report-file ... --result no_op --strict` 刷新同一条摘要。完整 PR 仍使用当前 base/head/merge-base/patch 与现有 totals。只有在上一报告有效、PR identity 相同且两个 head 不同的情况下，才用 `git diff --find-renames --numstat {previous-head} {current-head}`、`--name-status`、`--summary` 描述独立的 head→head 树差异；不使用 merge-base 替代该范围，不把增量 totals 加入完整 PR。无有效上一 head 时写明未确认，不从完整 PR 推算或填零；head 相同只说明没有新的 head 转换。
+
+`--strict` 将报告或摘要刷新失败保留为 `failed/blocked`，不得把 warning 当作成功；刷新失败时不得进入 ready/complete 出口，按步骤 4 记录阻塞。刷新成功后，消费 `summary-sync` 结构化结果的 `nextAction`：`review-code` 立即结束 readiness/self-heal 路径，按步骤 7 的代码审查分支退出；`watch-pr` 才继续调用 `agent-infra-internal platform-checks watch {task-id} --interval-seconds 30 --deadline-seconds 1800`。缺失或 invalid `nextAction` 按刷新失败处理，不推断为 `watch-pr`。readiness 只按结构化 `readiness.state` 分流：`ready` 进入步骤 7，`conflicting` 或 `checks-failed` 进入步骤 3，`pending|timed-out|cancelled` 进入步骤 4。
 
 ### 3. 自愈循环
 
@@ -70,14 +85,14 @@ description: >
 date "+%Y-%m-%d %H:%M:%S%z" | sed 's/\([+-][0-9][0-9]\)\([0-9][0-9]\)$/\1:\2/'
 ```
 
-更新 `.agents/workspace/active/{task-id}/task.md`：
+更新 `<task-workspace>/active/{task-id}/task.md`：
 - `assigned_to`：{当前代理}
 - `updated_at`：{当前时间}
 - `agent_infra_version`：按 `.agents/rules/version-stamp.md` 取值
 - **不改** `pr_delivery_fact` 与 `current_step`
 - **追加**到 `## 活动日志`（不要覆盖之前的记录；`{N}` = 本任务已有 Watch PR 条目数 + 1）：
   ```
-  - {YYYY-MM-DD HH:mm:ss±HH:MM} — **Watch PR (Round {N})** by {agent} — {成功：PR ready, repair commits: {k} [{sha 摘要}] / 阻塞：blocked: {简述}}
+  - {YYYY-MM-DD HH:mm:ss±HH:MM} — **Watch PR (Round {N})** by {agent} — {成功：PR ready, repair commits: {k} [{sha 摘要}] / 需复核：nextAction=review-code / 阻塞：blocked: {简述}}
   ```
 
 ### 6. 完成校验
@@ -124,6 +139,8 @@ agent-infra-internal task-verify {task-id} watch-pr.completed --format text
   {next-step-commands}
   ```
 
+- `summary-sync.nextAction == review-code`：说明报告要求代码审查；这不表示 PR readiness 已通过。使用 `agent-infra-internal agent-client next-steps --skill review-code --task-ref {task-ref}` 生成唯一下一步，结束本轮。不得继续 readiness/self-heal 或自行修改代码。
+
 - 「阻塞」：仅输出步骤 4 的阻塞说明，不推荐下一步命令。
 
 ## 完成检查清单

package/templates/.agents/skills/watch-pr/config/verify.json

@@ -15,7 +15,6 @@
       ]
     },
     "activity-log": {
-      "expected_action_pattern": "(Watch PR|Watching PR) \\(Round \\d+\\)"
     }
   }
 }

package/templates/.agents/skills/watch-pr/reference/monitor-and-heal.en.md

@@ -17,6 +17,20 @@ Before readiness in every round, and after an external push, self-heal commit, o
 
 When rebuilding the precheck, each of the six `rationale` fields must state the corresponding high-level finding and include at least one path, line range, and concise `detail` as evidence. `change-composition` must describe where responsibilities are concentrated; compatibility, legacy-path, redundancy, and scope checks must state their actual results separately, without reused generic boilerplate. Use the deployed skill's language for rationales and evidence details; Chinese skill deployments must use Chinese.
 
+Use the six existing `rationale` fields and `Evidence[]` to explain each logical change group: its goal and acceptance-criteria alignment, behavior added or removed, necessity, redundancy or duplication, scope, related tests, and test adequacy. Cite locatable code, test, or documentation evidence; mark unsupported points as unconfirmed. The renderer displays every evidence item. Source line counts, execution/call counts, and workflow unification are distinct claims: diff line counts cannot prove execution-count or workflow-behavior changes, and green CI cannot prove necessity. Analysis must not expand self-heal or refactoring authority.
+
+Keep complete-PR scope bound to the current authoritative base/head/merge-base/patch and its full statistics. Report the increment separately as previous valid report head → current head. Before overwriting the prior sidecar, validate it with `readPrChangeReport`; use its `identity.head.sha` only when its repository/resource identity matches the current PR. Compare the two head trees directly and state both SHAs. Do not substitute a merge-base diff for these endpoints or add increment totals to complete-PR totals. If no prior report exists, it is invalid, or its identity differs, mark the previous head unconfirmed; do not infer values from the full PR or fill in zeroes. Identical SHAs mean the head did not change. After a rebase, compare the old and new head trees. An invalid sidecar makes only the increment unconfirmed; the existing full-PR report flow continues.
+
+## Precheck Route
+
+After `summary-sync --strict` succeeds, consume its structured `nextAction` result before entering readiness:
+
+- `nextAction=review-code`: stop this Watch PR readiness/self-heal loop, recommend `review-code` through the unified helper, and end the round. Green CI does not clear necessity concerns, and Watch PR must not perform automatic redundancy cleanup or refactoring.
+- `nextAction=watch-pr`: continue through the existing readiness classification and self-heal decision tree.
+- Missing or invalid `nextAction`: use the strict-refresh help exit; do not infer `watch-pr`.
+
+This route reuses the result already derived by the core from the six checks. It does not grant Watch PR authority to write a `review-code` report or perform automatic fixes.
+
 ## Self-Heal Decision Tree
 
 ```text

package/templates/.agents/skills/watch-pr/reference/monitor-and-heal.zh-CN.md

@@ -2,7 +2,7 @@
 
 `watch-pr` 步骤 2/3/4 的平台无关判定逻辑。具体平台命令（监控、解析失败 run、拉日志、读取 PR 号）见 `.agents/rules/pr-checks-commands.md`；本文件只描述与平台无关的分类与决策。
 
-## Readiness 分类
+## 就绪状态分类
 
 按 `.agents/rules/pr-checks-commands.md` 的监控命令执行后，依其退出码归为三类：
 
@@ -17,6 +17,20 @@
 
 每轮重建 precheck 时，六项 `rationale` 都必须是对应检查的实际高层结论，并各带至少一条路径、行号和简短 `detail` 证据；`change-composition` 要说明职责集中位置，兼容、旧路径、冗余和范围检查要分别说明实际结果，禁止复用泛化套话。理由和证据详情遵循当前已部署技能的语言，中文技能必须使用中文。
 
+按逻辑变化组使用现有六项 `rationale` 和 `Evidence[]` 说明目标/验收对应、行为增减、必要性、冗余或重复、范围、相关测试及测试充分性。列出可定位的代码/测试/文档证据；缺证据时明确写未确认。renderer 会展示每项的全部 evidence。源码行数、执行/调用次数和流程统一是不同结论：diff 行数不能证明执行次数或流程行为变化；CI 全绿也不能证明必要性。不得由分析建议自行扩大自愈或重构权限。
+
+完整 PR 的范围继续绑定当前权威 base/head/merge-base/patch 与完整统计。增量单独绑定上一有效报告 head → 当前 head：在覆盖旧 sidecar 前，用 `readPrChangeReport` 校验旧报告，只在 repository/resource identity 匹配当前 PR 时采用旧 `identity.head.sha`。对两个 head 做 tree-to-tree diff 并明确列出 SHA，不用 merge-base 替代端点差异，不把增量 totals 加到完整 PR totals。没有旧报告、报告无效或身份不符时标注上一 head 未确认，不从全量推算或填零。两个 SHA 相同只报告 head 未变化；rebase 后仍比较原 head 和新 head 的树差异。sidecar 无效只使增量不可确认，不改变现有 full-PR 报告流程。
+
+## 预检分流
+
+`summary-sync --strict` 成功后，消费其结构化结果中的 `nextAction`，再决定是否进入 readiness：
+
+- `nextAction=review-code`：停止当前 Watch PR readiness 与自愈循环，按统一 helper 推荐 `review-code` 并结束本轮。不得把 CI 绿色当作清除必要性疑点，也不得自动实施冗余清理或重构。
+- `nextAction=watch-pr`：继续现有 readiness 分类与自愈决策树。
+- `nextAction` 缺失或 invalid：遵循严格刷新失败出口，进入求助流程，不推断为 `watch-pr`。
+
+此 route 只复用 core 已由六项 checks 推导的结果；不会把 `review-code` 报告或自动修复权限授予 Watch PR。
+
 ## 自愈决策树
 
 ```text

package/templates/.agents/templates/handoff.en.md

@@ -55,6 +55,6 @@
 
 ## References
 
-- Task file: `.agents/workspace/active/task-XXX.md`
+- Task file: `<task-workspace>/active/task-XXX.md`
 - Related docs: [links or file paths]
 - Related issues: #XXX

package/templates/.agents/templates/handoff.zh-CN.md

@@ -55,6 +55,6 @@
 
 ## 参考资料
 
-- 任务文件：`.agents/workspace/active/task-XXX.md`
+- 任务文件：`<task-workspace>/active/task-XXX.md`
 - 相关文档：[链接或文件路径]
 - 相关 Issue：#XXX

package/templates/.agents/workflows/bug-fix.en.yaml

@@ -200,4 +200,4 @@ steps:
       - Task workspace
     outputs:
       - Pull request (only on the PR path)
-      - Completed task workspace under .agents/workspace/completed/ after merge and final gates
+      - Completed task under `completed/{task-id}` in the host root returned by `task-workspace resolve`

package/templates/.agents/workflows/feature-development.en.yaml

@@ -200,4 +200,4 @@ steps:
       - Task workspace
     outputs:
       - Pull request (only on the PR path)
-      - Completed task workspace under .agents/workspace/completed/ after merge and final gates
+      - Completed task under `completed/{task-id}` in the host root returned by `task-workspace resolve`

package/templates/.agents/workflows/refactoring.en.yaml

@@ -204,4 +204,4 @@ steps:
       - Task workspace
     outputs:
       - Pull request (only on the PR path)
-      - Completed task workspace under .agents/workspace/completed/ after merge and final gates
+      - Completed task under `completed/{task-id}` in the host root returned by `task-workspace resolve`

package/dist/lib/runtime/agent-runtime.js

@@ -1,33 +0,0 @@
-import path from 'node:path';
-import { resolveTaskRuntimeRoot } from '../task/runtime-paths.js';
-function runtimeError(code, message) {
-    const error = new Error(`${code}: ${message}`);
-    error.name = code;
-    return error;
-}
-function boundControlContext(env) {
-    return [
-        'AGENT_INFRA_CONTROL_TOKEN',
-        'AGENT_INFRA_CONTROL_GENERATION',
-        'AGENT_INFRA_EXECUTOR_MANIFEST'
-    ].some((key) => typeof env[key] === 'string' && env[key].length > 0);
-}
-export function resolveAgentRuntimeRoot(options = {}) {
-    const env = options.env ?? process.env;
-    const configured = env.AGENT_INFRA_RUNTIME_DIR;
-    if (configured !== undefined && configured.length > 0) {
-        if (!path.isAbsolute(configured)) {
-            throw runtimeError('AGENT_INFRA_RUNTIME_DIR_INVALID', 'runtime directory must be absolute');
-        }
-        return path.resolve(configured);
-    }
-    const taskId = env.AGENT_INFRA_TASK_ID;
-    if (taskId) {
-        return resolveTaskRuntimeRoot(taskId, { repoRoot: options.repoRoot });
-    }
-    if (boundControlContext(env)) {
-        throw runtimeError('AGENT_INFRA_RUNTIME_DIR_REQUIRED', 'task-bound control context requires AGENT_INFRA_RUNTIME_DIR');
-    }
-    return path.join(path.resolve(options.repoRoot ?? process.cwd()), '.agents', 'workspace', '.runtime');
-}
-//# sourceMappingURL=agent-runtime.js.map

package/dist/lib/task/runtime-paths.js

@@ -1,10 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { resolveTaskRef } from './resolve-ref.js';
-export function resolveTaskRuntimeRoot(taskRef, options = {}) {
-    const resolved = resolveTaskRef(taskRef, options);
-    if (!resolved.ok)
-        throw new Error(`${resolved.code}: ${resolved.message}`);
-    return path.join(fs.realpathSync.native(resolved.taskDir), '.runtime');
-}
-//# sourceMappingURL=runtime-paths.js.map

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

@@ -1,250 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { createHash, randomUUID } from 'node:crypto';
-import { getProcessStartTime, processIdentityMatches } from '../server/process-state.js';
-class TaskExecutionLockError extends Error {
-    code;
-    detail;
-    constructor(code, message, detail) {
-        super(message);
-        this.name = 'TaskExecutionLockError';
-        this.code = code;
-        this.detail = detail;
-    }
-}
-function errno(error) {
-    const value = error?.code;
-    return typeof value === 'string' ? value : null;
-}
-function mapLinkError(operation, error, key) {
-    const code = errno(error);
-    if (code === 'EEXIST')
-        return 'exists';
-    if (operation === 'quarantine' && code === 'ENOENT')
-        return 'missing';
-    const detail = { operation, errno: code, key };
-    if (['EPERM', 'EACCES', 'ENOSYS', 'ENOTSUP', 'EOPNOTSUPP', 'EXDEV'].includes(code ?? '')) {
-        return new TaskExecutionLockError('ORCHESTRATION_LOCK_UNSUPPORTED', `lifecycle lock hard-link operation '${operation}' is unsupported`, detail);
-    }
-    return new TaskExecutionLockError('ORCHESTRATION_LOCK_FAILED', `lifecycle lock hard-link operation '${operation}' failed`, detail);
-}
-function lockKey(repoRoot, taskId, identityScope) {
-    const canonicalRepoRoot = fs.realpathSync.native(repoRoot);
-    const identity = identityScope === undefined
-        ? `${canonicalRepoRoot}\0${taskId}`
-        : `${identityScope}\0${taskId}`;
-    const key = createHash('sha256').update(identity).digest('hex');
-    return { canonicalRepoRoot, key };
-}
-function parseOwner(raw, key) {
-    try {
-        const value = JSON.parse(raw);
-        if (value !== null
-            && value.version === 2
-            && Number.isSafeInteger(value.pid)
-            && (value.pid ?? 0) > 0
-            && typeof value.startTime === 'number'
-            && Number.isSafeInteger(value.startTime)
-            && value.startTime >= 0
-            && typeof value.token === 'string'
-            && value.token.length > 0
-            && typeof value.owner === 'string'
-            && typeof value.canonicalRepoRoot === 'string'
-            && typeof value.taskId === 'string'
-            && typeof value.acquiredAt === 'string') {
-            return value;
-        }
-    }
-    catch {
-        // Fall through to the stable lock failure below.
-    }
-    throw new TaskExecutionLockError('ORCHESTRATION_LOCK_FAILED', 'lifecycle lock owner record is invalid', { operation: 'read', errno: null, key });
-}
-function unlinkIfPresent(file) {
-    try {
-        fs.unlinkSync(file);
-    }
-    catch (error) {
-        if (errno(error) !== 'ENOENT')
-            throw error;
-    }
-}
-function sameInode(left, right) {
-    return left.dev === right.dev && left.ino === right.ino;
-}
-function reclaimStaleLock(fixed, quarantine, snapshot, key, link) {
-    let linked = false;
-    try {
-        link(fixed, quarantine);
-        linked = true;
-    }
-    catch (error) {
-        const disposition = mapLinkError('quarantine', error, key);
-        if (disposition === 'missing')
-            return;
-        if (disposition === 'exists') {
-            try {
-                const quarantineSnapshot = fs.readFileSync(quarantine, 'utf8');
-                const fixedStat = fs.statSync(fixed);
-                const quarantineStat = fs.statSync(quarantine);
-                if (quarantineSnapshot === snapshot && sameInode(fixedStat, quarantineStat)) {
-                    unlinkIfPresent(quarantine);
-                }
-            }
-            catch (readError) {
-                if (errno(readError) !== 'ENOENT')
-                    throw readError;
-            }
-            return;
-        }
-        if (disposition instanceof TaskExecutionLockError)
-            throw disposition;
-    }
-    try {
-        const fixedSnapshot = fs.readFileSync(fixed, 'utf8');
-        const fixedStat = fs.statSync(fixed);
-        const quarantineStat = fs.statSync(quarantine);
-        if (fixedSnapshot === snapshot && sameInode(fixedStat, quarantineStat))
-            unlinkIfPresent(fixed);
-    }
-    catch (error) {
-        if (errno(error) !== 'ENOENT')
-            throw error;
-    }
-    finally {
-        if (linked)
-            unlinkIfPresent(quarantine);
-    }
-}
-function cleanStaleCandidates(lockRoot, key, identityMatches) {
-    const prefix = `${key}.candidate.`;
-    for (const name of fs.readdirSync(lockRoot)) {
-        if (!name.startsWith(prefix))
-            continue;
-        const candidate = path.join(lockRoot, name);
-        try {
-            const owner = parseOwner(fs.readFileSync(candidate, 'utf8'), key);
-            if (!identityMatches(owner))
-                unlinkIfPresent(candidate);
-        }
-        catch {
-            // A malformed candidate never owns the fixed lock and is left for manual diagnosis.
-        }
-    }
-}
-function withTaskExecutionLock(repoRoot, taskId, ownerName, callback, options = {}) {
-    let identity;
-    try {
-        identity = lockKey(repoRoot, taskId, options.identityScope);
-    }
-    catch (error) {
-        throw new TaskExecutionLockError('ORCHESTRATION_LOCK_FAILED', 'failed to canonicalize the repository for lifecycle locking', { operation: 'canonicalize', errno: errno(error), key: 'unresolved' });
-    }
-    const { canonicalRepoRoot, key } = identity;
-    const lockRoot = options.lockRoot ?? path.join(os.tmpdir(), 'agent-infra-lifecycle-locks');
-    const token = (options.token ?? randomUUID)();
-    const candidate = path.join(lockRoot, `${key}.candidate.${process.pid}.${token}`);
-    const fixed = path.join(lockRoot, `${key}.lock`);
-    const link = options.linkSync ?? fs.linkSync;
-    const startTime = (options.getStartTime ?? getProcessStartTime)(process.pid);
-    if (startTime === null) {
-        throw new TaskExecutionLockError('ORCHESTRATION_LOCK_FAILED', 'current process start time is unavailable', { operation: 'identity', errno: null, key });
-    }
-    const owner = {
-        version: 2,
-        pid: process.pid,
-        startTime,
-        token,
-        owner: ownerName,
-        canonicalRepoRoot,
-        taskId,
-        acquiredAt: (options.now ?? (() => new Date().toISOString()))()
-    };
-    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);
-        const descriptor = fs.openSync(candidate, 'wx', 0o600);
-        try {
-            fs.writeFileSync(descriptor, serialized);
-            fs.fsyncSync(descriptor);
-        }
-        finally {
-            fs.closeSync(descriptor);
-        }
-        for (let attempt = 0; attempt < 16; attempt += 1) {
-            try {
-                link(candidate, fixed);
-                ownsFixed = true;
-                break;
-            }
-            catch (error) {
-                const disposition = mapLinkError('acquire', error, key);
-                if (disposition instanceof TaskExecutionLockError)
-                    throw disposition;
-                let snapshot;
-                let current;
-                try {
-                    snapshot = fs.readFileSync(fixed, 'utf8');
-                    current = parseOwner(snapshot, key);
-                }
-                catch (readError) {
-                    if (errno(readError) === 'ENOENT')
-                        continue;
-                    throw readError;
-                }
-                if ((options.identityMatches ?? processIdentityMatches)(current)) {
-                    throw new TaskExecutionLockError('ORCHESTRATION_LOCK_BUSY', 'another lifecycle operation holds the task lock', { operation: 'acquire', errno: 'EEXIST', key });
-                }
-                reclaimStaleLock(fixed, `${fixed}.quarantine.${current.token}`, snapshot, key, link);
-            }
-        }
-        if (!ownsFixed) {
-            throw new TaskExecutionLockError('ORCHESTRATION_LOCK_BUSY', 'lifecycle task lock could not be acquired after stale recovery', { operation: 'acquire', errno: 'EEXIST', key });
-        }
-        unlinkIfPresent(candidate);
-        const value = callback();
-        if (value && typeof value.then === 'function') {
-            deferRelease = true;
-            return value.finally(release);
-        }
-        return value;
-    }
-    catch (error) {
-        if (error instanceof TaskExecutionLockError)
-            throw error;
-        if (error instanceof Error && ['OrchestrationStateError', 'ArtifactRecoveryError'].includes(error.name))
-            throw error;
-        throw new TaskExecutionLockError('ORCHESTRATION_LOCK_FAILED', 'lifecycle task lock operation failed', { operation: ownsFixed ? 'callback' : 'acquire', errno: errno(error), key });
-    }
-    finally {
-        if (!deferRelease)
-            release();
-    }
-}
-function withRepositoryMutationLock(repoRoot, callback, options = {}) {
-    return withTaskExecutionLock(repoRoot, '__repository_mutation__', 'repository-mutation', callback, options);
-}
-export { TaskExecutionLockError, lockKey, mapLinkError, withRepositoryMutationLock, withTaskExecutionLock };
-//# sourceMappingURL=task-execution-lock.js.map

package/lib/runtime/agent-runtime.ts

@@ -1,41 +0,0 @@
-import path from 'node:path';
-import { resolveTaskRuntimeRoot } from '../task/runtime-paths.ts';
-
-function runtimeError(code: string, message: string): Error {
-  const error = new Error(`${code}: ${message}`);
-  error.name = code;
-  return error;
-}
-
-function boundControlContext(env: NodeJS.ProcessEnv): boolean {
-  return [
-    'AGENT_INFRA_CONTROL_TOKEN',
-    'AGENT_INFRA_CONTROL_GENERATION',
-    'AGENT_INFRA_EXECUTOR_MANIFEST'
-  ].some((key) => typeof env[key] === 'string' && env[key]!.length > 0);
-}
-
-export function resolveAgentRuntimeRoot(options: Readonly<{
-  repoRoot?: string;
-  env?: NodeJS.ProcessEnv;
-}> = {}): string {
-  const env = options.env ?? process.env;
-  const configured = env.AGENT_INFRA_RUNTIME_DIR;
-  if (configured !== undefined && configured.length > 0) {
-    if (!path.isAbsolute(configured)) {
-      throw runtimeError('AGENT_INFRA_RUNTIME_DIR_INVALID', 'runtime directory must be absolute');
-    }
-    return path.resolve(configured);
-  }
-  const taskId = env.AGENT_INFRA_TASK_ID;
-  if (taskId) {
-    return resolveTaskRuntimeRoot(taskId, { repoRoot: options.repoRoot });
-  }
-  if (boundControlContext(env)) {
-    throw runtimeError(
-      'AGENT_INFRA_RUNTIME_DIR_REQUIRED',
-      'task-bound control context requires AGENT_INFRA_RUNTIME_DIR'
-    );
-  }
-  return path.join(path.resolve(options.repoRoot ?? process.cwd()), '.agents', 'workspace', '.runtime');
-}

package/lib/task/runtime-paths.ts

@@ -1,12 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { resolveTaskRef } from './resolve-ref.ts';
-
-export function resolveTaskRuntimeRoot(
-  taskRef: string,
-  options: Readonly<{ repoRoot?: string }> = {}
-): string {
-  const resolved = resolveTaskRef(taskRef, options);
-  if (!resolved.ok) throw new Error(`${resolved.code}: ${resolved.message}`);
-  return path.join(fs.realpathSync.native(resolved.taskDir), '.runtime');
-}