@pedrocivita/tocket 2.0.0 → 2.2.0

package/dist/tests/doctor.test.js

@@ -0,0 +1,102 @@
+import { describe, it, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { checkContentHealth, checkGitTracking, checkStaleness } from "../commands/doctor.cmd.js";
+describe("checkContentHealth", () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "tocket-doctor-content-"));
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("detects active focus in activeContext.md", () => {
+        mkdirSync(join(tempDir, ".context"), { recursive: true });
+        writeFileSync(join(tempDir, ".context", "activeContext.md"), "# Active Context\n\n## Current Focus\n\nWorking on feature X.\n\n## Recent Changes\n", "utf-8");
+        const results = checkContentHealth(tempDir);
+        const focusResult = results.find((r) => r.message.includes("active focus"));
+        assert.ok(focusResult);
+        assert.ok(focusResult.message.includes("active focus"));
+    });
+    it("warns when Current Focus is placeholder", () => {
+        const dir = join(tempDir, "placeholder");
+        mkdirSync(join(dir, ".context"), { recursive: true });
+        writeFileSync(join(dir, ".context", "activeContext.md"), "# Active Context\n\n## Current Focus\n\n_Describe what you're working on._\n", "utf-8");
+        const results = checkContentHealth(dir);
+        const focusResult = results.find((r) => r.message.includes("no meaningful"));
+        assert.ok(focusResult);
+    });
+    it("detects conventions in systemPatterns.md", () => {
+        writeFileSync(join(tempDir, ".context", "systemPatterns.md"), "# Patterns\n\n## Conventions\n\n- Code in English\n- ESM only\n", "utf-8");
+        const results = checkContentHealth(tempDir);
+        const patternResult = results.find((r) => r.message.includes("documented conventions"));
+        assert.ok(patternResult);
+    });
+    it("warns when systemPatterns.md has no conventions", () => {
+        const dir = join(tempDir, "empty-patterns");
+        mkdirSync(join(dir, ".context"), { recursive: true });
+        writeFileSync(join(dir, ".context", "systemPatterns.md"), "# Patterns\n\nNothing here yet.\n", "utf-8");
+        const results = checkContentHealth(dir);
+        const patternResult = results.find((r) => r.message.includes("no conventions"));
+        assert.ok(patternResult);
+    });
+    it("validates TOCKET.md contains protocol keywords", () => {
+        writeFileSync(join(tempDir, "TOCKET.md"), "# Tocket Protocol\n\nThe payload version is 2.0.\n", "utf-8");
+        const results = checkContentHealth(tempDir);
+        const tocketResult = results.find((r) => r.message.includes("protocol keywords"));
+        assert.ok(tocketResult);
+    });
+    it("checks agent config references .context/", () => {
+        writeFileSync(join(tempDir, "CLAUDE.md"), "# Claude\n\nRead `.context/` before acting.\n", "utf-8");
+        const results = checkContentHealth(tempDir);
+        const agentResult = results.find((r) => r.message.includes("CLAUDE.md references"));
+        assert.ok(agentResult);
+    });
+    it("warns when agent config does not reference .context/", () => {
+        const dir = join(tempDir, "no-ref");
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "CLAUDE.md"), "# Claude\n\nJust some instructions.\n", "utf-8");
+        const results = checkContentHealth(dir);
+        const agentResult = results.find((r) => r.message.includes("does not reference"));
+        assert.ok(agentResult);
+    });
+});
+describe("checkGitTracking", () => {
+    // Use the Tocket repo itself for git tests
+    const tocketRoot = join(import.meta.dirname, "..", "..");
+    it("returns results in a git repository", () => {
+        const results = checkGitTracking(tocketRoot);
+        assert.ok(results.length > 0);
+    });
+    it("detects .context/ is not gitignored", () => {
+        const results = checkGitTracking(tocketRoot);
+        const ignoreResult = results.find((r) => r.message.includes("gitignore"));
+        assert.ok(ignoreResult);
+        assert.ok(ignoreResult.message.includes("not gitignored"));
+    });
+    it("returns warn for non-git directory", () => {
+        const tempDir = mkdtempSync(join(tmpdir(), "tocket-doctor-git-"));
+        try {
+            const results = checkGitTracking(tempDir);
+            assert.ok(results.some((r) => r.message.includes("Not a git repository")));
+        }
+        finally {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+});
+describe("checkStaleness", () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "tocket-doctor-stale-"));
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("returns null when .context/activeContext.md does not exist", () => {
+        const result = checkStaleness(tempDir);
+        assert.equal(result, null);
+    });
+    it("returns null when file is fresh", () => {
+        mkdirSync(join(tempDir, ".context"), { recursive: true });
+        writeFileSync(join(tempDir, ".context", "activeContext.md"), "fresh", "utf-8");
+        const result = checkStaleness(tempDir);
+        assert.equal(result, null);
+    });
+});

