codehere 1.0.1 → 1.0.2

package/dist/infrastructure/hooks/hook-mode.js

@@ -1,87 +0,0 @@
-/**
- * Hook mode detection — Pattern 20 backend.
- *
- * Reads ~/.claude/settings.json and reports which posture the safety
- * hook is in. Mode is encoded as flags on the configured command:
- *
- *   off       — no codehere scan-tool entry in PreToolUse
- *   log-only  — `codehere scan-tool --log-only`
- *   advisory  — DETECTION ONLY (LOW #20, atomic audit): getHookMode
- *               recognizes a `--advisory` flag for forward-compat, but
- *               scan-tool implements no advisory posture — a user writing
- *               --advisory gets the DEFAULT block behavior while the nav
- *               indicator would read 'advisory'. Don't advertise the flag.
- *   block     — `codehere scan-tool` (default critical/high block)
- *               OR `codehere scan-tool --block-all` (all severity levels)
- *
- * Read-only by design — this module never WRITES the config. Mode
- * switching belongs in `codehere hook install/uninstall` so users go
- * through the same path that re-validates the hook surface.
- */
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-/**
- * Resolve at call time, not at import.
- *
- * This was a module-level const, which froze the path to whatever HOME happened to be when the
- * module first loaded. For a one-shot CLI that is harmless — HOME does not move mid-process —
- * but it made the safety-mode read untestable against an isolated home, and the test that
- * covered it compensated by writing to the developer's REAL ~/.claude/settings.json instead.
- * A safety feature whose only test edits the user's live safety config is not covered, it is
- * gambled with, and on CI (no ~/.claude at all) it failed outright.
- *
- * A function costs one stat call per invocation and makes the module honest under any HOME.
- */
-const settingsPath = () => join(homedir(), '.claude', 'settings.json');
-/**
- * Detect the current safety-hook mode from ~/.claude/settings.json.
- * Defensive against missing / malformed settings — anything we can't
- * parse cleanly returns 'off' (the most-conservative read).
- */
-export function getHookMode() {
-    if (!existsSync(settingsPath()))
-        return 'off';
-    let parsed;
-    try {
-        parsed = JSON.parse(readFileSync(settingsPath(), 'utf-8'));
-    }
-    catch {
-        return 'off';
-    }
-    const hooks = (parsed.hooks ?? {});
-    const preToolUse = (hooks.PreToolUse ?? []);
-    if (!Array.isArray(preToolUse) || preToolUse.length === 0)
-        return 'off';
-    let bestMatch = 'off';
-    for (const entry of preToolUse) {
-        if (!entry?.hooks)
-            continue;
-        for (const hk of entry.hooks) {
-            const cmd = hk?.command;
-            if (typeof cmd !== 'string')
-                continue;
-            if (!cmd.includes('codehere scan-tool'))
-                continue;
-            // Earliest match wins block > advisory > log-only — once a stricter
-            // mode is found we keep it. (block is the operational default;
-            // log-only is opt-in.)
-            if (cmd.includes('--log-only')) {
-                if (bestMatch === 'off')
-                    bestMatch = 'log-only';
-            }
-            else if (cmd.includes('--advisory')) {
-                if (bestMatch === 'off' || bestMatch === 'log-only')
-                    bestMatch = 'advisory';
-            }
-            else {
-                // No flag OR --block-all: both render as 'block' in the UI.
-                // Block-all is stricter but the user-visible posture ("safety
-                // hook actively blocks risky calls") is the same.
-                return 'block';
-            }
-        }
-    }
-    return bestMatch;
-}
-//# sourceMappingURL=hook-mode.js.map

package/dist/infrastructure/hooks/mirror-tool-call-to-audit.js

