@fitlab-ai/agent-infra 0.11.5 → 0.11.7

package/dist/lib/platform/release-notes.js

@@ -154,16 +154,16 @@ async function releaseNoteContext(input, options = {}) {
         return { ...baseResult(platform.error.retryable ? 'blocked' : 'failed'), error: providerError(platform.error, 'PLATFORM_PROVIDER_OPERATION_FAILED') };
     const commits = commitFacts.map((commit) => {
         const seen = new Set();
-        const authors = platform.value.history.filter((item) => item.sha === commit.oid).flatMap((item) => item.author ? [item.author] : [])
-            .concat(platform.value.actors)
+        const facts = platform.value.commits.find((item) => item.sha === commit.oid);
+        const authors = (facts?.authors || [])
             .filter((actor) => {
-            const key = actor.id || actor.name || '';
+            const key = actor.login || actor.name;
             if (seen.has(key))
                 return false;
             seen.add(key);
             return true;
         });
-        return { ...commit, authors };
+        return { ...commit, url: facts?.url || null, pullRequestNumbers: facts?.pullRequestNumbers || [], authors };
     });
     const pullRequests = platform.value.mergedPullRequests
         .map((item) => ({
@@ -174,14 +174,13 @@ async function releaseNoteContext(input, options = {}) {
         url: item.displayUrl || '',
         mergedAt: item.mergedAt || '',
         labels: item.labels || [],
-        author: item.author ? { login: item.author.name || item.author.id || '', bot: false } : null,
-        closingIssues: platform.value.closingIssues.filter((issue) => issue.id === item.id).map((issue) => ({
+        author: item.author,
+        closingIssues: item.closingIssues.map((issue) => ({
             number: issue.number || resourceIdentityNumber(issue.identity) || 0,
             ...(issue.identity ? { identity: issue.identity } : {}),
             title: issue.title,
             url: issue.displayUrl || '',
-            labels: issue.labels || [],
-            author: issue.author ? { login: issue.author.name || issue.author.id || '', bot: false } : null
+            author: issue.author
         }))
     }))
         .sort((left, right) => left.number - right.number);

package/dist/lib/sandbox/capture.js

@@ -154,7 +154,7 @@ export async function runInSandbox(request, options = {}) {
             allowRecreate: request.recreate,
             recreate: async () => {
                 const { create } = await import('./commands/create.js');
-                await create([request.taskRef, '--no-refresh']);
+                await create([request.taskRef, '--no-refresh'], { runProjectInitCommand: false });
             }
         })).container;
     }

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

@@ -18,6 +18,7 @@ import { createSandboxCapabilityPlan, runSandboxHooks, runBoundedSandboxHookComm
 import { resolveTools, tmpfsSeedStagingPath, tmpfsSeedTargetPath, toolConfigDirCandidates } from '../tools.js';
 import { assertFreshSandboxReady, hydrateTmpfsSeedEntries, prepareTmpfsMounts, startSandboxControlBroker } from '../recovery.js';
 import { acquireSandboxControlReplacement, assertSandboxControlCutoverSnapshot, beginSandboxControlReplacement, captureSandboxControlCutoverSnapshot, commitSandboxControlReplacement, quiesceSandboxControlRoot, recoverSandboxControlReplacement, readSandboxControlManifest } from '../control/lifecycle.js';
+import { atomicWriteJson } from '../control/state.js';
 import { inspectSandboxControlContainer } from '../control/container-identity.js';
 import { hostJoin, toEnginePath, volumeArg } from '../engines/wsl2-paths.js';
 import { sandboxCoreBindMounts } from '../mounts.js';
@@ -652,7 +653,24 @@ function readImageLabels(config, engine) {
         config.imageName
     ]));
 }
