tack-cli 0.1.0

package/dist/plain/diff.js

@@ -0,0 +1,129 @@
+import { blue, bold, gray, green, red } from "./colors.js";
+import { computeArchDiff } from "../engine/diff.js";
+export function runDiffPlain(baseBranch) {
+    if (!baseBranch) {
+        // eslint-disable-next-line no-console
+        console.error("Missing base branch. Usage: tack diff <base-branch>");
+        return false;
+    }
+    let diff;
+    try {
+        diff = computeArchDiff(baseBranch);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        // eslint-disable-next-line no-console
+        console.error(`✗ ${message}`);
+        return false;
+    }
+    const header = `${bold("Architecture diff")} ${gray(`(base: ${baseBranch}, head: ${diff.headRef})`)}`;
+    // eslint-disable-next-line no-console
+    console.log(header);
+    // eslint-disable-next-line no-console
+    console.log("");
+    if (diff.warnings.length > 0) {
+        // eslint-disable-next-line no-console
+        console.log(red("Warnings:"));
+        for (const w of diff.warnings) {
+            // eslint-disable-next-line no-console
+            console.log(`  - ${w}`);
+        }
+        // eslint-disable-next-line no-console
+        console.log("");
+    }
+    // Systems
+    // eslint-disable-next-line no-console
+    console.log(bold("Systems:"));
+    if (!diff.systems.available) {
+        // eslint-disable-next-line no-console
+        console.log(gray("  (systems diff unavailable; see warnings above)"));
+    }
+    else if (diff.systems.added.length === 0 &&
+        diff.systems.removed.length === 0 &&
+        diff.systems.changed.length === 0) {
+        // eslint-disable-next-line no-console
+        console.log(green("  No system-level changes detected."));
+    }
+    else {
+        if (diff.systems.added.length > 0) {
+            // eslint-disable-next-line no-console
+            console.log(green("  Systems added:"));
+            for (const s of diff.systems.added) {
+                const detail = s.detail ? `: ${s.detail}` : "";
+                // eslint-disable-next-line no-console
+                console.log(`    + ${s.id}${detail}`);
+            }
+        }
+        if (diff.systems.removed.length > 0) {
+            // eslint-disable-next-line no-console
+            console.log(red("  Systems removed:"));
+            for (const s of diff.systems.removed) {
+                const detail = s.detail ? `: ${s.detail}` : "";
+                // eslint-disable-next-line no-console
+                console.log(`    - ${s.id}${detail}`);
+            }
+        }
+        if (diff.systems.changed.length > 0) {
+            // eslint-disable-next-line no-console
+            console.log(blue("  Systems changed:"));
+            for (const change of diff.systems.changed) {
+                const before = change.before.detail ?? "unknown";
+                const after = change.after.detail ?? "unknown";
+                // eslint-disable-next-line no-console
+                console.log(`    ~ ${change.id}: ${before} → ${after}`);
+            }
+        }
+    }
+    // eslint-disable-next-line no-console
+    console.log("");
+    // Drift
+    // eslint-disable-next-line no-console
+    console.log(bold("Drift:"));
+    if (!diff.drift.available) {
+        // eslint-disable-next-line no-console
+        console.log(gray("  (drift status diff unavailable; see warnings above)"));
+    }
+    else if (diff.drift.newlyUnresolved.length === 0 &&
+        diff.drift.resolved.length === 0) {
+        // eslint-disable-next-line no-console
+        console.log(green("  No drift status changes detected."));
+    }
+    else {
+        if (diff.drift.newlyUnresolved.length > 0) {
+            // eslint-disable-next-line no-console
+            console.log(red("  Newly unresolved drift items:"));
+            for (const item of diff.drift.newlyUnresolved) {
+                const key = item.system ?? item.risk ?? item.type;
+                // eslint-disable-next-line no-console
+                console.log(`    + ${key}: ${item.signal}`);
+            }
+        }
+        if (diff.drift.resolved.length > 0) {
+            // eslint-disable-next-line no-console
+            console.log(green("  Resolved drift items:"));
+            for (const change of diff.drift.resolved) {
+                const before = change.before;
+                const key = before?.system ?? before?.risk ?? before?.type ?? change.id;
+                const finalStatus = change.after?.status ?? "resolved";
+                // eslint-disable-next-line no-console
+                console.log(`    - ${key}: unresolved → ${finalStatus}${before?.signal ? ` (${before.signal})` : ""}`);
+            }
+        }
+    }
+    // eslint-disable-next-line no-console
+    console.log("");
+    // Decisions
+    // eslint-disable-next-line no-console
+    console.log(bold("Decisions added since base:"));
+    if (diff.decisions.newDecisions.length === 0) {
+        // eslint-disable-next-line no-console
+        console.log(gray("  (no new decisions)"));
+    }
+    else {
+        for (const d of diff.decisions.newDecisions) {
+            // eslint-disable-next-line no-console
+            console.log(`  - [${d.date}] ${d.decision} — ${d.reasoning}`);
+        }
+    }
+    return true;
+}

