bitacora-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SK3L3TØR
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+Bitacora is a deterministic project memory CLI for agent-driven workflows. It stores project context in files, validates structure, and keeps state rebuildable.
+
+## Install
+
+```bash
+npm i -g bitacora-cli
+```
+
+## Usage
+
+Show help:
+
+```bash
+bitacora --help
+```
+
+Typical flow:
+
+```bash
+# init bitacora files structure and add SKILL
+bitacora init
+
+# ask your agent to complete bitacora
+# whith your project info. You can
+# complete bitacora by yourself if you wish.
+codex "$bitacora read and fill bitacora template with this project info"
+
+# plan some tasks
+codex (planner )"$bitacora plan the unit test for this repo and add separated tasks to bitacora"
+
+# use another agent
+codex "$bitacora implement the 003 track"
+```
+
+Use `--root <path>` on any command to target a different project directory.
+
+## What Each Bitacora File Stores
+
+- `bitacora/index.md`: memory map and session read order.
+- `bitacora/product.md`: project goals, scope, constraints, and non-goals.
+- `bitacora/tech-stack.md`: runtime/tooling/dependencies and technical rules.
+- `bitacora/workflow.md`: development method, quality gates, and handoff checklist.
+- `bitacora/ux-style-guide.md`: visual tokens and UX interaction rules.
+- `bitacora/tracks/tracks.md`: canonical track registry, current snapshot, and handoff summary.
+- `bitacora/tracks/TRACK-*/track.md`: per-track plan, tasks, decisions, and timestamped log.
+- `.agents/skills/bitacora/SKILL.md`: instructions agents follow to keep the memory system updated.
+
+## How Agents Read and Update Bitacora
+
+Recommended memory read order for agents:
+
+1. `bitacora/index.md`
+2. `bitacora/product.md`
+3. `bitacora/tech-stack.md`
+4. `bitacora/workflow.md`
+5. `bitacora/ux-style-guide.md`
+6. `bitacora/tracks/tracks.md`
+7. Active files in `bitacora/tracks/TRACK-*/track.md`
+
+Typical agent write operations:
+
+- `bitacora new-track`: create a new work unit.
+- `bitacora log --track-id ... --message ...`: append progress updates.
+- direct updates to `bitacora/tracks/TRACK-*/track.md`: tasks, decisions, execution details.
+- direct updates to `bitacora/tracks/tracks.md`: canonical project status and next action.
+- `bitacora validate` and `bitacora rebuild-state`: ensure memory remains valid and deterministic.
+
+## Agent Skill Integration
+
+When you run `bitacora init`, Bitacora also creates an agent skill at:
+
+```text
+.agents/skills/bitacora/SKILL.md
+```
+
+This skill guides agents to keep memory updated during implementation:
+
+- Read project memory before coding.
+- Create and update tracks as work progresses.
+- Log decisions and progress.
+- Keep a consistent handoff summary in `bitacora/tracks/tracks.md`.
+
+## Commands
+
+### `bitacora init [--force] [--root <path>]`
+
+Creates the `bitacora/` memory structure in the project root.
+
+- `--force`: recreates memory files if they already exist.
+- `--root <path>`: sets the project root (default: current directory).
+
+### `bitacora new-track [trackId] [--status <status>] [--priority <priority>] [--root <path>]`
+
+Creates a new track file. If `trackId` is omitted, Bitacora picks the next sequential ID.
+
+- `trackId`: optional explicit track ID (example: `TRACK-010`).
+- `--status <status>`: sets the initial track status.
+- `--priority <priority>`: sets the initial track priority.
+- `--root <path>`: sets the project root.
+
+### `bitacora log --track-id <trackId> --message <text> [--root <path>]`
+
+Appends a timestamped log entry to an existing track.
+
+- `--track-id <trackId>`: required track identifier.
+- `--message <text>`: required log message.
+- `--root <path>`: sets the project root.
+
+### `bitacora validate [--json] [--root <path>]`
+
+Validates the Bitacora file/folder structure and reports errors.
+
+- `--json`: prints validation output as JSON.
+- `--root <path>`: sets the project root.
+
+### `bitacora rebuild-state [--root <path>]`
+
+Revalidates memory and confirms deterministic state can be rebuilt from tracks.
+
+- `--root <path>`: sets the project root.
+
+## Exit Codes
+
+- `0`: success
+- `1`: validation or input error
+- `2`: unexpected runtime error
+
+## Development
+
+Internal development documentation is in `README-DEV.md`.

