tack-cli 0.1.0 → 0.1.2

package/dist/index.js

@@ -17,18 +17,19 @@ import { runWatchPlain } from "./plain/watch.js";
 import { log, readRecentLogs } from "./lib/logger.js";
 import { appendDecision, normalizeDecisionActor, readDecisionsMarkdown } from "./engine/decisions.js";
 import { ensureTackIntegrity } from "./lib/files.js";
-import { fileExists } from "./lib/files.js";
 import { readSpecWithError, specExists } from "./lib/files.js";
+import { getDefaultCommand } from "./lib/cli.js";
 import { printNotes, addNotePlain } from "./plain/notes.js";
 import { compactNotes } from "./lib/notes.js";
 import { runDiffPlain } from "./plain/diff.js";
-const ASCII_LOGO = `
- ████████╗ █████╗  ██████╗██╗  ██╗
- ╚══██╔══╝██╔══██╗██╔════╝██║ ██╔╝
-    ██║   ███████║██║     █████╔╝
-    ██║   ██╔══██║██║     ██╔═██╗
-    ██║   ██║  ██║╚██████╗██║  ██╗
-    ╚═╝   ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝
+import { formatMissingTackContextMessage, tackDirExists } from "./lib/files.js";
+const ASCII_LOGO = `
+ ████████╗ █████╗  ██████╗██╗  ██╗
+ ╚══██╔══╝██╔══██╗██╔════╝██║ ██╔╝
+    ██║   ███████║██║     █████╔╝
+    ██║   ██╔══██║██║     ██╔═██╗
+    ██║   ██║  ██║╚██████╗██║  ██╗
+    ╚═╝   ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝
 `;
 import updateNotifier from "update-notifier";
 import { readFileSync } from "node:fs";
@@ -42,41 +43,45 @@ if (args.version || args.v) {
     process.exit(0);
 }
 const rawCommand = args._[0];
-const command = rawCommand ?? (fileExists(".tack") ? "watch" : "init");
+const command = rawCommand ?? getDefaultCommand();
 const VALID_COMMANDS = ["init", "status", "watch", "handoff", "log", "note", "diff", "mcp", "help"];
 function isValidCommand(value) {
     return VALID_COMMANDS.includes(value);
 }
 if (command === "help" || args.help || args.h) {
     // eslint-disable-next-line no-console
-    console.log(`
-${ASCII_LOGO}
-  tack — Architecture drift guard
-
-  Usage:
-    npx tack init [--ink]          Set up spec.yaml from detected architecture
-    npx tack status [--ink]        Run a scan and show current state
-    npx tack watch [--plain]       Persistent watcher with live drift alerts
-    npx tack handoff [--ink]       Generate agent handoff artifacts
-    npx tack log                   View or append decisions
-    npx tack log events [N]        Show last N log events (default 50)
-    npx tack note                  View/add agent notes
-    npx tack diff <base-branch>    Compare architecture vs base branch (plain)
-    npx tack mcp                   Start MCP server (for Cursor / agent integrations)
-    npx tack help                  Show this help text
-
-  Output mode:
-    default: plain output for all commands except watch
-    --ink: force Ink UI for init/status/handoff
-    --plain or TACK_PLAIN=1: force plain output (including watch)
-
-  Files (all in .tack/):
-    spec.yaml     Your declared architecture contract
-    _audit.yaml   Latest detector sweep results
-    _drift.yaml   Current unresolved drift items
-    _logs.ndjson  Append-only event log
-    context.md, goals.md, assumptions.md, open_questions.md
-    handoffs/<ts>.md, handoffs/<ts>.json
+    console.log(`
+${ASCII_LOGO}
+  tack — Architecture drift guard
+
+  Usage:
+    npx tack init [--ink]          Set up spec.yaml from detected architecture
+    npx tack status [--ink]        Run a scan and show current state
+    npx tack watch [--plain]       Persistent watcher with live drift alerts
+    npx tack handoff [--ink]       Generate agent handoff artifacts
+    npx tack log                   View or append decisions
+    npx tack log events [N]        Show last N log events (default 50)
+    npx tack note                  View/add agent notes
+    npx tack diff <base-branch>    Compare architecture vs base branch (plain)
+    npx tack mcp                   Start MCP server (for Cursor / agent integrations)
+    npx tack help                  Show this help text
+
+  Output mode:
+    default: plain output for all commands except watch
+    --ink: force Ink UI for init/status/handoff
+    --plain or TACK_PLAIN=1: force plain output (including watch)
+
+  Files (all in .tack/):
+    spec.yaml     Your declared architecture contract
+    _audit.yaml   Latest detector sweep results
+    _drift.yaml   Current unresolved drift items
+    _logs.ndjson  Append-only event log
+    context.md, goals.md, assumptions.md, open_questions.md
+    handoffs/<ts>.md, handoffs/<ts>.json
+
+  Project root:
+    Existing Tack project: nearest ancestor directory that contains .tack/
+    New project: cd to the intended project root, then run "tack init"
   `);
     process.exit(0);
 }
