@fitlab-ai/agent-infra 0.9.4 → 0.9.5

package/dist/lib/internal/task-orchestration.js

@@ -1,7 +1,7 @@
 import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
-import { abortCommitIntent, activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, completeCommitIntent, pauseOrchestration, prepareOrchestrationDelegation, recoverCommitIntent, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusCommitIntent, statusOrchestration } from '../task/orchestration.js';
+import { abortCommitIntent, activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, completeCommitIntent, pauseOrchestration, prepareOrchestrationDelegation, recoverCommitIntent, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, startCommitAttempt, statusCommitIntent, statusOrchestration, terminateCommitAttempt } from '../task/orchestration.js';
 import { isAgentClientId } from '../agent-clients/types.js';
-const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|hook-start|hook-stop|advance|pause|status|commit-begin|commit-checkpoint|commit-complete|commit-recover|commit-abort|commit-status> [options]\n';
+const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|hook-start|hook-stop|advance|pause|status|commit-start|commit-begin|commit-checkpoint|commit-complete|commit-recover|commit-abort|commit-terminate|commit-status> [options]\n';
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed', changed: false,
@@ -22,7 +22,7 @@ function taskOrchestration(args = []) {
     const [taskRef, intent] = args;
     if (![
         'begin-or-resume', 'route', 'prepare', 'hook-start', 'hook-stop', 'advance', 'pause', 'status',
-        'commit-begin', 'commit-checkpoint', 'commit-complete', 'commit-recover', 'commit-abort', 'commit-status'
+        'commit-start', 'commit-begin', 'commit-checkpoint', 'commit-complete', 'commit-recover', 'commit-abort', 'commit-terminate', 'commit-status'
     ].includes(intent)) {
         usageFailure(`unknown intent '${intent}'`);
         return;
@@ -48,7 +48,8 @@ function taskOrchestration(args = []) {
             '--native-agent', '--child-id', '--spawn-mode', '--actual-model', '--actual-reasoning-effort',
             '--model-fallback-reason', '--reasoning-effort-fallback-reason',
             '--exit-code', '--after-fingerprint', '--changed-paths', '--code', '--message', '--recoverable', '--agent',
-            '--baseline-head', '--token', '--kind', '--head', '--remote', '--ref', '--expected-head'
+            '--baseline-head', '--token', '--kind', '--head', '--remote', '--ref', '--expected-head',
+            '--attempt', '--git-worktree-root'
         ].includes(flag)) {
             usageFailure(`unknown option '${flag}'`);
             return;
@@ -66,12 +67,14 @@ function taskOrchestration(args = []) {
         values[flag] = value;
     }
     const commitIntentFlags = {
-        'commit-begin': ['--agent', '--baseline-head', '--orchestrated'],
-        'commit-checkpoint': ['--token', '--kind', '--head', '--remote', '--ref'],
-        'commit-complete': ['--token', '--agent'],
-        'commit-recover': ['--agent'],
-        'commit-abort': ['--token', '--expected-head'],
-        'commit-status': []
+        'commit-start': ['--agent', '--git-worktree-root'],
+        'commit-begin': ['--agent', '--baseline-head', '--attempt', '--orchestrated', '--git-worktree-root'],
+        'commit-checkpoint': ['--token', '--kind', '--head', '--remote', '--ref', '--git-worktree-root'],
+        'commit-complete': ['--token', '--agent', '--git-worktree-root'],
+        'commit-recover': ['--agent', '--git-worktree-root'],
+        'commit-abort': ['--token', '--expected-head', '--git-worktree-root'],
+        'commit-terminate': ['--attempt', '--agent', '--code', '--git-worktree-root'],
+        'commit-status': ['--git-worktree-root']
     };
     if (intent in commitIntentFlags) {
         const allowed = commitIntentFlags[intent];
@@ -83,7 +86,7 @@ function taskOrchestration(args = []) {
     }
     else {
         const commitOnly = [...seen].find((flag) => [
-            '--orchestrated', '--baseline-head', '--token', '--kind', '--head', '--remote', '--ref', '--expected-head'
+            '--orchestrated', '--baseline-head', '--attempt', '--token', '--kind', '--head', '--remote', '--ref', '--expected-head'
         ].includes(flag));
         if (commitOnly) {
             usageFailure(`intent '${intent}' does not accept '${commitOnly}'`);
@@ -91,13 +94,29 @@ function taskOrchestration(args = []) {
         }
     }
     const requireValues = (flags) => flags.find((flag) => values[flag] === undefined);
+    const coreOptions = values['--git-worktree-root'] === undefined
+        ? {}
+        : { gitWorktreeRoot: values['--git-worktree-root'] };
     if (values['--client'] !== undefined && !isAgentClientId(values['--client'])) {
         usageFailure(`unknown client '${values['--client']}'`);
         return;
     }
     let result;
-    if (intent === 'commit-begin') {
-        const missing = requireValues(['--agent', '--baseline-head']);
+    if (intent === 'commit-start') {
+        const missing = requireValues(['--agent']);
+        if (missing) {
+            usageFailure(`intent 'commit-start' requires '${missing}'`);
+            return;
+        }
+        const agent = normalizeAgentToken(values['--agent']);
+        if (!agent) {
+            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
+            return;
+        }
+        result = startCommitAttempt(taskRef, { agent }, coreOptions);
+    }
+    else if (intent === 'commit-begin') {
+        const missing = requireValues(['--agent', '--baseline-head', '--attempt']);
         if (missing) {
             usageFailure(`intent 'commit-begin' requires '${missing}'`);
             return;
@@ -108,8 +127,8 @@ function taskOrchestration(args = []) {
             return;
         }
         result = beginCommitIntent(taskRef, {
-            agent, orchestrated, baselineHead: values['--baseline-head']
-        });
+            agent, orchestrated, baselineHead: values['--baseline-head'], attempt: values['--attempt']
+        }, coreOptions);
     }
     else if (intent === 'commit-checkpoint') {
         const missing = requireValues(['--token', '--kind', '--head']);
@@ -135,7 +154,7 @@ function taskOrchestration(args = []) {
         result = checkpointCommitIntent(taskRef, {
             token: values['--token'], kind: values['--kind'],
             head: values['--head'], remote: values['--remote'], ref: values['--ref']
-        });
+        }, coreOptions);
     }
     else if (intent === 'commit-complete') {
         const missing = requireValues(['--token', '--agent']);
@@ -148,7 +167,7 @@ function taskOrchestration(args = []) {
             usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
             return;
         }
-        result = completeCommitIntent(taskRef, { token: values['--token'], agent });
+        result = completeCommitIntent(taskRef, { token: values['--token'], agent }, coreOptions);
     }
     else if (intent === 'commit-recover') {
         const missing = requireValues(['--agent']);
@@ -161,7 +180,7 @@ function taskOrchestration(args = []) {
             usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
             return;
         }
-        result = recoverCommitIntent(taskRef, { agent });
+        result = recoverCommitIntent(taskRef, { agent }, coreOptions);
     }
     else if (intent === 'commit-abort') {
         const missing = requireValues(['--token', '--expected-head']);
@@ -169,10 +188,29 @@ function taskOrchestration(args = []) {
             usageFailure(`intent 'commit-abort' requires '${missing}'`);
             return;
         }
-        result = abortCommitIntent(taskRef, { token: values['--token'], expectedHead: values['--expected-head'] });
+        result = abortCommitIntent(taskRef, { token: values['--token'], expectedHead: values['--expected-head'] }, coreOptions);
+    }
+    else if (intent === 'commit-terminate') {
+        const missing = requireValues(['--attempt', '--agent', '--code']);
+        if (missing) {
+            usageFailure(`intent 'commit-terminate' requires '${missing}'`);
+            return;
+        }
+        const agent = normalizeAgentToken(values['--agent']);
+        if (!agent) {
+            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
+            return;
+        }
+        if (!/^[A-Z][A-Z0-9_]{2,63}$/.test(values['--code'])) {
+            usageFailure('--code must be a stable uppercase identifier');
+            return;
+        }
+        result = terminateCommitAttempt(taskRef, {
+            attempt: values['--attempt'], agent, code: values['--code']
+        }, coreOptions);
     }
     else if (intent === 'commit-status') {
-        result = statusCommitIntent(taskRef);
+        result = statusCommitIntent(taskRef, coreOptions);
     }
     else if (intent === 'begin-or-resume') {
         const missing = requireValues(['--client']);
@@ -195,6 +233,7 @@ function taskOrchestration(args = []) {
             return;
         }
         result = beginOrResumeOrchestration(taskRef, {
+            ...coreOptions,
             maxSteps,
             client: values['--client'],
             modelPolicy: hasAnyPolicy ? {
@@ -210,10 +249,10 @@ function taskOrchestration(args = []) {
         });
     }
     else if (intent === 'route') {
-        result = routeOrchestration(taskRef);
+        result = routeOrchestration(taskRef, coreOptions);
     }
     else if (intent === 'status') {
-        result = statusOrchestration(taskRef);
+        result = statusOrchestration(taskRef, coreOptions);
     }
     else if (intent === 'prepare') {
         const missing = requireValues(['--client']);
@@ -225,7 +264,7 @@ function taskOrchestration(args = []) {
             client: values['--client'],
             requestedModel: values['--requested-model'],
             requestedReasoningEffort: values['--requested-reasoning-effort']
-        });
+        }, coreOptions);
     }
     else if (intent === 'hook-start') {
         const missing = requireValues([
@@ -245,8 +284,8 @@ function taskOrchestration(args = []) {
             reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
         };
         result = taskRef === 'auto'
-            ? activateMatchingOrchestrationDelegation(values['--client'], event)
-            : activateOrchestrationDelegation(taskRef, event);
+            ? activateMatchingOrchestrationDelegation(values['--client'], event, coreOptions)
+            : activateOrchestrationDelegation(taskRef, event, coreOptions);
     }
     else if (intent === 'hook-stop') {
         if (taskRef === 'auto') {
@@ -257,7 +296,7 @@ function taskOrchestration(args = []) {
             }
             result = sealMatchingOrchestrationDelegation(values['--client'], {
                 nativeAgent: values['--native-agent'], childId: values['--child-id']
-            });
+            }, coreOptions);
         }
         else {
             const missing = requireValues(['--child-id', '--exit-code', '--after-fingerprint']);
@@ -274,11 +313,11 @@ function taskOrchestration(args = []) {
                 childId: values['--child-id'], exitCode,
                 afterFingerprint: values['--after-fingerprint'],
                 changedPaths: values['--changed-paths'] ? values['--changed-paths'].split(',').filter(Boolean) : []
-            });
+            }, coreOptions);
         }
     }
     else if (intent === 'advance') {
-        result = advanceOrchestration(taskRef);
+        result = advanceOrchestration(taskRef, coreOptions);
     }
     else {
         const missing = requireValues(['--code', '--message', '--recoverable']);
@@ -290,7 +329,7 @@ function taskOrchestration(args = []) {
             usageFailure('--recoverable must be true or false');
             return;
         }
-        result = pauseOrchestration(taskRef, values['--code'], values['--message'], values['--recoverable'] === 'true');
+        result = pauseOrchestration(taskRef, values['--code'], values['--message'], values['--recoverable'] === 'true', coreOptions);
     }
     process.stdout.write(`${JSON.stringify(result)}\n`);
     if (result.status === 'failed')