package/dist/plain/handoff.d.ts

@@ -0,0 +1 @@
+export declare function printHandoffPlain(markdownPath: string, jsonPath: string, generatedAt: string): void;

package/dist/plain/handoff.js

@@ -0,0 +1,9 @@
+import { blue, bold, green, gray } from "./colors.js";
+export function printHandoffPlain(markdownPath, jsonPath, generatedAt) {
+    console.log(green("Handoff generated"));
+    console.log(`${gray("Time:")}     ${blue(generatedAt)}`);
+    console.log(`${bold("Markdown:")} ${markdownPath}`);
+    console.log(`${bold("JSON:")}     ${jsonPath}`);
+    console.log("");
+    console.log("Give this to your agent: attach the .md file to your chat (or add it to context in Cursor). For structured use, give the .json or use tack://handoff/latest (MCP).");
+}

package/dist/plain/init.d.ts

@@ -0,0 +1 @@
+export declare function runInitPlain(): boolean;

package/dist/plain/init.js

@@ -0,0 +1,44 @@
+import * as path from "node:path";
+import { runAllDetectors } from "../detectors/index.js";
+import { ensureTackIntegrity, ensureContextTemplates, ensureTackDir, projectRoot, specExists, writeAudit, writeDrift, writeSpec, } from "../lib/files.js";
+import { log } from "../lib/logger.js";
+import { createAudit, createEmptySpec } from "../lib/signals.js";
+import { getProjectName } from "../lib/project.js";
+export function runInitPlain() {
+    if (specExists()) {
+        const { repaired } = ensureTackIntegrity();
+        if (repaired.length > 0) {
+            log({ event: "repair", files: repaired });
+            console.log(`✓ Repaired .tack integrity (${repaired.length} file(s))`);
+            console.log(`Files recreated: ${repaired.join(", ")}`);
+            return true;
+        }
+        console.error("⚠ .tack already initialized. Run 'tack status' instead.");
+        return true;
+    }
+    ensureTackDir();
+    ensureContextTemplates();
+    const { signals } = runAllDetectors();
+    const projectName = getProjectName() || path.basename(projectRoot()) || "my-project";
+    const spec = createEmptySpec(projectName);
+    const inferredAllowed = Array.from(new Set(signals.filter((s) => s.category === "system" || s.category === "scope").map((s) => s.id)));
+    spec.allowed_systems = inferredAllowed;
+    writeSpec(spec);
+    writeAudit(createAudit(signals));
+    writeDrift({ items: [] });
+    log({
+        event: "init",
+        spec_seeded: true,
+        systems_detected: signals.filter((s) => s.category === "system").length,
+    });
+    console.log("✓ Initialized /.tack/");
+    console.log(`Project: ${projectName}`);
+    if (inferredAllowed.length > 0) {
+        console.log(`Allowed systems (seeded): ${inferredAllowed.join(", ")}`);
+    }
+    else {
+        console.log("Allowed systems (seeded): none detected");
+    }
+    console.log('Run "tack status" for a scan or "tack watch" for live monitoring.');
+    return true;
+}

package/dist/plain/notes.d.ts