package/dist/tests/eject.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/eject.test.js

@@ -0,0 +1,88 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync, } from "node:fs";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { EJECT_FILES, EJECT_DIRS } from "../commands/eject.cmd.js";
+describe("eject - constants", () => {
+    it("EJECT_FILES contains all expected files", () => {
+        assert.ok(EJECT_FILES.includes("TOCKET.md"));
+        assert.ok(EJECT_FILES.includes("CLAUDE.md"));
+        assert.ok(EJECT_FILES.includes("GEMINI.md"));
+        assert.ok(EJECT_FILES.includes(".cursorrules"));
+    });
+    it("EJECT_DIRS contains .context", () => {
+        assert.ok(EJECT_DIRS.includes(".context"));
+    });
+});
+describe("eject - removal logic", () => {
+    let tempDir;
+    before(() => {
+        tempDir = mkdtempSync(join(tmpdir(), "tocket-eject-test-"));
+    });
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("removes .context directory recursively", async () => {
+        const contextDir = join(tempDir, ".context");
+        mkdirSync(contextDir, { recursive: true });
+        writeFileSync(join(contextDir, "activeContext.md"), "test", "utf-8");
+        writeFileSync(join(contextDir, "systemPatterns.md"), "test", "utf-8");
+        assert.ok(existsSync(contextDir));
+        await rm(contextDir, { recursive: true, force: true });
+        assert.ok(!existsSync(contextDir));
+    });
+    it("removes individual eject files", async () => {
+        for (const file of EJECT_FILES) {
+            const fullPath = join(tempDir, file);
+            writeFileSync(fullPath, "test content", "utf-8");
+            assert.ok(existsSync(fullPath));
+            await rm(fullPath, { force: true });
+            assert.ok(!existsSync(fullPath));
+        }
+    });
+    it("does not error when files are already missing", async () => {
+        for (const file of EJECT_FILES) {
+            const fullPath = join(tempDir, file);
+            assert.ok(!existsSync(fullPath));
+            await rm(fullPath, { force: true });
+        }
+    });
+    it("does not error when .context is already missing", async () => {
+        const contextDir = join(tempDir, ".context");
+        assert.ok(!existsSync(contextDir));
+        await rm(contextDir, { recursive: true, force: true });
+    });
+});
+describe("eject - partial workspace", () => {
+    let tempDir;
+    before(() => {
+        tempDir = mkdtempSync(join(tmpdir(), "tocket-eject-partial-"));
+        mkdirSync(join(tempDir, ".context"), { recursive: true });
+        writeFileSync(join(tempDir, ".context", "activeContext.md"), "data", "utf-8");
+        writeFileSync(join(tempDir, "TOCKET.md"), "data", "utf-8");
+    });
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("removes existing files and skips missing ones", async () => {
+        assert.ok(existsSync(join(tempDir, ".context")));
+        assert.ok(existsSync(join(tempDir, "TOCKET.md")));
+        assert.ok(!existsSync(join(tempDir, "CLAUDE.md")));
+        for (const dir of EJECT_DIRS) {
+            const fullPath = join(tempDir, dir);
+            if (existsSync(fullPath)) {
+                await rm(fullPath, { recursive: true, force: true });
+            }
+        }
+        for (const file of EJECT_FILES) {
+            const fullPath = join(tempDir, file);
+            if (existsSync(fullPath)) {
+                await rm(fullPath, { force: true });
+            }
+        }
+        assert.ok(!existsSync(join(tempDir, ".context")));
+        assert.ok(!existsSync(join(tempDir, "TOCKET.md")));
+    });
+});