@@ -86,14 +91,14 @@ if (!isValidCommand(command)) {
     process.exit(1);
 }
 const normalizedCommand = command;
+const commandsRequiringExistingTack = new Set(["status", "watch", "handoff", "log", "note", "diff", "mcp"]);
+if (commandsRequiringExistingTack.has(normalizedCommand) && !tackDirExists()) {
+    // eslint-disable-next-line no-console
+    console.error(formatMissingTackContextMessage(normalizedCommand));
+    process.exit(1);
+}
 // tack mcp: start the MCP server (stdio). Run from a project root that has .tack/
 if (normalizedCommand === "mcp") {
-    const cwdTack = path.join(process.cwd(), ".tack");
-    if (!existsSync(cwdTack)) {
-        // eslint-disable-next-line no-console
-        console.error("Run `tack mcp` from a project root that contains a .tack/ directory.");
-        process.exit(1);
-    }
     const dir = path.dirname(fileURLToPath(import.meta.url));
     const mcpHere = path.join(dir, "mcp.js");
     const mcpInDist = path.join(dir, "..", "dist", "mcp.js");

package/dist/lib/cli.d.ts

@@ -1,4 +1,6 @@
 /**
- * Default command resolution: no-arg CLI runs init when .tack/ is missing, otherwise watch.
+ * Returns the default command when `tack` is invoked with no arguments:
+ * - "init" when .tack/ does not exist
+ * - "watch" when .tack/ exists
  */
-export declare function resolveDefaultCommand(raw: string | undefined, tackDirExists: boolean): "init" | "watch" | string;
+export declare function getDefaultCommand(tackExists?: () => boolean): "init" | "watch";

package/dist/lib/cli.js

@@ -1,8 +1,9 @@
+import { tackDirExists } from "./files.js";
 /**
- * Default command resolution: no-arg CLI runs init when .tack/ is missing, otherwise watch.
+ * Returns the default command when `tack` is invoked with no arguments:
+ * - "init" when .tack/ does not exist
+ * - "watch" when .tack/ exists
  */
-export function resolveDefaultCommand(raw, tackDirExists) {
-    if (raw !== undefined && raw !== "")
-        return raw;
-    return tackDirExists ? "watch" : "init";
+export function getDefaultCommand(tackExists = tackDirExists) {
+    return tackExists() ? "watch" : "init";
 }

package/dist/lib/files.d.ts

@@ -1,6 +1,9 @@
 import { type Spec, type Audit, type DriftState } from "./signals.js";
 export declare function projectRoot(): string;
 export declare function findProjectRoot(): string;
+/** True when the .tack/ directory exists (used for default CLI behavior). */
+export declare function tackDirExists(): boolean;
+export declare function formatMissingTackContextMessage(command: string): string;
 export declare function writeSafe(filepath: string, content: string): void;
 export declare function appendSafe(filepath: string, content: string): void;
 export declare function ensureTackDir(): void;

package/dist/lib/files.js

@@ -6,19 +6,77 @@ import { safeLoadYaml } from "./yaml.js";
 import { validateAudit, validateDriftState, validateSpec } from "./validate.js";
 const LEGACY_DIRNAME = "tack";
 const TACK_DIRNAME = ".tack";
-export function projectRoot() {
-    const cwd = path.resolve(process.cwd());
-    let current = cwd;
+const LEGACY_TACK_MARKERS = [
+    "spec.yaml",
+    "audit.yaml",
+    "drift.yaml",
+    "logs.ndjson",
+    "context.md",
+    "goals.md",
+    "assumptions.md",
+    "open_questions.md",
+    "decisions.md",
+    "implementation_status.md",
+    "verification.md",
+    "handoffs",
+];
+const PROJECT_MARKERS = [
+    ".git",
+    "package.json",
+    "README.md",
+    "src",
+    "node_modules",
+    "backlog",
+    "dist",
+];
+function looksLikeLegacyTackDir(dir) {
+    try {
+        if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+            return false;
+        }
+        const entries = new Set(fs.readdirSync(dir));
+        const hasLegacyMarkers = LEGACY_TACK_MARKERS.some((name) => entries.has(name));
+        if (!hasLegacyMarkers) {
+            return false;
+        }
+        const hasProjectMarkers = PROJECT_MARKERS.some((name) => entries.has(name));
+        return !hasProjectMarkers;
+    }
+    catch {
+        return false;
+    }
+}
+function findNearestProjectRootWithContext(start = process.cwd()) {
+    let current = path.resolve(start);
+    if (path.basename(current) === TACK_DIRNAME) {
+        current = path.dirname(current);
+    }
+    else if (path.basename(current) === LEGACY_DIRNAME && looksLikeLegacyTackDir(current)) {
+        current = path.dirname(current);
+    }
     while (true) {
-        if (path.basename(current) === TACK_DIRNAME) {
-            return path.dirname(current);
+        const tackDir = path.join(current, TACK_DIRNAME);
+        try {
+            if (fs.existsSync(tackDir) && fs.statSync(tackDir).isDirectory()) {
+                return current;
+            }
+        }
+        catch {
+            // Ignore stat failures and keep walking upward.
+        }
+        const legacyDir = path.join(current, LEGACY_DIRNAME);
+        if (looksLikeLegacyTackDir(legacyDir)) {
+            return current;
         }
         const parent = path.dirname(current);
-        if (parent === current)
-            break;
+        if (parent === current) {
+            return null;
+        }
         current = parent;
     }
-    return cwd;
+}
+export function projectRoot() {
+    return findNearestProjectRootWithContext() ?? path.resolve(process.cwd());
 }
 export function findProjectRoot() {
     return projectRoot();
@@ -29,6 +87,10 @@ function getLegacyTackDir() {
 function getTackDir() {
     return path.resolve(projectRoot(), TACK_DIRNAME);
 }
+/** True when the .tack/ directory exists (used for default CLI behavior). */
+export function tackDirExists() {
+    return findNearestProjectRootWithContext() !== null;
+}
 function emitValidationWarnings(file, warnings) {
     if (warnings.length === 0)
         return;
@@ -39,10 +101,17 @@ function emitValidationWarnings(file, warnings) {
 function migrateLegacyDirIfNeeded() {
     const legacyDir = getLegacyTackDir();
     const newDir = getTackDir();
-    if (!fs.existsSync(newDir) && fs.existsSync(legacyDir)) {
+    if (!fs.existsSync(newDir) && looksLikeLegacyTackDir(legacyDir)) {
         fs.renameSync(legacyDir, newDir);
     }
 }
+export function formatMissingTackContextMessage(command) {
+    return [
+        `No .tack/ directory was found for \`${command}\`.`,
+        "Run Tack from your project root (the directory that contains .tack/).",
+        "If this is a new project, cd to the intended root and run `tack init` first.",
+    ].join(" ");
+}
 function migrateMachineFilesIfNeeded() {
     const mapping = [
         { oldName: "audit.yaml", newName: "_audit.yaml" },

package/dist/lib/logger.d.ts

@@ -1,3 +1,15 @@
 import type { LogEvent, LogEventInput } from "./signals.js";
+export type McpActivityEvent = Extract<LogEvent, {
+    event: "mcp:resource" | "mcp:tool";
+}>;
+export type McpActivityNotice = {
+    event: McpActivityEvent;
+    message: string;
+};
 export declare function log(event: LogEventInput): void;
 export declare function readRecentLogs<T = LogEvent>(limit?: number): T[];
+export declare function isMcpActivityEvent(event: LogEvent): event is McpActivityEvent;
+export declare function readRecentMcpActivity(limit?: number): McpActivityEvent[];
+export declare function mcpActivityEventKey(event: McpActivityEvent): string;
+export declare function formatMcpActivityEvent(event: McpActivityEvent): string;
+export declare function createMcpActivityMonitor(): () => McpActivityNotice[];

package/dist/lib/logger.js

@@ -1,7 +1,8 @@
 import { appendSafe, logsPath } from "./files.js";
-import { rotateNdjsonFile, safeReadNdjson } from "./ndjson.js";
+import { createNdjsonTailReader, rotateNdjsonFile, safeReadNdjson } from "./ndjson.js";
 const LOG_MAX_BYTES = 5 * 1024 * 1024;
 const LOG_KEEP_LINES = 5000;
+const MCP_ACTIVITY_SUPPRESS_MS = 1500;
 export function log(event) {
     const entry = {
         ts: new Date().toISOString(),
@@ -19,3 +20,54 @@ export function log(event) {
 export function readRecentLogs(limit = 50) {
     return safeReadNdjson(logsPath(), limit);
 }
+export function isMcpActivityEvent(event) {
+    return event.event === "mcp:resource" || event.event === "mcp:tool";
+}
+export function readRecentMcpActivity(limit = 50) {
+    return readRecentLogs(limit).filter(isMcpActivityEvent);
+}
+export function mcpActivityEventKey(event) {
+    return `${event.ts}:${event.event}:${event.event === "mcp:resource" ? event.resource : event.tool}`;
+}
+function formatMcpResourceName(resource) {
+    if (!resource.startsWith("tack://")) {
+        return resource;
+    }
+    return resource.replace(/^tack:\/\//, "");
+}
+export function formatMcpActivityEvent(event) {
+    if (event.event === "mcp:resource") {
+        return `MCP read ${formatMcpResourceName(event.resource)}`;
+    }
+    return `MCP called ${event.tool}`;
+}
+export function createMcpActivityMonitor() {
+    const seen = new Set(safeReadNdjson(logsPath()).filter(isMcpActivityEvent).map(mcpActivityEventKey));
+    const lastShownAt = new Map();
+    const readNewLogEvents = createNdjsonTailReader(logsPath());
+    return () => {
+        const notices = [];
+        for (const event of readNewLogEvents()) {
+            if (!isMcpActivityEvent(event))
+                continue;
+            const key = mcpActivityEventKey(event);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const kind = event.event === "mcp:resource" ? `resource:${event.resource}` : `tool:${event.tool}`;
+            const tsMs = Date.parse(event.ts);
+            const lastMs = lastShownAt.get(kind) ?? 0;
+            if (Number.isFinite(tsMs) && tsMs - lastMs < MCP_ACTIVITY_SUPPRESS_MS) {
+                continue;
+            }
+            if (Number.isFinite(tsMs)) {
+                lastShownAt.set(kind, tsMs);
+            }
+            notices.push({
+                event,
+                message: formatMcpActivityEvent(event),
+            });
+        }
+        return notices;
+    };
+}

package/dist/lib/ndjson.d.ts

@@ -1,2 +1,3 @@
 export declare function safeReadNdjson<T = Record<string, unknown>>(filepath: string, limit?: number): T[];
+export declare function createNdjsonTailReader<T = Record<string, unknown>>(filepath: string): () => T[];
 export declare function rotateNdjsonFile(filepath: string, maxBytes: number, keepLines: number): void;

package/dist/lib/ndjson.js

@@ -1,4 +1,18 @@
 import * as fs from "node:fs";
+function parseNdjsonLines(lines) {
+    const out = [];
+    for (const line of lines) {
+        if (line.trim().length === 0)
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            continue;
+        }
+    }
+    return out;
+}
 export function safeReadNdjson(filepath, limit) {
     if (!fs.existsSync(filepath))
         return [];
@@ -6,21 +20,67 @@ export function safeReadNdjson(filepath, limit) {
         const raw = fs.readFileSync(filepath, "utf-8");
         const lines = raw.split("\n").filter((line) => line.trim().length > 0);
         const slice = limit ? lines.slice(-limit) : lines;
-        const out = [];
-        for (const line of slice) {
-            try {
-                out.push(JSON.parse(line));
-            }
-            catch {
-                continue;
-            }
-        }
-        return out;
+        return parseNdjsonLines(slice);
     }
     catch {
         return [];
     }
 }
+export function createNdjsonTailReader(filepath) {
+    let offset = 0;
+    let remainder = "";
+    try {
+        offset = fs.existsSync(filepath) ? fs.statSync(filepath).size : 0;
+    }
+    catch {
+        offset = 0;
+    }
+    return () => {
+        if (!fs.existsSync(filepath)) {
+            offset = 0;
+            remainder = "";
+            return [];
+        }
+        let stat;
+        try {
+            stat = fs.statSync(filepath);
+        }
+        catch {
+            return [];
+        }
+        const start = stat.size < offset ? 0 : offset;
+        const length = stat.size - start;
+        if (length <= 0) {
+            offset = stat.size;
+            return [];
+        }
+        let fd;
+        try {
+            fd = fs.openSync(filepath, "r");
+            const buffer = Buffer.alloc(length);
+            fs.readSync(fd, buffer, 0, length, start);
+            offset = stat.size;
+            const chunk = remainder + buffer.toString("utf-8");
+            const endsWithNewline = chunk.endsWith("\n");
+            const lines = chunk.split("\n");
+            remainder = endsWithNewline ? "" : (lines.pop() ?? "");
+            return parseNdjsonLines(lines);
+        }
+        catch {
+            return [];
+        }
+        finally {
+            if (fd !== undefined) {
+                try {
+                    fs.closeSync(fd);
+                }
+                catch {
+                    // Ignore close failures.
+                }
+            }
+        }
+    };
+}
 export function rotateNdjsonFile(filepath, maxBytes, keepLines) {
     if (!fs.existsSync(filepath))
         return;

package/dist/lib/signals.d.ts

@@ -95,6 +95,14 @@ export type LogEvent = {
     systems_detected: number;
     drift_items: number;
     duration_ms: number;
+} | {
+    ts: string;
+    event: "mcp:resource";
+    resource: string;
+} | {
+    ts: string;
+    event: "mcp:tool";
+    tool: string;
 } | {
     ts: string;
     event: "drift:detected";

package/dist/mcp.js

@@ -42,7 +42,7 @@ function latestHandoffJsonPath() {
 async function main() {
     const server = new McpServer({
         name: "tack-mcp",
-        version: "0.1.0",
+        version: "0.1.2",
     }, {});
     // Intent: high-level purpose and goals, without architecture internals.
     server.registerResource("intent", "tack://context/intent", {
@@ -50,6 +50,7 @@ async function main() {
         description: "High-level North Star, goals, and open questions for this project.",
         mimeType: "text/markdown",
     }, async (uri) => {
+        log({ event: "mcp:resource", resource: uri.href });
         const parts = [];
         const context = safeReadFile(contextPath());
         if (context) {
@@ -86,6 +87,7 @@ async function main() {
         description: "Binary, source-anchored implementation status and architecture spec.",
         mimeType: "text/markdown",
     }, async (uri) => {
+        log({ event: "mcp:resource", resource: uri.href });
         const parts = [];
         const impl = safeReadFile(implementationStatusPath());
         if (impl) {
@@ -114,6 +116,7 @@ async function main() {
         description: "Latest handoff JSON generated by `tack handoff`.",
         mimeType: "application/json",
     }, async (uri) => {
+        log({ event: "mcp:resource", resource: uri.href });
         const jsonPath = latestHandoffJsonPath();
         if (!jsonPath) {
             return {
@@ -141,6 +144,7 @@ async function main() {
         description: "Recent architecture and product decisions driving this project.",
         mimeType: "text/markdown",
     }, async (uri) => {
+        log({ event: "mcp:resource", resource: uri.href });
         const pack = parseContextPack();
         const recent = pack.decisions.slice(-10);
         if (recent.length === 0) {
@@ -174,6 +178,7 @@ async function main() {
         description: "Raw machine state from _audit.yaml and _drift.yaml.",
         mimeType: "text/markdown",
     }, async (uri) => {
+        log({ event: "mcp:resource", resource: uri.href });
         const parts = [];
         const audit = safeReadFile(auditPath());
         if (audit) {
@@ -205,6 +210,7 @@ async function main() {
             actor: z.string().optional(),
         }),
     }, async (args) => {
+        log({ event: "mcp:tool", tool: "log_decision" });
         const decision = args.decision;
         const reasoning = args.reasoning;
         const actor = typeof args.actor === "string" ? args.actor : undefined;
@@ -233,6 +239,7 @@ async function main() {
             related_files: z.array(z.string()).optional(),
         }),
     }, async (args) => {
+        log({ event: "mcp:tool", tool: "log_agent_note" });
         const actor = args.actor && args.actor.trim().length > 0 ? args.actor : "user";
         const ok = addNote({
             type: args.type,

package/dist/plain/colors.d.ts

@@ -1,5 +1,9 @@
 export declare function green(text: string): string;
 export declare function red(text: string): string;
 export declare function blue(text: string): string;
+export declare function cyan(text: string): string;
+export declare function yellow(text: string): string;
 export declare function gray(text: string): string;
 export declare function bold(text: string): string;
+export declare function checkBadge(): string;
+export declare function mcpBadge(): string;

package/dist/plain/colors.js

@@ -8,9 +8,21 @@ export function red(text) {
 export function blue(text) {
     return pc.blue(text);
 }
+export function cyan(text) {
+    return pc.cyan(text);
+}
+export function yellow(text) {
+    return pc.yellow(text);
+}
 export function gray(text) {
     return pc.gray(text);
 }
 export function bold(text) {
     return pc.bold(text);
 }
+export function checkBadge() {
+    return pc.bgYellow(pc.black(" CHECK "));
+}
+export function mcpBadge() {
+    return pc.bgCyan(pc.black(" MCP "));
+}

package/dist/plain/watch.js

@@ -1,7 +1,9 @@
 import chokidar from "chokidar";
 import * as path from "node:path";
+import { logsPath } from "../lib/files.js";
 import { runStatusScan } from "../engine/status.js";
-import { blue, gray, green, red } from "./colors.js";
+import { createMcpActivityMonitor } from "../lib/logger.js";
+import { blue, checkBadge, gray, green, mcpBadge, red, yellow } from "./colors.js";
 const IGNORE_PATTERNS = [
     "**/node_modules/**",
     "**/.git/**",
@@ -25,7 +27,7 @@ function printSnapshot(reason) {
     }
     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")}`);
+    console.log(`${checkBadge()} ${blue(`[${ts}]`)} ${yellow(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}`);
     }
@@ -38,7 +40,7 @@ export async function runWatchPlain() {
     const ok = printSnapshot("initial");
     if (!ok)
         return;
-    console.log(`${gray("Watching for changes (plain mode). Press Ctrl+C to stop.")}`);
+    console.log(`${gray("Watching for changes and MCP activity (plain mode). Press Ctrl+C to stop.")}`);
     const watcher = chokidar.watch(".", {
         ignored: IGNORE_PATTERNS,
         persistent: true,
@@ -48,6 +50,15 @@ export async function runWatchPlain() {
             pollInterval: 50,
         },
     });
+    const logsWatcher = chokidar.watch(logsPath(), {
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 100,
+            pollInterval: 50,
+        },
+    });
+    const readNewMcpActivity = createMcpActivityMonitor();
     let debounceTimer = null;
     const shutdown = async () => {
         if (debounceTimer) {
@@ -55,8 +66,14 @@ export async function runWatchPlain() {
             debounceTimer = null;
         }
         await watcher.close();
+        await logsWatcher.close();
         console.log(gray("Stopped watch mode."));
     };
+    logsWatcher.on("change", () => {
+        for (const notice of readNewMcpActivity()) {
+            console.log(`${mcpBadge()} ${blue(`[${notice.event.ts}]`)} ${gray(notice.message)}`);
+        }
+    });
     watcher.on("all", (event, filepath) => {
         if (filepath.includes(`${path.sep}.tack${path.sep}`))
             return;

package/dist/ui/Logo.js

@@ -9,5 +9,5 @@ const LOGO = `
     ╚═╝   ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝
 `;
 export function Logo() {
-    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: "cyan", children: LOGO }), _jsx(Text, { dimColor: true, children: "  Architecture drift guard \u2022 v0.1.0" })] }));
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: "cyan", children: LOGO }), _jsx(Text, { dimColor: true, children: "  Architecture drift guard \u2022 v0.1.2" })] }));
 }