opensquid 0.5.441 → 0.5.449

package/dist/codex/activate.test.js

@@ -1,229 +0,0 @@
-import * as crypto from "node:crypto";
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { CodexActivationCache, evaluateDetection, extractCodexId, isCodexActive, } from "./activate.js";
-import { installCodex } from "./store.js";
-let tmpCwd;
-let tmpStore;
-beforeEach(async () => {
-    const uniq = crypto.randomUUID();
-    tmpCwd = path.join(os.tmpdir(), `oscli-activate-cwd-${uniq}`);
-    tmpStore = path.join(os.tmpdir(), `oscli-activate-store-${uniq}`);
-    await fs.mkdir(tmpCwd, { recursive: true });
-    await fs.mkdir(tmpStore, { recursive: true });
-});
-afterEach(async () => {
-    await fs.rm(tmpCwd, { recursive: true, force: true });
-    await fs.rm(tmpStore, { recursive: true, force: true });
-});
-// ---------------------------------------------------------------------
-// extractCodexId
-// ---------------------------------------------------------------------
-describe("extractCodexId", () => {
-    it("extracts id from codex-suffixed description", () => {
-        expect(extractCodexId("before any push (codex:loop-engineering-workflow)")).toBe("loop-engineering-workflow");
-    });
-    it("trims trailing whitespace tolerantly", () => {
-        expect(extractCodexId("rule (codex:x)  ")).toBe("x");
-    });
-    it("returns null when no suffix", () => {
-        expect(extractCodexId("some legacy lesson description")).toBeNull();
-    });
-    it("returns null for non-id-shaped content in parens", () => {
-        expect(extractCodexId("see (PR #42)")).toBeNull();
-        expect(extractCodexId("see (codex:Bad-Id)")).toBeNull();
-    });
-});
-// ---------------------------------------------------------------------
-// evaluateDetection — filesystem signals
-// ---------------------------------------------------------------------
-describe("evaluateDetection: file_exists", () => {
-    it("matches when file present", async () => {
-        await fs.writeFile(path.join(tmpCwd, "package.json"), "{}", "utf8");
-        expect(await evaluateDetection({ kind: "file_exists", path: "package.json" }, tmpCwd)).toBe(true);
-    });
-    it("misses when file absent", async () => {
-        expect(await evaluateDetection({ kind: "file_exists", path: "package.json" }, tmpCwd)).toBe(false);
-    });
-    it("misses when path is a directory", async () => {
-        await fs.mkdir(path.join(tmpCwd, "package.json"));
-        expect(await evaluateDetection({ kind: "file_exists", path: "package.json" }, tmpCwd)).toBe(false);
-    });
-});
-describe("evaluateDetection: dir_exists", () => {
-    it("matches when dir present", async () => {
-        await fs.mkdir(path.join(tmpCwd, "src/components/atoms"), { recursive: true });
-        expect(await evaluateDetection({ kind: "dir_exists", path: "src/components/atoms" }, tmpCwd)).toBe(true);
-    });
-    it("misses when dir absent", async () => {
-        expect(await evaluateDetection({ kind: "dir_exists", path: "src/components/atoms" }, tmpCwd)).toBe(false);
-    });
-});
-describe("evaluateDetection: file_match (JSON)", () => {
-    it("matches when dotted path resolves to a truthy value", async () => {
-        await fs.writeFile(path.join(tmpCwd, "package.json"), JSON.stringify({ dependencies: { react: "^19.0.0" } }), "utf8");
-        expect(await evaluateDetection({
-            kind: "file_match",
-            path: "package.json",
-            matches: { "dependencies.react": ">=19" },
-        }, tmpCwd)).toBe(true);
-    });
-    it("misses when dotted path is missing", async () => {
-        await fs.writeFile(path.join(tmpCwd, "package.json"), JSON.stringify({ name: "x" }), "utf8");
-        expect(await evaluateDetection({
-            kind: "file_match",
-            path: "package.json",
-            matches: { "dependencies.react": ">=19" },
-        }, tmpCwd)).toBe(false);
-    });
-    it("misses when file is absent", async () => {
-        expect(await evaluateDetection({
-            kind: "file_match",
-            path: "package.json",
-            matches: { "dependencies.react": ">=19" },
-        }, tmpCwd)).toBe(false);
-    });
-});
-describe("evaluateDetection: file_glob", () => {
-    it("matches when min_count met", async () => {
-        await fs.mkdir(path.join(tmpCwd, "data"));
-        await fs.writeFile(path.join(tmpCwd, "data/sample1.h5ad"), "", "utf8");
-        await fs.writeFile(path.join(tmpCwd, "data/sample2.h5ad"), "", "utf8");
-        expect(await evaluateDetection({ kind: "file_glob", pattern: "**/*.h5ad", min_count: 2 }, tmpCwd)).toBe(true);
-    });
-    it("misses when below min_count", async () => {
-        await fs.mkdir(path.join(tmpCwd, "data"));
-        await fs.writeFile(path.join(tmpCwd, "data/sample1.h5ad"), "", "utf8");
-        expect(await evaluateDetection({ kind: "file_glob", pattern: "**/*.h5ad", min_count: 2 }, tmpCwd)).toBe(false);
-    });
-    it("skips node_modules + dot-dirs during walk", async () => {
-        await fs.mkdir(path.join(tmpCwd, "node_modules/foo"), { recursive: true });
-        await fs.mkdir(path.join(tmpCwd, ".git"), { recursive: true });
-        await fs.writeFile(path.join(tmpCwd, "node_modules/foo/x.h5ad"), "", "utf8");
-        await fs.writeFile(path.join(tmpCwd, ".git/x.h5ad"), "", "utf8");
-        expect(await evaluateDetection({ kind: "file_glob", pattern: "**/*.h5ad", min_count: 1 }, tmpCwd)).toBe(false);
-    });
-});
-describe("evaluateDetection: user_pinned", () => {
-    it("always returns true", async () => {
-        expect(await evaluateDetection({ kind: "user_pinned" }, tmpCwd)).toBe(true);
-    });
-});
-describe("evaluateDetection: all_of / any_of", () => {
-    it("all_of requires every condition", async () => {
-        await fs.writeFile(path.join(tmpCwd, "a"), "", "utf8");
-        expect(await evaluateDetection({
-            kind: "all_of",
-            conditions: [
-                { kind: "file_exists", path: "a" },
-                { kind: "file_exists", path: "b" },
-            ],
-        }, tmpCwd)).toBe(false);
-        await fs.writeFile(path.join(tmpCwd, "b"), "", "utf8");
-        expect(await evaluateDetection({
-            kind: "all_of",
-            conditions: [
-                { kind: "file_exists", path: "a" },
-                { kind: "file_exists", path: "b" },
-            ],
-        }, tmpCwd)).toBe(true);
-    });
-    it("any_of accepts any single match", async () => {
-        await fs.writeFile(path.join(tmpCwd, "a"), "", "utf8");
-        expect(await evaluateDetection({
-            kind: "any_of",
-            conditions: [
-                { kind: "file_exists", path: "a" },
-                { kind: "file_exists", path: "b" },
-            ],
-        }, tmpCwd)).toBe(true);
-    });
-});
-describe("evaluateDetection: memory_match / conversation_signal", () => {
-    it("memory_match defaults to true (runtime context not available here)", async () => {
-        expect(await evaluateDetection({ kind: "memory_match", memory_kind: "profession", value: "clinician" }, tmpCwd)).toBe(true);
-    });
-    it("conversation_signal defaults to true", async () => {
-        expect(await evaluateDetection({ kind: "conversation_signal", contains: ["case law"] }, tmpCwd)).toBe(true);
-    });
-});
-// ---------------------------------------------------------------------
-// isCodexActive
-// ---------------------------------------------------------------------
-describe("isCodexActive", () => {
-    function focused(detected_by) {
-        return {
-            id: "test",
-            version: "1.0.0",
-            detected_by,
-        };
-    }
-    it("composite codexes are inactive (includes activate via their own detected_by)", async () => {
-        const composite = {
-            id: "x",
-            kind: "composite",
-            version: "1.0.0",
-            includes: [{ id: "a", semver: ">=1" }],
-        };
-        expect(await isCodexActive(composite, tmpCwd)).toBe(false);
-    });
-    it("focused codex with no detected_by defaults to active", async () => {
-        expect(await isCodexActive(focused(undefined), tmpCwd)).toBe(true);
-        expect(await isCodexActive(focused([]), tmpCwd)).toBe(true);
-    });
-    it("top-level detected_by list = OR semantics", async () => {
-        await fs.writeFile(path.join(tmpCwd, "tsconfig.json"), "{}", "utf8");
-        expect(await isCodexActive(focused([
-            { kind: "file_exists", path: "Cargo.toml" }, // miss
-            { kind: "file_exists", path: "tsconfig.json" }, // hit
-        ]), tmpCwd)).toBe(true);
-    });
-    it("no matching detection → inactive", async () => {
-        expect(await isCodexActive(focused([{ kind: "file_exists", path: "Cargo.toml" }]), tmpCwd)).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------
-// CodexActivationCache
-// ---------------------------------------------------------------------
-describe("CodexActivationCache", () => {
-    it("returns true for an installed user_pinned codex", async () => {
-        const codex = {
-            id: "wf",
-            version: "1.0.0",
-            activation_scope: "user",
-            detected_by: [{ kind: "user_pinned" }],
-        };
-        await installCodex(codex, { rootDir: tmpStore });
-        const cache = new CodexActivationCache(tmpCwd, tmpStore);
-        expect(await cache.isActive("wf")).toBe(true);
-    });
-    it("returns false when detected_by doesn't match cwd", async () => {
-        const codex = {
-            id: "react-19",
-            version: "1.0.0",
-            detected_by: [{ kind: "file_exists", path: "package.json" }],
-        };
-        await installCodex(codex, { rootDir: tmpStore });
-        const cache = new CodexActivationCache(tmpCwd, tmpStore);
-        expect(await cache.isActive("react-19")).toBe(false);
-    });
-    it("returns false for non-installed codex (stale lesson reference)", async () => {
-        const cache = new CodexActivationCache(tmpCwd, tmpStore);
-        expect(await cache.isActive("ghost-codex")).toBe(false);
-    });
-    it("caches the same decision across repeated lookups", async () => {
-        const codex = {
-            id: "wf",
-            version: "1.0.0",
-            detected_by: [{ kind: "user_pinned" }],
-        };
-        await installCodex(codex, { rootDir: tmpStore });
-        const cache = new CodexActivationCache(tmpCwd, tmpStore);
-        const a = await cache.isActive("wf");
-        const b = await cache.isActive("wf");
-        expect(a).toBe(true);
-        expect(b).toBe(true);
-    });
-});

package/dist/codex/bundled-default/bundled-default.test.js

@@ -1,161 +0,0 @@
-/**
- * Verifies that the bundled-default codex round-trips through the
- * codex parser. Acts as both a fixture test (proves the schema
- * additions actually parse) and a CI tripwire (any drift between
- * codex YAML + zod schema fails here first).
- *
- * Part of drift-as-codex chunk 1 (#146).
- */
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-import { parseCodexYaml } from "../parse.js";
-import { isFocusedCodex } from "../types.js";
-const HERE = path.dirname(fileURLToPath(import.meta.url));
-const BUNDLED_DEFAULT_PATH = path.join(HERE, "codex.yaml");
-describe("bundled-default codex", () => {
-    it("parses without errors", async () => {
-        const yaml = await fs.readFile(BUNDLED_DEFAULT_PATH, "utf8");
-        expect(() => parseCodexYaml(yaml)).not.toThrow();
-    });
-    it("is a focused codex with the expected id + version", async () => {
-        const yaml = await fs.readFile(BUNDLED_DEFAULT_PATH, "utf8");
-        const c = parseCodexYaml(yaml);
-        expect(isFocusedCodex(c)).toBe(true);
-        if (!isFocusedCodex(c))
-            return;
-        expect(c.id).toBe("opensquid-default");
-        expect(c.version).toBe("1.0.0");
-    });
-    it("declares the four standard drifts (never-amend / no-implicit-push / substrate-purity / no-force-push-main)", async () => {
-        const yaml = await fs.readFile(BUNDLED_DEFAULT_PATH, "utf8");
-        const c = parseCodexYaml(yaml);
-        if (!isFocusedCodex(c))
-            throw new Error("expected focused codex");
-        const ids = (c.drifts ?? []).map((d) => d.id);
-        expect(ids).toEqual(expect.arrayContaining([
-            "never-amend",
-            "no-implicit-push",
-            "substrate-purity",
-            "no-force-push-main",
-        ]));
-    });
-    it("declares the standard-7-phase workflow with all 7 phases", async () => {
-        const yaml = await fs.readFile(BUNDLED_DEFAULT_PATH, "utf8");
-        const c = parseCodexYaml(yaml);
-        if (!isFocusedCodex(c))
-            throw new Error("expected focused codex");
-        const wf = (c.workflows ?? []).find((w) => w.id === "standard-7-phase");
-        expect(wf).toBeDefined();
-        expect(wf?.phases.map((p) => p.name)).toEqual([
-            "pre_research",
-            "learn",
-            "code",
-            "test",
-            "audit",
-            "post_research",
-            "fix",
-        ]);
-        expect(c.default_workflow_id).toBe("standard-7-phase");
-    });
-    it("marks `fix` phase as optional (skip-with-reason allowed)", async () => {
-        const yaml = await fs.readFile(BUNDLED_DEFAULT_PATH, "utf8");
-        const c = parseCodexYaml(yaml);
-        if (!isFocusedCodex(c))
-            throw new Error("expected focused codex");
-        const wf = (c.workflows ?? []).find((w) => w.id === "standard-7-phase");
-        const fixPhase = wf?.phases.find((p) => p.name === "fix");
-        expect(fixPhase?.required).toBe(false);
-    });
-    it("declares the PATCH-ONLY pre-1.0 versioning policy", async () => {
-        const yaml = await fs.readFile(BUNDLED_DEFAULT_PATH, "utf8");
-        const c = parseCodexYaml(yaml);
-        if (!isFocusedCodex(c))
-            throw new Error("expected focused codex");
-        const versioning = (c.policies ?? []).find((p) => p.kind === "versioning");
-        expect(versioning).toBeDefined();
-        if (versioning?.kind !== "versioning")
-            return;
-        expect(versioning.params.allowed_slots).toEqual(["patch"]);
-        expect(versioning.params.per_commit_required).toBe(true);
-        expect(versioning.params.slot_for?.bug_fix).toBe("patch");
-        expect(versioning.params.slot_for?.feature).toBe("patch");
-        expect(versioning.params.slot_for?.breaking).toBe("patch");
-    });
-    it("declares a phase_logged policy that references the standard workflow", async () => {
-        const yaml = await fs.readFile(BUNDLED_DEFAULT_PATH, "utf8");
-        const c = parseCodexYaml(yaml);
-        if (!isFocusedCodex(c))
-            throw new Error("expected focused codex");
-        const phasePolicy = (c.policies ?? []).find((p) => p.kind === "phase_logged");
-        expect(phasePolicy).toBeDefined();
-        if (phasePolicy?.kind !== "phase_logged")
-            return;
-        expect(phasePolicy.params.workflow_id).toBe("standard-7-phase");
-        expect(phasePolicy.params.enforce_on).toContain("git_commit");
-    });
-    it("ports the five load-bearing honesty-ledger claims", async () => {
-        const yaml = await fs.readFile(BUNDLED_DEFAULT_PATH, "utf8");
-        const c = parseCodexYaml(yaml);
-        if (!isFocusedCodex(c))
-            throw new Error("expected focused codex");
-        const ids = (c.claims ?? []).map((cl) => cl.id);
-        expect(ids).toEqual(expect.arrayContaining(["telegram-sent", "pushed", "tagged", "phase-logged", "fmt-clippy"]));
-    });
-    it("uses any_of evidence for the telegram-sent claim (proves recursive schema works)", async () => {
-        const yaml = await fs.readFile(BUNDLED_DEFAULT_PATH, "utf8");
-        const c = parseCodexYaml(yaml);
-        if (!isFocusedCodex(c))
-            throw new Error("expected focused codex");
-        const telegramSent = (c.claims ?? []).find((cl) => cl.id === "telegram-sent");
-        expect(telegramSent?.evidence.kind).toBe("any_of");
-        if (telegramSent?.evidence.kind !== "any_of")
-            return;
-        expect(telegramSent.evidence.options.length).toBeGreaterThanOrEqual(2);
-    });
-});
-describe("FocusedCodex schema — drift-as-codex additions (chunk 1)", () => {
-    it("accepts a codex with no drift-as-codex sections (backward compat)", () => {
-        const c = parseCodexYaml(`id: legacy\nversion: "1.0.0"\n`);
-        expect(isFocusedCodex(c)).toBe(true);
-    });
-    it("rejects a drift entry with an unknown severity", () => {
-        const bad = `
-id: bad
-version: "1.0.0"
-drifts:
-  - id: x
-    tool: Bash
-    trigger: { kind: bash_regex, pattern: "foo" }
-    lesson: y
-    severity: maybe
-    message: hi
-`;
-        expect(() => parseCodexYaml(bad)).toThrow();
-    });
-    it("rejects a workflow with zero phases", () => {
-        const bad = `
-id: bad
-version: "1.0.0"
-workflows:
-  - id: empty
-    enforce_on: [git_commit]
-    phases: []
-`;
-        expect(() => parseCodexYaml(bad)).toThrow();
-    });
-    it("rejects a versioning policy with empty allowed_slots", () => {
-        const bad = `
-id: bad
-version: "1.0.0"
-policies:
-  - id: bad-pol
-    kind: versioning
-    params:
-      per_commit_required: true
-      allowed_slots: []
-`;
-        expect(() => parseCodexYaml(bad)).toThrow();
-    });
-});

package/dist/codex/cli-publish.test.js

@@ -1,133 +0,0 @@
-/**
- * Tests for #116 — codex-install auto-publish to CLAUDE.md.
- *
- * Covers `publishSeededLessonToClaudeMd` directly so we don't need a
- * real engine subprocess to verify the auto-publish behavior.
- */
-import * as crypto from "node:crypto";
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { publishSeededLessonToClaudeMd } from "./cli.js";
-let tmpDir;
-let claudeMdPath;
-const INSTALLED_BLOCK = [
-    "# CLAUDE.md",
-    "",
-    "<!-- opensquid-automation:start v0.4.0 -->",
-    "Some opensquid automation guidance lives here.",
-    "",
-    "<!-- opensquid-rules:start (auto-managed) -->",
-    "(no promoted lessons yet — this block populates as `lesson.promote`",
-    "succeeds for user-endorsed candidates)",
-    "<!-- opensquid-rules:end -->",
-    "<!-- opensquid-automation:end -->",
-    "",
-].join("\n");
-beforeEach(async () => {
-    tmpDir = path.join(os.tmpdir(), `opensquid-publish-test-${crypto.randomUUID()}`);
-    await fs.mkdir(tmpDir, { recursive: true });
-    claudeMdPath = path.join(tmpDir, "CLAUDE.md");
-    await fs.writeFile(claudeMdPath, INSTALLED_BLOCK, "utf8");
-});
-afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true });
-});
-describe("publishSeededLessonToClaudeMd", () => {
-    it("appends a new line into the rules block", async () => {
-        const appended = await publishSeededLessonToClaudeMd({
-            engineLessonId: "les-abc12345",
-            description: "before doing X (codex:test-codex)",
-            createdAt: "2026-05-15T22:00:00Z",
-            codexLessonId: "do-x",
-        }, { target: claudeMdPath });
-        expect(appended).toBe(true);
-        const content = await fs.readFile(claudeMdPath, "utf8");
-        expect(content).toContain("(lesson:les-abc12345)");
-        expect(content).toContain("before doing X (codex:test-codex)");
-        expect(content).toContain("promoted 2026-05-15T22:00:00Z");
-        // Placeholder line should be gone.
-        expect(content).not.toContain("(no promoted lessons yet");
-    });
-    it("is idempotent — second call with same id is a no-op", async () => {
-        const first = await publishSeededLessonToClaudeMd({
-            engineLessonId: "les-dup",
-            description: "x",
-            createdAt: "2026-05-15T22:00:00Z",
-            codexLessonId: "x",
-        }, { target: claudeMdPath });
-        expect(first).toBe(true);
-        const second = await publishSeededLessonToClaudeMd({
-            engineLessonId: "les-dup",
-            description: "x",
-            createdAt: "2026-05-15T22:01:00Z",
-            codexLessonId: "x",
-        }, { target: claudeMdPath });
-        expect(second).toBe(false);
-        const content = await fs.readFile(claudeMdPath, "utf8");
-        const matches = content.match(/\(lesson:les-dup\)/g);
-        expect(matches?.length).toBe(1);
-    });
-    it("appends multiple distinct lesson ids in order", async () => {
-        await publishSeededLessonToClaudeMd({
-            engineLessonId: "les-1",
-            description: "first",
-            createdAt: "2026-05-15T22:00:00Z",
-            codexLessonId: "a",
-        }, { target: claudeMdPath });
-        await publishSeededLessonToClaudeMd({
-            engineLessonId: "les-2",
-            description: "second",
-            createdAt: "2026-05-15T22:00:01Z",
-            codexLessonId: "b",
-        }, { target: claudeMdPath });
-        await publishSeededLessonToClaudeMd({
-            engineLessonId: "les-3",
-            description: "third",
-            createdAt: "2026-05-15T22:00:02Z",
-            codexLessonId: "c",
-        }, { target: claudeMdPath });
-        const content = await fs.readFile(claudeMdPath, "utf8");
-        const idx1 = content.indexOf("first");
-        const idx2 = content.indexOf("second");
-        const idx3 = content.indexOf("third");
-        expect(idx1).toBeGreaterThan(0);
-        expect(idx2).toBeGreaterThan(idx1);
-        expect(idx3).toBeGreaterThan(idx2);
-    });
-    it("returns false when engineLessonId is undefined", async () => {
-        const appended = await publishSeededLessonToClaudeMd({
-            engineLessonId: undefined,
-            description: "no id",
-            createdAt: "2026-05-15T22:00:00Z",
-            codexLessonId: "no-id",
-        }, { target: claudeMdPath });
-        expect(appended).toBe(false);
-        const content = await fs.readFile(claudeMdPath, "utf8");
-        expect(content).toContain("(no promoted lessons yet");
-    });
-    it("returns false (silent no-op) when CLAUDE.md is missing", async () => {
-        const appended = await publishSeededLessonToClaudeMd({
-            engineLessonId: "les-orphan",
-            description: "orphan",
-            createdAt: "2026-05-15T22:00:00Z",
-            codexLessonId: "orphan",
-        }, { target: path.join(tmpDir, "does-not-exist.md") });
-        expect(appended).toBe(false);
-    });
-    it("returns false when CLAUDE.md exists but has no rules block", async () => {
-        const noBlockPath = path.join(tmpDir, "no-block.md");
-        await fs.writeFile(noBlockPath, "# CLAUDE.md\n\nNo opensquid block here.\n", "utf8");
-        const appended = await publishSeededLessonToClaudeMd({
-            engineLessonId: "les-orphan2",
-            description: "orphan2",
-            createdAt: "2026-05-15T22:00:00Z",
-            codexLessonId: "orphan2",
-        }, { target: noBlockPath });
-        expect(appended).toBe(false);
-        // Original file is untouched.
-        const content = await fs.readFile(noBlockPath, "utf8");
-        expect(content).toBe("# CLAUDE.md\n\nNo opensquid block here.\n");
-    });
-});