@@ -0,0 +1,5 @@
+export declare function printNotes(opts?: {
+    limit?: number;
+    type?: string;
+}): void;
+export declare function addNotePlain(type: string, message: string, actor?: string): boolean;

package/dist/plain/notes.js

@@ -0,0 +1,49 @@
+import { AGENT_NOTE_TYPES } from "../lib/signals.js";
+import { readNotes, addNote, formatRelativeTime } from "../lib/notes.js";
+function isValidNoteType(value) {
+    return AGENT_NOTE_TYPES.includes(value);
+}
+export function printNotes(opts) {
+    const limit = opts?.limit;
+    const rawType = opts?.type;
+    let typeFilter;
+    if (typeof rawType === "string") {
+        if (!isValidNoteType(rawType)) {
+            // eslint-disable-next-line no-console
+            console.error(`Unknown note type: "${rawType}". Allowed types: ${AGENT_NOTE_TYPES.join(", ")}.`);
+            return;
+        }
+        typeFilter = rawType;
+    }
+    const notes = readNotes({ limit, type: typeFilter });
+    if (!notes.length) {
+        // eslint-disable-next-line no-console
+        console.log("No agent notes recorded.");
+        return;
+    }
+    for (const note of notes) {
+        const ago = formatRelativeTime(note.ts);
+        const actor = note.actor || "unknown";
+        // eslint-disable-next-line no-console
+        console.log(`[${note.type}] ${ago} — ${note.message} (${actor})`);
+    }
+}
+export function addNotePlain(type, message, actor) {
+    const normalizedActor = actor ?? "user";
+    if (!isValidNoteType(type)) {
+        // eslint-disable-next-line no-console
+        console.error(`Unknown note type: "${type}". Allowed types: ${AGENT_NOTE_TYPES.join(", ")}.`);
+        return false;
+    }
+    const ok = addNote({
+        type,
+        message,
+        actor: normalizedActor,
+        related_files: undefined,
+    });
+    if (!ok) {
+        // eslint-disable-next-line no-console
+        console.error("Failed to add note. See _logs.ndjson for details.");
+    }
+    return ok;
+}

package/dist/plain/status.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectStatus } from "../lib/signals.js";
+export declare function printStatusPlain(status: ProjectStatus): void;

package/dist/plain/status.js

@@ -0,0 +1,13 @@
+import { blue, bold, gray, green, red } from "./colors.js";
+export function printStatusPlain(status) {
+    const healthy = status.health === "aligned";
+    console.log(`${bold("Project:")} ${status.name}`);
+    console.log(`${bold("Health:")}  ${healthy ? green(status.health) : red(status.health)}`);
+    console.log(`${bold("Drift:")}   ${status.driftCount > 0 ? red(`${status.driftCount} item(s)`) : green("0 item(s)")}`);
+    if (status.driftItems.length) {
+        for (const item of status.driftItems) {
+            console.log(`  - ${red(item.system)}: ${item.message}`);
+        }
+    }
+    console.log(`${gray("Last scan:")} ${blue(status.lastScan ?? "never")}`);
+}

package/dist/plain/watch.d.ts

@@ -0,0 +1 @@
+export declare function runWatchPlain(): Promise<void>;

package/dist/plain/watch.js

