@moda-ai/cli 1.22.1 → 1.23.0

package/dist/workspace.js

@@ -1,1294 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { createHash, randomUUID } from 'node:crypto';
-import { appendFileSync, chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { basename, dirname, join, relative, resolve, sep, } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { resolveApiKey, resolveIngestUrl, resolveTenantId } from './config.js';
-import { getActiveProfile } from './profiles.js';
-class WorkspaceError extends Error {
-    exitCode;
-    constructor(message, exitCode = 1) {
-        super(message);
-        this.exitCode = exitCode;
-        this.name = 'WorkspaceError';
-    }
-}
-const MODA_DIR = '.moda';
-const WORKSPACES_DIR = 'workspaces';
-const GIT_STATE_DIR = 'git-state';
-const META_FILE = '.moda-workspace.json';
-const COMMIT_NAME = 'moda-snapshot';
-const COMMIT_EMAIL = 'noreply@moda.dev';
-const ALL_HOOK_AGENTS = ['claude', 'codex', 'cursor'];
-const RSYNC_EXCLUDES = [
-    '.git',
-    'node_modules',
-    '.turbo',
-    'dist',
-    'build',
-    '.next',
-];
-export async function runWorkspaceCommand(args, options = {}) {
-    const subcommand = args.positionals[0] || 'log';
-    try {
-        switch (subcommand) {
-            case 'init':
-                return workspaceInit(args, options);
-            case 'snapshot':
-                return await workspaceSnapshot(args, options);
-            case 'status':
-                return workspaceStatus(args, options);
-            case 'explain':
-                return workspaceExplain(args, options);
-            case 'log':
-                return workspaceLog(args, options);
-            case 'bundle':
-                return workspaceBundle(args, options);
-            case 'remove':
-                return workspaceRemove(args, options);
-            default:
-                throw new WorkspaceError(`Unknown workspace command '${subcommand}'. Use init, snapshot, status, explain, log, bundle, or remove.`, 2);
-        }
-    }
-    catch (error) {
-        printWorkspaceError(error);
-        return error instanceof WorkspaceError ? error.exitCode : 1;
-    }
-}
-export async function runSparkCommand(context) {
-    const subcommand = context.positionals[0] || 'status';
-    try {
-        switch (subcommand) {
-            case 'init':
-                context.output.writeData(workspaceInitPayload({ cwd: context.cwd }));
-                return { exitCode: 0 };
-            case 'snapshot':
-                context.output.writeData(await createWorkspaceSnapshotPayload(contextToWorkspaceArgs(context, 'snapshot'), { cwd: context.cwd }));
-                return { exitCode: 0 };
-            case 'status':
-                context.output.writeData(workspaceStatusPayload(context.cwd, context.profile));
-                return { exitCode: 0 };
-            case 'explain':
-                context.output.writeData(workspaceExplainPayload(context.cwd, context.profile));
-                return { exitCode: 0 };
-            case 'log':
-                context.output.writeData(workspaceLogPayload(contextToWorkspaceArgs(context, 'log'), { cwd: context.cwd }));
-                return { exitCode: 0 };
-            case 'bundle':
-                context.output.writeData(workspaceBundlePayload(contextToWorkspaceArgs(context, 'bundle'), { cwd: context.cwd }));
-                return { exitCode: 0 };
-            case 'remove':
-                context.output.writeData(workspaceRemovePayload(contextToWorkspaceArgs(context, 'remove'), { cwd: context.cwd }));
-                return { exitCode: 0 };
-            default:
-                throw new WorkspaceError(`Unknown spark command '${subcommand}'. Use status, explain, snapshot, log, bundle, init, or remove.`, 2);
-        }
-    }
-    catch (error) {
-        if (error instanceof WorkspaceError) {
-            throw error;
-        }
-        throw new WorkspaceError(error instanceof Error ? error.message : String(error));
-    }
-}
-export async function runHooksInstall(args) {
-    const subcommand = args.positionals[0] || args.positional;
-    if (subcommand && subcommand !== 'install') {
-        console.error(`Error: Unknown hooks command '${subcommand}'. Use install.`);
-        return 2;
-    }
-    try {
-        installAgentHooks(args.flags);
-        return 0;
-    }
-    catch (error) {
-        printWorkspaceError(error);
-        return 1;
-    }
-}
-function workspaceInit(args, options) {
-    const payload = workspaceInitPayload(options);
-    printOutput(args.flags.json === 'true', payload, [
-        `workspace_id: ${payload.workspace_id}`,
-        `shadow_path: ${payload.shadow_path}`,
-        `config_path: ${payload.config_path}`,
-    ]);
-    return 0;
-}
-function workspaceInitPayload(options) {
-    const workspace = ensureShadowWorkspace(options.cwd);
-    const meta = readWorkspaceMeta(workspace.workspaceId);
-    writeWorkspaceMeta(workspace.workspaceId, {
-        ...meta,
-        user_toplevel: workspace.repo.toplevel,
-        origin_url: workspace.repo.originUrl,
-        user_head_sha: workspace.repo.head,
-        updated_at: new Date().toISOString(),
-    });
-    return {
-        workspace_id: workspace.workspaceId,
-        shadow_path: workspace.shadowPath,
-        config_path: workspace.configPath,
-        user_toplevel: workspace.repo.toplevel,
-        origin_url: workspace.repo.originUrl,
-        user_head_sha: workspace.repo.head,
-    };
-}
-/**
- * Read Claude's hook JSON from stdin (fd 0). Returns `{}` on any failure —
- * a malformed or missing hook payload must NEVER fail the snapshot, which
- * also serves as a manual-run path (no stdin, falls through to flag/env
- * defaults).
- */
-function readHookStdinPayload() {
-    try {
-        const text = readFileSync(0, 'utf8');
-        if (!text.trim())
-            return {};
-        const parsed = JSON.parse(text);
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return {};
-        }
-        return parsed;
-    }
-    catch {
-        return {};
-    }
-}
-async function workspaceSnapshot(args, options) {
-    const payload = await createWorkspaceSnapshotPayload(args, options);
-    if (args.flags.agent === 'true') {
-        printAgentOutput(args.command || 'workspace', payload);
-    }
-    else if (args.flags.json === 'true') {
-        console.log(JSON.stringify(payload));
-    }
-    else if (payload.dry_run === true) {
-        console.log([
-            'Shadow Spark snapshot dry run',
-            `workspace_id: ${payload.workspace_id}`,
-            `would_change: ${payload.would_change}`,
-            `files_considered: ${payload.files_considered}`,
-            `fingerprint: ${payload.fingerprint}`,
-        ].join('\n'));
-    }
-    else {
-        console.log(payload.shadow_sha);
-    }
-    return 0;
-}
-async function createWorkspaceSnapshotPayload(args, options) {
-    const workspace = ensureShadowWorkspace(options.cwd);
-    const before = readWorkspaceMeta(workspace.workspaceId);
-    // When invoked by `moda-snapshot.sh` Claude's hook context arrives on
-    // stdin (session_id, tool_use_id, prompt). Stdin parsing is gated on
-    // --hook-stdin so an interactive `moda workspace snapshot` doesn't
-    // block waiting for input that will never come.
-    const hookStdin = args.flags['hook-stdin'] === 'true'
-        ? readHookStdinPayload()
-        : {};
-    const provider = normalizeSnapshotProvider(args.flags.provider || hookStdin.provider);
-    const sessionId = hookStdin.session_id ||
-        args.flags['session-id'] ||
-        process.env.CLAUDE_SESSION_ID ||
-        randomUUID();
-    const event = hookStdin.hook_event_name ||
-        args.flags.event ||
-        'UserPromptSubmit';
-    // tool_use_id is the documented join key for PostToolUse-derived
-    // snapshots (see migration 030 header). Empty for non-tool events.
-    const toolUseId = hookStdin.tool_use_id || args.flags['tool-use-id'] || '';
-    // sha256(utf8(prompt)) lowercase hex — see migration 030 for the
-    // recipe that MUST match the ingest worker's OTLP prompt normalizer.
-    const rawPrompt = typeof hookStdin.prompt === 'string' ? hookStdin.prompt : '';
-    const promptSha = rawPrompt.length > 0
-        ? createHash('sha256').update(rawPrompt).digest('hex')
-        : '';
-    // Legacy --prompt-hash flag is preserved for back-compat with manual
-    // callers but no longer set by `moda-snapshot.sh`.
-    const promptHash = promptSha || args.flags['prompt-hash'] || process.env.CLAUDE_PROMPT_HASH || '';
-    const harness = readHarnessSnapshotContext(workspace.repo.toplevel);
-    const profile = safeActiveProfile(args.flags.profile);
-    const tenantId = resolveTenantId({ profile });
-    const deployment = args.flags.deployment || args.flags.environment || undefined;
-    const dryRun = args.flags['dry-run'] === 'true';
-    if (dryRun) {
-        const files = listSyncFiles(workspace.repo.toplevel);
-        const fingerprint = fingerprintFiles(workspace.repo.toplevel, files);
-        return {
-            schemaVersion: 'shadow_spark_snapshot.v0.1',
-            dry_run: true,
-            workspace_id: workspace.workspaceId,
-            shadow_path: workspace.shadowPath,
-            user_head_sha: workspace.repo.head,
-            session_id: sessionId,
-            event,
-            tool_use_id: toolUseId || undefined,
-            prompt_sha: promptSha || undefined,
-            prompt_hash: promptHash || undefined,
-            provider,
-            would_change: before.last_fingerprint !== fingerprint,
-            fingerprint,
-            files_considered: files.length,
-            included_files_sample: files.slice(0, 100),
-            excluded: RSYNC_EXCLUDES,
-            profile,
-            tenant_id: tenantId,
-            deployment,
-            harness_id: harness.harnessId,
-            harness_graph_hash: harness.graphHash,
-            harness_schema_version: harness.schemaVersion,
-            privacy: [
-                'Dry-run does not copy files, create commits, append JSONL, or post to Moda Cloud.',
-                'Snapshot POSTs include hashes and refs, not raw prompts.',
-            ],
-        };
-    }
-    const sync = syncTree(workspace.repo.toplevel, workspace.shadowPath);
-    const messageParts = ['moda', sessionId];
-    if (promptHash)
-        messageParts.push(promptHash);
-    const commit = sync.changed
-        ? shadowCommit(workspace.shadowPath, messageParts.join(':'))
-        : { sha: before.last_shadow_sha };
-    const shadowSha = commit.sha || before.last_shadow_sha;
-    const reused = !sync.changed || (Boolean(before.last_shadow_sha) && shadowSha === before.last_shadow_sha);
-    const now = new Date().toISOString();
-    const meta = {
-        ...before,
-        user_toplevel: workspace.repo.toplevel,
-        origin_url: workspace.repo.originUrl,
-        user_head_sha: workspace.repo.head,
-        last_shadow_sha: shadowSha,
-        last_fingerprint: sync.fingerprint,
-        updated_at: now,
-    };
-    writeWorkspaceMeta(workspace.workspaceId, meta);
-    const payload = {
-        workspace_id: workspace.workspaceId,
-        shadow_sha: shadowSha,
-        user_head_sha: workspace.repo.head,
-        session_id: sessionId,
-        event,
-        tool_use_id: toolUseId || undefined,
-        prompt_sha: promptSha || undefined,
-        prompt_hash: promptHash || undefined,
-        provider,
-        profile,
-        tenant_id: tenantId,
-        deployment,
-        harness_id: harness.harnessId,
-        harness_graph_hash: harness.graphHash,
-        harness_schema_version: harness.schemaVersion,
-        reused,
-        fingerprint: sync.fingerprint,
-        captured_at: now,
-        origin_url: workspace.repo.originUrl,
-        user_toplevel: workspace.repo.toplevel,
-    };
-    appendJsonl(sessionId, payload);
-    // Ship snapshot through the existing /v1/otel/claude/hooks endpoint so
-    // the shadow_sha / workspace_id / user_head_sha land in
-    // moda.coding_agent_events as a `workspace_snapshot` row. Never throws —
-    // a network blip can't break the user's Claude session.
-    await postSnapshot(payload);
-    return payload;
-}
-const SNAPSHOT_POST_TIMEOUT_MS = 2000;
-/**
- * POST the shadow-repo snapshot to the ingest worker's existing Claude
- * Code hooks endpoint, reshaped as a `WorkspaceSnapshot` hook payload
- * (see `coding-agent-claude-hooks.ts` normalizer + migration 030).
- *
- * Failures are swallowed:
- *   - no MODA_API_KEY: ingest auth is unavailable, skip silently. The
- *     local JSONL still has the snapshot for manual replay.
- *   - network error / non-2xx: log nothing visible; the user's Claude
- *     session must never be interrupted by an ingest blip.
- *   - timeout after SNAPSHOT_POST_TIMEOUT_MS: aborted via AbortController
- *     so we don't keep the Node event loop alive after the hook
- *     subshell ends.
- */
-async function postSnapshot(snapshot) {
-    // Resolve at call time (not module-load time) so the hook subshell picks
-    // up the current env, and so tests can set/unset between cases. resolveApiKey
-    // falls back to ~/.moda/config.json (written by `moda init`) so the snapshot
-    // works even when MODA_API_KEY is not exported into the shell that launched
-    // Claude (e.g. under Infisical or a login-shell that lacks the var).
-    const apiKey = resolveApiKey({ profile: snapshot.profile });
-    if (!apiKey)
-        return;
-    const ingestUrl = resolveIngestUrl({ profile: snapshot.profile });
-    // End/stop snapshots double as the creds-free "session ended" signal the
-    // server-side scheduler polls for (lands as event_type='session_end'); all
-    // other events stay 'WorkspaceSnapshot' (event_type='workspace_snapshot').
-    // Either way the shadow_sha/workspace_id columns are projected on the row.
-    const hook = snapshotEndHook(snapshot);
-    const body = {
-        hook,
-        workspace_id: snapshot.workspace_id,
-        shadow_sha: snapshot.shadow_sha,
-        user_head_sha: snapshot.user_head_sha,
-        origin_url: snapshot.origin_url,
-        session_id: snapshot.session_id,
-        tool_use_id: snapshot.tool_use_id,
-        prompt_sha: snapshot.prompt_sha,
-        event: snapshot.event,
-        provider: snapshot.provider,
-        profile: snapshot.profile,
-        tenant_id: snapshot.tenant_id,
-        deployment: snapshot.deployment,
-        harness_id: snapshot.harness_id,
-        harness_graph_hash: snapshot.harness_graph_hash,
-        harness_schema_version: snapshot.harness_schema_version,
-        timestamp: snapshot.captured_at,
-        reused: snapshot.reused,
-        fingerprint: snapshot.fingerprint,
-        cwd: snapshot.user_toplevel,
-    };
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), SNAPSHOT_POST_TIMEOUT_MS);
-    if (typeof timeout.unref === 'function') {
-        timeout.unref();
-    }
-    try {
-        await fetch(`${ingestUrl.replace(/\/$/, '')}/v1/otel/${snapshotProviderPath(snapshot.provider)}/hooks`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(body),
-            signal: controller.signal,
-        });
-    }
-    catch {
-        // Intentionally swallowed — snapshot POST is best-effort. Local
-        // ~/.moda/git-state/{session}.jsonl already has the canonical record.
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
-function normalizeSnapshotProvider(value) {
-    const normalized = (value || '').trim().toLowerCase().replace(/-/g, '_');
-    if (normalized === 'codex')
-        return 'codex';
-    if (normalized === 'cursor')
-        return 'cursor';
-    return 'claude_code';
-}
-function snapshotProviderPath(provider) {
-    return provider === 'claude_code' ? 'claude' : provider;
-}
-function snapshotEndHook(snapshot) {
-    if (snapshot.provider === 'claude_code') {
-        return snapshot.event === 'SessionEnd' ? 'SessionEnd' : 'WorkspaceSnapshot';
-    }
-    return snapshot.event === 'Stop' || snapshot.event === 'SessionEnd'
-        ? 'Stop'
-        : 'WorkspaceSnapshot';
-}
-function workspaceStatus(args, options) {
-    const payload = workspaceStatusPayload(options.cwd, args.flags.profile);
-    if (args.flags.agent === 'true') {
-        printAgentOutput(args.command || 'workspace', payload);
-    }
-    else {
-        printOutput(args.flags.json === 'true', payload, [
-            `workspace_id: ${payload.workspace_id}`,
-            `shadow_path: ${payload.shadow_path}`,
-            `shadow_git: ${payload.shadow_git}`,
-            `last_shadow_sha: ${payload.last_shadow_sha || 'none'}`,
-            `would_change: ${payload.would_change}`,
-        ]);
-    }
-    return 0;
-}
-function workspaceStatusPayload(cwd = process.cwd(), profileFlag) {
-    const workspace = resolveShadowWorkspacePaths(cwd);
-    const meta = readWorkspaceMeta(workspace.workspaceId);
-    const files = listSyncFiles(workspace.repo.toplevel);
-    const fingerprint = fingerprintFiles(workspace.repo.toplevel, files);
-    const harness = readHarnessSnapshotContext(workspace.repo.toplevel);
-    const profile = safeActiveProfile(profileFlag);
-    return {
-        schemaVersion: 'shadow_spark_status.v0.1',
-        workspace_id: workspace.workspaceId,
-        shadow_path: workspace.shadowPath,
-        config_path: workspace.configPath,
-        user_toplevel: workspace.repo.toplevel,
-        origin_url: workspace.repo.originUrl,
-        user_head_sha: workspace.repo.head,
-        shadow_exists: workspace.exists,
-        shadow_git: existsSync(join(workspace.shadowPath, '.git')) ? 'present' : 'missing',
-        last_shadow_sha: meta.last_shadow_sha,
-        last_fingerprint: meta.last_fingerprint,
-        current_fingerprint: fingerprint,
-        would_change: meta.last_fingerprint !== fingerprint,
-        files_considered: files.length,
-        updated_at: meta.updated_at,
-        profile,
-        tenant_id: resolveTenantId({ profile }),
-        harness_id: harness.harnessId,
-        harness_graph_hash: harness.graphHash,
-        next_commands: [
-            'moda spark snapshot --dry-run --json',
-            'moda spark snapshot --json',
-            'moda spark explain',
-        ],
-    };
-}
-function workspaceExplain(args, options) {
-    const payload = workspaceExplainPayload(options.cwd, args.flags.profile);
-    if (args.flags.agent === 'true') {
-        printAgentOutput(args.command || 'workspace', payload);
-    }
-    else if (args.flags.json === 'true') {
-        console.log(JSON.stringify(payload));
-    }
-    else {
-        console.log([
-            'Shadow Spark Workspace',
-            '',
-            'Moda keeps a git-backed shadow copy of this repo so agent sessions can be correlated to exact local code state without touching your git history.',
-            `Local path: ${payload.shadow_path}`,
-            '',
-            'Captures:',
-            '- git-tracked and unignored local files',
-            '- prompt hash, session id, provider, user head sha, and shadow sha',
-            '- harness id/hash when .moda/harness.json exists',
-            '',
-            'Does not capture:',
-            '- raw prompt text in cloud payloads',
-            '- .git, node_modules, build output, dist, .next, or .turbo',
-            '',
-            'Cloud behavior:',
-            '- snapshot hooks POST metadata refs best-effort and never block the agent',
-            '- local JSONL remains under ~/.moda/git-state for replay/debugging',
-            '',
-            'Disable/remove:',
-            '- remove hook entries from Claude/Codex/Cursor config, or rerun hooks install after editing',
-            '- delete the local shadow repo with `moda spark remove --yes`',
-        ].join('\n'));
-    }
-    return 0;
-}
-function workspaceExplainPayload(cwd = process.cwd(), profileFlag) {
-    const workspace = resolveShadowWorkspacePaths(cwd);
-    const harness = readHarnessSnapshotContext(workspace.repo.toplevel);
-    const profile = safeActiveProfile(profileFlag);
-    return {
-        schemaVersion: 'shadow_spark_explain.v0.1',
-        name: 'Shadow Spark Workspace',
-        workspace_id: workspace.workspaceId,
-        shadow_path: workspace.shadowPath,
-        shadow_exists: workspace.exists,
-        user_toplevel: workspace.repo.toplevel,
-        captures: [
-            'git-tracked and unignored local files copied into a private shadow git repo',
-            'workspace_id, shadow_sha, user_head_sha, session_id, tool_use_id, provider, prompt_sha',
-            'harness_id and harness_graph_hash when a local harness manifest exists',
-        ],
-        skips: RSYNC_EXCLUDES,
-        cloud_posts: [
-            'metadata refs through /v1/otel/{provider}/hooks',
-            'no raw prompt text',
-            'best-effort only; hook failures are swallowed',
-        ],
-        local_files: [
-            '~/.moda/workspaces/<workspace_id>',
-            '~/.moda/git-state/<session_id>.jsonl',
-            '~/.claude/hooks/moda-snapshot.sh',
-            '~/.moda/hooks/moda-snapshot.sh',
-        ],
-        disable_or_remove: [
-            'Remove Moda hook entries from ~/.claude/settings.json, ~/.codex/hooks.json, or ~/.cursor/hooks.json.',
-            'Run `moda spark remove --yes` to delete the local shadow repo for this project.',
-        ],
-        harness_id: harness.harnessId,
-        harness_graph_hash: harness.graphHash,
-        profile,
-        tenant_id: resolveTenantId({ profile }),
-    };
-}
-function workspaceLog(args, options) {
-    const payload = workspaceLogPayload(args, options);
-    if (args.flags.json === 'true') {
-        console.log(JSON.stringify(payload));
-    }
-    else if (args.flags.agent === 'true') {
-        printAgentOutput(args.command || 'workspace', payload);
-    }
-    else {
-        console.log(String(payload.log));
-    }
-    return 0;
-}
-function workspaceLogPayload(args, options) {
-    const workspace = ensureShadowWorkspace(options.cwd);
-    const limit = parsePositiveInt(args.flags.limit, 20);
-    return {
-        workspace_id: workspace.workspaceId,
-        shadow_path: workspace.shadowPath,
-        log: shadowLog(workspace.shadowPath, limit),
-    };
-}
-function workspaceBundle(args, options) {
-    const payload = workspaceBundlePayload(args, options);
-    if (args.flags.agent === 'true') {
-        printAgentOutput(args.command || 'workspace', payload);
-    }
-    else {
-        printOutput(args.flags.json === 'true', payload, [
-            `bundle: ${payload.out_path}`,
-            `workspace_id: ${payload.workspace_id}`,
-        ]);
-    }
-    return 0;
-}
-function workspaceBundlePayload(args, options) {
-    const workspace = ensureShadowWorkspace(options.cwd);
-    const caseId = args.flags['case-id'];
-    const endSha = args.flags['end-sha'];
-    const startSha = args.flags['start-sha'] || '';
-    const outPath = args.flags.out;
-    if (!caseId)
-        throw new WorkspaceError('Missing required flag: --case-id ID', 2);
-    if (!endSha)
-        throw new WorkspaceError('Missing required flag: --end-sha SHA', 2);
-    if (!outPath)
-        throw new WorkspaceError('Missing required flag: --out PATH', 2);
-    if (args.flags['dry-run'] !== 'true') {
-        createBundle({
-            startSha,
-            endSha,
-            outPath,
-            workspaceId: workspace.workspaceId,
-        });
-    }
-    return {
-        workspace_id: workspace.workspaceId,
-        case_id: caseId,
-        start_sha: startSha,
-        end_sha: endSha,
-        out_path: resolve(outPath),
-        dry_run: args.flags['dry-run'] === 'true',
-    };
-}
-function workspaceRemove(args, options) {
-    const payload = workspaceRemovePayload(args, options);
-    if (args.flags.agent === 'true') {
-        printAgentOutput(args.command || 'workspace', payload);
-        return 0;
-    }
-    printOutput(args.flags.json === 'true', payload, [
-        `workspace_id: ${payload.workspace_id}`,
-        `shadow_path: ${payload.shadow_path}`,
-        payload.removed ? 'removed: true' : `removed: false (${payload.reason})`,
-    ]);
-    return 0;
-}
-function workspaceRemovePayload(args, options) {
-    const repo = detectUserRepo(options.cwd);
-    const id = workspaceId(repo.toplevel, repo.originUrl);
-    const path = shadowPath(id);
-    const exists = existsSync(path);
-    const dryRun = args.flags['dry-run'] === 'true';
-    if (!dryRun && args.flags.yes !== 'true') {
-        throw new WorkspaceError('Refusing to remove the local shadow workspace without --yes.', 2);
-    }
-    if (!dryRun) {
-        rmSync(path, { recursive: true, force: true });
-    }
-    return {
-        workspace_id: id,
-        shadow_path: path,
-        existed: exists,
-        removed: !dryRun,
-        dry_run: dryRun,
-        reason: dryRun ? 'dry-run' : undefined,
-    };
-}
-function detectUserRepo(cwd = process.cwd()) {
-    const toplevelResult = runGit(cwd, ['rev-parse', '--show-toplevel']);
-    if (toplevelResult.code !== 0 || !toplevelResult.stdout.trim()) {
-        throw new WorkspaceError('Not inside a git repository. Run this command from a project with a git working tree.', 2);
-    }
-    const toplevel = resolve(toplevelResult.stdout.trim());
-    const originResult = runGit(toplevel, ['config', '--get', 'remote.origin.url']);
-    const headResult = runGit(toplevel, ['rev-parse', 'HEAD']);
-    return {
-        toplevel,
-        originUrl: originResult.code === 0 ? originResult.stdout.trim() : '',
-        head: headResult.code === 0 ? headResult.stdout.trim() : '',
-    };
-}
-function workspaceId(toplevel, originUrl) {
-    return createHash('sha256')
-        .update(`${toplevel}:${originUrl || ''}`)
-        .digest('hex')
-        .slice(0, 16);
-}
-function shadowPath(id) {
-    return join(homeDir(), MODA_DIR, WORKSPACES_DIR, id);
-}
-function resolveShadowWorkspacePaths(cwd = process.cwd()) {
-    const repo = detectUserRepo(cwd);
-    const id = workspaceId(repo.toplevel, repo.originUrl);
-    const path = shadowPath(id);
-    return {
-        workspaceId: id,
-        shadowPath: path,
-        configPath: join(path, META_FILE),
-        repo,
-        exists: existsSync(path),
-    };
-}
-function ensureShadowWorkspace(cwd = process.cwd()) {
-    const repo = detectUserRepo(cwd);
-    const id = workspaceId(repo.toplevel, repo.originUrl);
-    const path = shadowPath(id);
-    const configPath = join(path, META_FILE);
-    mkdirSync(path, { recursive: true });
-    if (!existsSync(join(path, '.git'))) {
-        const init = runGit(path, ['init']);
-        if (init.code !== 0) {
-            throw new WorkspaceError(`Failed to initialize shadow git repo: ${init.stderr || init.stdout}`);
-        }
-    }
-    ensureShadowGitExclude(path);
-    if (!existsSync(configPath)) {
-        writeWorkspaceMeta(id, {
-            version: 1,
-            workspace_id: id,
-            user_toplevel: repo.toplevel,
-            origin_url: repo.originUrl,
-            user_head_sha: repo.head,
-            last_shadow_sha: currentShadowHead(path),
-            last_fingerprint: '',
-            updated_at: new Date().toISOString(),
-        });
-    }
-    return { workspaceId: id, shadowPath: path, configPath, repo };
-}
-function readWorkspaceMeta(id) {
-    const path = join(shadowPath(id), META_FILE);
-    if (!existsSync(path)) {
-        return {
-            version: 1,
-            workspace_id: id,
-            user_toplevel: '',
-            origin_url: '',
-            user_head_sha: '',
-            last_shadow_sha: '',
-            last_fingerprint: '',
-            updated_at: new Date().toISOString(),
-        };
-    }
-    const parsed = JSON.parse(readFileSync(path, 'utf8'));
-    return {
-        version: 1,
-        workspace_id: id,
-        user_toplevel: parsed.user_toplevel ?? '',
-        origin_url: parsed.origin_url ?? '',
-        user_head_sha: parsed.user_head_sha ?? '',
-        last_shadow_sha: parsed.last_shadow_sha ?? '',
-        last_fingerprint: parsed.last_fingerprint ?? '',
-        updated_at: parsed.updated_at ?? new Date().toISOString(),
-    };
-}
-function writeWorkspaceMeta(id, meta) {
-    const path = shadowPath(id);
-    mkdirSync(path, { recursive: true });
-    writeFileSync(join(path, META_FILE), `${JSON.stringify(meta, null, 2)}\n`);
-}
-function syncTree(toplevel, targetShadowPath) {
-    const files = listSyncFiles(toplevel);
-    const fingerprint = fingerprintFiles(toplevel, files);
-    const meta = readMetaFromShadowPath(targetShadowPath);
-    if (meta?.last_fingerprint === fingerprint) {
-        return { changed: false, fingerprint };
-    }
-    cleanShadowTree(targetShadowPath);
-    copyListedFiles(toplevel, targetShadowPath, files);
-    return { changed: true, fingerprint };
-}
-function shadowCommit(targetShadowPath, message) {
-    const add = runGit(targetShadowPath, ['add', '-A']);
-    if (add.code !== 0) {
-        throw new WorkspaceError(`Failed to stage shadow workspace: ${add.stderr || add.stdout}`);
-    }
-    const diff = runGit(targetShadowPath, ['diff', '--cached', '--quiet']);
-    if (diff.code === 0) {
-        return { sha: currentShadowHead(targetShadowPath) };
-    }
-    if (diff.code !== 1) {
-        throw new WorkspaceError(`Failed to inspect shadow changes: ${diff.stderr || diff.stdout}`);
-    }
-    const commit = runGit(targetShadowPath, [
-        '-c',
-        `user.name=${COMMIT_NAME}`,
-        '-c',
-        `user.email=${COMMIT_EMAIL}`,
-        'commit',
-        '-m',
-        message,
-    ]);
-    if (commit.code !== 0) {
-        throw new WorkspaceError(`Failed to commit shadow workspace: ${commit.stderr || commit.stdout}`);
-    }
-    return { sha: currentShadowHead(targetShadowPath) };
-}
-function appendJsonl(sessionId, payload) {
-    const dir = join(homeDir(), MODA_DIR, GIT_STATE_DIR);
-    mkdirSync(dir, { recursive: true });
-    const safeSessionId = sanitizeSessionId(sessionId);
-    appendFileSync(join(dir, `${safeSessionId}.jsonl`), `${JSON.stringify(payload)}\n`);
-}
-function shadowLog(targetShadowPath, limit) {
-    const result = runGit(targetShadowPath, ['log', '--oneline', '-n', String(limit)]);
-    if (result.code === 0)
-        return result.stdout.trim();
-    const noCommits = runGit(targetShadowPath, ['rev-parse', '--verify', 'HEAD']);
-    if (noCommits.code !== 0)
-        return '';
-    throw new WorkspaceError(`Failed to read shadow log: ${result.stderr || result.stdout}`);
-}
-function createBundle(opts) {
-    const targetShadowPath = shadowPath(opts.workspaceId);
-    mkdirSync(dirname(resolve(opts.outPath)), { recursive: true });
-    const range = opts.startSha ? `${opts.startSha}..${opts.endSha}` : opts.endSha;
-    const result = runGit(targetShadowPath, ['bundle', 'create', resolve(opts.outPath), range]);
-    if (result.code === 0)
-        return;
-    if ((result.stderr || result.stdout).includes('Refusing to create empty bundle')) {
-        createBundleFromTemporaryRef(targetShadowPath, opts);
-        return;
-    }
-    if (result.code !== 0) {
-        throw new WorkspaceError(`Failed to create git bundle: ${result.stderr || result.stdout}`);
-    }
-}
-function createBundleFromTemporaryRef(targetShadowPath, opts) {
-    const tempRef = `refs/moda/bundles/${Date.now()}-${randomUUID()}`;
-    const update = runGit(targetShadowPath, ['update-ref', tempRef, opts.endSha]);
-    if (update.code !== 0) {
-        throw new WorkspaceError(`Failed to prepare bundle ref: ${update.stderr || update.stdout}`);
-    }
-    try {
-        const bundleArgs = opts.startSha
-            ? ['bundle', 'create', resolve(opts.outPath), tempRef, `^${opts.startSha}`]
-            : ['bundle', 'create', resolve(opts.outPath), tempRef];
-        const fallback = runGit(targetShadowPath, bundleArgs);
-        if (fallback.code !== 0) {
-            throw new WorkspaceError(`Failed to create git bundle: ${fallback.stderr || fallback.stdout}`);
-        }
-    }
-    finally {
-        runGit(targetShadowPath, ['update-ref', '-d', tempRef]);
-    }
-}
-function runGit(cwd, args) {
-    const result = spawnSync('git', args, {
-        cwd,
-        encoding: 'utf8',
-        timeout: 60_000,
-    });
-    return {
-        stdout: result.stdout ?? '',
-        stderr: result.stderr ?? result.error?.message ?? '',
-        code: typeof result.status === 'number' ? result.status : 1,
-    };
-}
-function listSyncFiles(toplevel) {
-    const result = runGit(toplevel, ['ls-files', '-z', '--cached', '--others', '--exclude-standard']);
-    if (result.code === 0) {
-        return result.stdout
-            .split('\0')
-            .filter((file) => file.length > 0)
-            .filter(isSafeRelativePath)
-            .sort();
-    }
-    return listFilesFallback(toplevel).sort();
-}
-function fingerprintFiles(toplevel, files) {
-    const hash = createHash('sha256');
-    for (const file of files) {
-        const absolute = join(toplevel, file);
-        if (!existsSync(absolute))
-            continue;
-        const stat = lstatSync(absolute);
-        if (!stat.isFile())
-            continue;
-        hash.update(`${Math.floor(stat.mtimeMs)}|${stat.size}|${file}\0`);
-    }
-    return hash.digest('hex');
-}
-function copyListedFiles(toplevel, targetShadowPath, files) {
-    const fileList = writeRsyncFileList(files);
-    let rsync;
-    try {
-        rsync = spawnSync('rsync', [
-            '-a',
-            ...RSYNC_EXCLUDES.flatMap((name) => ['--exclude', name]),
-            `--files-from=${fileList}`,
-            `${withTrailingSep(toplevel)}`,
-            targetShadowPath,
-        ], {
-            encoding: 'utf8',
-            timeout: 60_000,
-        });
-    }
-    finally {
-        // Always clean up the temporary file list so /tmp doesn't grow per snapshot.
-        rmSync(fileList, { force: true });
-    }
-    if (rsync.status === 0)
-        return;
-    if (rsync.error && 'code' in rsync.error && rsync.error.code !== 'ENOENT') {
-        throw new WorkspaceError(`Failed to sync shadow workspace: ${rsync.stderr || rsync.error.message}`);
-    }
-    if (!rsync.error && rsync.status !== 0) {
-        throw new WorkspaceError(`Failed to sync shadow workspace: ${rsync.stderr || rsync.stdout}`);
-    }
-    for (const file of files) {
-        const source = join(toplevel, file);
-        if (!existsSync(source) || !lstatSync(source).isFile())
-            continue;
-        const destination = join(targetShadowPath, file);
-        mkdirSync(dirname(destination), { recursive: true });
-        copyFileSync(source, destination);
-    }
-}
-function writeRsyncFileList(files) {
-    const path = join(tmpdir(), `moda-rsync-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`);
-    writeFileSync(path, files.join('\n'));
-    return path;
-}
-function cleanShadowTree(targetShadowPath) {
-    for (const entry of readdirSync(targetShadowPath)) {
-        if (entry === '.git' || entry === META_FILE)
-            continue;
-        rmSync(join(targetShadowPath, entry), { recursive: true, force: true });
-    }
-}
-function readMetaFromShadowPath(targetShadowPath) {
-    const path = join(targetShadowPath, META_FILE);
-    if (!existsSync(path))
-        return null;
-    const parsed = JSON.parse(readFileSync(path, 'utf8'));
-    return parsed;
-}
-function currentShadowHead(targetShadowPath) {
-    const result = runGit(targetShadowPath, ['rev-parse', 'HEAD']);
-    return result.code === 0 ? result.stdout.trim() : '';
-}
-function ensureShadowGitExclude(targetShadowPath) {
-    const infoDir = join(targetShadowPath, '.git', 'info');
-    const excludePath = join(infoDir, 'exclude');
-    mkdirSync(infoDir, { recursive: true });
-    const existing = existsSync(excludePath) ? readFileSync(excludePath, 'utf8') : '';
-    if (!existing.split(/\r?\n/).includes(META_FILE)) {
-        writeFileSync(excludePath, `${existing}${existing.endsWith('\n') || existing.length === 0 ? '' : '\n'}${META_FILE}\n`);
-    }
-}
-function listFilesFallback(root) {
-    const out = [];
-    const excluded = new Set(RSYNC_EXCLUDES);
-    function walk(dir) {
-        for (const entry of readdirSync(dir)) {
-            if (excluded.has(entry))
-                continue;
-            const absolute = join(dir, entry);
-            const rel = relative(root, absolute);
-            if (!isSafeRelativePath(rel))
-                continue;
-            const stat = lstatSync(absolute);
-            if (stat.isDirectory()) {
-                walk(absolute);
-            }
-            else if (stat.isFile()) {
-                out.push(rel);
-            }
-        }
-    }
-    walk(root);
-    return out;
-}
-function installAgentHooks(flags) {
-    const agents = parseHookAgents(flags.agent);
-    const results = agents.map((agent) => {
-        if (agent === 'claude')
-            return installClaudeHook();
-        if (agent === 'codex')
-            return installCodexHook();
-        return installCursorHook();
-    });
-    if (results.length === 1) {
-        printOutput(flags.json === 'true', results[0].payload, results[0].lines);
-        return;
-    }
-    const payload = {
-        agents,
-    };
-    const lines = [];
-    for (const result of results) {
-        payload[result.agent] = result.payload;
-        lines.push(...result.lines);
-    }
-    printOutput(flags.json === 'true', payload, lines);
-}
-function parseHookAgents(raw) {
-    const value = (raw || 'claude').trim().toLowerCase();
-    const requested = value === 'all'
-        ? ALL_HOOK_AGENTS
-        : value.split(',').map((part) => part.trim()).filter(Boolean);
-    const agents = [];
-    for (const agent of requested) {
-        if (!ALL_HOOK_AGENTS.includes(agent)) {
-            throw new WorkspaceError(`Unsupported hooks agent '${agent}'. Use one of: claude, codex, cursor, all.`, 2);
-        }
-        if (!agents.includes(agent)) {
-            agents.push(agent);
-        }
-    }
-    return agents.length > 0 ? agents : ['claude'];
-}
-/**
- * Install the Moda Claude Code hooks.
- *
- * The snapshot hook (`moda-snapshot.sh`) is always installed and registered on
- * SessionStart, UserPromptSubmit, PostToolUse, and SessionEnd. The SessionEnd
- * registration posts a creds-free `session_end` signal (only MODA_API_KEY is
- * needed) that `moda skills gen` can process server-side.
- */
-function installClaudeHook() {
-    const claudeHooksDir = join(homeDir(), '.claude', 'hooks');
-    mkdirSync(claudeHooksDir, { recursive: true });
-    const snapshotHook = installBundledHook(claudeHooksDir, 'moda-snapshot.sh');
-    const settingsPath = join(homeDir(), '.claude', 'settings.json');
-    const settings = readClaudeSettings(settingsPath);
-    const hooks = isRecord(settings.hooks) ? settings.hooks : {};
-    settings.hooks = hooks;
-    mergeHookEntry(hooks, 'SessionStart', {
-        matcher: '*',
-        command: '~/.claude/hooks/moda-snapshot.sh SessionStart',
-    }, 'moda-snapshot.sh');
-    mergeHookEntry(hooks, 'UserPromptSubmit', {
-        matcher: '*',
-        command: '~/.claude/hooks/moda-snapshot.sh UserPromptSubmit',
-    }, 'moda-snapshot.sh');
-    mergeHookEntry(hooks, 'PostToolUse', {
-        matcher: 'Write|Edit|MultiEdit|Bash',
-        command: '~/.claude/hooks/moda-snapshot.sh PostToolUse',
-    }, 'moda-snapshot.sh');
-    // SessionEnd posts the final snapshot, which the ingest worker stores as a
-    // `session_end` event. The server-side scheduler picks it up and runs
-    // orchestration. Creds-free: only the snapshot POST (MODA_API_KEY) is needed.
-    mergeHookEntry(hooks, 'SessionEnd', {
-        matcher: '*',
-        command: '~/.claude/hooks/moda-snapshot.sh SessionEnd',
-    }, 'moda-snapshot.sh');
-    // Wire Claude Code's OTLP exporter so traces/logs/metrics reach Moda without
-    // the user exporting OTEL_* by hand. Claude Code reads telemetry config from
-    // env (or settings.json's `env` block) — it never looks at ~/.moda/config.json
-    // — so this is the only place the resolved API key + ingest URL become visible
-    // to the exporter. Returns whether the auth header has a usable key.
-    const telemetry = applyTelemetryEnv(settings, 'claude_code');
-    mkdirSync(dirname(settingsPath), { recursive: true });
-    writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
-    // settings.json now embeds the API key in OTEL_EXPORTER_OTLP_HEADERS; tighten
-    // perms to match ~/.moda/config.json (0600). Best-effort on exotic filesystems.
-    chmodSecretConfig(settingsPath);
-    const payload = {
-        hook_path: snapshotHook,
-        settings_path: settingsPath,
-        telemetry_env: true,
-        telemetry_api_key: telemetry.hasApiKey,
-    };
-    const lines = [
-        'Installed Moda Claude Code hooks.',
-        `hook_path: ${snapshotHook}`,
-    ];
-    lines.push(`settings_path: ${settingsPath}`);
-    lines.push('Telemetry exporter (traces + logs + metrics) wired into settings.json env.');
-    if (!telemetry.hasApiKey) {
-        lines.push(noTelemetryApiKeyWarning());
-    }
-    return { agent: 'claude', payload, lines };
-}
-function installCodexHook() {
-    const hookPath = installSharedSnapshotHook();
-    const hooksPath = join(homeDir(), '.codex', 'hooks.json');
-    const settings = readJsonObject(hooksPath);
-    const hooks = isRecord(settings.hooks) ? settings.hooks : {};
-    settings.hooks = hooks;
-    mergeCodexHookEntry(hooks, 'SessionStart', `${hookPath} codex SessionStart`);
-    mergeCodexHookEntry(hooks, 'UserPromptSubmit', `${hookPath} codex UserPromptSubmit`);
-    mergeCodexHookEntry(hooks, 'PostToolUse', `${hookPath} codex PostToolUse`);
-    mergeCodexHookEntry(hooks, 'Stop', `${hookPath} codex Stop`);
-    const telemetry = applyTelemetryEnv(settings, 'codex');
-    mkdirSync(dirname(hooksPath), { recursive: true });
-    writeFileSync(hooksPath, `${JSON.stringify(settings, null, 2)}\n`);
-    chmodSecretConfig(hooksPath);
-    const payload = {
-        hook_path: hookPath,
-        hooks_path: hooksPath,
-        telemetry_env: true,
-        telemetry_api_key: telemetry.hasApiKey,
-    };
-    const lines = [
-        'Installed Moda Codex hooks.',
-        `hook_path: ${hookPath}`,
-        `hooks_path: ${hooksPath}`,
-        'Telemetry exporter (traces + logs + metrics) wired into hooks.json env.',
-    ];
-    if (!telemetry.hasApiKey)
-        lines.push(noTelemetryApiKeyWarning());
-    return { agent: 'codex', payload, lines };
-}
-function installCursorHook() {
-    const hookPath = installSharedSnapshotHook();
-    const hooksPath = join(homeDir(), '.cursor', 'hooks.json');
-    const settings = readJsonObject(hooksPath);
-    settings.version = typeof settings.version === 'number' ? settings.version : 1;
-    const hooks = isRecord(settings.hooks) ? settings.hooks : {};
-    settings.hooks = hooks;
-    mergeCursorHookEntry(hooks, 'sessionStart', `${hookPath} cursor SessionStart`);
-    mergeCursorHookEntry(hooks, 'beforeSubmitPrompt', `${hookPath} cursor UserPromptSubmit`);
-    mergeCursorHookEntry(hooks, 'afterShellExecution', `${hookPath} cursor PostToolUse`);
-    mergeCursorHookEntry(hooks, 'sessionEnd', `${hookPath} cursor Stop`);
-    const telemetry = applyTelemetryEnv(settings, 'cursor');
-    mkdirSync(dirname(hooksPath), { recursive: true });
-    writeFileSync(hooksPath, `${JSON.stringify(settings, null, 2)}\n`);
-    chmodSecretConfig(hooksPath);
-    const payload = {
-        hook_path: hookPath,
-        hooks_path: hooksPath,
-        telemetry_env: true,
-        telemetry_api_key: telemetry.hasApiKey,
-    };
-    const lines = [
-        'Installed Moda Cursor hooks.',
-        `hook_path: ${hookPath}`,
-        `hooks_path: ${hooksPath}`,
-        'Telemetry exporter (traces + logs + metrics) wired into hooks.json env.',
-    ];
-    if (!telemetry.hasApiKey)
-        lines.push(noTelemetryApiKeyWarning());
-    return { agent: 'cursor', payload, lines };
-}
-// Moda-owned keys in settings.json's `env` block. Re-running install
-// overwrites exactly these (so a rotated key / changed ingest URL propagates)
-// while leaving any other user-defined env entries untouched.
-function applyTelemetryEnv(settings, provider) {
-    const apiKey = resolveApiKey();
-    const tenantId = resolveTenantId();
-    const ingestUrl = resolveIngestUrl().replace(/\/+$/, '');
-    const env = isRecord(settings.env) ? settings.env : {};
-    settings.env = env;
-    if (provider === 'claude_code') {
-        env.CLAUDE_CODE_ENABLE_TELEMETRY = '1';
-    }
-    // Capture user prompt text in logs. The ingest worker gates/redacts prompt
-    // content server-side (capture is default-off there), so this only controls
-    // what the local coding agent emits; matches the documented Moda integration.
-    env.OTEL_LOG_USER_PROMPTS = '1';
-    env.OTEL_LOGS_EXPORTER = 'otlp';
-    env.OTEL_METRICS_EXPORTER = 'otlp';
-    env.OTEL_TRACES_EXPORTER = 'otlp';
-    // Logs + metrics ingest as protobuf; the traces endpoint expects JSON
-    // (the worker parses traces via parseOtlpTracesJson).
-    env.OTEL_EXPORTER_OTLP_PROTOCOL = 'http/protobuf';
-    env.OTEL_EXPORTER_OTLP_TRACES_PROTOCOL = 'http/json';
-    const providerPath = snapshotProviderPath(provider);
-    env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT = `${ingestUrl}/v1/otel/${providerPath}/logs`;
-    env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT = `${ingestUrl}/v1/otel/${providerPath}/metrics`;
-    env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT = `${ingestUrl}/v1/otel/${providerPath}/traces`;
-    // Tenant is resolved server-side from the API key; company.id is carried as a
-    // resource attribute for context only.
-    env.OTEL_EXPORTER_OTLP_HEADERS = `Authorization=Bearer ${apiKey ?? ''}`;
-    const attrs = [`provider=${provider}`];
-    if (tenantId)
-        attrs.push(`company.id=${tenantId}`);
-    env.OTEL_RESOURCE_ATTRIBUTES = attrs.join(',');
-    return { hasApiKey: Boolean(apiKey) };
-}
-function noTelemetryApiKeyWarning() {
-    return 'WARNING: no API key resolved — the OTLP auth header is empty. Run `moda init` ' +
-        'or export MODA_API_KEY, then re-run `moda hooks install`.';
-}
-function chmodSecretConfig(path) {
-    try {
-        chmodSync(path, 0o600);
-    }
-    catch {
-        // chmod may fail on some filesystems; the key is still written.
-    }
-}
-function installBundledHook(claudeHooksDir, scriptName) {
-    const bundledHook = resolveBundledHookPath(scriptName);
-    const installedHook = join(claudeHooksDir, scriptName);
-    copyFileSync(bundledHook, installedHook);
-    chmodSync(installedHook, 0o755);
-    return installedHook;
-}
-function installSharedSnapshotHook() {
-    const hooksDir = join(homeDir(), '.moda', 'hooks');
-    mkdirSync(hooksDir, { recursive: true });
-    return installBundledHook(hooksDir, 'moda-snapshot.sh');
-}
-function resolveBundledHookPath(scriptName) {
-    const candidate = fileURLToPath(new URL(`../hooks/${scriptName}`, import.meta.url));
-    if (existsSync(candidate))
-        return candidate;
-    throw new WorkspaceError(`Bundled hook script not found at ${candidate}`);
-}
-function readClaudeSettings(settingsPath) {
-    return readJsonObject(settingsPath);
-}
-function readJsonObject(settingsPath) {
-    if (!existsSync(settingsPath))
-        return {};
-    const parsed = JSON.parse(readFileSync(settingsPath, 'utf8'));
-    if (!isRecord(parsed)) {
-        throw new WorkspaceError(`${settingsPath} must contain a JSON object.`);
-    }
-    return parsed;
-}
-function mergeHookEntry(hooks, event, entry, scriptName) {
-    const existing = Array.isArray(hooks[event]) ? hooks[event] : [];
-    if (!existing.some((value) => referencesModaHook(value, scriptName))) {
-        // Claude Code's hook schema is { matcher, hooks: [{ type, command }] }.
-        // Emitting the flat { matcher, command } shape trips `/doctor`'s
-        // "hooks: Expected array" validation, so always nest the command.
-        existing.push({
-            matcher: entry.matcher,
-            hooks: [{ type: 'command', command: entry.command }],
-        });
-    }
-    hooks[event] = existing;
-}
-function mergeCodexHookEntry(hooks, event, command) {
-    const existing = Array.isArray(hooks[event]) ? hooks[event] : [];
-    if (!existing.some((value) => referencesModaHook(value, 'moda-snapshot.sh'))) {
-        existing.push({
-            hooks: [{ type: 'command', command }],
-        });
-    }
-    hooks[event] = existing;
-}
-function mergeCursorHookEntry(hooks, event, command) {
-    const existing = Array.isArray(hooks[event]) ? hooks[event] : [];
-    if (!existing.some((value) => referencesModaHook(value, 'moda-snapshot.sh'))) {
-        existing.push({ command });
-    }
-    hooks[event] = existing;
-}
-/**
- * True if a hook matcher entry already wires up the given Moda hook script.
- * Handles both the current nested shape ({ hooks: [{ command }] }) and the
- * legacy flat shape ({ command }) so re-running `moda hooks install` over an
- * old settings.json dedups instead of appending a duplicate entry.
- */
-function referencesModaHook(value, scriptName) {
-    if (!isRecord(value))
-        return false;
-    if (String(value.command ?? '').includes(scriptName))
-        return true;
-    const nested = Array.isArray(value.hooks) ? value.hooks : [];
-    return nested.some((hook) => isRecord(hook) &&
-        String(hook.command ?? '').includes(scriptName));
-}
-function contextToWorkspaceArgs(context, subcommand) {
-    return {
-        command: context.command,
-        positional: subcommand,
-        positionals: [subcommand, ...context.positionals.slice(1)],
-        flags: context.flags,
-    };
-}
-function readHarnessSnapshotContext(rootDir) {
-    const path = join(rootDir, MODA_DIR, 'harness.json');
-    if (!existsSync(path))
-        return {};
-    try {
-        const raw = readFileSync(path, 'utf8');
-        const parsed = JSON.parse(raw);
-        if (!isRecord(parsed))
-            return {};
-        const harnessId = typeof parsed.harnessId === 'string' ? parsed.harnessId : undefined;
-        const schemaVersion = typeof parsed.schemaVersion === 'string' ? parsed.schemaVersion : undefined;
-        return {
-            harnessId,
-            schemaVersion,
-            graphHash: createHash('sha256').update(raw).digest('hex'),
-        };
-    }
-    catch {
-        return {};
-    }
-}
-function safeActiveProfile(profile) {
-    try {
-        return getActiveProfile({ profile }).name;
-    }
-    catch {
-        return profile;
-    }
-}
-function printAgentOutput(command, payload) {
-    console.log(JSON.stringify({
-        schema_version: '2026-06-04',
-        command,
-        status: 'success',
-        data: payload,
-    }, null, 2));
-}
-function printOutput(json, payload, lines) {
-    if (json) {
-        console.log(JSON.stringify(payload));
-    }
-    else {
-        console.log(lines.join('\n'));
-    }
-}
-function printWorkspaceError(error) {
-    if (error instanceof WorkspaceError) {
-        console.error(`Error: ${error.message}`);
-    }
-    else if (error instanceof Error) {
-        console.error(`Error: ${error.message}`);
-    }
-    else {
-        console.error('Error:', error);
-    }
-}
-function parsePositiveInt(value, fallback) {
-    if (!value)
-        return fallback;
-    const parsed = Number.parseInt(value, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
-}
-function homeDir() {
-    return process.env.HOME || process.env.USERPROFILE || process.cwd();
-}
-function sanitizeSessionId(sessionId) {
-    return basename(sessionId || randomUUID()).replace(/[^a-zA-Z0-9._-]/g, '_') || randomUUID();
-}
-function isSafeRelativePath(path) {
-    return Boolean(path) &&
-        !path.startsWith('/') &&
-        !path.startsWith(`..${sep}`) &&
-        path !== '..' &&
-        !path.split(/[\\/]/).includes('.git');
-}
-function withTrailingSep(path) {
-    return path.endsWith(sep) ? path : `${path}${sep}`;
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-//# sourceMappingURL=workspace.js.map