package/dist/tests/focus.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/focus.test.js

@@ -0,0 +1,130 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { replaceFocusSection } from "../commands/focus.cmd.js";
+describe("replaceFocusSection", () => {
+    it("replaces single-line focus content", () => {
+        const input = `# Active Context
+
+## Current Focus
+
+Old focus text here.
+
+## Recent Changes
+
+Some changes.
+`;
+        const result = replaceFocusSection(input, "New focus message");
+        assert.ok(result.includes("New focus message"));
+        assert.ok(!result.includes("Old focus text here"));
+        assert.ok(result.includes("## Recent Changes"));
+    });
+    it("replaces multi-line focus content", () => {
+        const input = `# Active Context
+
+## Current Focus
+
+**v2.0.0 — UX Overhaul.** Added purple theme, dashboard,
+config command, smart generate, and 29 new tests.
+All decisions resolved.
+
+## Recent Changes
+
+| Date | Change |
+`;
+        const result = replaceFocusSection(input, "Working on v2.1.0 features");
+        assert.ok(result.includes("Working on v2.1.0 features"));
+        assert.ok(!result.includes("v2.0.0"));
+        assert.ok(result.includes("## Recent Changes"));
+    });
+    it("preserves sections before and after Current Focus", () => {
+        const input = `# Active Context
+
+<!-- comment -->
+
+## Current Focus
+
+Old stuff.
+
+## Recent Changes
+
+Data here.
+
+## Open Decisions
+
+Decisions here.
+`;
+        const result = replaceFocusSection(input, "Brand new focus");
+        assert.ok(result.includes("# Active Context"));
+        assert.ok(result.includes("<!-- comment -->"));
+        assert.ok(result.includes("## Recent Changes"));
+        assert.ok(result.includes("Data here."));
+        assert.ok(result.includes("## Open Decisions"));
+        assert.ok(result.includes("Decisions here."));
+    });
+    it("appends section when ## Current Focus is missing", () => {
+        const input = `# Active Context
+
+## Recent Changes
+
+Some data.
+`;
+        const result = replaceFocusSection(input, "New focus");
+        assert.ok(result.includes("## Current Focus"));
+        assert.ok(result.includes("New focus"));
+        assert.ok(result.includes("## Recent Changes"));
+    });
+    it("handles Current Focus at end of file (no following section)", () => {
+        const input = `# Active Context
+
+## Current Focus
+
+Last section, nothing after this.
+`;
+        const result = replaceFocusSection(input, "Updated final section");
+        assert.ok(result.includes("Updated final section"));
+        assert.ok(!result.includes("Last section"));
+    });
+    it("handles empty content between heading and next section", () => {
+        const input = `## Current Focus
+
+## Recent Changes
+`;
+        const result = replaceFocusSection(input, "Fill the gap");
+        assert.ok(result.includes("Fill the gap"));
+        assert.ok(result.includes("## Recent Changes"));
+    });
+});
+describe("focus - file integration", () => {
+    let tempDir;
+    before(() => {
+        tempDir = mkdtempSync(join(tmpdir(), "tocket-focus-test-"));
+        mkdirSync(join(tempDir, ".context"), { recursive: true });
+    });
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("correctly round-trips through file read/write", () => {
+        const filePath = join(tempDir, ".context", "activeContext.md");
+        const original = `# Active Context - Test
+
+## Current Focus
+
+Old focus.
+
+## Recent Changes
+
+Nothing yet.
+`;
+        writeFileSync(filePath, original, "utf-8");
+        const content = readFileSync(filePath, "utf-8");
+        const updated = replaceFocusSection(content, "Round-tripped focus");
+        writeFileSync(filePath, updated, "utf-8");
+        const final = readFileSync(filePath, "utf-8");
+        assert.ok(final.includes("Round-tripped focus"));
+        assert.ok(!final.includes("Old focus"));
+        assert.ok(final.includes("## Recent Changes"));
+    });
+});

