@fitlab-ai/agent-infra 0.9.4 → 0.9.5

package/dist/lib/task/orchestration.js

@@ -13,10 +13,12 @@ import { inspectPlatformPullRequest } from '../platform/pull-requests.js';
 import { getAgentClientCapability, getAgentClientDelegationEvidence, getAgentClientModelSelection } from '../agent-clients/registry.js';
 import { isAgentClientId } from '../agent-clients/types.js';
 import { captureRepositorySnapshot, captureWorkspaceSnapshot, diffWorkspaceSnapshots } from './workspace-snapshot.js';
+import { assertGitRepositoryBinding } from '../git/worktree-identity.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { CommitIntentError, commitIntentPath, createCommitIntent, digest, readCommitIntent, removeCommitIntent, removeCommitIntentByDigest, serialize, updateCommitIntent } from './commit-intent.js';
 import { inspectCommitFinalization, planCommitTaskFinalization } from './commit-finalization.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
+import { appendActivityEntry, commitAttemptStartedNote, locateActivityLog, pairEntries } from './activity-log.js';
 function supportsLifecycleDelegation(client) {
     return getAgentClientCapability(client, 'subagents').level !== 'unsupported'
         && getAgentClientCapability(client, 'orchestration').level !== 'unsupported'
@@ -71,6 +73,11 @@ function repositoryHead(repoRoot) {
         stdio: ['ignore', 'pipe', 'pipe']
     }).trim();
 }