package/dist/src/cli.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCliProgram = createCliProgram;
+exports.runCli = runCli;
+const commander_1 = require("commander");
+const init_1 = require("./commands/init");
+const log_1 = require("./commands/log");
+const new_track_1 = require("./commands/new-track");
+const rebuild_state_1 = require("./commands/rebuild-state");
+const validate_1 = require("./commands/validate");
+const COMMAND_HELP_OVERVIEW = `
+Command details:
+  init
+    Creates the bitacora memory structure in the selected project root.
+    Options:
+      --force        Recreate bitacora memory if it already exists.
+      --root <path>  Project root path (default: current directory).
+
+  new-track [trackId]
+    Creates a new track file, automatically picking the next track id when omitted.
+    Options:
+      --status <status>      Initial status for the track.
+      --priority <priority>  Initial priority for the track.
+      --root <path>          Project root path (default: current directory).
+
+  validate
+    Validates bitacora files and folders against the expected deterministic format.
+    Options:
+      --json         Prints validation output as JSON.
+      --root <path>  Project root path (default: current directory).
+
+  rebuild-state
+    Revalidates track memory and confirms deterministic state can be rebuilt.
+    Options:
+      --root <path>  Project root path (default: current directory).
+
+  log
+    Appends a timestamped log entry to an existing track.
+    Options:
+      --track-id <trackId>  Track identifier.
+      --message <text>      Log entry message.
+      --root <path>         Project root path (default: current directory).
+`;
+function writeLine(writer, message) {
+    writer(message.endsWith("\n") ? message : `${message}\n`);
+}
+function createCliProgram(runtime = {}, onCommandExitCode) {
+    const now = runtime.now ?? (() => new Date().toISOString());
+    const cwd = runtime.cwd ?? (() => process.cwd());
+    const stdout = runtime.stdout ?? ((message) => process.stdout.write(message));
+    const stderr = runtime.stderr ?? ((message) => process.stderr.write(message));
+    const program = new commander_1.Command();
+    program
+        .name("bitacora")
+        .description("Deterministic agent-oriented project memory system")
+        .configureOutput({
+        writeOut: (message) => writeLine(stdout, message),
+        writeErr: (message) => writeLine(stderr, message)
+    });
+    program
+        .command("init")
+        .description("Create bitacora memory files and folders.")
+        .option("--force", "delete and recreate bitacora memory")
+        .option("--root <path>", "project root path")
+        .action((options) => {
+        const exitCode = (0, init_1.runInitCommand)({
+            rootDir: options.root ?? cwd(),
+            force: Boolean(options.force)
+        }, {
+            now,
+            onError: (message) => writeLine(stderr, message)
+        });
+        onCommandExitCode?.(exitCode);
+    });
+    program
+        .command("new-track [trackId]")
+        .description("Create a new track with optional id, status, and priority.")
+        .option("--status <status>", "track status")
+        .option("--priority <priority>", "track priority")
+        .option("--root <path>", "project root path")
+        .action((trackId, options) => {
+        const newTrackOptions = {
+            rootDir: options.root ?? cwd()
+        };
+        if (trackId !== undefined) {
+            newTrackOptions.trackId = trackId;
+        }
+        if (options.status !== undefined) {
+            newTrackOptions.status = options.status;
+        }
+        if (options.priority !== undefined) {
+            newTrackOptions.priority = options.priority;
+        }
+        const exitCode = (0, new_track_1.runNewTrackCommand)(newTrackOptions, {
+            now,
+            onError: (message) => writeLine(stderr, message)
+        });
+        onCommandExitCode?.(exitCode);
+    });
+    program
+        .command("validate")
+        .description("Validate bitacora structure and report errors.")
+        .option("--json", "output JSON validation result")
+        .option("--root <path>", "project root path")
+        .action((options) => {
+        const exitCode = (0, validate_1.runValidateCommand)({
+            rootDir: options.root ?? cwd(),
+            json: Boolean(options.json)
+        }, {
+            onOutput: (message) => writeLine(stdout, message)
+        });
+        onCommandExitCode?.(exitCode);
+    });
+    program
+        .command("rebuild-state")
+        .description("Revalidate memory and rebuild in-memory state from tracks.")
+        .option("--root <path>", "project root path")
+        .action((options) => {
+        const exitCode = (0, rebuild_state_1.runRebuildStateCommand)({
+            rootDir: options.root ?? cwd()
+        }, {
+            onOutput: (message) => writeLine(stdout, message),
+            onError: (message) => writeLine(stderr, message)
+        });
+        onCommandExitCode?.(exitCode);
+    });
+    program
+        .command("log")
+        .description("Append a log entry to a track.")
+        .requiredOption("--track-id <trackId>", "track identifier")
+        .requiredOption("--message <text>", "log message")
+        .option("--root <path>", "project root path")
+        .action((options) => {
+        const exitCode = (0, log_1.runLogCommand)({
+            rootDir: options.root ?? cwd(),
+            trackId: options.trackId,
+            message: options.message
+        }, {
+            now,
+            onError: (message) => writeLine(stderr, message)
+        });
+        onCommandExitCode?.(exitCode);
+    });
+    program.addHelpText("after", COMMAND_HELP_OVERVIEW);
+    return program;
+}
+async function runCli(argv, runtime = {}) {
+    let commandExitCode = 0;
+    const program = createCliProgram(runtime, (exitCode) => {
+        commandExitCode = exitCode;
+    });
+    program.exitOverride();
+    try {
+        await program.parseAsync(argv, { from: "node" });
+        return commandExitCode;
+    }
+    catch (error) {
+        if (error instanceof commander_1.CommanderError) {
+            return commandExitCode !== 0 ? commandExitCode : 1;
+        }
+        throw error;
+    }
+}
+if (require.main === module) {
+    runCli(process.argv)
+        .then((exitCode) => {
+        process.exitCode = exitCode;
+    })
+        .catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        process.exitCode = 2;
+    });
+}