package/dist/tests/generate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/generate.test.js

@@ -0,0 +1,67 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { buildPayloadXml } from "../commands/generate.cmd.js";
+describe("buildPayloadXml", () => {
+    const baseTask = {
+        intent: "Add input validation",
+        scope: "src/commands/sync.cmd.ts",
+        priority: "medium",
+        skills: "",
+    };
+    it("produces valid XML with version 2.0", () => {
+        const xml = buildPayloadXml([baseTask]);
+        assert.ok(xml.includes('<payload version="2.0">'));
+        assert.ok(xml.includes("</payload>"));
+    });
+    it("includes intent, scope, and priority in meta", () => {
+        const xml = buildPayloadXml([baseTask]);
+        assert.ok(xml.includes("<intent>Add input validation</intent>"));
+        assert.ok(xml.includes("<scope>src/commands/sync.cmd.ts</scope>"));
+        assert.ok(xml.includes("<priority>medium</priority>"));
+    });
+    it("omits skills tag when skills is empty", () => {
+        const xml = buildPayloadXml([baseTask]);
+        assert.ok(!xml.includes("<skills>"));
+    });
+    it("includes skills tag when skills is provided", () => {
+        const task = { ...baseTask, skills: "core,lsp" };
+        const xml = buildPayloadXml([task]);
+        assert.ok(xml.includes("<skills>core,lsp</skills>"));
+    });
+    it("generates correct task ids for multiple tasks", () => {
+        const tasks = [
+            { ...baseTask, intent: "Task one" },
+            { ...baseTask, intent: "Task two" },
+            { ...baseTask, intent: "Task three" },
+        ];
+        const xml = buildPayloadXml(tasks);
+        assert.ok(xml.includes('task id="1"'));
+        assert.ok(xml.includes('task id="2"'));
+        assert.ok(xml.includes('task id="3"'));
+    });
+    it("includes action text from each task intent", () => {
+        const tasks = [
+            { ...baseTask, intent: "First action" },
+            { ...baseTask, intent: "Second action" },
+        ];
+        const xml = buildPayloadXml(tasks);
+        assert.ok(xml.includes("<action>First action</action>"));
+        assert.ok(xml.includes("<action>Second action</action>"));
+    });
+    it("includes validate section", () => {
+        const xml = buildPayloadXml([baseTask]);
+        assert.ok(xml.includes("<validate>"));
+        assert.ok(xml.includes("<check>"));
+    });
+    it("uses first task meta for the payload-level meta", () => {
+        const tasks = [
+            { intent: "Main goal", scope: "src/", priority: "high", skills: "api" },
+            { intent: "Secondary", scope: "test/", priority: "low", skills: "" },
+        ];
+        const xml = buildPayloadXml(tasks);
+        // Meta should come from first task
+        assert.ok(xml.includes("<intent>Main goal</intent>"));
+        assert.ok(xml.includes("<scope>src/</scope>"));
+        assert.ok(xml.includes("<priority>high</priority>"));
+    });
+});