@@ -1,49 +0,0 @@
-/**
- * Cross-vendor tool-call audit mirror — #110 slice 2 (Codex first).
- *
- * When non-Claude adapters emit a tool-call event, we can't BLOCK
- * (no synchronous pre-tool intercept yet) but we CAN mirror the
- * call into the audit log post-hoc. Closes the audit-trail-parity
- * gap: every adapter's tool calls land in the same hook-events.jsonl
- * the per-tool Claude hook writes to.
- *
- * Future slices (per-adapter blocking) replace the post-hoc mirror
- * with pre-call intercepts. For now: visibility today, blocking next.
- */
-import { scanPayload, calculateRiskScore, appendAuditLog, AUDIT_FILE } from './claude-sdk-hook.js';
-import { signAuditTip } from './audit-tip-signature.js';
-export function mirrorToolCallToAudit(rec) {
-    // Run the same pattern bank the per-tool hook uses, so post-hoc
-    // findings show up in the audit feed with the same severity calibration.
-    const findings = scanPayload(rec.toolInput);
-    const riskScore = calculateRiskScore(findings);
-    const truncated = rec.toolInput.length > 500 ? rec.toolInput.slice(0, 500) + '…' : rec.toolInput;
-    const entry = {
-        timestamp: new Date().toISOString(),
-        sessionId: rec.sessionId,
-        toolName: rec.toolName,
-        toolInput: JSON.stringify({
-            agent: rec.agent,
-            input: truncated,
-            cwd: rec.cwd ?? null,
-            inputLength: rec.toolInput.length,
-            mirrored: true, // marks post-hoc vs the synchronous Claude hook
-        }),
-        riskScore,
-        blocked: false, // post-hoc — can't block, only log
-        findings: findings.length,
-        criticalFindings: findings.filter((f) => f.severity === 'critical').length,
-        // R1.5 · the mirror runs IN the daemon — stamp the provenance it promises.
-        writer: 'daemon',
-    };
-    try {
-        appendAuditLog(entry);
-        // R1.3 · sign-at-write — the daemon's mirror is a daemon append; advance
-        // the signed tip per write (sub-ms, fail-open).
-        signAuditTip(AUDIT_FILE);
-    }
-    catch {
-        // Audit-write failures don't propagate — the agent's already running.
-    }
-}
-//# sourceMappingURL=mirror-tool-call-to-audit.js.map

package/dist/infrastructure/hooks/pre-prompt-scan.js