package/dist/src/commands/init.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInitCommand = runInitCommand;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const templates_1 = require("../core/templates");
+function computeHash(content) {
+    return (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
+}
+function readSkillsLockFile(filePath) {
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return {
+            version: 1,
+            skills: {}
+        };
+    }
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+        if (typeof parsed !== "object" || parsed === null) {
+            return { version: 1, skills: {} };
+        }
+        const versionRaw = parsed.version;
+        const skillsRaw = parsed.skills;
+        const normalized = {};
+        if (typeof skillsRaw === "object" && skillsRaw !== null) {
+            for (const [name, value] of Object.entries(skillsRaw)) {
+                if (typeof value !== "object" || value === null) {
+                    continue;
+                }
+                const source = value.source;
+                const sourceType = value.sourceType;
+                const computedHash = value.computedHash;
+                if (typeof source === "string" &&
+                    typeof sourceType === "string" &&
+                    typeof computedHash === "string") {
+                    normalized[name] = { source, sourceType, computedHash };
+                }
+            }
+        }
+        return {
+            version: typeof versionRaw === "number" ? versionRaw : 1,
+            skills: normalized
+        };
+    }
+    catch {
+        return {
+            version: 1,
+            skills: {}
+        };
+    }
+}
+function writeSkillsLockFile(rootDir, skillContent) {
+    const lockPath = node_path_1.default.join(rootDir, "skills-lock.json");
+    const lock = readSkillsLockFile(lockPath);
+    lock.skills.bitacora = {
+        source: ".agents/skills/bitacora/SKILL.md",
+        sourceType: "local",
+        computedHash: computeHash(skillContent)
+    };
+    node_fs_1.default.writeFileSync(lockPath, `${JSON.stringify(lock, null, 2)}\n`, "utf8");
+}
+function runInitCommand(options, dependencies = {}) {
+    const now = dependencies.now ?? (() => new Date().toISOString());
+    const onError = dependencies.onError ?? (() => { });
+    const memoryRoot = node_path_1.default.join(options.rootDir, "bitacora");
+    if (node_fs_1.default.existsSync(memoryRoot)) {
+        if (!options.force) {
+            onError("bitacora already exists");
+            return 1;
+        }
+        node_fs_1.default.rmSync(memoryRoot, { recursive: true, force: true });
+    }
+    const createdAt = now();
+    const createdOnDate = createdAt.slice(0, 10);
+    const trackId = "TRACK-001";
+    node_fs_1.default.mkdirSync(node_path_1.default.join(memoryRoot, "tracks", trackId), { recursive: true });
+    node_fs_1.default.mkdirSync(node_path_1.default.join(options.rootDir, ".agents", "skills", "bitacora"), { recursive: true });
+    node_fs_1.default.writeFileSync(node_path_1.default.join(memoryRoot, "product.md"), (0, templates_1.createProductTemplate)(), "utf8");
+    node_fs_1.default.writeFileSync(node_path_1.default.join(memoryRoot, "tech-stack.md"), (0, templates_1.createTechStackTemplate)(), "utf8");
+    node_fs_1.default.writeFileSync(node_path_1.default.join(memoryRoot, "workflow.md"), (0, templates_1.createWorkflowTemplate)(), "utf8");
+    node_fs_1.default.writeFileSync(node_path_1.default.join(memoryRoot, "ux-style-guide.md"), (0, templates_1.createUxStyleGuideTemplate)(), "utf8");
+    node_fs_1.default.writeFileSync(node_path_1.default.join(memoryRoot, "index.md"), (0, templates_1.createIndexTemplate)(), "utf8");
+    const skillContent = (0, templates_1.createAgentSkillTemplate)();
+    node_fs_1.default.writeFileSync(node_path_1.default.join(options.rootDir, ".agents", "skills", "bitacora", "SKILL.md"), skillContent, "utf8");
+    writeSkillsLockFile(options.rootDir, skillContent);
+    node_fs_1.default.writeFileSync(node_path_1.default.join(memoryRoot, "tracks", "tracks.md"), (0, templates_1.createTracksRegistryTemplate)(createdOnDate), "utf8");
+    node_fs_1.default.writeFileSync(node_path_1.default.join(memoryRoot, "tracks", "tracks-template.md"), (0, templates_1.createTracksTemplate)(), "utf8");
+    node_fs_1.default.writeFileSync(node_path_1.default.join(memoryRoot, "tracks", trackId, "track.md"), (0, templates_1.createTrackTemplate)(trackId, "active", "medium", createdAt), "utf8");
+    return 0;
+}