-export async function create(args) {
+function readProjectInitCommandDigest(controlRoot) {
+    const markerPath = path.join(controlRoot, 'project-init.json');
+    if (!fs.existsSync(markerPath))
+        return null;
+    try {
+        const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
+        return marker.version === 1 && typeof marker.commandSha256 === 'string' && /^[a-f0-9]{64}$/.test(marker.commandSha256)
+            ? marker.commandSha256
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeProjectInitCommandDigest(controlRoot, commandSha256) {
+    atomicWriteJson(path.join(controlRoot, 'project-init.json'), { version: 1, commandSha256 });
+}
+export async function create(args, { runProjectInitCommand = true } = {}) {
     const { values, positionals } = parseArgs({
         args,
         allowPositionals: true,
@@ -720,6 +738,7 @@ export async function create(args) {
         identity: target.workspace
     });
     const worktree = worktreeCandidates.find((candidate) => fs.existsSync(candidate)) ?? worktreeCandidates[0] ?? '';
+    let worktreeCreated = false;
     const shareCommon = shareCommonDir(effectiveConfig);
     const shareBranch = shareBranchDir(effectiveConfig, branch);
     const preparedDockerfile = prepareDockerfile(effectiveConfig, capabilityPlan.image);
@@ -821,6 +840,7 @@ export async function create(args) {
                             toEnginePath(engine, worktree),
                             branch
                         ]);
+                        worktreeCreated = true;
                     }
                     else {
                         message(`Creating branch '${branch}' from '${baseBranch}'...`);
@@ -834,6 +854,7 @@ export async function create(args) {
                             toEnginePath(engine, worktree),
                             baseBranch
                         ]);
+                        worktreeCreated = true;
                     }
                     return `Worktree ready at ${worktree}`;
                 }
@@ -886,6 +907,7 @@ export async function create(args) {
                     let replacementCutover = null;
                     try {
                         const recoveryResult = await recoverSandboxControlReplacement(controlPaths.root, replacementLease);
+                        const previousProjectInitCommandDigest = readProjectInitCommandDigest(controlPaths.root);
                         const hadExistingControlRoot = hadControlRootBeforeAcquire || recoveryResult === 'restored';
                         const previousManifest = fs.existsSync(controlPaths.manifestPath)
                             ? readSandboxControlManifest(controlPaths.manifestPath)
@@ -1295,6 +1317,29 @@ export async function create(args) {
                             throw new Error(afterStartFailure.message
                                 ?? `Sandbox hook '${afterStartFailure.hookId}' failed.`);
                         }
+                        const initCommand = effectiveConfig.initCommand;
+                        const initCommandDigest = initCommand === null ? null : createHash('sha256').update(initCommand).digest('hex');
+                        const shouldRunProjectInitCommand = runProjectInitCommand
+                            && initCommand !== null
+                            && initCommandDigest !== null
+                            && (worktreeCreated || previousProjectInitCommandDigest !== initCommandDigest);
+                        let projectInitCompleted = !worktreeCreated
+                            && initCommandDigest !== null
+                            && previousProjectInitCommandDigest === initCommandDigest;
+                        if (shouldRunProjectInitCommand && initCommand !== null) {
+                            try {
+                                runVerboseEngine(engine, 'docker', [
+                                    'exec', '--workdir', '/workspace', container, 'bash', '-lc', initCommand
+                                ]);
+                                projectInitCompleted = true;
+                            }
+                            catch (error) {
+                                throw new Error(`Project initialization failed for '${branch}': ${error instanceof Error ? error.message : String(error)}`);
+                            }
+                        }
+                        if (projectInitCompleted && initCommandDigest !== null) {
+                            writeProjectInitCommandDigest(controlPaths.root, initCommandDigest);
+                        }
                         replacementLease.release();
                         replacementLeaseHeld = false;
                         return 'Container started';

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

@@ -109,7 +109,7 @@ export async function enter(args) {
         allowRecreate: parsed.recreate,
         recreate: async () => {
             const { create } = await import('./create.js');
-            await create([target.requestedRef, '--no-refresh']);
+            await create([target.requestedRef, '--no-refresh'], { runProjectInitCommand: false });
         }
     });
     const container = ready.container;

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

@@ -65,7 +65,7 @@ export async function start(args) {
         forceRecreate: parsed.recreate,
         recreate: async () => {
             const { create } = await import('./create.js');
-            await create([target.requestedRef, '--no-refresh']);
+            await create([target.requestedRef, '--no-refresh'], { runProjectInitCommand: false });
         }
     });
     const message = ready.path === 'healthy'

package/dist/lib/sandbox/config.js

@@ -14,6 +14,7 @@ const DEFAULTS = Object.freeze({
     tools: ['agent-infra'],
     refreshIntervalDays: 7,
     dockerfile: null,
+    initCommand: null,
     vm: {
         cpu: null,
         memory: null,
@@ -44,6 +45,7 @@ function cloneDefaults() {
         tools: [...DEFAULTS.tools],
         refreshIntervalDays: DEFAULTS.refreshIntervalDays,
         dockerfile: DEFAULTS.dockerfile,
+        initCommand: DEFAULTS.initCommand,
         vm: { ...DEFAULTS.vm }
     };
 }
@@ -77,6 +79,13 @@ export function loadConfig({ platformFn = platform, writeStderr = (chunk) => pro
         ? [...sandbox.runtimes]
         : defaults.runtimes;
     const dockerfile = typeof sandbox.dockerfile === 'string' ? sandbox.dockerfile : defaults.dockerfile ?? null;
+    if (sandbox.initCommand !== undefined &&
+        (typeof sandbox.initCommand !== 'string' || sandbox.initCommand.trim().length === 0)) {
+        throw new Error('sandbox.initCommand must be a non-empty string when configured');
+    }
+    const initCommand = typeof sandbox.initCommand === 'string'
+        ? sandbox.initCommand
+        : null;
     if (!dockerfile) {
         let enginesNode;
         try {
@@ -118,6 +127,7 @@ export function loadConfig({ platformFn = platform, writeStderr = (chunk) => pro
         },
         refreshIntervalDays: asNonNegativeIntegerOrDefault(sandbox.refreshIntervalDays, defaults.refreshIntervalDays),
         dockerfile,
+        initCommand,
         vm: {
             cpu: asPositiveNumberOrNull(sandbox.vm?.cpu) ?? defaults.vm.cpu,
             memory: asPositiveNumberOrNull(sandbox.vm?.memory) ?? defaults.vm.memory,

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

@@ -1152,17 +1152,25 @@ export async function quiesceSandboxControlRoot(root, options = {}) {
     if (!manifest && brokerLive)
         throw new Error('SANDBOX_CONTROL_OWNER_MISMATCH');
     const platform = options.platform ?? process.platform;
+    const processControl = options.executionProcessControl ?? {
+        isAlive: (execution) => executionAlive(execution, platform, identityProbe),
+        terminate: (execution, phase) => phase === 'graceful'
+            ? terminateSandboxControlExecution(execution, { platform, timeoutMs: 0, allowForce: false, identityProbe })
+            : terminateSandboxControlExecution(execution, {
+                platform, timeoutMs: Math.max(0, deadlineAt - Date.now()), deadlineAt, forceAt: Date.now(), identityProbe
+            })
+    };
     let executions = manifest ? readExecutions(manifest) : [];
     const owner = brokerLive ? broker : statusLive ? statusOwner : null;
     if (!owner) {
         if (manifest && !broker && !status)
             throw new Error('SANDBOX_CONTROL_OWNER_EVIDENCE_MISSING');
         for (const execution of executions) {
-            terminateSandboxControlExecution(execution, { platform, timeoutMs: 0, allowForce: false, identityProbe });
+            processControl.terminate(execution, 'graceful');
         }
         const softDeadlineAt = Math.min(forceAt, Date.now() + Math.floor(Math.max(0, forceAt - Date.now()) / 2));
         while (Date.now() < softDeadlineAt) {
-            if (!executions.some((execution) => executionAlive(execution, platform, identityProbe)))
+            if (!executions.some((execution) => processControl.isAlive(execution)))
                 break;
             await new Promise((resolve) => setTimeout(resolve, 25));
         }
@@ -1171,29 +1179,26 @@ export async function quiesceSandboxControlRoot(root, options = {}) {
         if (Date.now() >= deadlineAt)
             throw new Error('SANDBOX_CONTROL_QUIESCE_DEADLINE_EXCEEDED');
         for (const execution of executions) {
-            if (!terminateSandboxControlExecution(execution, {
-                platform, timeoutMs: Math.max(0, deadlineAt - Date.now()), deadlineAt, forceAt: Date.now(), identityProbe
-            })) {
+            if (!processControl.terminate(execution, 'force')) {
                 throw new Error(`SANDBOX_CONTROL_EXECUTION_STILL_RUNNING: ${execution.requestId}`);
             }
         }
-        if (executions.some((execution) => executionAlive(execution, platform, identityProbe))) {
+        if (executions.some((execution) => processControl.isAlive(execution))) {
             throw new Error('SANDBOX_CONTROL_EXECUTION_STILL_RUNNING');
         }
         return broker || status ? 'stale' : 'missing';
     }
-    const remaining = () => Math.max(0, deadlineAt - Date.now());
     signalOwner(owner, platform, false);
     for (const execution of executions) {
-        terminateSandboxControlExecution(execution, { platform, timeoutMs: 0, allowForce: false, identityProbe });
+        processControl.terminate(execution, 'graceful');
     }
     const softDeadlineAt = Math.min(forceAt, Date.now() + Math.floor(Math.max(0, forceAt - Date.now()) / 2));
     while (Date.now() < softDeadlineAt) {
-        if (!ownerLive(owner, identityProbe) && !executions.some((execution) => executionAlive(execution, platform, identityProbe)))
+        if (!ownerLive(owner, identityProbe) && !executions.some((execution) => processControl.isAlive(execution)))
             break;
         await new Promise((resolve) => setTimeout(resolve, 25));
     }
-    if (!ownerLive(owner, identityProbe) && !executions.some((execution) => executionAlive(execution, platform, identityProbe))) {
+    if (!ownerLive(owner, identityProbe) && !executions.some((execution) => processControl.isAlive(execution))) {
         return 'stopped';
     }
     if (manifest)
@@ -1201,17 +1206,17 @@ export async function quiesceSandboxControlRoot(root, options = {}) {
     if (Date.now() >= deadlineAt)
         throw new Error('SANDBOX_CONTROL_QUIESCE_DEADLINE_EXCEEDED');
     for (const execution of executions) {
-        terminateSandboxControlExecution(execution, { platform, timeoutMs: 0, deadlineAt, forceAt: Date.now(), identityProbe });
+        processControl.terminate(execution, 'force');
     }
     signalOwner(owner, platform, true);
     while (Date.now() < deadlineAt) {
-        if (!ownerLive(owner, identityProbe) && !executions.some((execution) => executionAlive(execution, platform, identityProbe)))
+        if (!ownerLive(owner, identityProbe) && !executions.some((execution) => processControl.isAlive(execution)))
             return 'stopped';
         await new Promise((resolve) => setTimeout(resolve, 25));
     }
     if (ownerLive(owner, identityProbe))
         throw new Error('SANDBOX_CONTROL_BROKER_STILL_RUNNING');
-    if (executions.some((execution) => executionAlive(execution, platform, identityProbe)))
+    if (executions.some((execution) => processControl.isAlive(execution)))
         throw new Error('SANDBOX_CONTROL_EXECUTION_STILL_RUNNING');
     return 'stopped';
 }

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

@@ -171,13 +171,17 @@ function taskCreateDomainEvidence(manifest, output) {
         ? output.task : null;
     const taskId = typeof task?.id === 'string' ? task.id : null;
     const shortId = typeof task?.shortId === 'string' ? task.shortId : null;
-    if (!taskId || !shortId)
+    const state = task?.state;
+    if (!taskId || !['active', 'blocked', 'completed', 'archive'].includes(String(state)))
+        return { consistent: false };
+    if (state === 'active' ? !shortId : output.status !== 'no-op' || shortId !== null)
         return { consistent: false };
     try {
         const resolved = resolveTaskRef(taskId, { repoRoot: manifest.repoRoot });
         const shortIds = loadShortIdByTaskId(manifest.repoRoot);
         return {
-            consistent: resolved.ok && resolved.taskId === taskId && resolved.state === 'active' && shortIds.get(taskId) === shortId,
+            consistent: resolved.ok && resolved.taskId === taskId && resolved.state === state
+                && (state === 'active' ? shortIds.get(taskId) === shortId : !shortIds.has(taskId)),
             taskId,
             shortId
         };

package/dist/lib/sandbox/task-resolver.js

@@ -21,7 +21,9 @@ function stripQuotes(value) {
 }
 function readTaskContent(repoRoot, taskId) {
     for (const state of TASK_WORKSPACE_STATES) {
-        const taskPath = path.join(repoRoot, '.agents', 'workspace', state, taskId, 'task.md');
+        const taskPath = state === 'archive'
+            ? path.join(repoRoot, '.agents', 'workspace', state, ...findArchiveTaskParts(repoRoot, taskId), 'local', 'task.md')
+            : path.join(repoRoot, '.agents', 'workspace', state, taskId, 'task.md');
         if (fs.existsSync(taskPath)) {
             return { content: fs.readFileSync(taskPath, 'utf8'), state, taskMd: taskPath };
         }
@@ -29,7 +31,7 @@ function readTaskContent(repoRoot, taskId) {
     throw new Error(`Task not found: ${taskId}`);
 }
 function taskWorkspaceCandidates(repoRoot, taskId) {
-    return TASK_WORKSPACE_STATES.flatMap((state) => {
+    const hot = TASK_WORKSPACE_STATES.filter((state) => state !== 'archive').flatMap((state) => {
         const taskMd = path.join(repoRoot, '.agents', 'workspace', state, taskId, 'task.md');
         if (!fs.existsSync(taskMd))
             return [];
@@ -41,6 +43,37 @@ function taskWorkspaceCandidates(repoRoot, taskId) {
                 taskMd
             }];
     });
+    const parts = findArchiveTaskParts(repoRoot, taskId);
+    if (parts.length === 0)
+        return hot;
+    const taskMd = path.join(repoRoot, '.agents', 'workspace', 'archive', ...parts, 'local', 'task.md');
+    if (!fs.existsSync(taskMd))
+        return hot;
+    const content = fs.readFileSync(taskMd, 'utf8');
+    return [...hot, {
+            taskId,
+            branch: resolveBranchFromTaskContent(content, taskId),
+            state: 'archive',
+            taskMd
+        }];
+}
+function findArchiveTaskParts(repoRoot, taskId) {
+    const archiveRoot = path.join(repoRoot, '.agents', 'workspace', 'archive');
+    if (!fs.existsSync(archiveRoot))
+        return [];
+    for (const year of fs.readdirSync(archiveRoot).sort().reverse()) {
+        if (!/^\d{4}$/.test(year))
+            continue;
+        for (const month of fs.readdirSync(path.join(archiveRoot, year)).sort().reverse()) {
+            if (!/^\d{2}$/.test(month))
+                continue;
+            for (const day of fs.readdirSync(path.join(archiveRoot, year, month)).sort().reverse()) {
+                if (/^\d{2}$/.test(day) && fs.existsSync(path.join(archiveRoot, year, month, day, taskId, 'local', 'task.md')))
+                    return [year, month, day, taskId];
+            }
+        }
+    }
+    return [];
 }
 function resolveBranchFromTaskContent(content, taskId) {
     const frontmatterBranch = content.match(/^branch:\s*(.+)$/m);
@@ -81,6 +114,33 @@ export function resolveTaskWorkspace(taskId, repoRoot) {
 }
 export function listTaskWorkspaces(repoRoot, state) {
     const stateRoot = path.join(repoRoot, '.agents', 'workspace', state);
+    if (state === 'archive') {
+        if (!fs.existsSync(stateRoot))
+            return [];
+        const rows = [];
+        for (const year of fs.readdirSync(stateRoot).sort()) {
+            if (!/^\d{4}$/.test(year))
+                continue;
+            for (const month of fs.readdirSync(path.join(stateRoot, year)).sort()) {
+                if (!/^\d{2}$/.test(month))
+                    continue;
+                for (const day of fs.readdirSync(path.join(stateRoot, year, month)).sort()) {
+                    if (!/^\d{2}$/.test(day))
+                        continue;
+                    for (const taskId of fs.readdirSync(path.join(stateRoot, year, month, day)).sort()) {
+                        if (!TASK_ID_RE.test(taskId))
+                            continue;
+                        const taskMd = path.join(stateRoot, year, month, day, taskId, 'local', 'task.md');
+                        if (!fs.existsSync(taskMd))
+                            continue;
+                        const content = fs.readFileSync(taskMd, 'utf8');
+                        rows.push({ taskId, branch: resolveBranchFromTaskContent(content, taskId), state, taskMd });
+                    }
+                }
+            }
+        }
+        return rows;
+    }
     if (!fs.existsSync(stateRoot))
         return [];
     return fs.readdirSync(stateRoot, { withFileTypes: true })

package/dist/lib/server/config.js

@@ -1,8 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { homedir } from 'node:os';
-import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
+import { resolvePrimaryWorktreeRoot } from '../git/primary-worktree.js';
 const ENV_PREFIX = 'AGENT_INFRA_SERVER_';
 // Keys whose presence in the *committed* server.json is treated as a leaked
 // secret. Secrets belong in .agents/server.local.json or the environment.
@@ -16,17 +16,7 @@ export const DEFAULT_SERVER_CONFIG = {
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-// Daemon runtime state (log + PID) lives OUTSIDE the repo, under the user's home
-// directory, keyed by the .airc.json "project" AND a stable hash of the repo
-// root path:
-//   ~/.agent-infra/logs/<project>/<repo-hash>/server.log
-//   ~/.agent-infra/run/<project>/<repo-hash>/server.pid
-// The <project> segment groups a project's checkouts for readability; the
-// <repo-hash> segment guarantees that two checkouts/worktrees of the same
-// project (same "project" but different absolute path) get ISOLATED runtime
-// dirs, so they never read/control each other's daemon. Using os.homedir() +
-// path.join keeps this correct on Windows too (C:\Users\<name>\.agent-infra\...).
-// An explicit log.path in server.json/.local/env still overrides the log default.
+// Runtime state is shared by all worktrees through the primary checkout.
 function resolveProjectKey(repoRoot) {
     try {
         const airc = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
@@ -39,12 +29,8 @@ function resolveProjectKey(repoRoot) {
     }
     return path.basename(repoRoot);
 }
-// Short, stable, filesystem-safe discriminator for a checkout's absolute path.
-function repoKey(repoRoot) {
-    return createHash('sha256').update(repoRoot).digest('hex').slice(0, 12);
-}
-function runtimePath(repoRoot, projectKey, kind, file) {
-    return path.join(homedir(), '.agent-infra', kind, projectKey, repoKey(repoRoot), file);
+function runtimePath(projectKey, kind, file) {
+    return path.join(homedir(), '.agent-infra', kind, projectKey, file);
 }
 function detectRepoRoot() {
     try {
@@ -147,7 +133,7 @@ export function validateServerConfig(committed) {
     return { ok: true };
 }
 export function loadServerConfig({ rootDir } = {}) {
-    const repoRoot = rootDir ?? detectRepoRoot();
+    const repoRoot = resolvePrimaryWorktreeRoot(rootDir ?? detectRepoRoot());
     const agentsDir = path.join(repoRoot, '.agents');
     const committed = readJsonIfPresent(path.join(agentsDir, 'server.json'));
     const validation = validateServerConfig(committed);
@@ -160,17 +146,11 @@ export function loadServerConfig({ rootDir } = {}) {
     merged = deepMerge(merged, envOverrides(process.env));
     const projectKey = resolveProjectKey(repoRoot);
     const log = isPlainObject(merged.log) ? merged.log : {};
-    // No explicit log.path → default under ~/.agent-infra/logs/<project>/.
-    // Explicit relative path resolves against the repo root; absolute is used as-is.
-    const explicitPath = typeof log.path === 'string' ? log.path : null;
-    const resolvedLogPath = explicitPath === null
-        ? runtimePath(repoRoot, projectKey, 'logs', 'server.log')
-        : (path.isAbsolute(explicitPath) ? explicitPath : path.join(repoRoot, explicitPath));
     return {
         repoRoot,
-        pidFile: runtimePath(repoRoot, projectKey, 'run', 'server.pid'),
+        pidFile: runtimePath(projectKey, 'run', 'server.pid'),
         log: {
-            path: resolvedLogPath,
+            path: runtimePath(projectKey, 'logs', 'server.log'),
             rotateAtBytes: typeof log.rotateAtBytes === 'number' ? log.rotateAtBytes : DEFAULT_ROTATE_BYTES
         },
         heartbeatMs: typeof merged.heartbeatMs === 'number' ? merged.heartbeatMs : DEFAULT_SERVER_CONFIG.heartbeatMs,

package/dist/lib/server/daemon.js

@@ -61,7 +61,7 @@ export function createMessageDispatcher(options) {
                 title: `ai ${plan.argv.join(' ')}`,
                 chunkChars: typeof options.config.stream?.chunkChars === 'number' ? options.config.stream.chunkChars : 4000,
                 throttleMs: typeof options.config.stream?.throttleMs === 'number' ? options.config.stream.throttleMs : 1500
-            }, (emit) => runAiImpl(plan.argv, { onChunk: emit }), (outbound) => replyOutbound(message, outbound));
+            }, (emit) => runAiImpl(plan.argv, { onChunk: emit, cwd: options.config.repoRoot }), (outbound) => replyOutbound(message, outbound));
         }
     };
 }
@@ -75,15 +75,16 @@ export function createMessageDispatcher(options) {
 //   - runDaemon() awaits a shutdown promise that only resolves once a
 //     SIGINT/SIGTERM handler has finished graceful cleanup. We never unref()
 //     the only keep-alive timer (that would let the process exit immediately).
-export async function runDaemon() {
+export async function runDaemon({ rootDir } = {}) {
     let config;
     try {
-        config = loadServerConfig();
+        config = loadServerConfig({ rootDir });
     }
     catch (error) {
         process.stderr.write(`${errorMessage(error)}\n`);
         process.exit(1);
     }
+    process.chdir(config.repoRoot);
     const logger = createLogger(config.log);
     logger.info(`daemon starting agent-infra ${VERSION} pid=${process.pid}`);
     const ownStartTime = getProcessStartTime(process.pid);

package/dist/lib/server/process-control.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import path from 'node:path';
 import { spawn, execFileSync } from 'node:child_process';
 import { loadServerConfig } from './config.js';
 import { runDaemon } from './daemon.js';
@@ -65,7 +66,7 @@ export async function start({ foreground = false } = {}) {
         removePidFileIfMatches(pidPath, existing.snapshot);
     }
     if (foreground) {
-        await runDaemon();
+        await runDaemon({ rootDir: config.repoRoot });
         return;
     }
     const cliEntry = process.argv[1];
@@ -75,8 +76,9 @@ export async function start({ foreground = false } = {}) {
     // Re-spawn ourselves detached. process.execArgv is forwarded so the dev path
     // (node --experimental-strip-types ./bin/cli.ts) and the built path
     // (node dist/bin/cli.js) both work.
-    const child = spawn(process.execPath, [...process.execArgv, cliEntry, 'server', '__daemon'], {
+    const child = spawn(process.execPath, [...process.execArgv, path.resolve(cliEntry), 'server', '__daemon'], {
         detached: true,
+        cwd: config.repoRoot,
         stdio: 'ignore'
     });
     child.unref();

package/dist/lib/server/runner.js

@@ -22,12 +22,13 @@ function resolveCommand(file) {
 function needsShell(file) {
     return process.platform === 'win32' && /\.(?:bat|cmd)$/i.test(file);
 }
-function spawnCapture(file, args, onChunk) {
+function spawnCapture(file, args, onChunk, cwd) {
     return new Promise((resolve, reject) => {
         const resolvedFile = resolveCommand(file);
         const child = spawn(resolvedFile, args, {
             stdio: ['ignore', 'pipe', 'pipe'],
-            shell: needsShell(resolvedFile)
+            shell: needsShell(resolvedFile),
+            ...(cwd === undefined ? {} : { cwd })
         });
         let stdout = '';
         let stderr = '';
@@ -70,6 +71,6 @@ function spawnCapture(file, args, onChunk) {
     });
 }
 export async function runAi(args, options = {}) {
-    return (options.spawn ?? spawnCapture)('ai', args, options.onChunk);
+    return (options.spawn ?? spawnCapture)('ai', args, options.onChunk, options.cwd);
 }
 //# sourceMappingURL=runner.js.map

package/dist/lib/task/artifact-lifecycle.js

@@ -7,6 +7,8 @@ import { parseImplementationInputs, selectPendingImplementationInput } from './i
 import { parseVerdict } from './review-artifacts.js';
 import { extractSection, findSectionHeading } from './sections.js';
 import { receiptForOutput, sha256File } from './artifact-receipts.js';
+import { hasArtifactCompletionFact, hasArtifactCompletionLog } from './completion-facts.js';
+import { inspectReviewIdentity } from './review-identity.js';
 import { isArtifactInvalidated, parseInvalidationDocument } from './invalidation.js';
 import { parseLifecyclePathDecision } from './lifecycle-path.js';
 import { parseReworkIntentDocument } from './rework-intent.js';
@@ -149,7 +151,16 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
             diagnostics.push(diagnostic('ROUND_GAP', family, null, `${artifactName(family, round)} is missing`));
     }
     const latest = artifacts.at(-1) ?? null;
-    const reviewedInput = family.startsWith('review-') && latest
+    let hasReviewCodeReceipt = false;
+    if (family === 'review-code' && latest) {
+        try {
+            hasReviewCodeReceipt = Boolean(receiptForOutput(fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8'), latest.name));
+        }
+        catch {
+            hasReviewCodeReceipt = false;
+        }
+    }
+    const reviewedInput = family.startsWith('review-') && latest && (family !== 'review-code' || hasReviewCodeReceipt)
         ? resolveReviewedInput(taskDir, latest, family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code', diagnostics)
         : null;
     return {
@@ -248,14 +259,16 @@ function assertWritableInventory(inventory) {
     };
 }
 const REQUIRED_INPUT = {
-    'review-analysis': 'analysis', plan: 'analysis', 'review-plan': 'plan', 'review-code': 'code'
+    'review-analysis': 'analysis', plan: 'analysis', 'review-plan': 'plan'
 };
 const OPTIONAL_CONTEXT = {
-    analysis: { family: 'review-analysis' },
-    plan: { family: 'review-plan' },
-    'review-code': { family: 'review-plan' },
-    'manual-validation': { family: 'review-code' },
-    'validation-run': { family: 'review-code' }
+    analysis: ['review-analysis'],
+    plan: ['review-analysis', 'review-plan'],
+    'review-plan': ['review-analysis'],
+    code: ['review-plan'],
+    'review-code': ['code', 'plan', 'review-plan'],
+    'manual-validation': ['review-code'],
+    'validation-run': ['review-code']
 };
 function hasSelectionEvidence(content, family, options, context) {
     if (options.sourceFinding && options.sourceArtifact && options.sourceSha256)
@@ -265,6 +278,20 @@ function hasSelectionEvidence(content, family, options, context) {
     if (family.startsWith('review-')) {
         const reviewedFamily = family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code';
         const currentInput = context.inputs.find((input) => input.family === reviewedFamily);
+        if (family === 'review-code') {
+            if (!context.latest)
+                return false;
+            try {
+                const reportContent = fs.readFileSync(context.latest.path, 'utf8');
+                const identity = inspectReviewIdentity(context.taskDir, reportContent, options.repoRoot);
+                return identity.status !== 'matched'
+                    || !hasArtifactCompletionFact(content, context.latest.path, 'review-code.completed')
+                    || !hasArtifactCompletionLog(content, context.latest.name, 'review-code.completed');
+            }
+            catch {
+                return true;
+            }
+        }
         if (currentInput && context.reviewedInput?.name !== currentInput.name)
             return true;
     }
@@ -387,9 +414,10 @@ function resolveArtifactContext(taskRef, family, options = {}) {
     }
     const optional = OPTIONAL_CONTEXT[inventory.family];
     if (optional) {
-        const context = inspectTaskArtifacts(taskRef, optional.family, options);
-        if (context.status === 'ready' && context.latest) {
-            inputs.push(context.latest);
+        for (const family of optional) {
+            const context = inspectTaskArtifacts(taskRef, family, options);
+            if (context.status === 'ready' && context.latest)
+                inputs.push(context.latest);
         }
     }
     if (inventory.family === 'manual-validation' || inventory.family === 'validation-run') {
@@ -411,6 +439,10 @@ function resolveCodeContext(inventory, options) {
     const codeMax = latestCode?.round ?? 0;
     const reviewMax = reviewCode.latest?.round ?? 0;
     const inputs = [source.latest];
+    const sourceReviewFamily = inputFamily === 'analysis' ? 'review-analysis' : 'review-plan';
+    const sourceReview = inspectTaskArtifacts(taskRef, sourceReviewFamily, options);
+    if (sourceReview.status === 'ready' && sourceReview.latest && sourceReview.reviewedInput?.name === source.latest.name)
+        inputs.push(sourceReview.latest);
     if (latestCode) {
         try {
             const taskContent = fs.readFileSync(path.join(inventory.taskDir, 'task.md'), 'utf8');