@fitlab-ai/agent-infra 0.11.5 → 0.11.6

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/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/task/resolve-ref.js

@@ -41,7 +41,7 @@ function listSortedNumeric(dir, width) {
         .reverse();
 }
 function findInArchive(repoRoot, taskId) {
-    // archive-tasks SKILL writes to .agents/workspace/archive/YYYY/MM/DD/{taskId}/task.md
+    // archive-tasks stores local material at .agents/workspace/archive/YYYY/MM/DD/{taskId}/local/task.md
     // where YYYY/MM/DD comes from completed_at (or updated_at fallback) — NOT from
     // the task id's creation date. So we cannot derive the path from taskId alone;
     // walk the bounded YYYY/MM/DD tree instead. Newest-first to favor recent archives.
@@ -51,7 +51,7 @@ function findInArchive(repoRoot, taskId) {
         for (const month of listSortedNumeric(yearDir, 2)) {
             const monthDir = path.join(yearDir, month);
             for (const day of listSortedNumeric(monthDir, 2)) {
-                const candidate = path.join(monthDir, day, taskId, 'task.md');
+                const candidate = path.join(monthDir, day, taskId, 'local', 'task.md');
                 if (fs.existsSync(candidate))
                     return candidate;
             }
@@ -125,7 +125,7 @@ function enumerateAllTaskDirs(repoRoot) {
             for (const day of listSortedNumeric(monthDir, 2).reverse()) {
                 const dayDir = path.join(monthDir, day);
                 for (const taskId of fs.readdirSync(dayDir).sort())
-                    add(taskId, path.join(dayDir, taskId), 'archive');
+                    add(taskId, path.join(dayDir, taskId, 'local'), 'archive');
             }
         }
     }

package/dist/lib/task/write.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import crypto from 'node:crypto';
 import { isValidAgentInfraVersion, VERSION } from '../version.js';
 import { parseTypedTaskFrontmatter, updateTaskFrontmatter } from './frontmatter.js';
 import { resolveTaskRef } from './resolve-ref.js';
@@ -53,7 +54,7 @@ function errorDetails(error, fallback) {
         message: error instanceof Error ? error.message : String(error)
     };
 }
-function writeTask(request, options = {}) {
+function writeTaskCore(request, options = {}) {
     const resolved = options.taskLocation
         ? {
             ok: true,
@@ -258,5 +259,124 @@ function writeTask(request, options = {}) {
     }
     return { ...successBase, status: 'applied', changed: true };
 }
+function archiveContentsHash(localDir) {
+    const files = [];
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.name.includes('\n') || entry.name.includes('\r') || entry.name === 'manifest.md') {
+                throw new Error(`Archive source path is not valid: ${path.join(dir, entry.name)}`);
+            }
+            const target = path.join(dir, entry.name);
+            const stat = fs.lstatSync(target);
+            if (stat.isSymbolicLink())
+                throw new Error(`Archive source cannot contain symbolic links: ${target}`);
+            if (stat.isDirectory())
+                walk(target);
+            else if (stat.isFile()) {
+                if (entry.name !== 'contents.sha256')
+                    files.push(target);
+            }
+            else
+                throw new Error(`Archive source cannot contain special files: ${target}`);
+        }
+    };
+    walk(localDir);
+    const rows = files
+        .map((file) => ({ file, relative: path.relative(localDir, file).split(path.sep).join('/') }))
+        .sort((left, right) => Buffer.compare(Buffer.from(left.relative), Buffer.from(right.relative)))
+        .map(({ file, relative }) => `${crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex')}  ${relative}`);
+    return `${rows.join('\n')}${rows.length ? '\n' : ''}`;
+}
+function writeArchiveContentsHash(localDir) {
+    const contents = archiveContentsHash(localDir);
+    const hashPath = path.join(localDir, 'contents.sha256');
+    const tempPath = path.join(localDir, `.contents.sha256.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`);
+    try {
+        fs.writeFileSync(tempPath, contents, { flag: 'wx' });
+        fs.renameSync(tempPath, hashPath);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(tempPath);
+        }
+        catch (cleanupError) {
+            if (cleanupError.code !== 'ENOENT') {
+                throw new Error(`${error instanceof Error ? error.message : String(error)}; failed to remove ${tempPath}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            }
+        }
+        throw error;
+    }
+}
+function restoreArchivedTask(taskMdPath, contents, mode) {
+    const tempPath = `${taskMdPath}.${process.pid}.${Math.random().toString(36).slice(2)}.rollback`;
+    fs.writeFileSync(tempPath, contents, { flag: 'wx', mode });
+    try {
+        fs.renameSync(tempPath, taskMdPath);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(tempPath);
+        }
+        catch (cleanupError) {
+            if (cleanupError.code !== 'ENOENT') {
+                throw new Error(`${error instanceof Error ? error.message : String(error)}; failed to remove ${tempPath}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            }
+        }
+        throw error;
+    }
+}
+function writeTask(request, options = {}) {
+    const resolved = options.taskLocation
+        ? {
+            ok: true,
+            repoRoot: options.taskLocation.repoRoot,
+            taskId: options.taskLocation.taskId,
+            taskDir: path.dirname(options.taskLocation.taskMdPath),
+            taskMdPath: options.taskLocation.taskMdPath,
+            state: options.taskLocation.state
+        }
+        : resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok) {
+        return failure(request, { taskId: resolved.taskId, taskMdPath: null, actualState: null }, resolved.code, resolved.message);
+    }
+    if (resolved.state !== 'archive' || request.expectedState !== 'archive' || request.dryRun) {
+        return writeTaskCore(request, { ...options, taskLocation: {
+                repoRoot: resolved.repoRoot,
+                taskId: resolved.taskId,
+                taskMdPath: resolved.taskMdPath,
+                state: resolved.state
+            } });
+    }
+    const identity = { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, actualState: resolved.state };
+    try {
+        const originalTask = fs.readFileSync(resolved.taskMdPath);
+        const originalMode = fs.statSync(resolved.taskMdPath).mode;
+        archiveContentsHash(resolved.taskDir);
+        const result = writeTaskCore(request, { ...options, taskLocation: {
+                repoRoot: resolved.repoRoot,
+                taskId: resolved.taskId,
+                taskMdPath: resolved.taskMdPath,
+                state: resolved.state
+            } });
+        if (result.status === 'applied') {
+            try {
+                writeArchiveContentsHash(resolved.taskDir);
+            }
+            catch (error) {
+                try {
+                    restoreArchivedTask(resolved.taskMdPath, originalTask, originalMode);
+                }
+                catch (rollbackError) {
+                    throw new Error(`Archive checksum update failed: ${error instanceof Error ? error.message : String(error)}; task rollback failed: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+                }
+                throw error;
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        return failure(request, identity, 'TASK_READ_FAILED', error instanceof Error ? error.message : String(error));
+    }
+}
 export { writeTask, captureTaskWriteMetadata, canonicalTimestamp };
 //# sourceMappingURL=write.js.map

package/dist/lifecycle-build-manifest.json

@@ -1,6 +1,6 @@
 {
   "protocolVersion": 3,
-  "packageVersion": "0.11.5",
-  "sourceInputHash": "2f29b7f1f134733c3bc1bb7c92ea6c11e57462ed51a5a96b0198b8824a3f455d",
-  "internalExecutableBuildHash": "cb9d00aa3fa974cf936a8aad310e1fa5f28842351f52a53fed43345fe9c46439"
+  "packageVersion": "0.11.6",
+  "sourceInputHash": "402048e73650c5ac4edfb1bc4b48ca3fceb7b9068790b1321281c4994121e80c",
+  "internalExecutableBuildHash": "47ecd04ac30183443b2b86f83d1668b8bdf9e59162cc9e2cedd333d3011843e9"
 }

package/lib/merge.ts

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import crypto from 'node:crypto';
 import { removeDirRecursive } from './remove-dir.ts';
 import { validateCurrentTaskContract } from './task/current-contract.ts';
 
@@ -107,7 +108,7 @@ function extractTitle(content: string): string | null {
 }
 
 function normalizeTaskRecord(taskDir: string, taskFile: string, dateParts: DateParts): TaskRecord {
-  const taskId = path.basename(taskDir);
+  const taskId = path.basename(taskDir) === 'local' ? path.basename(path.dirname(taskDir)) : path.basename(taskDir);
   const content = fs.readFileSync(taskFile, 'utf8');
   const completedAt = extractField(content, 'completed_at');
   const updatedAt = extractField(content, 'updated_at');
@@ -155,7 +156,7 @@ function scanSourceTasks(sourceDir: string): TaskRecord[] {
             continue;
           }
 
-          const taskDir = path.join(dayDir, taskEntry.name);
+          const taskDir = path.join(dayDir, taskEntry.name, 'local');
           const taskFile = path.join(taskDir, 'task.md');
           if (!fs.existsSync(taskFile)) {
             continue;
@@ -251,7 +252,7 @@ function collectArchiveEntries(archiveDir: string): ArchiveManifestEntry[] {
           }
 
           const taskDir = path.join(dayDir, taskEntry.name);
-          const taskFile = path.join(taskDir, 'task.md');
+          const taskFile = path.join(taskDir, 'local', 'task.md');
           const relativePath = `${yearEntry.name}/${monthEntry.name}/${dayEntry.name}/${taskEntry.name}/`;
           let title = taskEntry.name;
           let type = 'unknown';
@@ -624,10 +625,12 @@ function validateSourceRoot(sourceRoot: string): void {
 function validateTaskDirectory(
   sourceRoot: string,
   taskDir: string,
-  seenTaskIds: Map<string, string>
+  seenTaskIds: Map<string, string>,
+  archived = false
 ): void {
   const taskId = path.basename(taskDir);
-  const taskFile = path.join(taskDir, 'task.md');
+  const contentDir = archived ? path.join(taskDir, 'local') : taskDir;
+  const taskFile = path.join(contentDir, 'task.md');
   const taskDirStat = sourcePathStat(sourceRoot, taskDir);
   if (!taskDirStat || !taskDirStat.isDirectory()) {
     invalidSource(`${sourceRelativePath(sourceRoot, taskDir)} must be a directory`);
@@ -646,6 +649,33 @@ function validateTaskDirectory(
     invalidSource(`${sourceRelativePath(sourceRoot, taskFile)} id '${String(contract.metadata.id ?? 'missing')}' does not match directory '${taskId}'`);
   }
   validateTaskTree(sourceRoot, taskDir);
+  if (archived) {
+    for (const entry of fs.readdirSync(taskDir, { withFileTypes: true })) {
+      if (!['local', 'github', 'derived'].includes(entry.name) || !entry.isDirectory()) {
+        invalidSource(`${sourceRelativePath(sourceRoot, path.join(taskDir, entry.name))} is not an allowed archive source directory`);
+      }
+    }
+    validateArchiveSource(sourceRoot, contentDir);
+    const githubDir = path.join(taskDir, 'github');
+    if (fs.existsSync(githubDir)) {
+      for (const capture of fs.readdirSync(githubDir, { withFileTypes: true })) {
+        const captureDir = path.join(githubDir, capture.name);
+        if (!capture.isDirectory() || !/^capture-[A-Za-z0-9._-]+$/.test(capture.name) || !fs.existsSync(path.join(captureDir, 'capture.md'))) {
+          invalidSource(`${sourceRelativePath(sourceRoot, captureDir)} is not a valid GitHub capture`);
+        }
+        validateArchiveSource(sourceRoot, captureDir);
+      }
+    }
+    const derivedDir = path.join(taskDir, 'derived');
+    if (fs.existsSync(derivedDir)) {
+      for (const view of fs.readdirSync(derivedDir, { withFileTypes: true })) {
+        const viewDir = path.join(derivedDir, view.name);
+        if (!view.isDirectory() || !fs.existsSync(path.join(viewDir, 'inputs.md'))) {
+          invalidSource(`${sourceRelativePath(sourceRoot, viewDir)} requires inputs.md`);
+        }
+      }
+    }
+  }
 
   const previousPath = seenTaskIds.get(taskId);
   if (previousPath) {
@@ -654,6 +684,26 @@ function validateTaskDirectory(
   seenTaskIds.set(taskId, sourceRelativePath(sourceRoot, taskDir));
 }
 
+function validateArchiveSource(sourceRoot: string, sourceDir: string): void {
+  const hashFile = path.join(sourceDir, 'contents.sha256');
+  const hashStat = sourcePathStat(sourceRoot, hashFile);
+  if (!hashStat?.isFile()) invalidSource(`${sourceRelativePath(sourceRoot, sourceDir)} requires contents.sha256`);
+  const files: string[] = [];
+  const walk = (dir: string) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const target = path.join(dir, entry.name);
+      if (entry.name === 'manifest.md') invalidSource(`${sourceRelativePath(sourceRoot, target)} is forbidden inside a TASK`);
+      if (entry.isDirectory()) walk(target);
+      else if (entry.isFile() && target !== hashFile) files.push(target);
+    }
+  };
+  walk(sourceDir);
+  const expected = files.sort((a, b) => Buffer.compare(Buffer.from(path.relative(sourceDir, a).split(path.sep).join('/')), Buffer.from(path.relative(sourceDir, b).split(path.sep).join('/'))))
+    .map((file) => `${crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex')}  ${path.relative(sourceDir, file).split(path.sep).join('/')}`);
+  const actual = fs.readFileSync(hashFile, 'utf8').trimEnd().split(/\r?\n/).filter(Boolean);
+  if (JSON.stringify(expected) !== JSON.stringify(actual)) invalidSource(`${sourceRelativePath(sourceRoot, hashFile)} does not match local files`);
+}
+
 function validateMutableSection(
   sourceRoot: string,
   section: MutableSection,
@@ -730,9 +780,6 @@ function validateArchiveSection(
       const monthDir = monthPath;
       for (const dayEntry of fs.readdirSync(monthDir, { withFileTypes: true })) {
         const dayPath = path.join(monthDir, dayEntry.name);
-        if (allowManifest(monthDir, dayEntry)) {
-          continue;
-        }
         const dayStat = sourcePathStat(sourceRoot, dayPath);
         if (!dayStat?.isDirectory() || !/^\d{2}$/.test(dayEntry.name)) {
           invalidSource(`${sourceRelativePath(sourceRoot, dayPath)} is not a DD directory or manifest.md`);
@@ -745,7 +792,7 @@ function validateArchiveSection(
           if (!taskStat?.isDirectory() || !TASK_ID_RE.test(taskEntry.name)) {
             invalidSource(`${sourceRelativePath(sourceRoot, taskPath)} is not a TASK-YYYYMMDD-HHMMSS directory`);
           }
-          validateTaskDirectory(sourceRoot, taskPath, seenTaskIds);
+          validateTaskDirectory(sourceRoot, taskPath, seenTaskIds, true);
         }
       }
     }
@@ -904,9 +951,10 @@ function mergeArchiveSection(sourceArchive: string, localArchive: string, report
       continue;
     }
 
+    const sourceTaskDir = path.dirname(task.taskDir);
     const destinationDir = path.join(localArchive, task.relativePath);
     fs.mkdirSync(path.dirname(destinationDir), { recursive: true });
-    fs.cpSync(task.taskDir, destinationDir, { recursive: true });
+    fs.cpSync(sourceTaskDir, destinationDir, { recursive: true });
     recordArchive(report, 'copied', {
       action: 'copied',
       symbol: '✓',
@@ -1045,6 +1093,7 @@ async function cmdMerge(args: string[]): Promise<void> {
   const report = createReport(resolvedSource, backupRootRelative);
   detectSourceMode(resolvedSource);
   validateSourceWorkspace(resolvedSource);
+  validateArchiveSection(workspaceDir, new Map());
 
   for (const section of ALL_SECTIONS) {
     fs.mkdirSync(path.join(workspaceDir, section), { recursive: true });