package/dist/src/commands/log.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLogCommand = runLogCommand;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const parser_1 = require("../core/parser");
+function getTrackDirectories(rootDir) {
+    const tracksRoot = node_path_1.default.join(rootDir, "bitacora", "tracks");
+    if (!node_fs_1.default.existsSync(tracksRoot)) {
+        return [];
+    }
+    return node_fs_1.default
+        .readdirSync(tracksRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort((left, right) => left.localeCompare(right));
+}
+function runLogCommand(options, dependencies = {}) {
+    const now = dependencies.now ?? (() => new Date().toISOString());
+    const onError = dependencies.onError ?? (() => { });
+    const trackPath = node_path_1.default.join(options.rootDir, "bitacora", "tracks", options.trackId, "track.md");
+    if (!node_fs_1.default.existsSync(trackPath)) {
+        onError(`Track not found: ${options.trackId}`);
+        return 1;
+    }
+    const timestamp = now();
+    const normalized = node_fs_1.default.readFileSync(trackPath, "utf8").replace(/\r\n/g, "\n");
+    try {
+        (0, parser_1.parseTrackMarkdown)(normalized);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        onError(message);
+        return 1;
+    }
+    const updatedHeader = normalized.replace(/^updated_at:\s*.+$/m, `updated_at: ${timestamp}`);
+    const line = `- ${timestamp} | ${options.message}`;
+    const finalContent = updatedHeader.endsWith("\n")
+        ? `${updatedHeader}${line}\n`
+        : `${updatedHeader}\n${line}\n`;
+    node_fs_1.default.writeFileSync(trackPath, finalContent, "utf8");
+    return 0;
+}

package/dist/src/commands/new-track.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runNewTrackCommand = runNewTrackCommand;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const templates_1 = require("../core/templates");
+const validator_1 = require("../core/validator");
+const TRACK_ID_REGEX = /^TRACK-\d{3}$/;
+function getTrackDirectories(rootDir) {
+    const tracksRoot = node_path_1.default.join(rootDir, "bitacora", "tracks");
+    if (!node_fs_1.default.existsSync(tracksRoot)) {
+        return [];
+    }
+    return node_fs_1.default
+        .readdirSync(tracksRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort((left, right) => left.localeCompare(right));
+}
+function computeNextTrackId(trackDirectories) {
+    const lastTrackId = trackDirectories.at(-1);
+    if (!lastTrackId) {
+        return "TRACK-001";
+    }
+    const trackNumber = Number.parseInt(lastTrackId.slice("TRACK-".length), 10);
+    const nextTrackNumber = Number.isFinite(trackNumber) ? trackNumber + 1 : 1;
+    return `TRACK-${String(nextTrackNumber).padStart(3, "0")}`;
+}
+function runNewTrackCommand(options, dependencies = {}) {
+    const now = dependencies.now ?? (() => new Date().toISOString());
+    const onError = dependencies.onError ?? (() => { });
+    const validation = (0, validator_1.validateMemory)(options.rootDir);
+    if (!validation.ok) {
+        onError(`Memory structure is invalid: ${validation.errors.join("; ")}`);
+        return 1;
+    }
+    const trackDirectories = getTrackDirectories(options.rootDir);
+    const nextTrackId = computeNextTrackId(trackDirectories);
+    const desiredTrackId = options.trackId ?? nextTrackId;
+    if (!TRACK_ID_REGEX.test(desiredTrackId)) {
+        onError("Invalid track ID format. Expected TRACK-###");
+        return 1;
+    }
+    if (options.trackId && options.trackId !== nextTrackId) {
+        onError(`Explicit track ID must match next sequential ID: ${nextTrackId}`);
+        return 1;
+    }
+    const trackDir = node_path_1.default.join(options.rootDir, "bitacora", "tracks", desiredTrackId);
+    if (node_fs_1.default.existsSync(trackDir)) {
+        onError(`Track already exists: ${desiredTrackId}`);
+        return 1;
+    }
+    const status = options.status ?? "active";
+    const priority = options.priority ?? "medium";
+    const timestamp = now();
+    node_fs_1.default.mkdirSync(trackDir, { recursive: true });
+    node_fs_1.default.writeFileSync(node_path_1.default.join(trackDir, "track.md"), (0, templates_1.createTrackTemplate)(desiredTrackId, status, priority, timestamp), "utf8");
+    return 0;
+}

package/dist/src/commands/rebuild-state.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRebuildStateCommand = runRebuildStateCommand;
+const validator_1 = require("../core/validator");
+function runRebuildStateCommand(options, dependencies = {}) {
+    const onOutput = dependencies.onOutput ?? (() => { });
+    const onError = dependencies.onError ?? (() => { });
+    const validation = (0, validator_1.validateMemory)(options.rootDir);
+    if (!validation.ok) {
+        onError(`Memory structure is invalid: ${validation.errors.join("; ")}`);
+        return 1;
+    }
+    onOutput("State rebuilt");
+    return 0;
+}

package/dist/src/commands/validate.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runValidateCommand = runValidateCommand;
+const validator_1 = require("../core/validator");
+function runValidateCommand(options, dependencies = {}) {
+    const onOutput = dependencies.onOutput ?? (() => { });
+    const result = (0, validator_1.validateMemory)(options.rootDir);
+    if (options.json) {
+        onOutput(`${JSON.stringify(result, null, 2)}\n`);
+        return result.ok ? 0 : 1;
+    }
+    if (result.ok) {
+        onOutput("Validation passed");
+        return 0;
+    }
+    onOutput("Validation failed");
+    for (const error of result.errors) {
+        onOutput(error);
+    }
+    return 1;
+}

package/dist/src/core/boot.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boot = boot;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const state_builder_1 = require("./state-builder");
+const validator_1 = require("./validator");
+function readRequiredFile(rootDir, relativePath) {
+    const targetPath = node_path_1.default.join(rootDir, relativePath);
+    if (!node_fs_1.default.existsSync(targetPath)) {
+        throw new Error("Memory structure is invalid");
+    }
+    return node_fs_1.default.readFileSync(targetPath, "utf8");
+}
+function boot(rootDir, loaders = {}) {
+    const index = readRequiredFile(rootDir, node_path_1.default.join("bitacora", "index.md"));
+    const product = readRequiredFile(rootDir, node_path_1.default.join("bitacora", "product.md"));
+    const techStack = readRequiredFile(rootDir, node_path_1.default.join("bitacora", "tech-stack.md"));
+    const workflow = readRequiredFile(rootDir, node_path_1.default.join("bitacora", "workflow.md"));
+    const uxStyleGuide = readRequiredFile(rootDir, node_path_1.default.join("bitacora", "ux-style-guide.md"));
+    loaders.loadContext?.({ index, product, techStack, workflow, uxStyleGuide });
+    const tracksRoot = node_path_1.default.join(rootDir, "bitacora", "tracks");
+    if (!node_fs_1.default.existsSync(tracksRoot)) {
+        throw new Error("Memory structure is invalid");
+    }
+    const trackFiles = node_fs_1.default
+        .readdirSync(tracksRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => node_path_1.default.join(tracksRoot, entry.name, "track.md"))
+        .sort((left, right) => left.localeCompare(right));
+    loaders.loadTracks?.(trackFiles);
+    const validation = (0, validator_1.validateMemory)(rootDir);
+    if (!validation.ok) {
+        throw new Error(`Memory structure is invalid: ${validation.errors.join("; ")}`);
+    }
+    return (0, state_builder_1.buildStateFromTracks)(validation.tracks);
+}

package/dist/src/core/parser.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTrackMarkdown = parseTrackMarkdown;
+const types_1 = require("../types");
+function parseFrontmatterBlock(markdown) {
+    const normalized = markdown.replace(/\r\n/g, "\n");
+    const parts = normalized.split("\n");
+    if (parts[0] !== "---") {
+        throw new Error("Missing frontmatter");
+    }
+    const endIndex = parts.indexOf("---", 1);
+    if (endIndex === -1) {
+        throw new Error("Missing frontmatter");
+    }
+    const raw = {};
+    for (const line of parts.slice(1, endIndex)) {
+        if (line.trim() === "") {
+            continue;
+        }
+        const separatorIndex = line.indexOf(":");
+        if (separatorIndex === -1) {
+            continue;
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        const value = line.slice(separatorIndex + 1).trim();
+        raw[key] = value;
+    }
+    return raw;
+}
+function parseSections(markdown) {
+    const normalized = markdown.replace(/\r\n/g, "\n");
+    const parts = normalized.split("\n---\n");
+    const body = parts.length > 1 ? parts.slice(1).join("\n---\n") : "";
+    const sectionMap = {};
+    const headings = ["Overview", "Tasks", "Decisions", "Log"];
+    for (let index = 0; index < headings.length; index += 1) {
+        const heading = headings[index];
+        if (heading === undefined) {
+            continue;
+        }
+        const startToken = `# ${heading}\n`;
+        const startIndex = body.indexOf(startToken);
+        if (startIndex === -1) {
+            continue;
+        }
+        const contentStart = startIndex + startToken.length;
+        const nextHeading = headings[index + 1];
+        const endIndex = nextHeading === undefined
+            ? body.length
+            : body.indexOf(`# ${nextHeading}\n`, contentStart);
+        const content = body.slice(contentStart, endIndex === -1 ? body.length : endIndex).trim();
+        sectionMap[heading.toLowerCase()] = content;
+    }
+    return sectionMap;
+}
+function parseTrackMarkdown(markdown) {
+    const frontmatter = parseFrontmatterBlock(markdown);
+    const sections = parseSections(markdown);
+    const getRequiredField = (field) => {
+        const value = frontmatter[field];
+        if (!value) {
+            throw new Error(`Missing frontmatter field: ${field}`);
+        }
+        return value;
+    };
+    const requiredFrontmatterFields = [
+        "track_id",
+        "status",
+        "priority",
+        "created_at",
+        "updated_at"
+    ];
+    for (const field of requiredFrontmatterFields) {
+        getRequiredField(field);
+    }
+    const status = getRequiredField("status");
+    const priority = getRequiredField("priority");
+    const trackId = getRequiredField("track_id");
+    const createdAt = getRequiredField("created_at");
+    const updatedAt = getRequiredField("updated_at");
+    if (!types_1.TRACK_STATUSES.includes(status)) {
+        throw new Error("Invalid status");
+    }
+    if (!types_1.TRACK_PRIORITIES.includes(priority)) {
+        throw new Error("Invalid priority");
+    }
+    const requiredSections = ["overview", "tasks", "decisions", "log"];
+    for (const requiredSection of requiredSections) {
+        if (!(requiredSection in sections)) {
+            const heading = requiredSection.charAt(0).toUpperCase() + requiredSection.slice(1);
+            throw new Error(`Missing section: ${heading}`);
+        }
+    }
+    return {
+        frontmatter: {
+            track_id: trackId,
+            status: status,
+            priority: priority,
+            created_at: createdAt,
+            updated_at: updatedAt
+        },
+        sections: {
+            overview: sections.overview ?? "",
+            tasks: sections.tasks ?? "",
+            decisions: sections.decisions ?? "",
+            log: sections.log ?? ""
+        }
+    };
+}

package/dist/src/core/state-builder.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildIndexFromTracks = buildIndexFromTracks;
+exports.buildStateFromTracks = buildStateFromTracks;
+const node_path_1 = __importDefault(require("node:path"));
+function getTrackNumber(trackId) {
+    const match = /^TRACK-(\d{3})$/.exec(trackId);
+    if (!match) {
+        return Number.MAX_SAFE_INTEGER;
+    }
+    const numericPart = match[1];
+    if (!numericPart) {
+        return Number.MAX_SAFE_INTEGER;
+    }
+    return Number.parseInt(numericPart, 10);
+}
+function sortTrackEntries(entries) {
+    return [...entries].sort((left, right) => getTrackNumber(left.track_id) - getTrackNumber(right.track_id));
+}
+function buildIndexFromTracks(tracks) {
+    const entries = tracks.map((track) => ({
+        track_id: track.frontmatter.track_id,
+        status: track.frontmatter.status,
+        priority: track.frontmatter.priority,
+        created_at: track.frontmatter.created_at,
+        updated_at: track.frontmatter.updated_at,
+        path: node_path_1.default.join("bitacora", "tracks", track.directoryName, "track.md").replace(/\\/g, "/")
+    }));
+    return sortTrackEntries(entries);
+}
+function buildStateFromTracks(tracks) {
+    const indexEntries = buildIndexFromTracks(tracks);
+    return {
+        project: {
+            memory_root: "bitacora",
+            context_paths: [
+                "bitacora/product.md",
+                "bitacora/tech-stack.md",
+                "bitacora/workflow.md",
+                "bitacora/ux-style-guide.md"
+            ],
+            track_count: tracks.length
+        },
+        active_tracks: sortTrackEntries(indexEntries.filter((entry) => entry.status === "active")),
+        blocked_tracks: sortTrackEntries(indexEntries.filter((entry) => entry.status === "blocked")),
+        completed_tracks: sortTrackEntries(indexEntries.filter((entry) => entry.status === "completed"))
+    };
+}

package/dist/src/core/templates.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIndexTemplate = createIndexTemplate;
+exports.createProductTemplate = createProductTemplate;
+exports.createTechStackTemplate = createTechStackTemplate;
+exports.createWorkflowTemplate = createWorkflowTemplate;
+exports.createUxStyleGuideTemplate = createUxStyleGuideTemplate;
+exports.createAgentSkillTemplate = createAgentSkillTemplate;
+exports.createTracksRegistryTemplate = createTracksRegistryTemplate;
+exports.createTracksTemplate = createTracksTemplate;
+exports.createTrackTemplate = createTrackTemplate;
+function createIndexTemplate() {
+    return `# Bitacora Index
+
+Quick map of where to find each kind of project memory.
+
+## Read Order (Session Start)
+
+1. \`product.md\` (product goals, constraints, and scope)
+2. \`tech-stack.md\` (runtime, dependencies, and technical rules)
+3. \`workflow.md\` (execution process and mandatory handoff rules)
+4. \`ux-style-guide.md\` (visual style tokens and UX constraints)
+5. \`tracks/tracks.md\` (canonical project status and next actions)
+6. \`tracks/TRACK-*/track.md\` (details for active or relevant tracks)
+
+## File Index
+
+### Root Docs
+- \`product.md\`: what the project is, why it exists, and what is in scope.
+- \`tech-stack.md\`: runtime, dependencies, architecture constraints, and technical rules.
+- \`workflow.md\`: TDD process, quality gates, and mandatory handoff rules.
+- \`ux-style-guide.md\`: colors, typography, spacing, and interaction style rules.
+
+### \`tracks/\`
+- \`tracks/tracks.md\`: canonical project status, registry, and handoff summary.
+- \`tracks/tracks-template.md\`: template used when creating new tracks.
+- \`tracks/TRACK-001/track.md\`: first active track created by \`bitacora init\`.
+- \`tracks/TRACK-*/track.md\`: per-track execution details (overview, tasks, decisions, log).
+
+Mandatory behavior:
+
+- Always read this index at session start.
+- Always update memory before session end.
+- Always keep \`tracks/tracks.md\` aligned with track-level changes.
+`;
+}
+function createProductTemplate() {
+    return `# Product
+
+## Name
+<project name>
+
+## One-liner
+<single sentence describing the product and core value>
+
+## Problem
+<what pain/problem this project solves>
+
+## Goals
+- <goal 1>
+- <goal 2>
+
+## Non-goals
+- <out of scope 1>
+- <out of scope 2>
+
+## Success Criteria
+- <measurable outcome 1>
+- <measurable outcome 2>
+`;
+}
+function createTechStackTemplate() {
+    return `# Tech Stack
+
+## Runtime
+- Node.js <version>
+- TypeScript
+
+## Tooling
+- <test runner>
+- <build tool>
+- <dev runtime>
+
+## Runtime Dependencies
+- <dependency>: <why it exists>
+
+## Core Technical Rules
+- Keep core/domain modules isolated from infra adapters.
+- Keep persistence and external integrations behind explicit contracts.
+- Keep logs and outputs deterministic when possible.
+`;
+}
+function createWorkflowTemplate() {
+    return `# Workflow
+
+## Development Method
+- Mandatory TDD: RED -> GREEN -> REFACTOR.
+- Prefer small vertical slices with deterministic verification.
+
+## Implementation Rules
+- Start from domain/core behavior before adapters when feasible.
+- Keep side effects isolated behind explicit interfaces.
+- Keep tests focused, deterministic, and close to behavior.
+
+## Non-negotiable Session Rules
+- Always read \`bitacora/index.md\` at the beginning of every session.
+- Always update \`bitacora/tracks/tracks.md\` after meaningful implementation changes.
+- Always write handoff updates before ending a session.
+
+## Handoff Checklist
+- What changed
+- Tests run (exact commands + result)
+- Current TDD phase
+- Blockers or assumptions
+- Single best next action
+`;
+}
+function createUxStyleGuideTemplate() {
+    return `# UX Style Guide
+
+## Visual Tokens
+- Background: <hex>
+- Surface: <hex>
+- Surface alt: <hex>
+- Text: <hex>
+- Muted text: <hex>
+- Primary accent: <hex>
+- Success: <hex>
+- Warning: <hex>
+- Error: <hex>
+- Border: <hex>
+
+## Layout / Spacing
+- Base spacing unit: 4px grid.
+- Panel gap: <value>.
+- Panel padding: <value>.
+- Header padding: <value>.
+
+## Borders / Depth
+- Border style: <width and color>.
+- Shadow style: <value>.
+- Effects policy: avoid visual noise; prefer crisp, readable UI.
+
+## Typography
+- Font family: <font stack>.
+- Heading style: <size/weight>.
+- Body style: <size/weight>.
+- Label style: <size/weight/casing>.
+
+## Components / Interaction Rules
+- Buttons: <primary and secondary behavior>.
+- Inputs: <states and readability constraints>.
+- Data views: <tables/charts/cards style constraints>.
+- Feedback states: define clear success/warning/error treatment.
+
+## Motion / Performance
+- Keep animations minimal and purposeful.
+- Prefer readability and responsiveness over decoration.
+- Avoid expensive full-screen effects in frequent update paths.
+`;
+}
+function createAgentSkillTemplate() {
+    return `---
+name: bitacora
+description: Keep deterministic project memory in bitacora/ and update it continuously during implementation sessions.
+version: 1.0.0
+type: local
+source: .agents/skills/bitacora/SKILL.md
+---
+
+# Bitacora Skill
+
+Use this skill to keep deterministic project memory in \`bitacora/\` and to update it continuously while implementing changes.
+
+Canonical skill file path: \`.agents/skills/bitacora/SKILL.md\`.
+
+## Mandatory Session Protocol
+- Always read \`bitacora/index.md\` at session start.
+- Always read \`bitacora/product.md\`, \`bitacora/tech-stack.md\`, \`bitacora/workflow.md\`, and \`bitacora/ux-style-guide.md\` before making code changes.
+- Always read \`bitacora/tracks/tracks.md\` and the active \`bitacora/tracks/TRACK-*/track.md\` files before implementation.
+- Always write memory updates before ending the session.
+
+## What To Update During Work
+- Update \`bitacora/tracks/TRACK-*/track.md\` while work progresses (tasks, decisions, logs).
+- Update \`bitacora/tracks/tracks.md\` after meaningful changes, including current status and next action.
+- Update root docs when product/tech/workflow/ux assumptions change.
+
+## File Map (Where To Look)
+- \`bitacora/product.md\`: scope, goals, constraints, non-goals.
+- \`bitacora/tech-stack.md\`: runtime, dependencies, architecture rules.
+- \`bitacora/workflow.md\`: TDD rules, handoff checklist, quality gates.
+- \`bitacora/ux-style-guide.md\`: visual tokens, layout, typography, interaction style.
+- \`bitacora/tracks/tracks.md\`: canonical status registry and handoff summary.
+- \`bitacora/tracks/tracks-template.md\`: template for new tracks.
+- \`bitacora/tracks/TRACK-*/track.md\`: per-track execution details.
+
+## Manual Bootstrap (No CLI Required)
+If the CLI is unavailable, create this exact structure manually:
+
+\`\`\`text
+bitacora/
+  index.md
+  product.md
+  tech-stack.md
+  workflow.md
+  ux-style-guide.md
+  tracks/
+    tracks.md
+    tracks-template.md
+    TRACK-001/
+      track.md
+\`\`\`
+
+Required initial metadata for \`TRACK-001\` in \`track.md\` frontmatter:
+- \`track_id: TRACK-001\`
+- \`status: active\`
+- \`priority: medium\`
+- \`created_at\` and \`updated_at\` as ISO timestamps
+
+Required track sections in \`track.md\`:
+- \`# Overview\`
+- \`# Tasks\`
+- \`# Decisions\`
+- \`# Log\`
+
+## End Of Session Checklist
+- Confirm \`bitacora/tracks/tracks.md\` is updated.
+- Confirm active \`TRACK-*/track.md\` files include latest decisions and logs.
+`;
+}
+function createTracksRegistryTemplate(date) {
+    return `# Tracks
+
+> Canonical project status and handoff registry.
+>
+> Last updated: ${date}
+>
+> Rule: update this file after meaningful implementation changes.
+
+## Snapshot
+
+- Project: <project-name>
+- Current status: TRACK-001 initialized
+- Active tracks: TRACK-001
+
+## Track Registry
+
+| ID | Title | Status | Phase | Last Update | Notes |
+| --- | --- | --- | --- | --- | --- |
+| TRACK-001 | Bootstrap memory | active | red | ${date} | Initial track created by \`bitacora init\` |
+
+## Session Handoff (Required)
+
+After each substantial change, update:
+
+1. This file (\`tracks/tracks.md\`).
+2. Affected \`tracks/TRACK-*/track.md\` files.
+
+Minimum handoff payload:
+- Track(s) touched
+- Tests run (exact command + result)
+- Current TDD phase
+- Blockers/assumptions
+- Next recommended action
+`;
+}
+function createTracksTemplate() {
+    return `# Tracks Template
+
+Use this template when creating a new track.
+
+## Header
+
+- Track ID: \`TRACK-XYZ\`
+- Title: <short title>
+- Status: \`active | blocked | completed | archived\`
+- Priority: \`low | medium | high\`
+- Updated at: \`YYYY-MM-DDTHH:mm:ss.sssZ\`
+
+## Overview
+
+- Goal: <one sentence>
+- Scope:
+  - <item>
+  - <item>
+- Out of scope:
+  - <item>
+
+## Tasks
+
+- [ ] RED: <failing test>
+- [ ] GREEN: <minimal implementation>
+- [ ] REFACTOR: <safe cleanup>
+
+## Decisions
+
+- <YYYY-MM-DD> | <decision and rationale>
+
+## Log
+
+- <YYYY-MM-DDTHH:mm:ss.sssZ> | <progress update>
+`;
+}
+function createTrackTemplate(trackId, status, priority, isoTimestamp) {
+    return `---
+track_id: ${trackId}
+status: ${status}
+priority: ${priority}
+created_at: ${isoTimestamp}
+updated_at: ${isoTimestamp}
+---
+
+# Overview
+
+- Goal: <one sentence>
+- Scope:
+  - <item>
+  - <item>
+
+# Tasks
+
+- [ ] RED: add failing test(s)
+- [ ] GREEN: implement minimal passing behavior
+- [ ] REFACTOR: improve without changing behavior
+
+# Decisions
+
+- ${isoTimestamp} | track created
+
+# Log
+- ${isoTimestamp} | track created
+`;
+}

package/dist/src/core/validator.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMemory = validateMemory;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const parser_1 = require("./parser");
+const TRACK_DIRECTORY_REGEX = /^TRACK-(\d{3})$/;
+function getTrackDirectories(rootDir) {
+    const tracksRoot = node_path_1.default.join(rootDir, "bitacora", "tracks");
+    if (!node_fs_1.default.existsSync(tracksRoot)) {
+        return [];
+    }
+    return node_fs_1.default
+        .readdirSync(tracksRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort();
+}
+function loadTracks(rootDir, errors) {
+    const tracksRoot = node_path_1.default.join(rootDir, "bitacora", "tracks");
+    const trackDirs = getTrackDirectories(rootDir);
+    const tracks = [];
+    for (const directoryName of trackDirs) {
+        const filePath = node_path_1.default.join(tracksRoot, directoryName, "track.md");
+        if (!node_fs_1.default.existsSync(filePath)) {
+            errors.push(`Missing track.md: ${directoryName}`);
+            continue;
+        }
+        const markdown = node_fs_1.default.readFileSync(filePath, "utf8");
+        try {
+            const parsed = (0, parser_1.parseTrackMarkdown)(markdown);
+            tracks.push({
+                ...parsed,
+                filePath,
+                directoryName
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            errors.push(`Invalid track file ${directoryName}: ${message}`);
+        }
+    }
+    return tracks;
+}
+function validateTrackNumbering(trackDirectories, errors) {
+    const numericTrackIds = trackDirectories
+        .map((directoryName) => {
+        const match = TRACK_DIRECTORY_REGEX.exec(directoryName);
+        if (!match) {
+            errors.push(`Invalid track directory name: ${directoryName}`);
+            return null;
+        }
+        const numericPart = match[1];
+        if (!numericPart) {
+            errors.push(`Invalid track directory name: ${directoryName}`);
+            return null;
+        }
+        return Number.parseInt(numericPart, 10);
+    })
+        .filter((trackNumber) => trackNumber !== null)
+        .sort((left, right) => left - right);
+    for (let index = 0; index < numericTrackIds.length; index += 1) {
+        const expected = index + 1;
+        const actual = numericTrackIds[index];
+        if (actual !== expected) {
+            const expectedId = `TRACK-${String(expected).padStart(3, "0")}`;
+            const actualId = `TRACK-${String(actual).padStart(3, "0")}`;
+            errors.push(`Track numbering gap: expected ${expectedId} but found ${actualId}`);
+            return;
+        }
+    }
+}
+function validateDuplicateTrackIds(tracks, errors) {
+    const seen = new Set();
+    for (const track of tracks) {
+        const trackId = track.frontmatter.track_id;
+        if (seen.has(trackId)) {
+            errors.push(`Duplicate track_id: ${trackId}`);
+            continue;
+        }
+        seen.add(trackId);
+    }
+}
+function parseLogTimestamp(line) {
+    const match = /^-\s+([^|]+)\s+\|\s+.+$/.exec(line.trim());
+    if (!match) {
+        return null;
+    }
+    const timestampRaw = match[1];
+    if (!timestampRaw) {
+        return null;
+    }
+    const timestamp = Date.parse(timestampRaw.trim());
+    return Number.isNaN(timestamp) ? null : timestamp;
+}
+function validateUpdatedAtAgainstLogEntries(tracks, errors) {
+    for (const track of tracks) {
+        const updatedAt = Date.parse(track.frontmatter.updated_at);
+        if (Number.isNaN(updatedAt)) {
+            continue;
+        }
+        const latestLogTimestamp = track.sections.log
+            .split("\n")
+            .map((line) => parseLogTimestamp(line))
+            .filter((timestamp) => timestamp !== null)
+            .reduce((latest, current) => (latest === null || current > latest ? current : latest), null);
+        if (latestLogTimestamp !== null && updatedAt < latestLogTimestamp) {
+            errors.push(`updated_at is older than latest log entry for ${track.frontmatter.track_id}`);
+        }
+    }
+}
+function validateMemory(rootDir) {
+    const errors = [];
+    const trackDirectories = getTrackDirectories(rootDir);
+    validateTrackNumbering(trackDirectories, errors);
+    const tracks = loadTracks(rootDir, errors);
+    validateDuplicateTrackIds(tracks, errors);
+    validateUpdatedAtAgainstLogEntries(tracks, errors);
+    errors.sort((left, right) => left.localeCompare(right));
+    return {
+        ok: errors.length === 0,
+        errors,
+        tracks
+    };
+}

package/dist/src/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMemory = exports.buildStateFromTracks = exports.buildIndexFromTracks = exports.parseTrackMarkdown = exports.boot = void 0;
+var boot_1 = require("./core/boot");
+Object.defineProperty(exports, "boot", { enumerable: true, get: function () { return boot_1.boot; } });
+var parser_1 = require("./core/parser");
+Object.defineProperty(exports, "parseTrackMarkdown", { enumerable: true, get: function () { return parser_1.parseTrackMarkdown; } });
+var state_builder_1 = require("./core/state-builder");
+Object.defineProperty(exports, "buildIndexFromTracks", { enumerable: true, get: function () { return state_builder_1.buildIndexFromTracks; } });
+Object.defineProperty(exports, "buildStateFromTracks", { enumerable: true, get: function () { return state_builder_1.buildStateFromTracks; } });
+var validator_1 = require("./core/validator");
+Object.defineProperty(exports, "validateMemory", { enumerable: true, get: function () { return validator_1.validateMemory; } });

package/dist/src/types/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRACK_PRIORITIES = exports.TRACK_STATUSES = void 0;
+exports.TRACK_STATUSES = ["active", "completed", "blocked", "archived"];
+exports.TRACK_PRIORITIES = ["low", "medium", "high"];

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "bitacora-cli",
+  "version": "1.0.0",
+  "description": "Deterministic agent-oriented project memory system. Provides structured Markdown-based long-term memory, strict validation, state reconstruction, and an enforcement CLI with agent skill integration to guide and limit agent behavior.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/N0M4D-D3V/bitacora.git"
+  },
+  "homepage": "https://github.com/N0M4D-D3V/bitacora#readme",
+  "bugs": {
+    "url": "https://github.com/N0M4D-D3V/bitacora/issues"
+  },
+  "keywords": [
+    "bitacora",
+    "deterministic",
+    "memory",
+    "cli",
+    "agent"
+  ],
+  "license": "MIT",
+  "author": "SK3L3TØR",
+  "files": [
+    "dist/src/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "commonjs",
+  "main": "dist/src/index.js",
+  "bin": {
+    "bitacora": "dist/src/cli.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:unit": "vitest run",
+    "start": "tsx src/cli.ts"
+  },
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2",
+    "vitest": "^3.0.9"
+  }
+}