@@ -0,0 +1,78 @@
+import chokidar from "chokidar";
+import * as path from "node:path";
+import { runStatusScan } from "../engine/status.js";
+import { blue, gray, green, red } from "./colors.js";
+const IGNORE_PATTERNS = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/.tack/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**",
+    "**/.cache/**",
+    "**/.svelte-kit/**",
+    "**/coverage/**",
+    "**/venv/**",
+    "**/.venv/**",
+    "**/env/**",
+    "**/site-packages/**",
+];
+function printSnapshot(reason) {
+    const result = runStatusScan();
+    if (!result) {
+        console.error("No spec.yaml found. Run 'tack init' first.");
+        return false;
+    }
+    const ts = new Date().toISOString();
+    const healthy = result.status.health === "aligned";
+    console.log(`${blue(`[${ts}]`)} ${reason} :: health=${healthy ? green("aligned") : red("drift")} drift=${result.status.driftCount > 0 ? red(String(result.status.driftCount)) : green("0")}`);
+    for (const item of result.status.driftItems.slice(0, 5)) {
+        console.log(`  - ${red(item.system)}: ${item.message}`);
+    }
+    if (result.status.driftItems.length > 5) {
+        console.log(`  - ${gray(`...and ${result.status.driftItems.length - 5} more`)}`);
+    }
+    return true;
+}
+export async function runWatchPlain() {
+    const ok = printSnapshot("initial");
+    if (!ok)
+        return;
+    console.log(`${gray("Watching for changes (plain mode). Press Ctrl+C to stop.")}`);
+    const watcher = chokidar.watch(".", {
+        ignored: IGNORE_PATTERNS,
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 200,
+            pollInterval: 50,
+        },
+    });
+    let debounceTimer = null;
+    const shutdown = async () => {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+            debounceTimer = null;
+        }
+        await watcher.close();
+        console.log(gray("Stopped watch mode."));
+    };
+    watcher.on("all", (event, filepath) => {
+        if (filepath.includes(`${path.sep}.tack${path.sep}`))
+            return;
+        if (filepath.startsWith(".tack/") || filepath.startsWith(".tack\\"))
+            return;
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => {
+            printSnapshot(`${event} ${filepath}`);
+        }, 300);
+    });
+    await new Promise((resolve) => {
+        const onSignal = () => {
+            void shutdown().then(resolve);
+        };
+        process.once("SIGINT", onSignal);
+        process.once("SIGTERM", onSignal);
+    });
+}

package/dist/ui/CleanupPlan.d.ts

@@ -0,0 +1,5 @@
+type Props = {
+    systemId: string;
+};
+export declare function CleanupPlan({ systemId }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/CleanupPlan.js

@@ -0,0 +1,8 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { Text, Box } from "ink";
+import { generateCleanupPlan } from "../engine/cleanup.js";
+export function CleanupPlan({ systemId }) {
+    const plan = useMemo(() => generateCleanupPlan(systemId), [systemId]);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: ["Cleanup plan for: ", systemId] }), plan.packagesToRemove.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Packages to remove:" }), plan.packagesToRemove.map((pkg) => (_jsxs(Text, { children: ["  bun remove ", pkg] }, pkg)))] })), plan.configFilesToCheck.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Config files to check:" }), plan.configFilesToCheck.map((f) => (_jsxs(Text, { children: ["  ", f] }, f)))] })), plan.filesToReview.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { bold: true, children: ["Files referencing ", systemId, ":"] }), plan.filesToReview.slice(0, 15).map((m, i) => (_jsxs(Text, { children: ["  ", _jsxs(Text, { dimColor: true, children: [m.file, ":", m.line] }), " ", m.content.slice(0, 80)] }, `${m.file}-${m.line}-${i}`))), plan.filesToReview.length > 15 && _jsxs(Text, { dimColor: true, children: ["  ", "...and ", plan.filesToReview.length - 15, " more"] })] })), plan.packagesToRemove.length === 0 && plan.filesToReview.length === 0 && plan.configFilesToCheck.length === 0 && (_jsx(Text, { dimColor: true, children: "No actionable cleanup items found." }))] }));
+}

package/dist/ui/DetectorSweep.d.ts