@@ -1,122 +0,0 @@
-/**
- * Pre-prompt safety scan — cross-vendor parity, task #110.
- *
- * The substrate the FAQ landing claims for v0.5.x → v0.6: "per-tool
- * blocking parity for Codex / Aider / OpenCode / Gemini." Today, only
- * Claude Code has a per-tool PreToolUse hook. The other 4 adapters
- * spawn raw — every Bash/Edit they make goes unscanned.
- *
- * Closing that gap fully needs per-adapter pre-tool intercepts (huge
- * scope per-adapter — different IPC + lifecycle for each CLI). This
- * module ships the FIRST cross-vendor slice: scan the user's PROMPT
- * before spawn. Catches the prompt-side leaks (API key in prompt,
- * injection-pattern poisoning, credential paste) for ALL 5 adapters
- * with one piece of code.
- *
- * Posture follows getHookMode():
- *   block    → high+ severity findings refuse spawn (throw)
- *   advisory → findings logged + warning event, spawn proceeds
- *   log-only → findings logged, spawn proceeds, no warning
- *   off      → no scan, spawn proceeds
- *
- * Every scan writes one audit-log entry with synthetic toolName
- * 'pre_prompt' so the audit feed + hash chain pick it up
- * without surface changes.
- */
-import { scanPayload, calculateRiskScore, appendAuditLog } from './claude-sdk-hook.js';
-import { getHookMode } from './hook-mode.js';
-import { filterAllowed } from '../security/permissions-config.js';
-/**
- * Scan a user prompt before spawn. Always writes one audit-log entry.
- * Returns allowed=false ONLY when mode === 'block' AND there's a
- * high-or-critical finding. Other modes always allow but still log.
- */
-export function scanPromptBeforeSpawn(input) {
-    const rawFindings = scanPayload(input.prompt);
-    // P18 slice 1 — filter against the cwd's permissions.yaml allow-list.
-    // Allow-listed findings are dropped from the BLOCK calculation but
-    // still recorded in the audit-log allowed-list field so a forensic
-    // reviewer can see what was suppressed and why.
-    const { surviving, allowed } = input.cwd
-        ? filterAllowed(rawFindings, input.cwd)
-        : { surviving: rawFindings, allowed: [] };
-    const findings = surviving;
-    const riskScore = calculateRiskScore(findings);
-    const mode = (() => {
-        try {
-            return getHookMode();
-        }
-        catch {
-            return 'off';
-        }
-    })();
-    // Severity gate: only critical/high findings can refuse a spawn.
-    // Medium/low findings get logged but never block — they're flagged
-    // for visibility, not enforcement. Matches the per-tool hook's
-    // existing severity-to-action policy.
-    const hardFindings = findings.filter((f) => f.severity === 'critical' || f.severity === 'high');
-    const wouldBlock = hardFindings.length > 0;
-    const blocked = mode === 'block' && wouldBlock;
-    // Audit entry — written for every scan, regardless of mode. Synthetic
-    // toolName 'pre_prompt' lets audit-feed filters group these
-    // separately from per-tool entries (existing chip filters on tool).
-    const entry = {
-        timestamp: new Date().toISOString(),
-        sessionId: input.sessionId,
-        toolName: 'pre_prompt',
-        // Truncate the prompt for the audit record — full prompts can be
-        // 10K+ chars and we don't want the audit log to balloon.
-        toolInput: JSON.stringify({
-            agent: input.agent,
-            prompt: input.prompt.length > 500 ? input.prompt.slice(0, 500) + '…' : input.prompt,
-            cwd: input.cwd ?? null,
-            promptLength: input.prompt.length,
-            // P18 slice 1 — record what got allow-listed for forensic audit.
-            // Empty array when no permissions.yaml exists in the cwd.
-            ...(allowed.length > 0
-                ? {
-                    allowedByPermissions: allowed.map((a) => ({
-                        category: a.finding.category,
-                        matched: a.finding.matched,
-                        reason: a.entry.reason ?? '(no reason given)',
-                    })),
-                }
-                : {}),
-        }),
-        riskScore,
-        blocked,
-        findings: findings.length,
-        criticalFindings: findings.filter((f) => f.severity === 'critical').length,
-        // Mode-driven override marker so the audit reader knows WHY a
-        // would-block finding wasn't enforced. Reuses the existing
-        // OverrideReason 'log_only_mode' for log-only AND advisory + off
-        // (all three skip the block; 'log_only_mode' is the closest
-        // shared semantic — the entry's mode field can be added as a new
-        // OverrideReason later without breaking the audit chain).
-        ...(wouldBlock && !blocked ? { overrideReason: 'log_only_mode' } : {}),
-    };
-    try {
-        appendAuditLog(entry);
-    }
-    catch {
-        // Audit-write failure should NOT itself block a spawn — that would
-        // be a denial-of-service vector (fill the log dir → no spawns).
-        // The audit infra has its own failure-mode logging.
-    }
-    // Compose a block reason from the worst findings. Used by the
-    // session-manager to throw an actionable error.
-    let blockReason = '';
-    if (blocked) {
-        const top = hardFindings.slice(0, 3);
-        const summary = top.map((f) => `[${f.severity}] ${f.description}`).join('; ');
-        blockReason = `pre-prompt scan blocked: ${summary}`;
-    }
-    return {
-        allowed: !blocked,
-        blocked,
-        riskScore,
-        findings,
-        blockReason,
-    };
-}
-//# sourceMappingURL=pre-prompt-scan.js.map

package/dist/infrastructure/hooks/session-analyzer.js

