@indigoai-us/hq-cli 5.313.0 → 5.314.0

package/dist/lib/lanes/monitor.js

@@ -1,428 +0,0 @@
-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

@@ -1,56 +0,0 @@
-/**
- * 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

@@ -1,193 +0,0 @@
-/**
- * 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