@@ -0,0 +1,6 @@
+import type { Signal } from "../lib/signals.js";
+type Props = {
+    onComplete: (signals: Signal[]) => void;
+};
+export declare function DetectorSweep({ onComplete }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/DetectorSweep.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { Text, Box } from "ink";
+import Spinner from "ink-spinner";
+import { PRIMARY_DETECTORS } from "../detectors/index.js";
+import { detectDuplicates } from "../detectors/duplicates.js";
+export function DetectorSweep({ onComplete }) {
+    const [detectors, setDetectors] = useState(PRIMARY_DETECTORS.map((d) => ({
+        name: d.name,
+        displayName: d.displayName,
+        status: "pending",
+    })));
+    useEffect(() => {
+        async function runSweep() {
+            const allSignals = [];
+            for (let i = 0; i < PRIMARY_DETECTORS.length; i += 1) {
+                const detector = PRIMARY_DETECTORS[i];
+                setDetectors((prev) => prev.map((d, idx) => (idx === i ? { ...d, status: "running" } : d)));
+                await new Promise((r) => setTimeout(r, 80));
+                const result = detector.run();
+                allSignals.push(...result.signals);
+                let summary = "none";
+                if (result.signals.length > 0) {
+                    summary = result.signals.map((s) => s.detail ?? s.id).join(" + ");
+                }
+                setDetectors((prev) => prev.map((d, idx) => idx === i
+                    ? {
+                        ...d,
+                        status: "done",
+                        result,
+                        summary,
+                    }
+                    : d));
+            }
+            const dupeResult = detectDuplicates(allSignals);
+            allSignals.push(...dupeResult.signals);
+            if (dupeResult.signals.length > 0) {
+                setDetectors((prev) => [
+                    ...prev,
+                    {
+                        name: "duplicates",
+                        displayName: "Checking for duplicate systems",
+                        status: "warning",
+                        result: dupeResult,
+                        summary: dupeResult.signals.map((s) => s.detail ?? s.id).join(", "),
+                    },
+                ]);
+            }
+            onComplete(allSignals);
+        }
+        void runSweep();
+    }, [onComplete]);
+    return (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { bold: true, children: "Scanning project..." }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: detectors.map((d) => (_jsxs(Box, { children: [_jsxs(Box, { width: 2, children: [d.status === "running" && _jsx(Spinner, { type: "dots" }), d.status === "done" && _jsx(Text, { color: "green", children: "\u2713" }), d.status === "warning" && _jsx(Text, { color: "yellow", children: "\u26A0" }), d.status === "pending" && _jsx(Text, { dimColor: true, children: "\u25CB" })] }), _jsxs(Text, { children: [" ", d.displayName, d.summary && d.status !== "pending" && d.status !== "running" && _jsxs(Text, { dimColor: true, children: [": ", d.summary] })] })] }, d.name))) })] }));
+}

package/dist/ui/DriftAlert.d.ts