@@ -1,177 +0,0 @@
-/**
- * Session Analyzer
- *
- * Detects multi-agent amplification patterns in the hook audit log.
- *
- * When Claude Code spawns sub-agents via the Task tool, each agent makes
- * additional tool calls. One compromised instruction can amplify into
- * many downstream tool calls — the "17.2x amplification" risk.
- *
- * This analyzer groups audit events by session and detects:
- *   1. High tool call volume per session (potential amplification)
- *   2. Sessions with blocked calls (injection attempts)
- *   3. Sessions with unusual tool mix (e.g., many Bash calls in a row)
- */
-/**
- * Group audit entries by session and compute per-session stats.
- */
-export function analyzeSessions(entries) {
-    const bySession = new Map();
-    for (const entry of entries) {
-        const sid = entry.sessionId || 'unknown';
-        if (!bySession.has(sid))
-            bySession.set(sid, []);
-        bySession.get(sid).push(entry);
-    }
-    const summaries = [];
-    for (const [sessionId, sessionEntries] of bySession) {
-        const sorted = [...sessionEntries].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-        const first = sorted[0];
-        const last = sorted[sorted.length - 1];
-        const durationMs = new Date(last.timestamp).getTime() - new Date(first.timestamp).getTime();
-        const toolMix = {};
-        let blocked = 0;
-        let critical = 0;
-        for (const e of sorted) {
-            toolMix[e.toolName] = (toolMix[e.toolName] ?? 0) + 1;
-            if (e.blocked)
-                blocked++;
-            if (e.criticalFindings > 0)
-                critical++;
-        }
-        // Risk heuristics. The signal we care about is amplification — a runaway
-        // or injected session doing things the user didn't watch. Volume ALONE is
-        // weak signal: a normal attended dev session easily runs 40+ calls with
-        // 20+ Bash (git, build, test, curl) and is perfectly clean. Crying "medium"
-        // at that is the false alarm UX_OBSERVATIONS.md P1 warns against, and it
-        // erodes trust in the real alerts. So:
-        //   - any blocked call or critical finding is genuine security signal
-        //   - pure volume only flags at a high bar (the code's own ">50" threshold)
-        //   - Bash-heavy only flags when ALSO high-volume (raised 10→20, +calls>40)
-        const bashCount = toolMix['Bash'] ?? 0;
-        const callCount = sorted.length;
-        let risk = 'low';
-        if ((blocked > 0 && callCount > 20) || critical > 0)
-            risk = 'high';
-        else if (blocked > 0)
-            risk = 'medium';
-        else if (callCount > 50 || (bashCount > 20 && callCount > 40))
-            risk = 'medium';
-        summaries.push({
-            sessionId,
-            firstSeen: first.timestamp,
-            lastSeen: last.timestamp,
-            totalCalls: callCount,
-            blockedCalls: blocked,
-            criticalCalls: critical,
-            toolMix,
-            amplificationRisk: risk,
-            durationMs,
-        });
-    }
-    return summaries.sort((a, b) => new Date(b.lastSeen).getTime() - new Date(a.lastSeen).getTime());
-}
-/**
- * Identify sessions with amplification risk worth flagging.
- */
-export function detectAmplificationAlerts(sessions) {
-    const alerts = [];
-    for (const session of sessions) {
-        if (session.amplificationRisk === 'low')
-            continue;
-        let message;
-        const risk = session.amplificationRisk;
-        // rc.17 framing: don't accuse "injection" by default — that wording scares
-        // users on perfectly normal long attended sessions. Reserve the strong
-        // language for cases where the *blocked-call ratio* is high (real signal
-        // of prompts trying things they shouldn't), not just call volume.
-        // UX_OBSERVATIONS.md P1.
-        const blockRatio = session.totalCalls > 0 ? session.blockedCalls / session.totalCalls : 0;
-        if (session.blockedCalls > 0 && session.totalCalls > 20 && blockRatio > 0.05) {
-            message = `${session.totalCalls} tool calls, ${session.blockedCalls} blocked (${(blockRatio * 100).toFixed(0)}%) — high block ratio, review for injection`;
-        }
-        else if (session.blockedCalls > 0 && session.totalCalls > 20) {
-            message = `${session.totalCalls} tool calls, ${session.blockedCalls} blocked — long session, review if unattended`;
-        }
-        else if (session.totalCalls > 50) {
-            message = `${session.totalCalls} tool calls in one session — high density, review if unattended`;
-        }
-        else if ((session.toolMix['Bash'] ?? 0) > 10) {
-            message = `${session.toolMix['Bash']} Bash calls in one session — elevated tool-mix`;
-        }
-        else {
-            message = `${session.totalCalls} calls, ${session.blockedCalls} blocked — worth a glance`;
-        }
-        alerts.push({
-            sessionId: session.sessionId,
-            message,
-            callCount: session.totalCalls,
-            blockedCount: session.blockedCalls,
-            risk: risk === 'high' ? 'high' : 'medium',
-        });
-    }
-    return alerts.slice(0, 5); // top 5 alerts
-}
-/**
- * Real coding tools — the ones a genuine host terminal session uses. Synthetic
- * audit-event types (WritePass.intent, pre_prompt, etc.) and seed fixtures only
- * carry these internal names, so requiring a real tool filters them out.
- */
-export const REAL_HOST_TOOLS = new Set([
-    'Bash',
-    'Edit',
-    'Write',
-    'MultiEdit',
-    'Read',
-    'Glob',
-    'Grep',
-    'Task',
-    'NotebookEdit',
-    'WebFetch',
-]);
-/**
- * Is this a genuine host coding session worth surfacing — not a seed fixture or
- * a stale log entry? Requires at least one real coding tool and recent activity.
- * Surfacing stale/synthetic sessions as "running in your terminal" is the
- * screen-lie the no-screen-lies rule bans.
- */
-export function isRealHostSession(s, nowMs = Date.now(), recencyMs = 48 * 60 * 60 * 1000) {
-    const hasRealTool = Object.keys(s.toolMix).some((t) => REAL_HOST_TOOLS.has(t));
-    if (!hasRealTool)
-        return false;
-    const last = new Date(s.lastSeen).getTime();
-    if (!Number.isFinite(last))
-        return false;
-    return last >= nowMs - recencyMs;
-}
-/**
- * Plain-English preview of a tool call for the host-session thread timeline.
- * The hook stores toolInput as a (sometimes truncated) JSON string. Extract the
- * meaningful field — the bash command, the file path — never dump raw JSON at
- * the user. Falls back to a regex when the JSON is cut off mid-string.
- */
-export function previewFromToolInput(toolInput, max = 140) {
-    if (!toolInput)
-        return '';
-    let out;
-    try {
-        const inp = JSON.parse(toolInput);
-        out = String(inp.command ?? inp.file_path ?? inp.path ?? inp.pattern ?? inp.url ?? '');
-    }
-    catch {
-        const m = toolInput.match(/"(?:command|file_path|path|pattern|url)"\s*:\s*"((?:[^"\\]|\\.)*)/);
-        out = m ? m[1].replace(/\\"/g, '"').replace(/\\n/g, ' ') : '';
-    }
-    return out.slice(0, max);
-}
-/**
- * Format session duration for display.
- */
-export function formatDuration(ms) {
-    if (ms < 60_000)
-        return `${Math.round(ms / 1000)}s`;
-    if (ms < 3_600_000)
-        return `${Math.round(ms / 60_000)}m`;
-    return `${Math.round(ms / 3_600_000)}h`;
-}
-//# sourceMappingURL=session-analyzer.js.map

