@indigoai-us/hq-cli 5.314.0 → 5.315.0

package/dist/lib/lanes/monitor.js

@@ -0,0 +1,428 @@
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { LanesError } from "./errors.js";
+export const MONITOR_MAX_TIMEOUT_MS = 1_800_000;
+export const MONITOR_UNCOVERED_EXIT_CODE = 2;
+export const MONITOR_ERROR_EXIT_CODE = 3;
+export const MONITOR_TRANSCRIPT_MAX_BYTES = 512 * 1024;
+export const MONITOR_TASK_OUTPUT_MAX_BYTES = 64 * 1024;
+const SESSION_ID_PATTERN = /^[A-Za-z0-9._-]+$/;
+const LANE_ID_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9._-]*$/;
+const TERMINAL_TASK_OUTPUT = /(?:\[(?:exited|killed|terminated|stopped)(?:\b|\])|task\s+(?:stopped|killed)|monitor\s+(?:stopped|expired))/i;
+export const MONITOR_ENGINES = [
+    "claude",
+    "codex",
+    "grok",
+];
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function contentText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((item) => {
+        if (typeof item === "string")
+            return item;
+        if (item && typeof item === "object") {
+            const text = item.text;
+            const contentValue = item.content;
+            return typeof text === "string"
+                ? text
+                : typeof contentValue === "string"
+                    ? contentValue
+                    : "";
+        }
+        return "";
+    })
+        .join("\n");
+}
+function toolUseBlocks(row) {
+    const message = row.message;
+    if (!message || typeof message !== "object")
+        return [];
+    const content = message.content;
+    if (!Array.isArray(content))
+        return [];
+    return content.filter((item) => Boolean(item && typeof item === "object" && item.type === "tool_use"));
+}
+function toolResultText(row) {
+    const message = row.message;
+    if (!message || typeof message !== "object")
+        return "";
+    return contentText(message.content);
+}
+function toolResultUseId(row) {
+    const message = row.message;
+    if (!message || typeof message !== "object")
+        return undefined;
+    const content = message.content;
+    if (!Array.isArray(content))
+        return undefined;
+    for (const item of content) {
+        if (!item || typeof item !== "object")
+            continue;
+        const block = item;
+        if (block.type === "tool_result") {
+            return stringValue(block.tool_use_id) ?? stringValue(block.toolUseId);
+        }
+    }
+    return undefined;
+}
+function monitorTaskId(text) {
+    const match = /\btask\s+([A-Za-z0-9_-]+)\b/i.exec(text);
+    return match?.[1];
+}
+function isMissingFilesystemEntry(err) {
+    if (!err || typeof err !== "object")
+        return false;
+    const code = err.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+}
+function monitorEvidenceUnreadable(filePath, err) {
+    const cause = err instanceof Error ? err.message : String(err);
+    return new LanesError("monitor_evidence_unreadable", `Unable to read monitor evidence ${filePath}: ${cause}`, { path: filePath, cause });
+}
+/**
+ * Parse only the JSONL shape emitted by Claude Code's Monitor tool. The
+ * caller supplies a bounded tail; malformed or partial lines are ignored so a
+ * torn final write cannot turn into positive liveness evidence.
+ */
+export function parseMonitorTranscript(text) {
+    const pending = [];
+    const stoppedIds = new Set();
+    for (const line of text.split("\n")) {
+        if (line.length === 0)
+            continue;
+        let row;
+        try {
+            const parsed = JSON.parse(line);
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+                continue;
+            row = parsed;
+        }
+        catch {
+            continue;
+        }
+        for (const block of toolUseBlocks(row)) {
+            const name = stringValue(block.name);
+            const input = block.input;
+            const inputObject = input && typeof input === "object" && !Array.isArray(input)
+                ? input
+                : {};
+            if (name === "Monitor") {
+                const command = stringValue(inputObject.command);
+                const startedAt = stringValue(row.timestamp);
+                const timeoutMs = numberValue(inputObject.timeout_ms);
+                if (command && startedAt && timeoutMs && timeoutMs > 0) {
+                    pending.push({
+                        command,
+                        startedAt,
+                        timeoutMs,
+                        toolUseId: stringValue(block.id),
+                        persistent: typeof inputObject.persistent === "boolean"
+                            ? inputObject.persistent
+                            : undefined,
+                    });
+                }
+            }
+            else if (name === "TaskStop") {
+                const taskId = stringValue(inputObject.task_id) ?? stringValue(inputObject.taskId);
+                if (taskId)
+                    stoppedIds.add(taskId);
+            }
+        }
+        const toolUseResult = row.toolUseResult;
+        if (toolUseResult &&
+            typeof toolUseResult === "object" &&
+            !Array.isArray(toolUseResult)) {
+            const result = toolUseResult;
+            const taskId = stringValue(result.taskId) ??
+                stringValue(result.task_id) ??
+                monitorTaskId(toolResultText(row));
+            const resultUseId = toolResultUseId(row);
+            const candidate = resultUseId
+                ? pending.find((item) => item.taskId === undefined && item.toolUseId === resultUseId)
+                : pending.find((item) => item.taskId === undefined);
+            if (taskId && candidate) {
+                candidate.taskId = taskId;
+                candidate.timeoutMs =
+                    numberValue(result.timeoutMs) ?? candidate.timeoutMs;
+                if (typeof result.persistent === "boolean") {
+                    candidate.persistent = result.persistent;
+                }
+                const file = result.file;
+                if (file && typeof file === "object" && !Array.isArray(file)) {
+                    candidate.outputPath = stringValue(file.filePath);
+                }
+            }
+        }
+        else {
+            const taskId = monitorTaskId(toolResultText(row));
+            const resultUseId = toolResultUseId(row);
+            const candidate = resultUseId
+                ? pending.find((item) => item.taskId === undefined && item.toolUseId === resultUseId)
+                : pending.find((item) => item.taskId === undefined);
+            if (taskId && candidate)
+                candidate.taskId = taskId;
+        }
+    }
+    return pending
+        .filter((item) => Boolean(item.taskId))
+        .map((item) => ({
+        taskId: item.taskId,
+        command: item.command,
+        startedAt: item.startedAt,
+        timeoutMs: item.timeoutMs,
+        persistent: item.persistent,
+        stopped: item.stopped || stoppedIds.has(item.taskId),
+        outputPresent: false,
+        outputPath: item.outputPath,
+    }));
+}
+/** Return argv only for the exact command form the gate arms. */
+export function parseCanonicalWatchCommand(command) {
+    const tokens = command.trim().split(/\s+/u);
+    if (tokens.length < 4)
+        return null;
+    const executable = path.basename(tokens[0]);
+    if (executable !== "hq" || tokens[1] !== "lanes" || tokens[2] !== "watch") {
+        return null;
+    }
+    const laneIds = tokens.slice(3);
+    if (laneIds.some((laneId) => !LANE_ID_PATTERN.test(laneId)))
+        return null;
+    return laneIds;
+}
+function taskOutputIsTerminal(outputText) {
+    return outputText ? TERMINAL_TASK_OUTPUT.test(outputText) : false;
+}
+export function isMonitorTaskLive(task, now) {
+    if (task.stopped || task.processAlive !== true)
+        return false;
+    if (taskOutputIsTerminal(task.outputText))
+        return false;
+    const startedAt = Date.parse(task.startedAt);
+    if (!Number.isFinite(startedAt) || !Number.isFinite(task.timeoutMs) || task.timeoutMs <= 0) {
+        return false;
+    }
+    const deadline = startedAt + Math.min(task.timeoutMs, MONITOR_MAX_TIMEOUT_MS);
+    return now.getTime() < deadline;
+}
+export function coveredLaneIds(evidence, now) {
+    const covered = new Set();
+    for (const task of evidence.tasks) {
+        if (!isMonitorTaskLive(task, now))
+            continue;
+        const laneIds = parseCanonicalWatchCommand(task.command);
+        if (!laneIds)
+            continue;
+        for (const laneId of laneIds)
+            covered.add(laneId);
+    }
+    return covered;
+}
+function boundedTail(filePath, maxBytes) {
+    let fd;
+    let content = null;
+    let failure;
+    try {
+        const stat = fs.statSync(filePath);
+        const size = Math.min(stat.size, maxBytes);
+        fd = fs.openSync(filePath, "r");
+        const buffer = Buffer.alloc(size);
+        fs.readSync(fd, buffer, 0, size, Math.max(0, stat.size - size));
+        content = buffer.toString("utf8");
+    }
+    catch (err) {
+        if (!isMissingFilesystemEntry(err))
+            failure = monitorEvidenceUnreadable(filePath, err);
+    }
+    if (fd !== undefined) {
+        try {
+            fs.closeSync(fd);
+        }
+        catch (err) {
+            if (!isMissingFilesystemEntry(err) && !failure) {
+                failure = monitorEvidenceUnreadable(filePath, err);
+            }
+        }
+    }
+    if (failure)
+        throw failure;
+    return content;
+}
+function configDirs(home, env) {
+    const found = new Set();
+    const configured = env.CLAUDE_CONFIG_DIR?.trim() || path.join(home, ".claude");
+    found.add(configured);
+    try {
+        for (const name of fs.readdirSync(home)) {
+            if (name === ".claude" || name.startsWith(".claude-")) {
+                found.add(path.join(home, name));
+                found.add(path.join(home, name, ".claude"));
+            }
+        }
+    }
+    catch (err) {
+        if (!isMissingFilesystemEntry(err))
+            throw monitorEvidenceUnreadable(home, err);
+    }
+    const accountRoot = path.join(home, ".claude-accounts");
+    try {
+        for (const account of fs.readdirSync(accountRoot)) {
+            found.add(path.join(accountRoot, account, ".claude"));
+        }
+    }
+    catch (err) {
+        if (!isMissingFilesystemEntry(err))
+            throw monitorEvidenceUnreadable(accountRoot, err);
+    }
+    return [...found];
+}
+function transcriptPathsFor(home, env, sessionId) {
+    const paths = [];
+    for (const configDir of configDirs(home, env)) {
+        const projectsDir = path.join(configDir, "projects");
+        let projectDirs;
+        try {
+            projectDirs = fs.readdirSync(projectsDir);
+        }
+        catch (err) {
+            if (!isMissingFilesystemEntry(err))
+                throw monitorEvidenceUnreadable(projectsDir, err);
+            continue;
+        }
+        for (const projectDir of projectDirs) {
+            const candidate = path.join(projectsDir, projectDir, `${sessionId}.jsonl`);
+            try {
+                if (fs.statSync(candidate).isFile())
+                    paths.push(candidate);
+            }
+            catch (err) {
+                if (!isMissingFilesystemEntry(err))
+                    throw monitorEvidenceUnreadable(candidate, err);
+            }
+        }
+    }
+    return [...new Set(paths)];
+}
+function taskOutputCandidates(transcriptPath, sessionId, task) {
+    const candidates = [];
+    if (task.outputPath)
+        candidates.push(task.outputPath);
+    const projectDir = path.basename(path.dirname(transcriptPath));
+    try {
+        for (const tempName of fs.readdirSync(os.tmpdir())) {
+            if (!tempName.startsWith("claude-"))
+                continue;
+            candidates.push(path.join(os.tmpdir(), tempName, projectDir, sessionId, "tasks", `${task.taskId}.output`));
+        }
+    }
+    catch (err) {
+        if (!isMissingFilesystemEntry(err))
+            throw monitorEvidenceUnreadable(os.tmpdir(), err);
+    }
+    return [...new Set(candidates)];
+}
+function defaultProcessCommands() {
+    try {
+        const output = execFileSync("ps", ["-eww", "-o", "args="], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return output
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+function processHasExactCommand(processCommands, command) {
+    const laneIds = parseCanonicalWatchCommand(command);
+    if (!laneIds)
+        return false;
+    const expectedSuffix = ["lanes", "watch", ...laneIds];
+    return processCommands.some((line) => {
+        const tokens = line.trim().split(/\s+/u);
+        const suffixStart = tokens.length - expectedSuffix.length;
+        if (suffixStart < 1)
+            return false;
+        if (!expectedSuffix.every((token, index) => tokens[suffixStart + index] === token)) {
+            return false;
+        }
+        const hqToken = tokens[suffixStart - 1];
+        if (path.basename(hqToken) !== "hq")
+            return false;
+        const prefix = tokens.slice(0, suffixStart - 1);
+        return (prefix.length === 0 ||
+            (prefix.length === 1 &&
+                ["bun", "deno", "node", "nodejs", "ts-node", "tsx"].includes(path.basename(prefix[0]))));
+    });
+}
+export function readLiveMonitorEvidence(sessionId, options = {}) {
+    if (!SESSION_ID_PATTERN.test(sessionId)) {
+        throw new LanesError("monitor_invalid_session", `Invalid senior session id ${JSON.stringify(sessionId)}`);
+    }
+    const home = options.homedir?.() ?? os.homedir();
+    const env = options.env ?? process.env;
+    const transcriptMaxBytes = options.transcriptMaxBytes ?? MONITOR_TRANSCRIPT_MAX_BYTES;
+    const taskOutputMaxBytes = options.taskOutputMaxBytes ?? MONITOR_TASK_OUTPUT_MAX_BYTES;
+    const processCommands = options.readProcessCommands?.() ?? defaultProcessCommands();
+    const tasks = new Map();
+    const transcriptPaths = transcriptPathsFor(home, env, sessionId);
+    const taskOutputPaths = [];
+    for (const transcriptPath of transcriptPaths) {
+        const transcript = boundedTail(transcriptPath, transcriptMaxBytes);
+        if (transcript === null)
+            continue;
+        for (const parsed of parseMonitorTranscript(transcript)) {
+            const outputCandidates = taskOutputCandidates(transcriptPath, sessionId, parsed);
+            let outputPath;
+            let outputText;
+            for (const candidate of outputCandidates) {
+                const content = boundedTail(candidate, taskOutputMaxBytes);
+                if (content === null)
+                    continue;
+                outputPath = candidate;
+                outputText = content;
+                taskOutputPaths.push(candidate);
+                break;
+            }
+            tasks.set(parsed.taskId, {
+                ...parsed,
+                outputPresent: outputPath !== undefined,
+                outputPath: outputPath ?? parsed.outputPath,
+                outputText,
+                processAlive: processHasExactCommand(processCommands, parsed.command)
+                    ? true
+                    : undefined,
+            });
+        }
+    }
+    return {
+        sessionId,
+        tasks: [...tasks.values()],
+        transcriptPaths,
+        taskOutputPaths: [...new Set(taskOutputPaths)],
+        processCommands,
+    };
+}
+export function monitorReminderText() {
+    return [
+        "For active Claude senior lanes, arm one live Claude Code Monitor task per uncovered lane:",
+        'Monitor(command="hq lanes watch <lane-id>...", timeout_ms=1800000, persistent=true)',
+        "Use `hq lanes monitor-check --session <id>` to verify coverage. `persistent=true` is requested where the installed Monitor tool honors it; Claude Code caps Monitor tasks at 30 minutes, so re-arm after expiry.",
+        "The caller must pass `--engine codex` or `--engine grok` (or set HQ_CONDUCT_ENGINE) for sessions whose engine has no Claude Monitor tool; those engines are never required to provide one.",
+    ].join("\n");
+}
+//# sourceMappingURL=monitor.js.map

package/dist/lib/lanes/move-account.d.ts

@@ -0,0 +1,56 @@
+/**
+ * US-023: move a lane's provider session to another account of the same
+ * provider. A provider CLI only resumes sessions stored under its own home
+ * (`CLAUDE_CONFIG_DIR/projects/<encoded cwd>/<id>.jsonl`,
+ * `CODEX_HOME/sessions/YYYY/MM/DD/rollout-*-<id>.jsonl`), so the session
+ * files are copied into the target home first. The source copy is never
+ * moved or deleted, so the lane can be moved back. Only session transcripts
+ * are copied: a credential file name is refused by name, whatever path it
+ * arrives on.
+ */
+import type { LaneProvider } from "./types.js";
+export declare const SESSION_MOVE_REASON: "operator_move";
+export interface SessionCopyPlan {
+    provider: LaneProvider;
+    /** Source files, absolute. */
+    sources: string[];
+    /** Target files, absolute, in the same order as `sources`. */
+    targets: string[];
+    /** Source directory copied as a tree (claude subagent transcripts), or null. */
+    source_dir: string | null;
+    target_dir: string | null;
+}
+export interface SessionCopyResult extends SessionCopyPlan {
+    /** Target paths that were written by this call (already-present ones are not listed). */
+    copied: string[];
+}
+/** `claude` keys a project directory by its cwd with every non-alphanumeric character as `-`. */
+export declare function encodeClaudeProjectDir(cwd: string): string;
+/**
+ * Locate the claude transcript `<sessionId>.jsonl` and its optional sibling
+ * `<sessionId>/` directory under `<home>/projects/<encoded cwd>/`.
+ */
+export declare function planClaudeSessionCopy(sourceHome: string, targetHome: string, cwd: string, sessionId: string): SessionCopyPlan;
+/** Walk `<home>/sessions/YYYY/MM/DD/` for `rollout-*-<sessionId>.jsonl`. */
+export declare function findCodexRollout(home: string, sessionId: string): string | null;
+export declare function planCodexSessionCopy(sourceHome: string, targetHome: string, sessionId: string): SessionCopyPlan;
+export declare function planSessionCopy(provider: LaneProvider, input: {
+    sourceHome: string;
+    targetHome: string;
+    cwd: string;
+    sessionId: string;
+}): SessionCopyPlan;
+/** Every file a plan would write, transcript(s) first, then the subagent tree. */
+export declare function planFiles(plan: SessionCopyPlan): Array<{
+    from: string;
+    to: string;
+}>;
+/**
+ * Execute a plan: copy the transcript(s) and the subagent tree into the
+ * target home. Every path is checked against the credential file names
+ * before the first byte is copied, so a refusal writes nothing. A file
+ * already present in the target with the same content is left alone; one
+ * that differs is replaced by the source copy. The source is never touched.
+ */
+export declare function copySessionFiles(plan: SessionCopyPlan): SessionCopyResult;
+//# sourceMappingURL=move-account.d.ts.map

package/dist/lib/lanes/move-account.js

@@ -0,0 +1,193 @@
+/**
+ * US-023: move a lane's provider session to another account of the same
+ * provider. A provider CLI only resumes sessions stored under its own home
+ * (`CLAUDE_CONFIG_DIR/projects/<encoded cwd>/<id>.jsonl`,
+ * `CODEX_HOME/sessions/YYYY/MM/DD/rollout-*-<id>.jsonl`), so the session
+ * files are copied into the target home first. The source copy is never
+ * moved or deleted, so the lane can be moved back. Only session transcripts
+ * are copied: a credential file name is refused by name, whatever path it
+ * arrives on.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { PROVIDER_CREDENTIAL_FILES } from "./accounts.js";
+import { LanesError } from "./errors.js";
+export const SESSION_MOVE_REASON = "operator_move";
+/** `claude` keys a project directory by its cwd with every non-alphanumeric character as `-`. */
+export function encodeClaudeProjectDir(cwd) {
+    return cwd.replace(/[^A-Za-z0-9]/g, "-");
+}
+function credentialName(provider, file) {
+    const base = path.basename(file);
+    return Object.values(PROVIDER_CREDENTIAL_FILES).some((names) => names.includes(base)) ||
+        PROVIDER_CREDENTIAL_FILES[provider].includes(base);
+}
+function isDirectory(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function isFile(p) {
+    try {
+        return fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function sessionMissing(provider, sessionId, searched) {
+    return new LanesError("provider_session_missing", `No ${provider} session ${sessionId} under the source account home. Searched: ${searched.join(", ")}`, { provider, session_id: sessionId, searched });
+}
+/**
+ * Locate the claude transcript `<sessionId>.jsonl` and its optional sibling
+ * `<sessionId>/` directory under `<home>/projects/<encoded cwd>/`.
+ */
+export function planClaudeSessionCopy(sourceHome, targetHome, cwd, sessionId) {
+    const rel = path.join("projects", encodeClaudeProjectDir(cwd));
+    const transcript = path.join(sourceHome, rel, `${sessionId}.jsonl`);
+    if (!isFile(transcript))
+        throw sessionMissing("claude", sessionId, [transcript]);
+    const subagents = path.join(sourceHome, rel, sessionId);
+    const hasSubagents = isDirectory(subagents);
+    return {
+        provider: "claude",
+        sources: [transcript],
+        targets: [path.join(targetHome, rel, `${sessionId}.jsonl`)],
+        source_dir: hasSubagents ? subagents : null,
+        target_dir: hasSubagents ? path.join(targetHome, rel, sessionId) : null,
+    };
+}
+/** Walk `<home>/sessions/YYYY/MM/DD/` for `rollout-*-<sessionId>.jsonl`. */
+export function findCodexRollout(home, sessionId) {
+    const root = path.join(home, "sessions");
+    if (!isDirectory(root))
+        return null;
+    const suffix = `-${sessionId}.jsonl`;
+    const stack = [{ dir: root, depth: 0 }];
+    while (stack.length > 0) {
+        const { dir, depth } = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (depth < 3)
+                    stack.push({ dir: full, depth: depth + 1 });
+            }
+            else if (entry.isFile() && entry.name.startsWith("rollout-") && entry.name.endsWith(suffix)) {
+                return full;
+            }
+        }
+    }
+    return null;
+}
+export function planCodexSessionCopy(sourceHome, targetHome, sessionId) {
+    const rollout = findCodexRollout(sourceHome, sessionId);
+    if (rollout === null) {
+        throw sessionMissing("codex", sessionId, [path.join(sourceHome, "sessions", "**", `rollout-*-${sessionId}.jsonl`)]);
+    }
+    const rel = path.relative(sourceHome, rollout);
+    return {
+        provider: "codex",
+        sources: [rollout],
+        targets: [path.join(targetHome, rel)],
+        source_dir: null,
+        target_dir: null,
+    };
+}
+export function planSessionCopy(provider, input) {
+    switch (provider) {
+        case "claude":
+            return planClaudeSessionCopy(input.sourceHome, input.targetHome, input.cwd, input.sessionId);
+        case "codex":
+            return planCodexSessionCopy(input.sourceHome, input.targetHome, input.sessionId);
+        case "grok":
+            throw new LanesError("provider_session_not_portable", "Grok session files are not copied between accounts, so a grok lane cannot move to another grok account", { provider });
+        default: {
+            const _exhaustive = provider;
+            return _exhaustive;
+        }
+    }
+}
+function refuseCredential(provider, file) {
+    if (credentialName(provider, file)) {
+        throw new LanesError("credential_copy_refused", `Refusing to copy ${path.basename(file)}: only session transcripts move between accounts`, { provider, file: path.basename(file) });
+    }
+}
+function sameContent(a, b) {
+    try {
+        const sa = fs.statSync(a);
+        const sb = fs.statSync(b);
+        if (sa.size !== sb.size)
+            return false;
+        return fs.readFileSync(a).equals(fs.readFileSync(b));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Copy one file via a temp name and rename, so a partial copy is never a
+ * visible transcript. A target that already exists is refreshed when its
+ * content differs: the lane last ran on the source account, so the source
+ * copy is the newer one (a lane moved A→B and back to A must not resume A's
+ * pre-move transcript). Returns false when the target already matched.
+ */
+function copyFileAtomic(source, target) {
+    if (fs.existsSync(target) && sameContent(source, target))
+        return false;
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    const tmp = `${target}.partial.${process.pid}`;
+    fs.copyFileSync(source, tmp);
+    fs.renameSync(tmp, target);
+    return true;
+}
+function listTree(sourceDir, targetDir, out) {
+    for (const entry of fs.readdirSync(sourceDir, { withFileTypes: true })) {
+        const from = path.join(sourceDir, entry.name);
+        const to = path.join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            listTree(from, to, out);
+        }
+        else if (entry.isFile()) {
+            out.push({ from, to });
+        }
+    }
+}
+/** Every file a plan would write, transcript(s) first, then the subagent tree. */
+export function planFiles(plan) {
+    const files = plan.sources.map((from, i) => ({ from, to: plan.targets[i] }));
+    if (plan.source_dir !== null && plan.target_dir !== null) {
+        listTree(plan.source_dir, plan.target_dir, files);
+    }
+    return files;
+}
+/**
+ * Execute a plan: copy the transcript(s) and the subagent tree into the
+ * target home. Every path is checked against the credential file names
+ * before the first byte is copied, so a refusal writes nothing. A file
+ * already present in the target with the same content is left alone; one
+ * that differs is replaced by the source copy. The source is never touched.
+ */
+export function copySessionFiles(plan) {
+    const files = planFiles(plan);
+    for (const file of files) {
+        refuseCredential(plan.provider, file.from);
+        refuseCredential(plan.provider, file.to);
+    }
+    const copied = [];
+    for (const file of files) {
+        if (copyFileAtomic(file.from, file.to))
+            copied.push(file.to);
+    }
+    return { ...plan, copied };
+}
+//# sourceMappingURL=move-account.js.map