+function gitRootFor(stateRoot, options) {
+    if (!options.gitWorktreeRoot)
+        return stateRoot;
+    return assertGitRepositoryBinding(stateRoot, options.gitWorktreeRoot).worktreeRoot;
+}
 function isAncestor(repoRoot, ancestor, descendant) {
     return spawnSync('git', ['merge-base', '--is-ancestor', ancestor, descendant], {
         cwd: repoRoot,
@@ -97,7 +104,8 @@ function commitFinalizationView(inspection) {
         currentHead: inspection.currentHead,
         committedHead: inspection.committedHead,
         needsAnchor: inspection.needsAnchor,
-        needsLog: inspection.needsLog
+        needsLog: inspection.needsLog,
+        attempt: inspection.attempt
     };
 }
 function validCommitRun(run, taskId) {
@@ -399,6 +407,13 @@ function routeOrchestration(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
+    let gitRoot;
+    try {
+        gitRoot = gitRootFor(resolved.repoRoot, options);
+    }
+    catch (error) {
+        return failed('ORCHESTRATION_WORKTREE_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
+    }
     let content;
     try {
         content = fs.readFileSync(resolved.taskMdPath, 'utf8');
@@ -469,7 +484,7 @@ function routeOrchestration(taskRef, options = {}) {
         const capture = options.captureRepository ?? captureRepositorySnapshot;
         let before;
         try {
-            before = capture(resolved.repoRoot);
+            before = capture(gitRoot);
         }
         catch (error) {
             return failed('ORCHESTRATION_SNAPSHOT_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
@@ -484,7 +499,7 @@ function routeOrchestration(taskRef, options = {}) {
         const inspect = options.inspectPullRequest ?? inspectPlatformPullRequest;
         let inspection;
         try {
-            inspection = inspect(resolved.taskId, { cwd: resolved.repoRoot });
+            inspection = inspect(resolved.taskId, { cwd: gitRoot });
         }
         catch (error) {
             return failed('ORCHESTRATION_PR_INSPECTION_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
@@ -505,7 +520,7 @@ function routeOrchestration(taskRef, options = {}) {
         }
         let after;
         try {
-            after = capture(resolved.repoRoot);
+            after = capture(gitRoot);
         }
         catch (error) {
             return failed('ORCHESTRATION_SNAPSHOT_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
@@ -538,13 +553,101 @@ function routeOrchestration(taskRef, options = {}) {
     }
     return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
 }
+function appendCommitActivity(resolved, step, agent, note) {
+    const taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
+    const activity = locateActivityLog(taskContent);
+    if (!activity)
+        return { code: 'ORCHESTRATION_TASK_INVALID', message: 'task activity log is missing or ambiguous' };
+    const metadata = captureTaskWriteMetadata();
+    const written = writeTask({
+        taskRef: resolved.taskId,
+        expectedState: 'active',
+        mutations: [{
+                kind: 'section',
+                aliases: ['活动日志', 'Activity Log'],
+                heading: activity.heading,
+                body: appendActivityEntry(activity, { time: metadata.timestamp, step, agent, note })
+            }]
+    }, { repoRoot: resolved.repoRoot, metadataProvider: () => metadata });
+    return written.status === 'failed' ? written.error : null;
+}
+function startCommitAttempt(taskRef, input, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
+    try {
+        const gitRoot = gitRootFor(resolved.repoRoot, options);
+        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'commit-attempt.start', () => {
+            if (fs.existsSync(commitIntentPath(resolved.taskDir))) {
+                return commitIntentFailed('ORCHESTRATION_COMMIT_INTENT_BUSY', 'an active commit intent already exists', resolved.taskId);
+            }
+            const taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
+            const activity = locateActivityLog(taskContent);
+            if (!activity)
+                return commitIntentFailed('ORCHESTRATION_TASK_INVALID', 'task activity log is missing or ambiguous', resolved.taskId);
+            const open = pairEntries(activity.entries).filter((row) => row.step === 'Commit' && row.started !== '' && row.done === '');
+            if (open.length > 0) {
+                return commitIntentFailed('ORCHESTRATION_COMMIT_ATTEMPT_BUSY', 'an open Commit activity entry already exists', resolved.taskId);
+            }
+            const currentHead = repositoryHead(gitRoot);
+            const attempt = (options.id ?? randomUUID)();
+            const error = appendCommitActivity(resolved, 'Commit [started]', input.agent, commitAttemptStartedNote({
+                attempt,
+                baseline: currentHead,
+                agent: input.agent
+            }));
+            if (error)
+                return commitIntentFailed(error.code, error.message, resolved.taskId);
+            const inspection = inspectCommitFinalization(resolved.taskDir, gitRoot, resolved.taskId);
+            return {
+                status: 'ready', changed: true, taskId: resolved.taskId, intent: null,
+                finalization: commitFinalizationView(inspection), error: null
+            };
+        });
+    }
+    catch (error) {
+        return mapCommitIntentError(error, resolved.taskId);
+    }
+}
+function terminateCommitAttempt(taskRef, input, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
+    try {
+        const gitRoot = gitRootFor(resolved.repoRoot, options);
+        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'commit-attempt.terminate', () => {
+            if (fs.existsSync(commitIntentPath(resolved.taskDir))) {
+                return commitIntentFailed('ORCHESTRATION_COMMIT_RECOVERY_REQUIRED', 'an active commit intent must be aborted or recovered first', resolved.taskId);
+            }
+            const inspection = inspectCommitFinalization(resolved.taskDir, gitRoot, resolved.taskId);
+            if (inspection.disposition !== 'retryable-start'
+                || inspection.attempt?.attempt !== input.attempt
+                || inspection.attempt.agent !== input.agent
+                || inspection.attempt.baseline !== inspection.currentHead) {
+                return commitIntentFailed('ORCHESTRATION_COMMIT_RECOVERY_REQUIRED', 'commit attempt identity or repository HEAD has drifted', resolved.taskId);
+            }
+            const error = appendCommitActivity(resolved, 'Commit [aborted]', input.agent, `aborted; attempt=${input.attempt}; code=${input.code}`);
+            if (error)
+                return commitIntentFailed(error.code, error.message, resolved.taskId);
+            return {
+                status: 'ready', changed: true, taskId: resolved.taskId, intent: null,
+                finalization: commitFinalizationView(inspectCommitFinalization(resolved.taskDir, gitRoot, resolved.taskId)),
+                error: null
+            };
+        });
+    }
+    catch (error) {
+        return mapCommitIntentError(error, resolved.taskId);
+    }
+}
 function beginCommitIntent(taskRef, input, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
     try {
+        const gitRoot = gitRootFor(resolved.repoRoot, options);
         return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'commit-intent.begin', () => {
-            const currentHead = repositoryHead(resolved.repoRoot);
+            const currentHead = repositoryHead(gitRoot);
             if (currentHead !== input.baselineHead) {
                 return commitIntentFailed('ORCHESTRATION_COMMIT_BASELINE_MISMATCH', 'baseline HEAD does not match the repository HEAD', resolved.taskId);
             }
@@ -557,6 +660,13 @@ function beginCommitIntent(taskRef, input, options = {}) {
                 }
                 return commitIntentFailed('ORCHESTRATION_COMMIT_INTENT_BUSY', 'an active commit intent already exists', resolved.taskId);
             }
+            const attemptInspection = inspectCommitFinalization(resolved.taskDir, gitRoot, resolved.taskId);
+            if (attemptInspection.disposition !== 'retryable-start'
+                || attemptInspection.attempt?.attempt !== input.attempt
+                || attemptInspection.attempt.agent !== input.agent
+                || attemptInspection.attempt.baseline !== input.baselineHead) {
+                return commitIntentFailed('ORCHESTRATION_COMMIT_ATTEMPT_MISMATCH', 'commit begin requires one matching retryable Commit attempt', resolved.taskId);
+            }
             const runFile = orchestrationPath(resolved.taskDir);
             let run = null;
             let sourceRunBytes = null;
@@ -646,13 +756,14 @@ function checkpointCommitIntent(taskRef, input, options = {}) {
     if (!resolved.ok)
         return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
     try {
+        const gitRoot = gitRootFor(resolved.repoRoot, options);
         return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'commit-intent.checkpoint', () => {
             const intent = readCommitIntent(resolved.taskDir, resolved.taskId, input.token);
-            const currentHead = repositoryHead(resolved.repoRoot);
+            const currentHead = repositoryHead(gitRoot);
             if (currentHead !== input.head) {
                 return commitIntentFailed('ORCHESTRATION_COMMIT_RECOVERY_REQUIRED', 'checkpoint HEAD does not match the repository HEAD', resolved.taskId);
             }
-            if (input.kind === 'committed' && !isAncestor(resolved.repoRoot, intent.baselineHead, input.head)) {
+            if (input.kind === 'committed' && !isAncestor(gitRoot, intent.baselineHead, input.head)) {
                 return commitIntentFailed('ORCHESTRATION_COMMIT_RECOVERY_REQUIRED', 'committed HEAD does not descend from the baseline', resolved.taskId);
             }
             if (input.kind === 'pushed') {
@@ -750,9 +861,10 @@ function completeCommitIntent(taskRef, input, options = {}) {
     if (!resolved.ok)
         return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
     try {
+        const gitRoot = gitRootFor(resolved.repoRoot, options);
         return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'commit-intent.complete', () => {
             readCommitIntent(resolved.taskDir, resolved.taskId, input.token);
-            const inspection = inspectCommitFinalization(resolved.taskDir, resolved.repoRoot, resolved.taskId);
+            const inspection = inspectCommitFinalization(resolved.taskDir, gitRoot, resolved.taskId);
             return finalizeCommitIntentUnlocked(resolved, inspection, input.agent, () => {
                 removeCommitIntent(resolved.taskDir, resolved.taskId, input.token);
             });
@@ -767,8 +879,15 @@ function recoverCommitIntent(taskRef, input, options = {}) {
     if (!resolved.ok)
         return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
     try {
+        const gitRoot = gitRootFor(resolved.repoRoot, options);
         return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'commit-intent.recover', () => {
-            const inspection = inspectCommitFinalization(resolved.taskDir, resolved.repoRoot, resolved.taskId);
+            const inspection = inspectCommitFinalization(resolved.taskDir, gitRoot, resolved.taskId);
+            if (inspection.disposition === 'retryable-start') {
+                return {
+                    status: 'ready', changed: false, taskId: resolved.taskId, intent: null,
+                    finalization: commitFinalizationView(inspection), error: null
+                };
+            }
             if (inspection.disposition === 'prepared' && inspection.intentDigest) {
                 removeCommitIntentByDigest(resolved.taskDir, resolved.taskId, inspection.intentDigest);
                 return { status: 'ready', changed: true, taskId: resolved.taskId, intent: null, error: null };
@@ -790,9 +909,10 @@ function abortCommitIntent(taskRef, input, options = {}) {
     if (!resolved.ok)
         return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
     try {
+        const gitRoot = gitRootFor(resolved.repoRoot, options);
         return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'commit-intent.abort', () => {
             const intent = readCommitIntent(resolved.taskDir, resolved.taskId, input.token);
-            const currentHead = repositoryHead(resolved.repoRoot);
+            const currentHead = repositoryHead(gitRoot);
             if (intent.phase !== 'prepared'
                 || intent.pushEvidence !== null
                 || input.expectedHead !== intent.baselineHead
@@ -811,7 +931,14 @@ function statusCommitIntent(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
-    const inspection = inspectCommitFinalization(resolved.taskDir, resolved.repoRoot, resolved.taskId);
+    let gitRoot;
+    try {
+        gitRoot = gitRootFor(resolved.repoRoot, options);
+    }
+    catch (error) {
+        return commitIntentFailed('ORCHESTRATION_WORKTREE_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
+    }
+    const inspection = inspectCommitFinalization(resolved.taskDir, gitRoot, resolved.taskId);
     return {
         status: 'ready',
         changed: false,
@@ -878,7 +1005,11 @@ function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
     }
     let beforeFingerprint;
     try {
-        beforeFingerprint = (options.captureWorkspace ?? captureWorkspaceSnapshot)(resolved.repoRoot, resolved.taskId);
+        beforeFingerprint = (options.captureWorkspace ?? captureWorkspaceSnapshot)({
+            gitRoot: gitRootFor(resolved.repoRoot, options),
+            stateRoot: resolved.repoRoot,
+            taskId: resolved.taskId
+        });
     }
     catch (error) {
         return failed('ORCHESTRATION_SNAPSHOT_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
@@ -969,9 +1100,14 @@ function sealMatchingOrchestrationDelegation(client, event, options = {}) {
     }
     const repoRoot = options.repoRoot ?? process.cwd();
     try {
+        const gitRoot = gitRootFor(repoRoot, options);
         const snapshotTaskId = receipt.workspaceSnapshotScope === 'task' ? receipt.taskId : null;
-        const afterFingerprint = (options.captureWorkspace ?? captureWorkspaceSnapshot)(repoRoot, snapshotTaskId);
-        const changedPaths = (options.diffWorkspace ?? diffWorkspaceSnapshots)(repoRoot, receipt.beforeFingerprint, afterFingerprint);
+        const afterFingerprint = (options.captureWorkspace ?? captureWorkspaceSnapshot)({
+            gitRoot,
+            stateRoot: repoRoot,
+            taskId: snapshotTaskId
+        });
+        const changedPaths = (options.diffWorkspace ?? diffWorkspaceSnapshots)(gitRoot, receipt.beforeFingerprint, afterFingerprint);
         return sealOrchestrationDelegation(matched.taskId, {
             childId: event.childId,
             exitCode: 0,
@@ -1115,5 +1251,5 @@ function pauseOrchestration(taskRef, code, message, recoverable, options = {}) {
     saveRun(resolved.taskDir, updated);
     return { status: 'paused', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
 }
-export { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, abortCommitIntent, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, commitOrchestrationStageCompletion, completeCommitIntent, completeOrchestrationStage, inspectOrchestrationStage, orchestrationPath, pauseOrchestration, planOrchestrationStageCompletion, prepareOrchestrationDelegation, readRun, recoverCommitIntent, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusCommitIntent, statusOrchestration };
+export { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, abortCommitIntent, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, commitOrchestrationStageCompletion, completeCommitIntent, completeOrchestrationStage, inspectOrchestrationStage, orchestrationPath, pauseOrchestration, planOrchestrationStageCompletion, prepareOrchestrationDelegation, readRun, recoverCommitIntent, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, startCommitAttempt, statusCommitIntent, statusOrchestration, terminateCommitAttempt };
 //# sourceMappingURL=orchestration.js.map

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

@@ -1,6 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
 import { artifactName, maxRound } from "./review-artifacts.js";
+const REVIEWED_TREE_RE = /^[a-f0-9]{40,64}$/;
+export function parseReviewedGitTree(value) {
+    return REVIEWED_TREE_RE.test(value) ? value : null;
+}
 // Paths excluded from the post-review coverage gate. Fail-closed: the gate
 // covers ALL tracked changes by default. This default denylist is EMPTY —
 // projects opt into exclusions explicitly via review.post_review_exclude_globs.

package/dist/lib/task/workspace-snapshot.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -25,12 +26,70 @@ function captureWorktreeTree(repoRoot, forcedPath) {
         fs.rmSync(tempDir, { recursive: true, force: true });
     }
 }
-function captureWorkspaceSnapshot(repoRoot, taskId) {
+function captureLegacyWorkspaceSnapshot(repoRoot, taskId) {
     const workspaceRelative = taskId
         ? `.agents/workspace/active/${taskId}`
         : '.agents/workspace/active';
     return captureWorktreeTree(repoRoot, workspaceRelative);
 }
+function taskFileFingerprints(stateRoot, taskId) {
+    const activeRoot = path.join(stateRoot, '.agents', 'workspace', 'active');
+    const roots = taskId ? [path.join(activeRoot, taskId)] : [activeRoot];
+    const records = [];
+    const visit = (absolute, relative) => {
+        const stat = fs.lstatSync(absolute);
+        if (stat.isDirectory()) {
+            for (const name of fs.readdirSync(absolute).sort()) {
+                visit(path.join(absolute, name), path.posix.join(relative, name));
+            }
+            return;
+        }
+        if (!stat.isFile() && !stat.isSymbolicLink())
+            return;
+        const content = stat.isSymbolicLink()
+            ? Buffer.from(fs.readlinkSync(absolute))
+            : fs.readFileSync(absolute);
+        records.push({
+            path: relative,
+            mode: stat.mode & 0o777,
+            kind: stat.isSymbolicLink() ? 'symlink' : 'file',
+            sha256: createHash('sha256').update(content).digest('hex')
+        });
+    };
+    for (const root of roots) {
+        if (!fs.existsSync(root))
+            continue;
+        const relative = path.posix.join('.agents/workspace/active', path.relative(activeRoot, root).split(path.sep).join('/'));
+        visit(root, relative.replace(/\/$/, ''));
+    }
+    return records.sort((left, right) => left.path.localeCompare(right.path));
+}
+function encodeWorkspaceFingerprint(value) {
+    return `ws2:${Buffer.from(JSON.stringify(value)).toString('base64url')}`;
+}
+function decodeWorkspaceFingerprint(value) {
+    if (!value.startsWith('ws2:'))
+        return null;
+    try {
+        const parsed = JSON.parse(Buffer.from(value.slice(4), 'base64url').toString('utf8'));
+        if (parsed.version !== 2 || !/^[a-f0-9]{40,64}$/.test(parsed.gitTree) || !Array.isArray(parsed.taskFiles)) {
+            throw new Error('invalid workspace fingerprint fields');
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`ORCHESTRATION_SNAPSHOT_FAILED: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function captureWorkspaceSnapshot(contextOrRoot, taskId) {
+    if (typeof contextOrRoot === 'string')
+        return captureLegacyWorkspaceSnapshot(contextOrRoot, taskId ?? null);
+    return encodeWorkspaceFingerprint({
+        version: 2,
+        gitTree: captureWorktreeTree(contextOrRoot.gitRoot, null),
+        taskFiles: taskFileFingerprints(contextOrRoot.stateRoot, contextOrRoot.taskId)
+    });
+}
 function captureRepositorySnapshot(repoRoot) {
     return {
         head: git(repoRoot, null, ['rev-parse', 'HEAD']).trim(),
@@ -39,8 +98,24 @@ function captureRepositorySnapshot(repoRoot) {
     };
 }
 function diffWorkspaceSnapshots(repoRoot, before, after) {
-    const output = git(repoRoot, null, ['diff', '--name-only', '-z', before, after]);
-    return output.split('\0').filter(Boolean);
+    const beforeV2 = decodeWorkspaceFingerprint(before);
+    const afterV2 = decodeWorkspaceFingerprint(after);
+    if ((beforeV2 === null) !== (afterV2 === null)) {
+        throw new Error('ORCHESTRATION_SNAPSHOT_FAILED: workspace fingerprint versions cannot be mixed');
+    }
+    if (!beforeV2 || !afterV2) {
+        const output = git(repoRoot, null, ['diff', '--name-only', '-z', before, after]);
+        return output.split('\0').filter(Boolean);
+    }
+    const output = git(repoRoot, null, ['diff', '--name-only', '-z', beforeV2.gitTree, afterV2.gitTree]);
+    const changed = new Set(output.split('\0').filter(Boolean));
+    const beforeFiles = new Map(beforeV2.taskFiles.map((record) => [record.path, JSON.stringify(record)]));
+    const afterFiles = new Map(afterV2.taskFiles.map((record) => [record.path, JSON.stringify(record)]));
+    for (const filePath of new Set([...beforeFiles.keys(), ...afterFiles.keys()])) {
+        if (beforeFiles.get(filePath) !== afterFiles.get(filePath))
+            changed.add(filePath);
+    }
+    return [...changed].sort();
 }
 export { captureRepositorySnapshot, captureWorkspaceSnapshot, diffWorkspaceSnapshots };
 //# sourceMappingURL=workspace-snapshot.js.map

package/lib/agent-clients/adapter.ts

@@ -39,8 +39,8 @@ type AgentClientModelSelectionContext =
     }>;
 
 type AgentClientDelegationEvidence = Readonly<{
-  actualModel: 'host-event' | 'unavailable';
-  actualReasoningEffort: 'host-event' | 'spawn-ack' | 'unavailable';
+  actualModel: 'host-event' | 'app-server' | 'unavailable';
+  actualReasoningEffort: 'host-event' | 'app-server' | 'spawn-ack' | 'unavailable';
 }>;
 
 type AgentClientSeedCommand = Readonly<{
@@ -331,8 +331,8 @@ function defineAgentClientAdapter(
   const evidence = candidate.delegationEvidence;
   if (
     !evidence
-    || !['host-event', 'unavailable'].includes(evidence.actualModel)
-    || !['host-event', 'spawn-ack', 'unavailable'].includes(evidence.actualReasoningEffort)
+    || !['host-event', 'app-server', 'unavailable'].includes(evidence.actualModel)
+    || !['host-event', 'app-server', 'spawn-ack', 'unavailable'].includes(evidence.actualReasoningEffort)
   ) {
     throw new Error(`Agent Client '${candidate.id}' has invalid delegation evidence`);
   }