package/dist/infrastructure/observability/execution-tracer.js

@@ -1,227 +0,0 @@
-/**
- * Infrastructure: Execution Tracer
- * Tracks every LLM call, tool invocation, and operation for reproducibility
- *
- * Clean Architecture: Infrastructure Layer
- * Strategic: Critical for production reliability and debugging
- */
-import { randomUUID } from 'crypto';
-import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { getVersion } from '../../utils/version.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-/**
- * Execution Tracer
- * Tracks all operations for debugging and reproducibility
- */
-export class ExecutionTracer {
-    currentRun = null;
-    tracesDir;
-    constructor() {
-        // Store traces in agent/data/traces/
-        const agentDir = join(__dirname, '../../..');
-        this.tracesDir = join(agentDir, 'data', 'traces');
-        if (!existsSync(this.tracesDir)) {
-            mkdirSync(this.tracesDir, { recursive: true });
-        }
-    }
-    /**
-     * Start a new run context
-     */
-    startRun(operation, context) {
-        const runId = randomUUID();
-        this.currentRun = {
-            runId,
-            startTime: Date.now(),
-            operation,
-            query: context?.query,
-            codebaseId: context?.codebaseId,
-            userAgent: context?.userAgent || 'codehere-cli',
-            version: getVersion(),
-            traces: [],
-        };
-        return runId;
-    }
-    /**
-     * End the current run and save to disk
-     */
-    endRun() {
-        if (!this.currentRun) {
-            return;
-        }
-        this.currentRun.endTime = Date.now();
-        // Save run to disk
-        const runFilePath = join(this.tracesDir, `${this.currentRun.runId}.json`);
-        writeFileSync(runFilePath, JSON.stringify(this.currentRun, null, 2), 'utf-8');
-        this.currentRun = null;
-    }
-    /**
-     * Trace an operation
-     */
-    trace(operation) {
-        if (!this.currentRun) {
-            // If no run context, create a temporary one
-            this.startRun('auto-trace');
-        }
-        const traceId = randomUUID();
-        const startTime = Date.now();
-        const trace = {
-            traceId,
-            runId: this.currentRun.runId,
-            operationType: operation.operationType,
-            operationName: operation.operationName,
-            timestamp: startTime,
-            duration: operation.duration,
-            input: this.sanitizeInput(operation.input),
-            output: this.sanitizeOutput(operation.output),
-            error: operation.error
-                ? {
-                    message: operation.error.message,
-                    stack: operation.error.stack,
-                    code: operation.error.code,
-                }
-                : undefined,
-            metadata: operation.metadata,
-        };
-        this.currentRun.traces.push(trace);
-        return traceId;
-    }
-    /**
-     * Get run by ID (for reproducibility)
-     */
-    getRun(runId) {
-        const runFilePath = join(this.tracesDir, `${runId}.json`);
-        if (!existsSync(runFilePath)) {
-            return null;
-        }
-        try {
-            const content = readFileSync(runFilePath, 'utf-8');
-            return JSON.parse(content);
-        }
-        catch (error) {
-            console.error(`Failed to load run ${runId}:`, error);
-            return null;
-        }
-    }
-    /**
-     * List recent runs
-     */
-    /**
-     * Reproduce a run (replay operations in sequence)
-     * Enhanced: Actually replays operations with state restoration
-     */
-    async reproduceRun(runId, options) {
-        const run = this.getRun(runId);
-        if (!run) {
-            throw new Error(`Run ${runId} not found`);
-        }
-        // Create new run context for reproduction
-        const reproductionRunId = this.startRun(`reproduce:${run.operation}`, {
-            query: run.query,
-            codebaseId: run.codebaseId,
-        });
-        // Log reproduction start
-        console.log(`Reproducing run ${runId}...`);
-        console.log(`Operation: ${run.operation}`);
-        console.log(`Query: ${run.query || 'N/A'}`);
-        console.log(`Traces: ${run.traces.length}`);
-        console.log(`Step-by-step: ${options?.stepByStep || false}`);
-        // Replay each trace in sequence
-        for (let index = 0; index < run.traces.length; index++) {
-            const trace = run.traces[index];
-            console.log(`\n[${index + 1}/${run.traces.length}] ${trace.operationType}: ${trace.operationName}`);
-            if (trace.error) {
-                console.log(`  !  Original error: ${trace.error.message}`);
-                // Replay error trace
-                this.trace({
-                    operationType: trace.operationType,
-                    operationName: trace.operationName,
-                    input: trace.input,
-                    output: trace.output,
-                    error: new Error(trace.error.message),
-                    metadata: trace.metadata,
-                    duration: trace.duration,
-                });
-            }
-            else {
-                // Replay successful trace
-                this.trace({
-                    operationType: trace.operationType,
-                    operationName: trace.operationName,
-                    input: trace.input,
-                    output: trace.output,
-                    metadata: trace.metadata,
-                    duration: trace.duration,
-                });
-                // For tool invocations, attempt to replay if input/output available
-                if (trace.operationType === 'tool_invocation' && trace.input && trace.output) {
-                    console.log(`  ✓ Replayed: ${trace.operationName}`);
-                    if (trace.metadata?.filepath) {
-                        console.log(`    File: ${trace.metadata.filepath}`);
-                    }
-                }
-            }
-            // Step-by-step mode: wait for user confirmation
-            if (options?.stepByStep && index < run.traces.length - 1) {
-                // In a real CLI, we'd use readline to wait for user input
-                // For now, just log that step-by-step is enabled
-                console.log(`  [Press Enter to continue to next step...]`);
-            }
-        }
-        console.log(`\n✓ Reproduction complete. New run ID: ${reproductionRunId}`);
-        this.endRun();
-    }
-    /**
-     * Get current run ID
-     */
-    getCurrentRunId() {
-        return this.currentRun?.runId || null;
-    }
-    /**
-     * Sanitize input for storage (remove sensitive data, large objects)
-     */
-    sanitizeInput(input) {
-        if (!input)
-            return input;
-        // Limit size and remove sensitive fields
-        const sanitized = JSON.parse(JSON.stringify(input, (key, value) => {
-            // Remove API keys and secrets
-            if (typeof key === 'string' &&
-                (key.toLowerCase().includes('key') ||
-                    key.toLowerCase().includes('secret') ||
-                    key.toLowerCase().includes('password'))) {
-                return '[REDACTED]';
-            }
-            // Limit string length
-            if (typeof value === 'string' && value.length > 10000) {
-                return value.substring(0, 10000) + '...[truncated]';
-            }
-            // Limit array/object depth
-            return value;
-        }));
-        // Limit total size
-        const serialized = JSON.stringify(sanitized);
-        if (serialized.length > 100000) {
-            return { _truncated: true, _size: serialized.length };
-        }
-        return sanitized;
-    }
-    /**
-     * Sanitize output for storage
-     */
-    sanitizeOutput(output) {
-        if (!output)
-            return output;
-        // Limit size
-        const serialized = JSON.stringify(output);
-        if (serialized.length > 50000) {
-            return { _truncated: true, _size: serialized.length, _preview: serialized.substring(0, 1000) };
-        }
-        return output;
-    }
-}
-// Singleton instance
-export const executionTracer = new ExecutionTracer();
-//# sourceMappingURL=execution-tracer.js.map

package/dist/infrastructure/orchestration/agent-adapter.js

@@ -1,13 +0,0 @@
-/**
- * AgentAdapter — F2 foundation.
- *
- * Uniform interface over every AI coding agent codehere can spawn and manage.
- * One adapter per backend: ClaudeCodeAdapter, CodexAdapter, AiderAdapter, …
- *
- * The interface intentionally carries **optional fields for later PM-UX layers**
- * so we don't force a breaking change when v0.4/v0.5 ship progress roll-up,
- * final report, intervention, and project scope. Unused today, ignored by the
- * current renderer. See memory/project_manager_ux_v1.md for the full shape.
- */
-export {};
-//# sourceMappingURL=agent-adapter.js.map