package/dist/lib/sandbox/commands/create.js

@@ -965,6 +965,7 @@ export async function create(args) {
                         const control = materializeSandboxControl({
                             base: effectiveConfig.controlBase,
                             repoRoot: effectiveConfig.repoRoot,
+                            worktreeRoot: worktree,
                             project: effectiveConfig.project,
                             container,
                             branch,

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

@@ -5,25 +5,17 @@ import { SANDBOX_CONTROL_MAX_BYTES, isSandboxControlFamily } from './protocol.js
 function sleep(milliseconds) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
 }
-export function requestSandboxControl(params) {
-    if (!isSandboxControlFamily(params.family)) {
-        throw new Error(`SANDBOX_CONTROL_COMMAND_DENIED: '${params.family}' is not allowed`);
-    }
+function exchangeSandboxControl(request, params) {
     const channelDir = params.channelDir ?? process.env.AGENT_INFRA_CONTROL_DIR ?? '/run/agent-infra/control';
-    const token = params.token ?? process.env.AGENT_INFRA_CONTROL_TOKEN;
-    if (!token)
-        throw new Error('SANDBOX_CONTROL_UNAVAILABLE: control token is missing');
-    const requestsDir = path.join(channelDir, 'requests');
-    const responsesDir = path.join(channelDir, 'responses');
-    const id = randomUUID();
-    const request = { version: 1, id, token, family: params.family, args: params.args };
     const encoded = `${JSON.stringify(request)}\n`;
     if (Buffer.byteLength(encoded, 'utf8') > SANDBOX_CONTROL_MAX_BYTES) {
         throw new Error('SANDBOX_CONTROL_REQUEST_TOO_LARGE: request exceeds the control limit');
     }
-    const temporary = path.join(requestsDir, `.${id}.tmp`);
-    const requestPath = path.join(requestsDir, `${id}.json`);
-    const responsePath = path.join(responsesDir, `${id}.json`);
+    const requestsDir = path.join(channelDir, 'requests');
+    const responsesDir = path.join(channelDir, 'responses');
+    const temporary = path.join(requestsDir, `.${request.id}.tmp`);
+    const requestPath = path.join(requestsDir, `${request.id}.json`);
+    const responsePath = path.join(responsesDir, `${request.id}.json`);
     fs.writeFileSync(temporary, encoded, { mode: 0o600, flag: 'wx' });
     fs.renameSync(temporary, requestPath);
     const deadline = Date.now() + (params.timeoutMs ?? 30_000);
@@ -32,7 +24,7 @@ export function requestSandboxControl(params) {
             const raw = fs.readFileSync(responsePath, 'utf8');
             fs.unlinkSync(responsePath);
             const response = JSON.parse(raw);
-            if (response.version !== 1 || response.id !== id || !Number.isInteger(response.exitCode)) {
+            if (response.version !== 1 || response.id !== request.id || !Number.isInteger(response.exitCode)) {
                 throw new Error('SANDBOX_CONTROL_RESPONSE_INVALID: broker response is invalid');
             }
             return response;
@@ -41,4 +33,26 @@ export function requestSandboxControl(params) {
     }
     throw new Error(`SANDBOX_CONTROL_TIMEOUT: broker did not respond within ${params.timeoutMs ?? 30_000}ms`);
 }
+export function requestSandboxControl(params) {
+    if (!isSandboxControlFamily(params.family)) {
+        throw new Error(`SANDBOX_CONTROL_COMMAND_DENIED: '${params.family}' is not allowed`);
+    }
+    if (params.family === 'task-create')
+        throw new Error("SANDBOX_CONTROL_COMMAND_DENIED: 'task-create' requires a typed candidate");
+    const token = params.token ?? process.env.AGENT_INFRA_CONTROL_TOKEN;
+    if (!token)
+        throw new Error('SANDBOX_CONTROL_UNAVAILABLE: control token is missing');
+    const id = randomUUID();
+    const request = { version: 1, id, token, family: params.family, args: params.args };
+    return exchangeSandboxControl(request, params);
+}
+export function requestSandboxTaskCreate(params) {
+    const token = params.token ?? process.env.AGENT_INFRA_CONTROL_TOKEN;
+    if (!token)
+        throw new Error('SANDBOX_CONTROL_UNAVAILABLE: control token is missing');
+    const request = {
+        version: 1, id: randomUUID(), token, family: 'task-create', candidate: params.candidate
+    };
+    return exchangeSandboxControl(request, { ...params, timeoutMs: params.timeoutMs ?? 120_000 });
+}
 //# sourceMappingURL=client.js.map

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

@@ -1,5 +1,6 @@
+import { validateTaskCreateCandidate } from '../../task/create.js';
 export const SANDBOX_CONTROL_MAX_BYTES = 64 * 1024;
-export const SANDBOX_CONTROL_FAMILIES = ['task-lifecycle', 'task-orchestration'];
+export const SANDBOX_CONTROL_FAMILIES = ['task-lifecycle', 'task-orchestration', 'task-create'];
 export function isSandboxControlFamily(value) {
     return SANDBOX_CONTROL_FAMILIES.includes(value);
 }
@@ -13,7 +14,21 @@ export function validateSandboxControlRequest(value, manifest) {
         || !/^[a-f0-9-]{16,64}$/.test(request.id)
         || request.token !== manifest.token
         || typeof request.family !== 'string'
-        || !isSandboxControlFamily(request.family)
+        || !isSandboxControlFamily(request.family)) {
+        throw new Error('SANDBOX_CONTROL_REQUEST_INVALID: request schema or authorization is invalid');
+    }
+    if (Buffer.byteLength(JSON.stringify(request), 'utf8') > SANDBOX_CONTROL_MAX_BYTES) {
+        throw new Error('SANDBOX_CONTROL_REQUEST_TOO_LARGE: request exceeds the control limit');
+    }
+    if (request.family === 'task-create') {
+        const keys = Object.keys(request).sort().join(',');
+        if (keys !== ['candidate', 'family', 'id', 'token', 'version'].sort().join(',')) {
+            throw new Error('SANDBOX_CONTROL_REQUEST_INVALID: request schema or authorization is invalid');
+        }
+        return { ...request, candidate: validateTaskCreateCandidate(request.candidate) };
+    }
+    const keys = Object.keys(request).sort().join(',');
+    if (keys !== ['args', 'family', 'id', 'token', 'version'].sort().join(',')
         || !Array.isArray(request.args)
         || !request.args.every((arg) => typeof arg === 'string')) {
         throw new Error('SANDBOX_CONTROL_REQUEST_INVALID: request schema or authorization is invalid');
@@ -21,12 +36,16 @@ export function validateSandboxControlRequest(value, manifest) {
     if (manifest.mode !== 'task-bound' || !manifest.taskId) {
         throw new Error('SANDBOX_CONTROL_BRANCH_ONLY: branch-only sandboxes cannot coordinate tasks');
     }
-    if (Buffer.byteLength(JSON.stringify(request), 'utf8') > SANDBOX_CONTROL_MAX_BYTES) {
-        throw new Error('SANDBOX_CONTROL_REQUEST_TOO_LARGE: request exceeds the control limit');
+    if (request.family === 'task-orchestration'
+        && request.args.some((arg) => arg === '--git-worktree-root' || arg.startsWith('--git-worktree-root='))) {
+        throw new Error('SANDBOX_CONTROL_REQUEST_INVALID: worktree binding is reserved for the control broker');
     }
     return request;
 }
 export function bindSandboxControlTask(request, taskId) {
+    if (request.family === 'task-create') {
+        throw new Error('SANDBOX_CONTROL_REQUEST_INVALID: task-create requests do not bind a current task');
+    }
     if (request.args.length === 0) {
         throw new Error('SANDBOX_CONTROL_REQUEST_INVALID: command arguments are required');
     }

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

@@ -2,14 +2,19 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { getProcessStartTime } from '../../server/process-state.js';
+import { createTask } from '../../task/create-service.js';
+import { assertGitWorktreeBinding } from '../../git/worktree-identity.js';
 import { bindSandboxControlTask, validateSandboxControlRequest } from './protocol.js';
 function readManifest(manifestPath) {
     const stat = fs.lstatSync(manifestPath);
     if (!stat.isFile() || stat.isSymbolicLink())
         throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
     const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-    if (manifest.version !== 1
-        || typeof manifest.repoRoot !== 'string'
+    if (manifest.version !== 2) {
+        throw new Error('SANDBOX_CONTROL_MANIFEST_VERSION_INVALID: expected version 2; recreate the sandbox');
+    }
+    if (typeof manifest.repoRoot !== 'string'
+        || typeof manifest.worktreeRoot !== 'string'
         || typeof manifest.channelDir !== 'string'
         || typeof manifest.token !== 'string')
         throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
@@ -31,8 +36,23 @@ function writeResponse(directory, response) {
     fs.writeFileSync(temporary, `${JSON.stringify(response)}\n`, { mode: 0o600, flag: 'wx' });
     fs.renameSync(temporary, path.join(directory, `${response.id}.json`));
 }
+export function sandboxControlSafeEnv(env = process.env) {
+    return Object.fromEntries(Object.entries(env).filter(([key]) => !key.toUpperCase().startsWith('AGENT_INFRA_CONTROL_')));
+}
+function consumeRequest(directory, id) {
+    try {
+        fs.writeFileSync(path.join(directory, id), '', { flag: 'wx', mode: 0o600 });
+    }
+    catch (error) {
+        if (error.code === 'EEXIST') {
+            throw new Error('SANDBOX_CONTROL_REQUEST_REPLAYED');
+        }
+        throw error;
+    }
+}
 export function serveSandboxControl(manifestPath, signal = new AbortController().signal) {
     const manifest = readManifest(manifestPath);
+    assertGitWorktreeBinding(manifest.repoRoot, manifest.worktreeRoot, manifest.branch);
     const brokerPath = path.join(path.dirname(manifestPath), 'broker.json');
     const startTime = getProcessStartTime(process.pid);
     if (!startTime)
@@ -45,16 +65,19 @@ export function serveSandboxControl(manifestPath, signal = new AbortController()
     })}\n`, { mode: 0o600, flag: 'wx' });
     const requestsDir = path.join(manifest.channelDir, 'requests');
     const responsesDir = path.join(manifest.channelDir, 'responses');
+    const consumedDir = path.join(path.dirname(manifestPath), 'consumed');
     assertRealDirectory(manifest.channelDir);
     fs.mkdirSync(requestsDir, { recursive: true, mode: 0o700 });
     fs.mkdirSync(responsesDir, { recursive: true, mode: 0o700 });
+    fs.mkdirSync(consumedDir, { recursive: true, mode: 0o700 });
     assertRealDirectory(requestsDir, manifest.channelDir);
     assertRealDirectory(responsesDir, manifest.channelDir);
-    const consumed = new Set();
+    assertRealDirectory(consumedDir, path.dirname(manifestPath));
     while (!signal.aborted) {
         const current = readManifest(manifestPath);
         if (current.token !== manifest.token)
             return;
+        assertGitWorktreeBinding(current.repoRoot, current.worktreeRoot, current.branch);
         assertRealDirectory(requestsDir, manifest.channelDir);
         assertRealDirectory(responsesDir, manifest.channelDir);
         for (const name of fs.readdirSync(requestsDir).sort()) {
@@ -69,21 +92,33 @@ export function serveSandboxControl(manifestPath, signal = new AbortController()
                     throw new Error('SANDBOX_CONTROL_REQUEST_INVALID');
                 const request = validateSandboxControlRequest(JSON.parse(fs.readFileSync(requestPath, 'utf8')), manifest);
                 id = request.id;
-                if (consumed.has(id))
-                    throw new Error('SANDBOX_CONTROL_REQUEST_REPLAYED');
-                consumed.add(id);
-                const result = spawnSync(process.execPath, ['--experimental-strip-types', '--no-warnings', process.argv[1], request.family, ...bindSandboxControlTask(request, manifest.taskId)], {
-                    cwd: manifest.repoRoot,
-                    encoding: 'utf8',
-                    env: Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith('AGENT_INFRA_CONTROL_')))
-                });
-                response = {
-                    version: 1,
-                    id,
-                    exitCode: result.status ?? 1,
-                    stdout: result.stdout ?? '',
-                    stderr: result.stderr ?? ''
-                };
+                consumeRequest(consumedDir, id);
+                if (request.family === 'task-create') {
+                    const result = createTask(request.candidate, { repoRoot: manifest.repoRoot });
+                    response = {
+                        version: 1, id,
+                        exitCode: result.status === 'blocked' ? 2 : result.status === 'failed' ? 1 : 0,
+                        stdout: `${JSON.stringify(result)}\n`, stderr: ''
+                    };
+                }
+                else {
+                    const boundArgs = bindSandboxControlTask(request, manifest.taskId);
+                    if (request.family === 'task-orchestration') {
+                        boundArgs.push('--git-worktree-root', manifest.worktreeRoot);
+                    }
+                    const result = spawnSync(process.execPath, ['--experimental-strip-types', '--no-warnings', process.argv[1], request.family, ...boundArgs], {
+                        cwd: manifest.repoRoot,
+                        encoding: 'utf8',
+                        env: sandboxControlSafeEnv()
+                    });
+                    response = {
+                        version: 1,
+                        id,
+                        exitCode: result.status ?? 1,
+                        stdout: result.stdout ?? '',
+                        stderr: result.stderr ?? ''
+                    };
+                }
             }
             catch (error) {
                 response = {

package/dist/lib/sandbox/workspace-view.js

@@ -79,6 +79,10 @@ export function materializeSandboxWorkspaceView(params) {
 export function materializeSandboxControl(params) {
     const { root, channelDir, manifestPath } = sandboxControlPaths(params);
     assertSafeDirectory(root, path.resolve(params.base));
+    const consumedDir = path.join(root, 'consumed');
+    assertSafeDirectory(consumedDir, root);
+    fs.rmSync(consumedDir, { recursive: true, force: true });
+    fs.mkdirSync(consumedDir, { recursive: true, mode: 0o700 });
     for (const queue of ['requests', 'responses']) {
         const directory = path.join(channelDir, queue);
         assertSafeDirectory(directory, root);
@@ -86,9 +90,11 @@ export function materializeSandboxControl(params) {
         fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
     }
     const token = randomBytes(32).toString('hex');
+    const repoRoot = fs.realpathSync.native(params.repoRoot);
     const manifest = {
-        version: 1,
-        repoRoot: fs.realpathSync.native(params.repoRoot),
+        version: 2,
+        repoRoot,
+        worktreeRoot: fs.realpathSync.native(params.worktreeRoot),
         project: params.project,
         container: params.container,
         branch: params.branch,

package/dist/lib/task/activity-log.js

@@ -2,6 +2,9 @@ const HEADING_RE = /^##\s+(活动日志|Activity Log)\s*$/;
 const NEXT_H2_RE = /^##\s/;
 const ENTRY_RE = /^- (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2}) — \*\*(.+?)\*\* by (.+?) — (.*)$/;
 const STARTED_SUFFIX_RE = /\s*\[started\]\s*$/;
+const ABORTED_SUFFIX_RE = /\s*\[aborted\]\s*$/;
+const ATTEMPT_RE = /(?:^|;\s*)attempt=([A-Za-z0-9-]{8,64})(?:;|$)/;
+const COMMIT_STARTED_RE = /^started; attempt=([A-Za-z0-9-]{8,64}); baseline=([a-f0-9]{40,64}); agent=([a-z-]+)$/;
 function parseActivityLog(content) {
     const section = locateActivityLog(content);
     return section ? { sectionFound: true, entries: section.entries } : { sectionFound: false, entries: [] };
@@ -34,28 +37,52 @@ function appendActivityEntry(section, entry) {
     const line = `- ${entry.time} — **${entry.step}** by ${entry.agent} — ${entry.note}`;
     return section.body ? `${section.body}\n${line}` : line;
 }
+function activityAttempt(note) {
+    return ATTEMPT_RE.exec(note)?.[1] ?? null;
+}
+function parseCommitAttemptStarted(note) {
+    const match = COMMIT_STARTED_RE.exec(note);
+    return match ? { attempt: match[1], baseline: match[2], agent: match[3] } : null;
+}
+function commitAttemptStartedNote(attempt) {
+    return `started; attempt=${attempt.attempt}; baseline=${attempt.baseline}; agent=${attempt.agent}`;
+}
 function pairEntries(entries) {
     const rows = [];
     const open = new Map();
     for (const entry of entries) {
         const started = STARTED_SUFFIX_RE.test(entry.step);
-        const base = entry.step.replace(STARTED_SUFFIX_RE, '');
+        const aborted = ABORTED_SUFFIX_RE.test(entry.step);
+        const base = entry.step.replace(STARTED_SUFFIX_RE, '').replace(ABORTED_SUFFIX_RE, '');
         if (started) {
-            const row = { step: base, agent: entry.agent, started: entry.time, done: '', note: entry.note };
+            const attempt = activityAttempt(entry.note);
+            const row = {
+                step: base, agent: entry.agent, started: entry.time, done: '', note: entry.note,
+                ...(attempt ? { attempt } : {})
+            };
             rows.push(row);
             const queue = open.get(base) ?? [];
             queue.push(row);
             open.set(base, queue);
         }
         else {
-            const pending = open.get(base)?.shift();
+            const queue = open.get(base) ?? [];
+            const terminalAttempt = aborted ? activityAttempt(entry.note) : null;
+            const pendingIndex = terminalAttempt === null
+                ? 0
+                : queue.findIndex((row) => row.attempt === terminalAttempt);
+            const pending = pendingIndex >= 0 ? queue.splice(pendingIndex, 1)[0] : undefined;
             if (pending)
                 Object.assign(pending, { done: entry.time, agent: entry.agent, note: entry.note });
             else
-                rows.push({ step: base, agent: entry.agent, started: '', done: entry.time, note: entry.note });
+                rows.push({
+                    step: aborted ? entry.step : base,
+                    agent: entry.agent, started: '', done: entry.time, note: entry.note,
+                    ...(terminalAttempt ? { attempt: terminalAttempt } : {})
+                });
         }
     }
     return rows;
 }
-export { parseActivityLog, locateActivityLog, appendActivityEntry, pairEntries };
+export { activityAttempt, appendActivityEntry, commitAttemptStartedNote, locateActivityLog, pairEntries, parseActivityLog, parseCommitAttemptStarted };
 //# sourceMappingURL=activity-log.js.map

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

@@ -1,11 +1,11 @@
 import { execFileSync, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { locateActivityLog, appendActivityEntry, pairEntries } from './activity-log.js';
+import { locateActivityLog, appendActivityEntry, pairEntries, parseCommitAttemptStarted } from './activity-log.js';
 import { commitIntentPath, digest, readCommitIntent } from './commit-intent.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { parseReviewSummary } from './review-artifacts.js';
-import { extractReviewBaseline, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact } from './review-fingerprint.js';
+import { extractReviewBaseline, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact, parseReviewedGitTree } from './review-fingerprint.js';
 const SHA_RE = /^[a-f0-9]{40,64}$/;
 function git(repoRoot, args) {
     return execFileSync('git', args, {
@@ -38,6 +38,7 @@ function outcome(disposition, overrides = {}) {
         needsLog: false,
         intent: null,
         intentDigest: null,
+        attempt: null,
         ...overrides
     };
 }
@@ -63,6 +64,16 @@ function inspectCommitFinalization(taskDir, repoRoot, taskId) {
     const openRows = commitRows.filter((row) => row.started !== '' && row.done === '');
     const file = commitIntentPath(taskDir);
     if (!fs.existsSync(file)) {
+        if (openRows.length === 1) {
+            const attempt = parseCommitAttemptStarted(openRows[0].note);
+            if (attempt && attempt.baseline === currentHead) {
+                return outcome('retryable-start', {
+                    message: 'a structured Commit attempt can be safely reused',
+                    currentHead,
+                    attempt
+                });
+            }
+        }
         if (openRows.length > 0) {
             return outcome('orphaned-start', {
                 code: 'COMMIT_FINALIZATION_EVIDENCE_MISSING',
@@ -132,7 +143,7 @@ function inspectCommitFinalization(taskDir, repoRoot, taskId) {
         const summary = parseReviewSummary(reviewContent);
         const reviewBaseline = extractReviewBaseline(reviewContent);
         const reviewTree = extractReviewedSnapshotTree(reviewContent);
-        if (!summary.ok || summary.summary.verdict !== 'Approved' || !commitExists(repoRoot, reviewBaseline) || !SHA_RE.test(reviewTree)) {
+        if (!summary.ok || summary.summary.verdict !== 'Approved' || !commitExists(repoRoot, reviewBaseline) || !parseReviewedGitTree(reviewTree)) {
             return invalid('authoritative review-code evidence is not a valid approved snapshot', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
         }
         const committedTree = git(repoRoot, ['rev-parse', `${intent.committedHead}^{tree}`]);