@fitlab-ai/agent-infra 0.9.10 → 0.9.12

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

@@ -1,6 +1,6 @@
-import { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, awaitOrchestrationDelegationActivation, beginOrResumeOrchestration, dispatchOrchestrationDelegation, OrchestrationStateError, pauseOrchestration, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration } from '../task/orchestration.js';
-import { prepareCodexOrchestrationDelegation } from '../task/codex-orchestration.js';
-import { isAgentClientId } from '../agent-clients/types.js';
+import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../task/control-authority.js';
+import { OrchestrationStateError } from '../task/orchestration.js';
+import { detectRepoRoot } from '../task/resolve-ref.js';
 const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|dispatch|await-activation|recover-prepared|hook-start|hook-stop|advance|pause|status> [options]\n';
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({
@@ -10,236 +10,50 @@ function usageFailure(message) {
     process.stderr.write(USAGE);
     process.exitCode = 2;
 }
+function parseFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.replace(/^TASK_CONTROL_OPERATION_INVALID: /u, '');
+}
 async function taskOrchestration(args = []) {
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
-    if (args.length < 2) {
-        usageFailure('task ref and intent are required');
-        return;
+    let operation;
+    try {
+        operation = parseTaskControlOperation('task-orchestration', args);
     }
-    const [taskRef, intent] = args;
-    if (![
-        'begin-or-resume', 'route', 'prepare', 'dispatch', 'await-activation', 'recover-prepared',
-        'hook-start', 'hook-stop', 'advance', 'pause', 'status'
-    ].includes(intent)) {
-        usageFailure(`unknown intent '${intent}'`);
+    catch (error) {
+        usageFailure(parseFailure(error));
         return;
     }
-    const values = {};
-    const seen = new Set();
-    for (let index = 2; index < args.length; index += 1) {
-        const flag = args[index];
-        if (![
-            '--max-steps', '--executor-model', '--executor-reasoning-effort',
-            '--reviewer-model', '--reviewer-reasoning-effort',
-            '--client', '--requested-model', '--requested-reasoning-effort', '--capability-token',
-            '--parent-id', '--before-fingerprint',
-            '--stage', '--round', '--artifact', '--role',
-            '--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',
-            '--git-worktree-root'
-        ].includes(flag)) {
-            usageFailure(`unknown option '${flag}'`);
-            return;
-        }
-        if (seen.has(flag)) {
-            usageFailure(`duplicate option '${flag}'`);
-            return;
-        }
-        seen.add(flag);
-        const value = args[++index];
-        if (!value || value.startsWith('--')) {
-            usageFailure(`option '${flag}' requires a value`);
-            return;
-        }
-        values[flag] = value;
-    }
-    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']}'`);
+    if (operation.family !== 'task-orchestration') {
+        usageFailure('orchestration operation is invalid');
         return;
     }
-    let result;
+    let repoRoot = process.cwd();
     try {
-        if (intent === 'begin-or-resume') {
-            const missing = requireValues(['--client']);
-            if (missing) {
-                usageFailure(`intent 'begin-or-resume' requires '${missing}'`);
-                return;
-            }
-            const maxSteps = values['--max-steps'] === undefined ? undefined : Number(values['--max-steps']);
-            if (maxSteps !== undefined && (!Number.isInteger(maxSteps) || maxSteps < 1)) {
-                usageFailure('--max-steps must be a positive integer');
-                return;
-            }
-            const policyFlags = [
-                '--executor-model', '--executor-reasoning-effort',
-                '--reviewer-model', '--reviewer-reasoning-effort'
-            ];
-            const hasAnyPolicy = policyFlags.some((flag) => values[flag] !== undefined);
-            if (hasAnyPolicy && policyFlags.some((flag) => values[flag] === undefined)) {
-                usageFailure('explicit model policy requires executor/reviewer model and reasoning effort');
-                return;
-            }
-            result = beginOrResumeOrchestration(taskRef, {
-                ...coreOptions,
-                maxSteps,
-                client: values['--client'],
-                modelPolicy: hasAnyPolicy ? {
-                    executor: {
-                        model: values['--executor-model'],
-                        reasoningEffort: values['--executor-reasoning-effort']
-                    },
-                    reviewer: {
-                        model: values['--reviewer-model'],
-                        reasoningEffort: values['--reviewer-reasoning-effort']
-                    }
-                } : undefined
-            });
-        }
-        else if (intent === 'route') {
-            result = routeOrchestration(taskRef, coreOptions);
-        }
-        else if (intent === 'status') {
-            result = statusOrchestration(taskRef, coreOptions);
-        }
-        else if (intent === 'prepare') {
-            const missing = requireValues(['--client']);
-            if (missing) {
-                usageFailure(`intent 'prepare' requires '${missing}'`);
-                return;
-            }
-            result = await prepareCodexOrchestrationDelegation(taskRef, {
-                client: values['--client'],
-                requestedModel: values['--requested-model'],
-                requestedReasoningEffort: values['--requested-reasoning-effort'],
-                capabilityToken: values['--capability-token']
-            }, { orchestrationOptions: coreOptions });
-        }
-        else if (intent === 'dispatch') {
-            result = dispatchOrchestrationDelegation(taskRef, coreOptions);
-        }
-        else if (intent === 'await-activation') {
-            const missing = requireValues(['--stage', '--round', '--artifact', '--role']);
-            if (missing) {
-                usageFailure(`intent 'await-activation' requires '${missing}'`);
-                return;
-            }
-            const round = Number(values['--round']);
-            if (!Number.isSafeInteger(round) || round < 1) {
-                usageFailure('--round must be a positive integer');
-                return;
-            }
-            if (!['executor', 'reviewer'].includes(values['--role'])) {
-                usageFailure('--role must be executor or reviewer');
-                return;
-            }
-            result = await awaitOrchestrationDelegationActivation(taskRef, {
-                stage: values['--stage'],
-                round,
-                artifact: values['--artifact'],
-                role: values['--role']
-            }, coreOptions);
-        }
-        else if (intent === 'recover-prepared') {
-            result = recoverPreparedOrchestrationDelegation(taskRef, coreOptions);
-        }
-        else if (intent === 'hook-start') {
-            const missing = requireValues([
-                ...(taskRef === 'auto' ? ['--client'] : []),
-                '--native-agent', '--child-id', '--parent-id'
-            ]);
-            if (missing) {
-                usageFailure(`intent 'hook-start' requires '${missing}'`);
-                return;
-            }
-            const event = {
-                nativeAgent: values['--native-agent'], childId: values['--child-id'],
-                parentId: values['--parent-id'], spawnMode: values['--spawn-mode'],
-                actualModel: values['--actual-model'],
-                actualReasoningEffort: values['--actual-reasoning-effort'],
-                modelFallbackReason: values['--model-fallback-reason'],
-                reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
-            };
-            result = taskRef === 'auto'
-                ? activateMatchingOrchestrationDelegation(values['--client'], event, coreOptions)
-                : activateOrchestrationDelegation(taskRef, event, coreOptions);
-        }
-        else if (intent === 'hook-stop') {
-            if (taskRef === 'auto') {
-                const missing = requireValues(['--client', '--native-agent', '--child-id']);
-                if (missing) {
-                    usageFailure(`intent 'hook-stop' requires '${missing}'`);
-                    return;
-                }
-                result = sealMatchingOrchestrationDelegation(values['--client'], {
-                    nativeAgent: values['--native-agent'], childId: values['--child-id'],
-                    actualModel: values['--actual-model'],
-                    actualReasoningEffort: values['--actual-reasoning-effort'],
-                    modelFallbackReason: values['--model-fallback-reason'],
-                    reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
-                }, coreOptions);
-            }
-            else {
-                const missing = requireValues(['--child-id', '--exit-code', '--after-fingerprint']);
-                if (missing) {
-                    usageFailure(`intent 'hook-stop' requires '${missing}'`);
-                    return;
-                }
-                const exitCode = Number(values['--exit-code']);
-                if (!Number.isInteger(exitCode)) {
-                    usageFailure('--exit-code must be an integer');
-                    return;
-                }
-                result = sealOrchestrationDelegation(taskRef, {
-                    childId: values['--child-id'], exitCode,
-                    afterFingerprint: values['--after-fingerprint'],
-                    changedPaths: values['--changed-paths'] ? values['--changed-paths'].split(',').filter(Boolean) : [],
-                    actualModel: values['--actual-model'],
-                    actualReasoningEffort: values['--actual-reasoning-effort'],
-                    modelFallbackReason: values['--model-fallback-reason'],
-                    reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
-                }, coreOptions);
-            }
-        }
-        else if (intent === 'advance') {
-            result = advanceOrchestration(taskRef, coreOptions);
-        }
-        else {
-            const missing = requireValues(['--code', '--message', '--recoverable']);
-            if (missing) {
-                usageFailure(`intent 'pause' requires '${missing}'`);
-                return;
-            }
-            if (!['true', 'false'].includes(values['--recoverable'])) {
-                usageFailure('--recoverable must be true or false');
-                return;
-            }
-            result = pauseOrchestration(taskRef, values['--code'], values['--message'], values['--recoverable'] === 'true', coreOptions);
-        }
+        repoRoot = detectRepoRoot();
+    }
+    catch { /* domain resolution reports the repository error */ }
+    try {
+        const result = await dispatchTaskControlOperation(createDirectHostExecutionContext({
+            repoRoot,
+            ...(process.env.AGENT_INFRA_RUNTIME_DIR ? { runtimeDir: process.env.AGENT_INFRA_RUNTIME_DIR } : {})
+        }), operation);
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        if (result.status === 'failed')
+            process.exitCode = 1;
     }
     catch (error) {
         if (!(error instanceof OrchestrationStateError))
             throw error;
-        result = {
-            status: 'failed',
-            changed: false,
-            taskId: error.taskId,
-            run: null,
-            next: null,
+        process.stdout.write(`${JSON.stringify({
+            status: 'failed', changed: false, taskId: error.taskId, run: null, next: null,
             error: { code: error.code, message: error.message }
-        };
-    }
-    const output = result;
-    process.stdout.write(`${JSON.stringify(output)}\n`);
-    if (result.status === 'failed')
+        })}\n`);
         process.exitCode = 1;
+    }
 }
 export { taskOrchestration };
 //# sourceMappingURL=task-orchestration.js.map

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

@@ -12,6 +12,7 @@ import { containerNameCandidates } from '../sandbox/constants.js';
 import { resolveSandboxTarget } from '../sandbox/workspace-identity.js';
 import { sandboxControlPaths } from '../sandbox/workspace-view.js';
 import { appendSandboxControlAudit, readActiveLease, readSandboxControlStatus } from '../sandbox/control/state.js';
+import { readSandboxControlManifest } from '../sandbox/control/lifecycle.js';
 import { SANDBOX_CONTROL_FUTURE_SKEW_MS, SANDBOX_CONTROL_STATUS_STALE_MS } from '../sandbox/control/protocol.js';
 import { getProcessStartTime } from '../server/process-state.js';
 import { assertGitWorktreeBinding } from '../git/worktree-identity.js';
@@ -150,7 +151,7 @@ function inplaceValidation(config, target, options) {
         base: config.controlBase, project: config.project,
         container: row.name, identity: target.workspace
     });
-    const manifest = JSON.parse(fs.readFileSync(control.manifestPath, 'utf8'));
+    const manifest = readSandboxControlManifest(control.manifestPath);
     const initial = readSandboxControlStatus(control.statusDir);
     const now = Date.now();
     if (initial.generation !== manifest.generation

package/dist/lib/merge.js

@@ -1,11 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { info, ok } from './log.js';
 import { removeDirRecursive } from './remove-dir.js';
+import { validateCurrentTaskContract } from './task/current-contract.js';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
 const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
 const TITLE_RE = /^# (.+)$/m;
-const DATE_FROM_PATH_RE = /(?:^|[/\\])(\d{4})[/\\](\d{2})[/\\](\d{2})(?:[/\\]|$)/;
 const MUTABLE_SECTIONS = ['active', 'blocked', 'completed'];
 const ALL_SECTIONS = [...MUTABLE_SECTIONS, 'archive'];
 const SECTION_LABELS = {
@@ -64,36 +63,6 @@ function normalizeTaskRecord(taskDir, taskFile, dateParts) {
         completedAt: taskDate
     };
 }
-function fallbackDateParts(taskDir, content) {
-    const pathMatch = taskDir.match(DATE_FROM_PATH_RE);
-    if (pathMatch) {
-        const [, year, month, day] = pathMatch;
-        if (!year || !month || !day) {
-            return null;
-        }
-        return {
-            year,
-            month,
-            day
-        };
-    }
-    const completedAt = extractField(content, 'completed_at');
-    const updatedAt = extractField(content, 'updated_at');
-    const source = completedAt || updatedAt;
-    const dateMatch = source?.match(/^(\d{4})-(\d{2})-(\d{2})/);
-    if (dateMatch) {
-        const [, year, month, day] = dateMatch;
-        if (!year || !month || !day) {
-            return null;
-        }
-        return {
-            year,
-            month,
-            day
-        };
-    }
-    return null;
-}
 function scanSourceTasks(sourceDir) {
     const tasks = [];
     const years = fs.existsSync(sourceDir) ? fs.readdirSync(sourceDir, { withFileTypes: true }) : [];
@@ -130,37 +99,6 @@ function scanSourceTasks(sourceDir) {
             }
         }
     }
-    if (tasks.length > 0) {
-        return tasks;
-    }
-    // Fall back to a deeper scan if the source layout is unusual but still contains archived tasks.
-    const stack = [sourceDir];
-    while (stack.length > 0) {
-        const currentDir = stack.pop();
-        if (!currentDir || !fs.existsSync(currentDir)) {
-            continue;
-        }
-        for (const entry of fs.readdirSync(currentDir, { withFileTypes: true })) {
-            const entryPath = path.join(currentDir, entry.name);
-            if (!entry.isDirectory()) {
-                continue;
-            }
-            if (TASK_ID_RE.test(entry.name)) {
-                const taskFile = path.join(entryPath, 'task.md');
-                if (!fs.existsSync(taskFile)) {
-                    continue;
-                }
-                const content = fs.readFileSync(taskFile, 'utf8');
-                const dateParts = fallbackDateParts(entryPath, content);
-                if (!dateParts) {
-                    continue;
-                }
-                tasks.push(normalizeTaskRecord(entryPath, taskFile, dateParts));
-                continue;
-            }
-            stack.push(entryPath);
-        }
-    }
     return tasks.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
 }
 function findTaskDirById(rootDir, taskId) {
@@ -470,14 +408,200 @@ function copyTaskToSection(sourceTask, workspaceDir) {
     fs.cpSync(sourceTask.taskDir, destinationDir, { recursive: true });
     return destinationDir;
 }
+function invalidSource(message) {
+    throw new Error(`Invalid merge source: ${message}`);
+}
+function sourceRelativePath(sourceRoot, targetPath) {
+    return path.relative(sourceRoot, targetPath).split(path.sep).join('/') || '.';
+}
+function isMissingPathError(error) {
+    return Boolean(error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT');
+}
+function assertSourcePathContained(sourceRoot, targetPath) {
+    let sourceRealPath;
+    let targetRealPath;
+    try {
+        sourceRealPath = fs.realpathSync(sourceRoot);
+        targetRealPath = fs.realpathSync(targetPath);
+    }
+    catch (error) {
+        invalidSource(`${sourceRelativePath(sourceRoot, targetPath)} cannot be resolved: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const relativePath = path.relative(sourceRealPath, targetRealPath);
+    if (relativePath === '..' || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath)) {
+        invalidSource(`${sourceRelativePath(sourceRoot, targetPath)} resolves outside the source workspace`);
+    }
+}
+function sourcePathStat(sourceRoot, targetPath) {
+    let stat;
+    try {
+        stat = fs.lstatSync(targetPath);
+    }
+    catch (error) {
+        if (isMissingPathError(error)) {
+            return null;
+        }
+        throw error;
+    }
+    if (stat.isSymbolicLink()) {
+        invalidSource(`${sourceRelativePath(sourceRoot, targetPath)} must not be a symbolic link`);
+    }
+    assertSourcePathContained(sourceRoot, targetPath);
+    return stat;
+}
+function validateTaskTree(sourceRoot, taskDir) {
+    for (const entry of fs.readdirSync(taskDir, { withFileTypes: true })) {
+        const entryPath = path.join(taskDir, entry.name);
+        const entryStat = sourcePathStat(sourceRoot, entryPath);
+        if (!entryStat) {
+            invalidSource(`${sourceRelativePath(sourceRoot, entryPath)} disappeared during validation`);
+        }
+        if (entryStat.isDirectory()) {
+            validateTaskTree(sourceRoot, entryPath);
+            continue;
+        }
+        if (!entryStat.isFile()) {
+            invalidSource(`${sourceRelativePath(sourceRoot, entryPath)} must be a regular file or directory`);
+        }
+    }
+}
+function validateSourceRoot(sourceRoot) {
+    const stat = sourcePathStat(sourceRoot, sourceRoot);
+    if (!stat || !stat.isDirectory()) {
+        invalidSource('source path must be a real directory');
+    }
+}
+function validateTaskDirectory(sourceRoot, taskDir, seenTaskIds) {
+    const taskId = path.basename(taskDir);
+    const taskFile = path.join(taskDir, 'task.md');
+    const taskDirStat = sourcePathStat(sourceRoot, taskDir);
+    if (!taskDirStat || !taskDirStat.isDirectory()) {
+        invalidSource(`${sourceRelativePath(sourceRoot, taskDir)} must be a directory`);
+    }
+    const taskFileStat = sourcePathStat(sourceRoot, taskFile);
+    if (!taskFileStat || !taskFileStat.isFile()) {
+        invalidSource(`${sourceRelativePath(sourceRoot, taskDir)} requires a regular task.md file`);
+    }
+    const content = fs.readFileSync(taskFile, 'utf8');
+    const contract = validateCurrentTaskContract(content);
+    if (!contract.ok) {
+        invalidSource(`${sourceRelativePath(sourceRoot, taskFile)} is not a valid current task: ${contract.message}`);
+    }
+    if (contract.metadata.id !== taskId) {
+        invalidSource(`${sourceRelativePath(sourceRoot, taskFile)} id '${String(contract.metadata.id ?? 'missing')}' does not match directory '${taskId}'`);
+    }
+    validateTaskTree(sourceRoot, taskDir);
+    const previousPath = seenTaskIds.get(taskId);
+    if (previousPath) {
+        invalidSource(`duplicate task ID ${taskId} at ${previousPath} and ${sourceRelativePath(sourceRoot, taskDir)}`);
+    }
+    seenTaskIds.set(taskId, sourceRelativePath(sourceRoot, taskDir));
+}
+function validateMutableSection(sourceRoot, section, seenTaskIds) {
+    const sectionDir = path.join(sourceRoot, section);
+    const sectionStat = sourcePathStat(sourceRoot, sectionDir);
+    if (!sectionStat) {
+        return;
+    }
+    if (!sectionStat.isDirectory()) {
+        invalidSource(`${section} must be a directory`);
+    }
+    for (const entry of fs.readdirSync(sectionDir, { withFileTypes: true })) {
+        const entryPath = path.join(sectionDir, entry.name);
+        const entryStat = sourcePathStat(sourceRoot, entryPath);
+        if (!entryStat) {
+            continue;
+        }
+        if (!entryStat.isDirectory()) {
+            if (TASK_ID_RE.test(entry.name)) {
+                invalidSource(`${sourceRelativePath(sourceRoot, entryPath)} is not a directory`);
+            }
+            continue;
+        }
+        if (!TASK_ID_RE.test(entry.name)) {
+            invalidSource(`${sourceRelativePath(sourceRoot, entryPath)} is not a direct TASK-YYYYMMDD-HHMMSS directory`);
+        }
+        validateTaskDirectory(sourceRoot, entryPath, seenTaskIds);
+    }
+}
+function validateArchiveSection(sourceRoot, seenTaskIds) {
+    const archiveDir = path.join(sourceRoot, 'archive');
+    const archiveStat = sourcePathStat(sourceRoot, archiveDir);
+    if (!archiveStat) {
+        return;
+    }
+    if (!archiveStat.isDirectory()) {
+        invalidSource('archive must be a directory');
+    }
+    const allowManifest = (directory, entry) => {
+        const entryPath = path.join(directory, entry.name);
+        const entryStat = sourcePathStat(sourceRoot, entryPath);
+        return Boolean(entryStat?.isFile() && entry.name === 'manifest.md');
+    };
+    const years = fs.readdirSync(archiveDir, { withFileTypes: true });
+    for (const yearEntry of years) {
+        const yearPath = path.join(archiveDir, yearEntry.name);
+        if (allowManifest(archiveDir, yearEntry)) {
+            continue;
+        }
+        const yearStat = sourcePathStat(sourceRoot, yearPath);
+        if (!yearStat?.isDirectory() || !/^\d{4}$/.test(yearEntry.name)) {
+            invalidSource(`${sourceRelativePath(sourceRoot, yearPath)} is not a YYYY directory or manifest.md`);
+        }
+        const yearDir = yearPath;
+        for (const monthEntry of fs.readdirSync(yearDir, { withFileTypes: true })) {
+            const monthPath = path.join(yearDir, monthEntry.name);
+            if (allowManifest(yearDir, monthEntry)) {
+                continue;
+            }
+            const monthStat = sourcePathStat(sourceRoot, monthPath);
+            if (!monthStat?.isDirectory() || !/^\d{2}$/.test(monthEntry.name)) {
+                invalidSource(`${sourceRelativePath(sourceRoot, monthPath)} is not a MM directory or manifest.md`);
+            }
+            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`);
+                }
+                const dayDir = dayPath;
+                for (const taskEntry of fs.readdirSync(dayDir, { withFileTypes: true })) {
+                    const taskPath = path.join(dayDir, taskEntry.name);
+                    const taskStat = sourcePathStat(sourceRoot, taskPath);
+                    if (!taskStat?.isDirectory() || !TASK_ID_RE.test(taskEntry.name)) {
+                        invalidSource(`${sourceRelativePath(sourceRoot, taskPath)} is not a TASK-YYYYMMDD-HHMMSS directory`);
+                    }
+                    validateTaskDirectory(sourceRoot, taskPath, seenTaskIds);
+                }
+            }
+        }
+    }
+}
+function validateSourceWorkspace(sourcePath) {
+    validateSourceRoot(sourcePath);
+    const seenTaskIds = new Map();
+    for (const section of MUTABLE_SECTIONS) {
+        validateMutableSection(sourcePath, section, seenTaskIds);
+    }
+    validateArchiveSection(sourcePath, seenTaskIds);
+}
 function detectSourceMode(sourcePath) {
+    validateSourceRoot(sourcePath);
     for (const section of ALL_SECTIONS) {
         const sectionDir = path.join(sourcePath, section);
-        if (fs.existsSync(sectionDir) && fs.statSync(sectionDir).isDirectory()) {
+        const sectionStat = sourcePathStat(sourcePath, sectionDir);
+        if (sectionStat?.isDirectory()) {
             return 'workspace';
         }
+        if (sectionStat) {
+            invalidSource(`${section} must be a directory`);
+        }
     }
-    return 'legacy-archive';
+    invalidSource('expected a current workspace containing active, blocked, completed, or archive sections');
 }
 function createReport(sourcePath, backupRoot) {
     return {
@@ -606,24 +730,6 @@ function mergeArchiveSection(sourceArchive, localArchive, report) {
     }
     return sourceTasks.length;
 }
-function printLegacyArchiveMessages(report, sourcePath) {
-    const merged = report.sections.archive.copied;
-    const skipped = report.sections.archive.skipped;
-    if (merged.length === 0 && skipped.length === 0) {
-        info(`No archived tasks found in ${sourcePath}`);
-    }
-    for (const task of merged) {
-        ok(`Merged ${task.taskId} -> ${task.relativePath}`);
-    }
-    for (const task of skipped) {
-        info(`Skipped ${task.taskId} (already exists at ${task.relativePath})`);
-    }
-    process.stdout.write('\n');
-    info('Merge summary');
-    info(`- Merged: ${merged.length}`);
-    info(`- Skipped: ${skipped.length}`);
-    process.stdout.write('\n');
-}
 function printSection(lines, name, counts) {
     const title = `${SECTION_LABELS[name].padEnd(9, ' ')} (.agents/workspace/${name}/):`;
     lines.push(title);
@@ -709,7 +815,10 @@ async function cmdMerge(args) {
     if (!fs.existsSync(resolvedSource)) {
         throw new Error(`Source path does not exist: ${sourcePath}`);
     }
-    if (!fs.statSync(resolvedSource).isDirectory()) {
+    if (fs.lstatSync(resolvedSource).isSymbolicLink()) {
+        throw new Error(`Invalid merge source: source path must be a real directory: ${sourcePath}`);
+    }
+    if (!fs.lstatSync(resolvedSource).isDirectory()) {
         throw new Error(`Source path is not a directory: ${sourcePath}`);
     }
     const workspaceDir = path.join(process.cwd(), '.agents', 'workspace');
@@ -718,30 +827,23 @@ async function cmdMerge(args) {
     const backupRootRelative = `.agents/workspace/.merge-backup/${backupStamp}/`;
     const backupRoot = path.join(workspaceDir, '.merge-backup', backupStamp);
     const report = createReport(resolvedSource, backupRootRelative);
-    const mode = detectSourceMode(resolvedSource);
+    detectSourceMode(resolvedSource);
+    validateSourceWorkspace(resolvedSource);
     for (const section of ALL_SECTIONS) {
         fs.mkdirSync(path.join(workspaceDir, section), { recursive: true });
     }
-    if (mode === 'legacy-archive') {
-        info('Detected legacy archive source; treating the input as archive-only for backward compatibility.');
-        mergeArchiveSection(resolvedSource, archiveDir, report);
-    }
-    else {
-        mergeMutableSections({
-            sourceWorkspace: resolvedSource,
-            localWorkspace: workspaceDir,
-            backupRoot,
-            report
-        });
-        const sourceArchive = path.join(resolvedSource, 'archive');
-        if (fs.existsSync(sourceArchive) && fs.statSync(sourceArchive).isDirectory()) {
-            mergeArchiveSection(sourceArchive, archiveDir, report);
-        }
+    mergeMutableSections({
+        sourceWorkspace: resolvedSource,
+        localWorkspace: workspaceDir,
+        backupRoot,
+        report
+    });
+    const sourceArchive = path.join(resolvedSource, 'archive');
+    const sourceArchiveStat = sourcePathStat(resolvedSource, sourceArchive);
+    if (sourceArchiveStat?.isDirectory()) {
+        mergeArchiveSection(sourceArchive, archiveDir, report);
     }
     rebuildManifests(archiveDir);
-    if (mode === 'legacy-archive') {
-        printLegacyArchiveMessages(report, sourcePath);
-    }
     printReport(report);
 }
 export { cmdMerge, compareTimestamps, detectSourceMode, extractField, extractTitle, formatBackupTimestamp, getTaskTimestamp, rebuildManifests, scanSourceTasks, scanWorkspaceSection, taskExistsInArchive };

package/dist/lib/platform/github-client.js

@@ -6,8 +6,14 @@ import semver from 'semver';
 const MINIMUM_GITHUB_CLI_VERSION = '2.72.0';
 const GITHUB_CLI_MAX_BUFFER = 64 * 1024 * 1024;
 const ERROR_DETAIL_LIMIT = 4096;
+function redactDiagnostic(value) {
+    return value
+        .replace(/\b(?:gh[pousr]_[A-Za-z0-9_]+|github_pat_[A-Za-z0-9_]+)\b/g, '[REDACTED_TOKEN]')
+        .replace(/\b(bearer|token)\s+[A-Za-z0-9._~+\/-]+/gi, '$1 [REDACTED_TOKEN]')
+        .replace(/([?&](?:access_token|token|client_secret|password)=)[^&\s]+/gi, '$1[REDACTED]');
+}
 function boundedFailureDetail(result) {
-    const diagnostic = `${result.stderr}\n${result.error?.message || ''}`.trim() || result.stdout.trim();
+    const diagnostic = redactDiagnostic(`${result.stderr}\n${result.error?.message || ''}`).trim() || redactDiagnostic(result.stdout.trim());
     return diagnostic.length <= ERROR_DETAIL_LIMIT
         ? diagnostic
         : `${diagnostic.slice(0, ERROR_DETAIL_LIMIT)}… [truncated]`;