package/dist/tests/git.test.js

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { isGitRepo, getStagedFiles, getModifiedFiles, getRecentCommits, getRecentCommitsRaw, getCurrentBranch, } from "../utils/git.js";
+import { isGitRepo, getStagedFiles, getModifiedFiles, getRecentCommits, getRecentCommitsRaw, getCurrentBranch, getLastCommitMessage, } from "../utils/git.js";
 // Use the Tocket repo itself for "in git" tests
 const tocketRoot = join(import.meta.dirname, "..", "..");
 describe("git - in a git repository", () => {
@@ -33,6 +33,11 @@ describe("git - in a git repository", () => {
         const files = getModifiedFiles(tocketRoot);
         assert.ok(Array.isArray(files));
     });
+    it("getLastCommitMessage returns a non-empty string", () => {
+        const msg = getLastCommitMessage(tocketRoot);
+        assert.ok(typeof msg === "string");
+        assert.ok(msg.length > 0);
+    });
 });
 describe("git - in a non-git directory", () => {
     const tempDir = mkdtempSync(join(tmpdir(), "tocket-git-test-"));
@@ -58,4 +63,7 @@ describe("git - in a non-git directory", () => {
     it("getCurrentBranch returns empty string", () => {
         assert.equal(getCurrentBranch(tempDir), "");
     });
+    it("getLastCommitMessage returns empty string", () => {
+        assert.equal(getLastCommitMessage(tempDir), "");
+    });
 });

package/dist/tests/init.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/init.test.js

@@ -0,0 +1,69 @@
+import { describe, it, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execSync } from "node:child_process";
+// Path to the built CLI
+const cliPath = join(import.meta.dirname, "..", "index.js");
+describe("init --minimal", () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "tocket-init-minimal-"));
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("creates only essential files with --minimal --name --description --force", () => {
+        execSync(`node "${cliPath}" init --minimal --name testproject --description "A test" --force`, { cwd: tempDir, encoding: "utf-8" });
+        // Essential files should exist
+        assert.ok(existsSync(join(tempDir, ".context", "activeContext.md")));
+        assert.ok(existsSync(join(tempDir, ".context", "systemPatterns.md")));
+        assert.ok(existsSync(join(tempDir, "TOCKET.md")));
+        // Non-essential files should NOT exist
+        assert.ok(!existsSync(join(tempDir, "CLAUDE.md")));
+        assert.ok(!existsSync(join(tempDir, "GEMINI.md")));
+        assert.ok(!existsSync(join(tempDir, ".cursorrules")));
+        assert.ok(!existsSync(join(tempDir, ".context", "productContext.md")));
+        assert.ok(!existsSync(join(tempDir, ".context", "techContext.md")));
+        assert.ok(!existsSync(join(tempDir, ".context", "progress.md")));
+    });
+});
+describe("init --name --description (non-interactive)", () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "tocket-init-flags-"));
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("creates full workspace without interactive prompts", () => {
+        execSync(`node "${cliPath}" init --name flagproject --description "Flag desc" --force`, { cwd: tempDir, encoding: "utf-8" });
+        // All 9 files should exist (not minimal)
+        assert.ok(existsSync(join(tempDir, ".context", "activeContext.md")));
+        assert.ok(existsSync(join(tempDir, ".context", "systemPatterns.md")));
+        assert.ok(existsSync(join(tempDir, ".context", "productContext.md")));
+        assert.ok(existsSync(join(tempDir, ".context", "techContext.md")));
+        assert.ok(existsSync(join(tempDir, ".context", "progress.md")));
+        assert.ok(existsSync(join(tempDir, "TOCKET.md")));
+        assert.ok(existsSync(join(tempDir, "CLAUDE.md")));
+        assert.ok(existsSync(join(tempDir, "GEMINI.md")));
+        assert.ok(existsSync(join(tempDir, ".cursorrules")));
+    });
+});
+describe("init --minimal file count", () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "tocket-init-count-"));
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("minimal creates exactly 3 files + 1 directory", () => {
+        execSync(`node "${cliPath}" init --minimal --name counttest --description "test" --force`, { cwd: tempDir, encoding: "utf-8" });
+        // Count files in .context/
+        const contextDir = join(tempDir, ".context");
+        assert.ok(existsSync(contextDir));
+        // Exactly 2 files in .context/
+        const contextFiles = ["activeContext.md", "systemPatterns.md"];
+        for (const f of contextFiles) {
+            assert.ok(existsSync(join(contextDir, f)), `${f} should exist`);
+        }
+        // These should NOT be in .context/ with minimal
+        const skippedContextFiles = ["productContext.md", "techContext.md", "progress.md"];
+        for (const f of skippedContextFiles) {
+            assert.ok(!existsSync(join(contextDir, f)), `${f} should not exist in minimal mode`);
+        }
+    });
+});

