@fitlab-ai/agent-infra 0.9.1 → 0.9.3

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

@@ -1,10 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
 import { execFileSync } from "node:child_process";
+import { hasPlatformCapability } from "./adapters.js";
 import { inspectRequiredChecks } from "./pr-checks.js";
 import { resolvePlatformContext } from "./context.js";
 import { resolveReviewedHeadRelation } from "./merged-pr-equivalence.js";
-import { loadPostReviewConfig, resolvePostReviewGlobs } from "../task/review-fingerprint.js";
 const CHECK_TYPE = "required-checks";
 const SHA_PATTERN = /^[0-9a-f]{7,40}$/i;
 function validPrNumber(value) {
@@ -50,10 +50,9 @@ export function evaluateRequiredChecks(context, shared) {
     const relation = context.relation || (context.gitRoot && inspection.pullRequest?.head
         ? resolveReviewedHeadRelation({
             gitRoot: context.gitRoot,
-            localHead,
+            comparisonHead: localHead,
             lastReviewedCommit: reviewedHead,
-            pullRequest: inspection.pullRequest,
-            pathspecs: context.pathspecs || [":/"]
+            pullRequest: inspection.pullRequest
         })
         : localHead === reviewedHead && localHead === prHead
             ? { status: "strict" }
@@ -78,14 +77,14 @@ export function check({ taskDir }, shared) {
     const task = shared.loadTask(taskDir);
     if (!task.ok)
         return shared.failResult(CHECK_TYPE, task.message);
-    const platform = resolvePlatformContext({ cwd: shared.repoRoot });
-    if (platform.platform.type !== "github") {
-        return shared.passResult(CHECK_TYPE, "Skipped: this code platform does not provide required checks");
-    }
     const prFlow = readPrFlow(shared.repoRoot);
     if (prFlow === "disabled" || task.metadata.pr_status === "skipped" || !validPrNumber(task.metadata.pr_number)) {
         return evaluateRequiredChecks({ metadata: task.metadata, localHead: null, inspection: null, prFlow }, shared);
     }
+    const platform = resolvePlatformContext({ cwd: shared.repoRoot });
+    if (!hasPlatformCapability(platform.platform.type, "required-checks")) {
+        return shared.blockedResult(CHECK_TYPE, `Platform '${platform.platform.type || "none"}' does not provide required-checks inspection`, "dependency_error");
+    }
     const localHead = readHead(shared.repoRoot);
     if (!localHead)
         return evaluateRequiredChecks({ metadata: task.metadata, localHead, inspection: null, prFlow }, shared);
@@ -95,8 +94,7 @@ export function check({ taskDir }, shared) {
         localHead,
         inspection,
         prFlow,
-        gitRoot: shared.repoRoot,
-        pathspecs: resolvePostReviewGlobs({}, loadPostReviewConfig(shared.repoRoot))
+        gitRoot: shared.repoRoot
     }, shared);
 }
 //# sourceMappingURL=verification-required.js.map

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

@@ -0,0 +1,229 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseTaskFrontmatter } from '../task/frontmatter.js';
+export class HostResolutionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'HostResolutionError';
+        this.code = code;
+    }
+}
+function toPositiveNumber(value) {
+    const n = Number(value);
+    return Number.isInteger(n) && n > 0 ? n : null;
+}
+/**
+ * Parse the PR body for closing-issue references. Handles the conventional
+ * `Closes #1` / `Fixes: #2, #3` shapes (case-insensitive, comma/space
+ * separated, optional keyword list on the same logical line).
+ */
+export function extractClosingIssueNumbers(body) {
+    const result = [];
+    const seen = new Set();
+    const linePattern = /(?:^|\n)[^\n]*\b(?:close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\b[^\n]*/gi;
+    let lineMatch;
+    while ((lineMatch = linePattern.exec(body)) !== null) {
+        const line = lineMatch[0];
+        for (const numMatch of line.matchAll(/#(\d+)/g)) {
+            const n = Number(numMatch[1]);
+            if (Number.isInteger(n) && n > 0 && !seen.has(n)) {
+                seen.add(n);
+                result.push(n);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * 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.
+ */
+export function collectHostCandidates(input) {
+    const activeRoot = path.join(input.workspaceRoot, '.agents', 'workspace', 'active');
+    const candidates = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(activeRoot, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const taskDir = path.join(activeRoot, entry.name);
+        const taskMdPath = path.join(taskDir, 'task.md');
+        let content;
+        try {
+            content = fs.readFileSync(taskMdPath, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const frontmatter = parseTaskFrontmatter(content);
+        const issueNumber = toPositiveNumber(frontmatter.issue_number);
+        const prNumber = toPositiveNumber(frontmatter.pr_number);
+        if (prNumber === input.prNumber) {
+            candidates.push({ taskId: entry.name, taskDir, issueNumber, prNumber });
+        }
+        else if (issueNumber !== null && input.closingIssues.includes(issueNumber)) {
+            candidates.push({ taskId: entry.name, taskDir, issueNumber, prNumber });
+        }
+    }
+    return candidates;
+}
+/**
+ * Collapse a candidate list into a typed HostResolution. Zero candidates ->
+ * none; exactly one -> unique; more than one (no stable selection rule) ->
+ * ambiguous (fail closed, AN-6).
+ */
+export function resolveHostFromCandidates(candidates) {
+    if (candidates.length === 0)
+        return { kind: 'none' };
+    if (candidates.length === 1) {
+        const candidate = candidates[0];
+        return {
+            kind: 'unique',
+            taskId: candidate.taskId,
+            taskDir: candidate.taskDir,
+            issueNumber: candidate.issueNumber ?? 0,
+            prNumber: candidate.prNumber ?? 0
+        };
+    }
+    return {
+        kind: 'ambiguous',
+        candidates: candidates.map((candidate) => ({ taskId: candidate.taskId, issueNumber: candidate.issueNumber ?? 0 }))
+    };
+}
+function hasNoLifecycleArtifacts(presence) {
+    return !presence.hasAnalysis && !presence.hasPlan && !presence.hasCode &&
+        !presence.hasReviewAnalysis && !presence.hasReviewPlan && !presence.hasReviewCode &&
+        !presence.hasPriorPrReview;
+}
+function hasFullArtifacts(presence) {
+    return presence.hasAnalysis && presence.hasPlan && presence.hasCode &&
+        presence.hasReviewAnalysis && presence.hasReviewPlan && presence.hasReviewCode;
+}
+function isTrusted(head) {
+    return head.issueNumberBound && head.taskIssueMatches && (!head.prNumberBound || head.taskPrMatches);
+}
+/**
+ * Derive the S1(a) trust factor `taskIssueMatches` (PL-3) mechanically from
+ * resolved data: a unique host is trusted on the issue dimension only when the
+ * task's bound issue_number is among the PR's closing issues. Ambiguous/none
+ * hosts and tasks without a positive issue_number cannot be confirmed -> false
+ * (fail closed to S2/audit). `resolve-host` emits this value so the prompt layer
+ * does not derive the trust factor ad hoc (CD-2).
+ */
+export function deriveTaskIssueMatches(host, closingIssues) {
+    return host.kind === 'unique' && host.issueNumber > 0 && closingIssues.includes(host.issueNumber);
+}
+/**
+ * S1 -> S2 -> S3 classification (analysis §6.1). The ambiguous host is rejected
+ * before classification (AN-6 fail closed). S3(a) is host.kind === 'none';
+ * S3(b) is a unique task with no lifecycle artifacts and no prior pr-review
+ * (PL-5/PL-9 symmetric: any review-only task falls to S2).
+ */
+export function classifyScenario(host, presence, head) {
+    if (host.kind === 'ambiguous') {
+        throw new HostResolutionError('HOST_AMBIGUOUS', 'multiple candidate hosts; resolve before evidence classification');
+    }
+    if (host.kind === 'none')
+        return 'S3';
+    if (hasNoLifecycleArtifacts(presence))
+        return 'S3';
+    const priorHeadMatches = presence.hasPriorPrReview && head.priorHeadSha !== null && head.priorHeadSha === head.currentHeadSha;
+    if (hasFullArtifacts(presence) && priorHeadMatches && isTrusted(head))
+        return 'S1';
+    return 'S2';
+}
+/**
+ * Freshness is benchmarked against the prior `pr-review*` reviewed head SHA
+ * (analysis §6.2, AN-7). No prior review -> n/a/n/a (first-review special case).
+ */
+export function evaluateHead(head) {
+    if (head.priorHeadSha === null)
+        return { freshness: 'n/a', alignment: 'n/a' };
+    const freshness = head.priorHeadSha === head.currentHeadSha ? 'fresh' : 'stale';
+    const aligned = freshness === 'fresh' && isTrusted(head);
+    return { freshness, alignment: aligned ? 'aligned' : 'misaligned' };
+}
+/**
+ * Pure-evidence risk aggregation (analysis §6.3, AN-5): any priority factor
+ * (sensitivity / sourceCredibility) HIGH -> HIGH; otherwise any HIGH -> MEDIUM;
+ * all LOW -> LOW. Identity factors are structurally absent from the input type.
+ */
+export function gradeRisk(factors) {
+    const priority = [factors.sensitivity, factors.sourceCredibility];
+    if (priority.includes('HIGH'))
+        return 'HIGH';
+    const values = Object.values(factors);
+    if (values.includes('HIGH'))
+        return 'MEDIUM';
+    return 'LOW';
+}
+/**
+ * verify / audit / reconstruct selection matrix (analysis §6.4). S3 ->
+ * reconstruct; S2 -> audit; S1 fresh+aligned -> verify (LOW/MEDIUM risk) or
+ * audit (HIGH risk); any other S1 combination falls back to audit.
+ */
+export function selectMode(scenario, freshness, alignment, risk) {
+    if (scenario === 'S3')
+        return 'reconstruct';
+    if (scenario === 'S2')
+        return 'audit';
+    if (freshness === 'fresh' && alignment === 'aligned') {
+        return risk === 'HIGH' ? 'audit' : 'verify';
+    }
+    return 'audit';
+}
+function buildReason(input) {
+    const pieces = [];
+    if (input.firstReview)
+        pieces.push('first review (no prior pr-review head)');
+    if (input.hasPriorPrReview)
+        pieces.push(`prior head ${input.freshness}`);
+    if (input.freshness === 'fresh')
+        pieces.push(`alignment ${input.alignment}`);
+    pieces.push(`evidence scenario ${input.scenario}`);
+    pieces.push(`risk ${input.risk}`);
+    pieces.push(`mode ${input.mode}`);
+    return pieces.join('; ');
+}
+/**
+ * Full decision pipeline: classify -> freshness/alignment -> risk -> mode,
+ * producing a traceable DecisionRecord (AC3). Ambiguous hosts are rejected
+ * before any classification runs (AN-6).
+ */
+export function decide(input) {
+    if (input.host.kind === 'ambiguous') {
+        throw new HostResolutionError('HOST_AMBIGUOUS', 'ambiguous host; resolve before evidence classification');
+    }
+    const scenario = classifyScenario(input.host, input.presence, input.head);
+    const { freshness, alignment } = evaluateHead(input.head);
+    const risk = gradeRisk(input.riskFactors);
+    const mode = selectMode(scenario, freshness, alignment, risk);
+    const firstReview = !input.presence.hasPriorPrReview;
+    return {
+        host: input.host,
+        scenario,
+        freshness,
+        alignment,
+        risk,
+        mode,
+        firstReview,
+        reason: buildReason({
+            scenario,
+            freshness,
+            alignment,
+            risk,
+            mode,
+            firstReview,
+            hasPriorPrReview: input.presence.hasPriorPrReview
+        })
+    };
+}
+export { hasFullArtifacts, hasNoLifecycleArtifacts, isTrusted };
+//# sourceMappingURL=evidence-grading.js.map

package/dist/lib/prompt.js

@@ -74,18 +74,30 @@ async function select(question, choices, defaultValue) {
     }
     return trimmed;
 }
-async function multiSelect(question, choices) {
+async function multiSelect(question, choices, defaultIds = choices.map((choice) => choice.id)) {
+    const choiceIds = new Set(choices.map((choice) => choice.id));
+    if (defaultIds.some((id) => !choiceIds.has(id))) {
+        throw new Error('Default selection contains an unknown id');
+    }
+    const normalizedDefaults = choices
+        .map((choice) => choice.id)
+        .filter((id) => defaultIds.includes(id));
     process.stdout.write(`  ${question}:\n`);
     const idWidth = Math.max(...choices.map((c) => c.id.length));
     choices.forEach((c, i) => {
         process.stdout.write(`      ${i + 1}) ${c.id.padEnd(idWidth)}  (${c.label})\n`);
     });
-    ask('Enter comma-separated numbers or ids to keep, or "none" to select nothing [default: all]: ');
+    const defaultLabel = normalizedDefaults.length === choices.length
+        ? 'all'
+        : normalizedDefaults.length === 0
+            ? 'none'
+            : normalizedDefaults.join(',');
+    ask(`Enter comma-separated numbers or ids to keep, or "none" to select nothing [default: ${defaultLabel}]: `);
     setupInterface();
     const line = await nextLine();
     // Strictly distinguish bare Enter (null/empty string) from whitespace input.
     if (line === null || line === '')
-        return choices.map((c) => c.id);
+        return normalizedDefaults;
     // Explicit empty selection: "none" means deliberately zero built-in choices.
     if (line.trim().toLowerCase() === 'none')
         return [];

package/dist/lib/release/channels.js

@@ -21,7 +21,10 @@ async function inspectHomebrewChannel(url, version, fetcher = fetch) {
             return { status: 'blocked', published: null, version, error: { code: 'HOMEBREW_UNAVAILABLE', message: `formula endpoint returned ${response.status}` } };
         const formula = await response.text();
         const escaped = version.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        return { status: 'no-op', published: new RegExp(`(?:version\\s+["']${escaped}["']|/v?${escaped}\\.)`).test(formula), version, error: null };
+        const formulaUrl = /^\s*url\s+["']([^"']+)["']\s*$/m.exec(formula)?.[1] ?? '';
+        const npmTarball = new RegExp(`^https://registry\\.npmjs\\.org/.+/-/[^/]+-${escaped}\\.tgz$`).test(formulaUrl);
+        const bottle = /^\s*bottle do\s*$/m.test(formula);
+        return { status: 'no-op', published: npmTarball && bottle, version, error: null };
     }
     catch (error) {
         return { status: 'blocked', published: null, version, error: { code: 'HOMEBREW_UNAVAILABLE', message: error instanceof Error ? error.message : String(error) } };

package/dist/lib/release/workflow.js

@@ -1,5 +1,5 @@
 function deriveReleasePhase(facts) {
-    if (!facts.localTag)
+    if (!facts.localTag && !facts.localTagAncestor)
         return 'unprepared';
     if (!facts.remoteBranch && !facts.remoteTag)
         return 'prepared';
@@ -18,8 +18,10 @@ async function runReleaseAction(input) {
     const before = releaseSnapshot(input.version, await input.inspect());
     if (input.action === 'inspect')
         return { status: 'no-op', changed: false, before, snapshot: before, error: null };
+    if (before.facts.localTagConflict)
+        return { status: 'failed', changed: false, before, snapshot: before, error: { code: 'GIT_TAG_CONFLICT', message: `Tag ${before.tag} is not reachable from HEAD` } };
     const allowed = input.action === 'prepare' ? before.phase === 'unprepared'
-        : input.action === 'publish' ? ['prepared', 'partially-published'].includes(before.phase)
+        : input.action === 'publish' ? before.facts.localTag && ['prepared', 'partially-published'].includes(before.phase)
             : ['published', 'post-pending'].includes(before.phase);
     if (!allowed)
         return { status: before.phase === 'complete' ? 'no-op' : 'failed', changed: false, before, snapshot: before, error: before.phase === 'complete' ? null : { code: 'RELEASE_PHASE_INVALID', message: `Cannot ${input.action} from ${before.phase}` } };

package/dist/lib/remove-dir.js

@@ -0,0 +1,25 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function removeDirRecursive(dir) {
+    if (!fs.existsSync(dir)) {
+        return;
+    }
+    const pending = [dir];
+    const directories = [];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        const stat = fs.lstatSync(current);
+        if (!stat.isDirectory() || stat.isSymbolicLink()) {
+            fs.unlinkSync(current);
+            continue;
+        }
+        directories.push(current);
+        for (const entry of fs.readdirSync(current)) {
+            pending.push(path.join(current, entry));
+        }
+    }
+    for (const directory of directories.reverse()) {
+        fs.rmdirSync(directory);
+    }
+}
+//# sourceMappingURL=remove-dir.js.map

package/dist/lib/run/tui.js

@@ -1,4 +1,6 @@
-const TUI_NAMES = new Set(['claude', 'codex', 'gemini', 'opencode']);
+import { renderAgentClientInvocation } from '../agent-clients/invocation.js';
+import { getAgentClientAdapter } from '../agent-clients/registry.js';
+const TUI_NAMES = new Set(['claude', 'codex', 'antigravity', 'opencode']);
 function isTuiName(value) {
     return typeof value === 'string' && TUI_NAMES.has(value);
 }
@@ -17,17 +19,19 @@ export function selectTui(skill, options) {
 }
 export function renderPrompt(params) {
     const suffix = [params.skill, ...params.args].join(' ').trim();
-    if (params.tui === 'codex')
-        return `$${suffix}`;
-    if (params.tui === 'gemini')
-        return `/agent-infra:${suffix}`;
+    if (params.tui === 'codex') {
+        return renderAgentClientInvocation(getAgentClientAdapter('codex').invocation, {
+            skillName: params.skill,
+            args: params.args
+        });
+    }
     return `/${suffix}`;
 }
 export function buildTuiCommand(tui, prompt) {
     if (tui === 'claude')
         return ['claude', ['--dangerously-skip-permissions', '--print', prompt]];
-    if (tui === 'gemini')
-        return ['gemini', ['--approval-mode', 'yolo', '--prompt', prompt]];
+    if (tui === 'antigravity')
+        return ['agy', ['--dangerously-skip-permissions', '--print', prompt]];
     if (tui === 'opencode')
         return ['opencode', ['run', '--dangerously-skip-permissions', prompt]];
     return ['codex', ['exec', '--dangerously-bypass-approvals-and-sandbox', prompt]];

package/dist/lib/sandbox/agent-client-reconciler.js

@@ -0,0 +1,234 @@
+import { createHash } from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { isAgentClientId } from '../agent-clients/types.js';
+import { listAgentClientAdapters, listInstalledAgentClientAdapters } from '../agent-clients/registry.js';
+import { hostJoin } from './engines/wsl2-paths.js';
+const DEFAULT_SANDBOX_HOOK_TIMEOUT_MS = 30_000;
+function agentInfraTool(home) {
+    return {
+        id: 'agent-infra',
+        name: 'agent-infra CLI',
+        install: { type: 'npm', cmd: '@fitlab-ai/agent-infra@latest' },
+        sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'agent-infra'),
+        containerMount: '/home/devuser/.agent-infra-cli',
+        versionCmd: 'ai version --raw',
+        setupHint: 'Provides the ai and agent-infra CLI commands inside the sandbox.'
+    };
+}
+function compatAgentClientState(tools) {
+    return Object.fromEntries(listAgentClientAdapters().map((adapter) => [
+        adapter.id,
+        {
+            enabled: true,
+            installInSandbox: tools.includes(adapter.id)
+        }
+    ]));
+}
+function stableValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(stableValue);
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, nested]) => [key, stableValue(nested)]));
+    }
+    return value;
+}
+function runtimeToolProjection(tool) {
+    return stableValue({
+        id: tool.id,
+        install: tool.install,
+        containerMount: tool.containerMount,
+        versionCmd: tool.versionCmd,
+        envVars: tool.envVars ?? {},
+        hostPreSeedFiles: (tool.hostPreSeedFiles ?? []).map(({ sandboxName }) => ({ sandboxName })),
+        hostPreSeedDirs: (tool.hostPreSeedDirs ?? []).map(({ sandboxSubdir }) => ({ sandboxSubdir })),
+        pathRewriteFiles: tool.pathRewriteFiles ?? [],
+        hostLiveMounts: (tool.hostLiveMounts ?? []).map(({ containerSubpath }) => ({ containerSubpath })),
+        postSetupCmds: tool.postSetupCmds ?? [],
+        tmpfs: tool.tmpfs ?? null
+    });
+}
+function hash(value) {
+    return createHash('sha256').update(JSON.stringify(stableValue(value))).digest('hex');
+}
+function assertUniqueTools(tools) {
+    const seen = new Set();
+    for (const tool of tools) {
+        if (seen.has(tool.id)) {
+            throw new Error(`Duplicate sandbox tool id "${tool.id}"`);
+        }
+        seen.add(tool.id);
+    }
+}
+function hooksByPhase(adapters) {
+    const phases = [
+        'prepare',
+        'before-container-create',
+        'after-container-start',
+        'before-enter'
+    ];
+    return Object.freeze(Object.fromEntries(phases.map((phase) => [
+        phase,
+        Object.freeze(adapters.flatMap((adapter) => adapter.sandbox.hooks.filter((hook) => hook.phase === phase)))
+    ])));
+}
+function createSandboxCapabilityPlan(config) {
+    const state = config.agentClientState ?? compatAgentClientState(config.tools);
+    const selectedAgentClients = listInstalledAgentClientAdapters(state);
+    const context = { home: config.home, project: config.project };
+    const selectedTools = selectedAgentClients.map((adapter) => adapter.sandbox.createTool(context));
+    const allClientTools = listAgentClientAdapters().map((adapter) => adapter.sandbox.createTool(context));
+    const customById = new Map((config.customTools ?? []).map((tool) => [tool.id, tool]));
+    if (customById.size !== (config.customTools ?? []).length) {
+        throw new Error('Duplicate sandbox tool id in customTools');
+    }
+    for (const id of customById.keys()) {
+        if (id === 'agent-infra' || isAgentClientId(id)) {
+            throw new Error(`Custom sandbox tool id "${id}" collides with a built-in tool`);
+        }
+    }
+    const nonClientTools = [];
+    const selectedCustomTools = [];
+    for (const id of config.tools) {
+        if (isAgentClientId(id))
+            continue;
+        if (id === 'agent-infra') {
+            if (!nonClientTools.some((tool) => tool.id === id)) {
+                nonClientTools.push(agentInfraTool(config.home));
+            }
+            continue;
+        }
+        const custom = customById.get(id);
+        if (!custom) {
+            throw new Error(`Unknown sandbox tool: ${id}`);
+        }
+        selectedCustomTools.push(custom);
+    }
+    const tools = Object.freeze([...nonClientTools, ...selectedTools, ...selectedCustomTools]);
+    assertUniqueTools(tools);
+    const phaseHooks = hooksByPhase(selectedAgentClients);
+    const hookProjection = selectedAgentClients.flatMap((adapter) => adapter.sandbox.hooks.map((hook) => ({
+        adapterId: adapter.id,
+        id: hook.id,
+        phase: hook.phase,
+        timeoutMs: hook.timeoutMs ?? DEFAULT_SANDBOX_HOOK_TIMEOUT_MS
+    })));
+    const recoveryChecks = Object.freeze(selectedAgentClients.flatMap((adapter) => (adapter.sandbox.recoveryChecks ?? []).map((check) => Object.freeze({
+        adapterId: adapter.id,
+        check
+    }))));
+    const recoveryCheckProjection = Object.freeze(recoveryChecks.map(({ adapterId, check }) => Object.freeze({
+        adapterId,
+        id: check.id,
+        ...(check.when === undefined ? {} : { when: check.when }),
+        probe: check.probe,
+        finding: Object.freeze({
+            repairKind: check.finding.repairKind,
+            ...(check.finding.path === undefined ? {} : { path: check.finding.path })
+        }),
+        ...(check.repair === undefined ? {} : { repair: check.repair })
+    })));
+    const runtimeProjection = Object.freeze({
+        tools: Object.freeze(tools.map(runtimeToolProjection)),
+        selectedAgentClients: Object.freeze(selectedAgentClients.map((adapter) => adapter.id)),
+        hooks: Object.freeze(hookProjection),
+        recoveryChecks: recoveryCheckProjection
+    });
+    const cleanupInventory = Object.freeze([
+        agentInfraTool(config.home),
+        ...allClientTools,
+        ...customById.values()
+    ]);
+    assertUniqueTools(cleanupInventory);
+    return Object.freeze({
+        tools,
+        selectedAgentClients,
+        hooksByPhase: phaseHooks,
+        recoveryChecks,
+        aliases: Object.freeze(listAgentClientAdapters().flatMap((adapter) => adapter.sandbox.aliases)),
+        imageSignature: hash(tools.map(({ id, install }) => ({ id, install }))),
+        runtimeSignature: hash(runtimeProjection),
+        runtimeProjection,
+        cleanupInventory
+    });
+}
+function timeoutStatus(phase) {
+    if (phase === 'before-enter')
+        return 'warning';
+    return 'fatal';
+}
+async function runSandboxHooks({ hooks, phase, context, runCommand = async () => {
+    throw new Error('Sandbox hook command runner is unavailable');
+}, scheduleTimeout = (callback, timeoutMs) => setTimeout(callback, timeoutMs), clearScheduledTimeout = (handle) => clearTimeout(handle) }) {
+    const results = [];
+    for (const hook of hooks) {
+        if (hook.phase !== phase)
+            continue;
+        const timeoutMs = hook.timeoutMs ?? DEFAULT_SANDBOX_HOOK_TIMEOUT_MS;
+        const controller = new AbortController();
+        let timedOut = false;
+        let timer;
+        const timeout = new Promise((resolve) => {
+            timer = scheduleTimeout(() => {
+                timedOut = true;
+                controller.abort();
+                resolve({
+                    status: timeoutStatus(phase),
+                    message: `Sandbox hook '${hook.id}' timed out after ${timeoutMs}ms.`
+                });
+            }, timeoutMs);
+        });
+        let result;
+        try {
+            const execution = Promise.resolve().then(() => hook.run({
+                ...context,
+                signal: controller.signal,
+                runCommand: (command) => runCommand(command, {
+                    signal: controller.signal,
+                    timeoutMs
+                })
+            }));
+            result = await Promise.race([execution, timeout]);
+        }
+        catch (error) {
+            result = {
+                status: timeoutStatus(phase),
+                message: error instanceof Error ? error.message : String(error)
+            };
+        }
+        finally {
+            clearScheduledTimeout(timer);
+        }
+        results.push({
+            hookId: hook.id,
+            phase,
+            status: result.status,
+            ...(result.message ? { message: result.message } : {})
+        });
+        if (timedOut || result.status === 'fatal' || result.status === 'hard-failure') {
+            break;
+        }
+    }
+    return results;
+}
+function runBoundedSandboxHookCommand(command, options) {
+    return new Promise((resolve, reject) => {
+        execFile(command.command, [...(command.args ?? [])], {
+            cwd: command.cwd,
+            env: command.env,
+            encoding: 'utf8',
+            signal: options.signal,
+            timeout: options.timeoutMs
+        }, (error, stdout) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve({ stdout: stdout.trim() });
+        });
+    });
+}
+export { DEFAULT_SANDBOX_HOOK_TIMEOUT_MS, createSandboxCapabilityPlan, runBoundedSandboxHookCommand, runSandboxHooks };
+//# sourceMappingURL=agent-client-reconciler.js.map

package/dist/lib/sandbox/clipboard/linux.js

@@ -2,10 +2,11 @@ import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { removeDirRecursive } from '../../remove-dir.js';
 const PROBE_TIMEOUT_MS = 2_000;
 const READ_IMAGE_TIMEOUT_MS = 5_000;
 const PNG_MAGIC = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-export function createLinuxClipboardAdapter({ env = process.env, execFn = execFileSync, execToFileFn = execToFile, mkdtempFn = fs.mkdtempSync, readFileFn = fs.readFileSync, rmFn = fs.rmSync } = {}) {
+export function createLinuxClipboardAdapter({ env = process.env, execFn = execFileSync, execToFileFn = execToFile, mkdtempFn = fs.mkdtempSync, readFileFn = fs.readFileSync, rmFn = removeDirRecursive } = {}) {
     return {
         available() {
             const backend = selectBackend(env);