package/dist/codex/cli.d.ts

@@ -1,35 +0,0 @@
-export declare class CodexCliError extends Error {
-    readonly hint?: string | undefined;
-    constructor(message: string, hint?: string | undefined);
-}
-/**
- * Iterate the codex's seed lessons and seed each into the engine's
- * lesson store at `promoted` status via `lesson.create` with
- * `authored_by: "pack"` + `seed_as_promoted: true`. The engine treats
- * Pack provenance as user-equivalent (codex install = user authorship).
- */
-/**
- * Append a single seeded lesson's one-line summary to the user's
- * CLAUDE.md `opensquid-rules` block. Exported for direct unit testing
- * — covers the auto-publish behavior without spawning the real engine.
- *
- * Returns true if a new line was appended, false if it was an idempotent
- * no-op (lesson id already present, or rules block missing). Failure is
- * non-fatal and logged to stderr — CLAUDE.md is downstream display, not
- * source of truth.
- */
-export declare function publishSeededLessonToClaudeMd(args: {
-    /** The engine-assigned `les-...` id for the seeded lesson. */
-    engineLessonId: string | undefined;
-    /** Human-readable description (typically `${trigger} (codex:${codexId})`). */
-    description: string;
-    /** ISO timestamp; defaults to now if engine doesn't return one. */
-    createdAt: string;
-    /** Codex-local lesson id, used only for error logging context. */
-    codexLessonId: string;
-}, options?: {
-    target?: string;
-}): Promise<boolean>;
-export type CodexCliCmd = "install" | "list" | "remove" | "doctor" | "export";
-export declare function runCodexCli(cmd: CodexCliCmd, argv: string[]): Promise<void>;
-//# sourceMappingURL=cli.d.ts.map

package/dist/codex/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src.legacy/codex/cli.ts"],"names":[],"mappings":"AAwDA,qBAAa,aAAc,SAAQ,KAAK;aAGpB,IAAI,CAAC,EAAE,MAAM;gBAD7B,OAAO,EAAE,MAAM,EACC,IAAI,CAAC,EAAE,MAAM,YAAA;CAKhC;AA8RD;;;;;GAKG;AACH;;;;;;;;;GASG;AACH,wBAAsB,6BAA6B,CACjD,IAAI,EAAE;IACJ,8DAA8D;IAC9D,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,8EAA8E;IAC9E,WAAW,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,aAAa,EAAE,MAAM,CAAC;CACvB,EACD,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAChC,OAAO,CAAC,OAAO,CAAC,CAiBlB;AA2QD,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE9E,wBAAsB,WAAW,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAmBjF"}