package/dist/tests/lint.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/lint.test.js

@@ -0,0 +1,120 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { lintActiveContext, lintSystemPatterns, lintProtocolSpec, lintAgentConfig, } from "../commands/lint.cmd.js";
+describe("lintActiveContext", () => {
+    const wellFormed = `# Active Context
+
+## Current Focus
+
+Working on feature X.
+
+## Recent Changes
+
+| Date | Change | Agent |
+|------|--------|-------|
+| 2026-02-25 | Added X | Claude |
+
+## Open Decisions
+
+- Should we use Y or Z?
+`;
+    it("passes all checks on well-formed content", () => {
+        const results = lintActiveContext(wellFormed);
+        const fails = results.filter((r) => r.severity === "fail");
+        assert.equal(fails.length, 0);
+    });
+    it("detects all three required sections", () => {
+        const results = lintActiveContext(wellFormed);
+        const sectionPasses = results.filter((r) => r.severity === "pass" && r.message.includes("Has ##"));
+        assert.equal(sectionPasses.length, 3);
+    });
+    it("detects populated focus", () => {
+        const results = lintActiveContext(wellFormed);
+        const focusPass = results.find((r) => r.message.includes("Focus is populated"));
+        assert.ok(focusPass);
+    });
+    it("warns on placeholder focus", () => {
+        const placeholder = wellFormed.replace("Working on feature X.", "_Describe what you're working on._");
+        const results = lintActiveContext(placeholder);
+        const focusWarn = results.find((r) => r.severity === "warn" && r.message.includes("Focus"));
+        assert.ok(focusWarn);
+        assert.ok(focusWarn.suggestion);
+    });
+    it("fails when Current Focus section is missing", () => {
+        const noFocus = "# Active Context\n\n## Recent Changes\n\n## Open Decisions\n";
+        const results = lintActiveContext(noFocus);
+        const fail = results.find((r) => r.severity === "fail" && r.message.includes("Current Focus"));
+        assert.ok(fail);
+    });
+    it("fails when Recent Changes section is missing", () => {
+        const noRecent = "# Active Context\n\n## Current Focus\n\nDoing X.\n\n## Open Decisions\n";
+        const results = lintActiveContext(noRecent);
+        const fail = results.find((r) => r.severity === "fail" && r.message.includes("Recent Changes"));
+        assert.ok(fail);
+    });
+    it("reports info when Open Decisions is empty", () => {
+        const emptyDecisions = wellFormed.replace("- Should we use Y or Z?", "_List anything unresolved._");
+        const results = lintActiveContext(emptyDecisions);
+        const info = results.find((r) => r.severity === "info" && r.message.includes("Open Decisions"));
+        assert.ok(info);
+    });
+});
+describe("lintSystemPatterns", () => {
+    it("passes when conventions are documented with bullet points", () => {
+        const content = "# Patterns\n\n- Code in English\n- ESM only\n";
+        const results = lintSystemPatterns(content);
+        const pass = results.find((r) => r.message.includes("documented conventions"));
+        assert.ok(pass);
+        assert.equal(pass.severity, "pass");
+    });
+    it("passes when conventions are documented with table rows", () => {
+        const content = "# Patterns\n\n| Convention | Detail |\n|---|---|\n| Language | English |\n";
+        const results = lintSystemPatterns(content);
+        const pass = results.find((r) => r.message.includes("documented conventions"));
+        assert.ok(pass);
+    });
+    it("warns when no conventions exist", () => {
+        const content = "# Patterns\n\nNothing here yet.\n";
+        const results = lintSystemPatterns(content);
+        const warn = results.find((r) => r.severity === "warn");
+        assert.ok(warn);
+        assert.ok(warn.suggestion);
+    });
+});
+describe("lintProtocolSpec", () => {
+    it("passes when payload and Memory Bank are referenced", () => {
+        const content = "# Protocol\n\nThe payload format...\n\nMemory Bank in .context/\n";
+        const results = lintProtocolSpec(content);
+        const passes = results.filter((r) => r.severity === "pass");
+        assert.equal(passes.length, 2);
+    });
+    it("warns when payload is not referenced", () => {
+        const content = "# Protocol\n\nMemory Bank in .context/\n";
+        const results = lintProtocolSpec(content);
+        const warn = results.find((r) => r.message.includes("payload"));
+        assert.ok(warn);
+        assert.equal(warn.severity, "warn");
+    });
+    it("warns when Memory Bank is not referenced", () => {
+        const content = "# Protocol\n\nPayload format is XML.\n";
+        const results = lintProtocolSpec(content);
+        const warn = results.find((r) => r.message.includes("Memory Bank"));
+        assert.ok(warn);
+        assert.equal(warn.severity, "warn");
+    });
+});
+describe("lintAgentConfig", () => {
+    it("passes when .context/ is referenced", () => {
+        const content = "# Claude\n\nRead .context/ before acting.\n";
+        const results = lintAgentConfig("CLAUDE.md", content);
+        assert.equal(results.length, 1);
+        assert.equal(results[0].severity, "pass");
+    });
+    it("warns when .context/ is not referenced", () => {
+        const content = "# Claude\n\nJust some instructions.\n";
+        const results = lintAgentConfig("CLAUDE.md", content);
+        assert.equal(results.length, 1);
+        assert.equal(results[0].severity, "warn");
+        assert.ok(results[0].suggestion);
+    });
+});