@@ -0,0 +1,7 @@
+import type { DriftItem } from "../lib/signals.js";
+type Props = {
+    item: DriftItem;
+    onResolved: () => void;
+};
+export declare function DriftAlert({ item, onResolved }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/DriftAlert.js

@@ -0,0 +1,105 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState } from "react";
+import { Text, Box } from "ink";
+import SelectInput from "ink-select-input";
+import { resolveDriftItem } from "../engine/computeDrift.js";
+import { readSpec, writeSpec } from "../lib/files.js";
+import { CleanupPlan as CleanupPlanView } from "./CleanupPlan.js";
+import { log } from "../lib/logger.js";
+export function DriftAlert({ item, onResolved }) {
+    const [view, setView] = useState("options");
+    const [resolutionLabel, setResolutionLabel] = useState("");
+    const options = [
+        { label: "[a] Accept — add to allowed_systems", value: "accept" },
+        { label: "[d] Deny — add to forbidden_systems", value: "deny" },
+        { label: "[i] Investigate — show referencing files", value: "investigate" },
+        { label: "[g] Generate cleanup plan", value: "cleanup" },
+        { label: "[s] Skip for now", value: "skip" },
+    ];
+    function handleSelect(opt) {
+        switch (opt.value) {
+            case "accept": {
+                const spec = readSpec();
+                if (spec && item.system) {
+                    let changed = false;
+                    if (!spec.allowed_systems.includes(item.system)) {
+                        spec.allowed_systems.push(item.system);
+                        changed = true;
+                    }
+                    spec.forbidden_systems = spec.forbidden_systems.filter((s) => s !== item.system);
+                    if (changed) {
+                        log({
+                            event: "spec:updated",
+                            field: "allowed_systems",
+                            diff: `added ${item.system}`,
+                        });
+                    }
+                    writeSpec(spec);
+                }
+                resolveDriftItem(item.id, "accepted", "Accepted via tack watch");
+                log({
+                    event: "decision",
+                    decision: `Accepted drift item ${item.id}`,
+                    reasoning: "Added detected system to allowed_systems from watch flow",
+                    actor: "user",
+                });
+                setResolutionLabel("Accepted — spec updated");
+                setView("resolved");
+                onResolved();
+                break;
+            }
+            case "deny": {
+                const spec = readSpec();
+                if (spec && item.system) {
+                    let changed = false;
+                    if (!spec.forbidden_systems.includes(item.system)) {
+                        spec.forbidden_systems.push(item.system);
+                        changed = true;
+                    }
+                    spec.allowed_systems = spec.allowed_systems.filter((s) => s !== item.system);
+                    if (changed) {
+                        log({
+                            event: "spec:updated",
+                            field: "forbidden_systems",
+                            diff: `added ${item.system}`,
+                        });
+                    }
+                    writeSpec(spec);
+                }
+                resolveDriftItem(item.id, "rejected", "Rejected via tack watch");
+                log({
+                    event: "decision",
+                    decision: `Rejected drift item ${item.id}`,
+                    reasoning: "Added detected system to forbidden_systems from watch flow",
+                    actor: "user",
+                });
+                setResolutionLabel("Denied — spec updated");
+                setView("resolved");
+                onResolved();
+                break;
+            }
+            case "investigate":
+            case "cleanup": {
+                setView("cleanup");
+                break;
+            }
+            case "skip": {
+                resolveDriftItem(item.id, "skipped");
+                log({
+                    event: "decision",
+                    decision: `Skipped drift item ${item.id}`,
+                    reasoning: "Deferred action from watch flow",
+                    actor: "user",
+                });
+                setResolutionLabel("Skipped — will remind on next scan");
+                setView("resolved");
+                onResolved();
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    const systemId = item.system ?? item.risk ?? "unknown";
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginY: 1, children: [_jsxs(Text, { bold: true, color: "yellow", children: ["\u26A0 Drift detected: ", systemId] }), _jsxs(Text, { children: ["  Source: ", item.signal] }), _jsxs(Text, { children: ["  Type: ", item.type.replace(/_/g, " ")] }), view === "options" && (_jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: options, onSelect: handleSelect }) })), view === "cleanup" && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(CleanupPlanView, { systemId: systemId }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press any key to return to options..." }) })] })), view === "resolved" && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "green", children: ["\u2713 ", resolutionLabel] }) }))] }));
+}

package/dist/ui/Handoff.d.ts

@@ -0,0 +1 @@
+export declare function Handoff(): import("react/jsx-runtime").JSX.Element;

package/dist/ui/Handoff.js

@@ -0,0 +1,37 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import React, { useState } from "react";
+import { Box, Text, useApp } from "ink";
+import { generateHandoff } from "../engine/handoff.js";
+import { log } from "../lib/logger.js";
+export function Handoff() {
+    const { exit } = useApp();
+    const [error, setError] = useState(null);
+    const [result, setResult] = useState(null);
+    React.useEffect(() => {
+        try {
+            const generated = generateHandoff();
+            setResult({
+                markdownPath: generated.markdownPath,
+                jsonPath: generated.jsonPath,
+                generatedAt: generated.report.generated_at,
+            });
+            log({
+                event: "handoff",
+                markdown_path: generated.markdownPath,
+                json_path: generated.jsonPath,
+            });
+            setTimeout(() => exit(), 100);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : "Failed to generate handoff");
+            setTimeout(() => exit(), 500);
+        }
+    }, [exit]);
+    if (error) {
+        return _jsxs(Text, { color: "red", children: ["\u2717 ", error] });
+    }
+    if (!result) {
+        return _jsx(Text, { children: "Generating handoff..." });
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "green", children: "\u2713 Handoff generated" }), _jsxs(Text, { children: ["  Time: ", result.generatedAt] }), _jsxs(Text, { children: ["  Markdown: ", result.markdownPath] }), _jsxs(Text, { children: ["  JSON: ", result.jsonPath] }), _jsx(Text, { dimColor: true, children: "  Give to your agent: .md for chat/context, .json or tack://handoff/latest for structured (MCP)." })] }));
+}

package/dist/ui/Init.d.ts

@@ -0,0 +1 @@
+export declare function Init(): import("react/jsx-runtime").JSX.Element;