package/dist/tests/status.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/status.test.js

@@ -0,0 +1,34 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+describe("status - workspace detection", () => {
+    let tempDir;
+    before(() => {
+        tempDir = mkdtempSync(join(tmpdir(), "tocket-status-test-"));
+    });
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("detects absence of .context directory", () => {
+        const contextDir = join(tempDir, ".context");
+        assert.ok(!existsSync(contextDir));
+    });
+    it("detects presence of .context directory with files", () => {
+        const contextDir = join(tempDir, ".context");
+        mkdirSync(contextDir, { recursive: true });
+        writeFileSync(join(contextDir, "activeContext.md"), "# Active Context\n\n## Current Focus\n\nTesting status command.\n", "utf-8");
+        writeFileSync(join(contextDir, "systemPatterns.md"), "test", "utf-8");
+        writeFileSync(join(contextDir, "progress.md"), "# Progress\n\n## Session: 2026-02-25\n\n**Summary**: test\n", "utf-8");
+        assert.ok(existsSync(contextDir));
+        assert.ok(existsSync(join(contextDir, "activeContext.md")));
+    });
+    it("counts context files correctly", () => {
+        const contextDir = join(tempDir, ".context");
+        const expected = ["activeContext.md", "systemPatterns.md", "productContext.md", "techContext.md", "progress.md"];
+        const count = expected.filter((f) => existsSync(join(contextDir, f))).length;
+        // We created 3 files above
+        assert.equal(count, 3);
+    });
+});

package/dist/tests/validate.test.d.ts

@@ -0,0 +1 @@
+export {};