@openfleet-tools/cli 0.0.0-stage → 0.1.0

package/dist/commands/project.js

@@ -0,0 +1,207 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import { appendEvent, readEvents } from "../events.js";
+import { deleteBranch, removeWorktree, tryGit } from "../git.js";
+import { launch } from "../launcher.js";
+import { newState, readState, updateState } from "../state.js";
+import { writeJson } from "../fsutil.js";
+import { listProjectNames, projectPaths, requireWorkspace, UserError, validateProjectName, } from "../workspace.js";
+import { out, warn } from "./output.js";
+const INACTIVE = new Set(["done", "cancelled"]);
+function childRepos(state) {
+    return new Set(Object.values(state.children).map((c) => c.repo));
+}
+/** Other active projects touching any of the same repos. */
+export function findOverlaps(ws, name) {
+    const mine = childRepos(readState(projectPaths(ws, name)));
+    if (!mine.size)
+        return [];
+    const result = [];
+    for (const other of listProjectNames(ws)) {
+        if (other === name)
+            continue;
+        let state;
+        try {
+            state = readState(projectPaths(ws, other));
+        }
+        catch {
+            continue;
+        }
+        if (INACTIVE.has(state.status))
+            continue;
+        const shared = [...childRepos(state)].filter((r) => mine.has(r));
+        if (shared.length)
+            result.push({ project: other, repos: shared });
+    }
+    return result;
+}
+function warnOverlaps(ws, name) {
+    for (const o of findOverlaps(ws, name)) {
+        warn(`Project "${o.project}" is also active on ${o.repos.join(", ")}. Changes may conflict.`);
+    }
+}
+export function createProject(ws, name) {
+    const p = projectPaths(ws, name);
+    if (fs.existsSync(p.state)) {
+        throw new UserError(`Project "${name}" already exists. Use \`npx openfleet resume ${name}\`.`);
+    }
+    fs.mkdirSync(p.contracts, { recursive: true });
+    fs.mkdirSync(p.plans, { recursive: true });
+    const state = newState(name, crypto.randomUUID());
+    writeJson(p.state, state);
+    appendEvent(p, { actor: "cli", type: "project.created", target: null, payload: { sessionId: state.sessionId } });
+    return state;
+}
+export function cmdNew(args, passthrough, opts = {}) {
+    const ws = requireWorkspace();
+    const [rawName, ...promptParts] = args;
+    const name = validateProjectName(rawName);
+    const state = createProject(ws, name);
+    const request = promptParts.join(" ").trim();
+    out(`Created project ${name} at ${projectPaths(ws, name).dir}. Launching the coordinator…`);
+    const prompt = [
+        `Start OpenFleet project \`${name}\` (openfleet/projects/${name}/).`,
+        request ? `The user's request: ${request}` : "Ask the user what they want to change.",
+        "Begin the grill session (skill openfleet-grill).",
+    ].join("\n");
+    return launch({
+        ws,
+        agent: "openfleet-coordinator",
+        prompt,
+        sessionId: state.sessionId,
+        name: `openfleet: ${name}`,
+        project: name,
+        passthrough,
+        ask: opts.ask,
+    });
+}
+export function cmdResume(args, passthrough, opts = {}) {
+    const ws = requireWorkspace();
+    const name = validateProjectName(args[0]);
+    const p = projectPaths(ws, name);
+    let state = readState(p);
+    if (opts.fresh || !state.sessionId) {
+        const sessionId = crypto.randomUUID();
+        state = updateState(p, (s) => {
+            s.sessionId = sessionId;
+        }, "cli");
+    }
+    warnOverlaps(ws, name);
+    out(`Resuming project ${name} (status: ${state.status})…`);
+    return launch({
+        ws,
+        agent: "openfleet-coordinator",
+        prompt: `Resume OpenFleet project \`${name}\`. Read openfleet/projects/${name}/state.json and continue from where it left off.`,
+        sessionId: state.sessionId,
+        name: `openfleet: ${name}`,
+        project: name,
+        passthrough,
+        ask: opts.ask,
+    });
+}
+function pad(s, n) {
+    return s.length >= n ? s : s + " ".repeat(n - s.length);
+}
+function table(rows) {
+    const widths = rows[0].map((_, i) => Math.max(...rows.map((r) => (r[i] ?? "").length)));
+    return rows.map((r) => r.map((c, i) => pad(c, widths[i])).join("  ").trimEnd()).join("\n");
+}
+export function cmdList() {
+    const ws = requireWorkspace();
+    const names = listProjectNames(ws);
+    if (!names.length) {
+        out("No projects yet. Start one with `npx openfleet new <name>`.");
+        return 0;
+    }
+    const rows = [["PROJECT", "STATUS", "CHILDREN", "UPDATED"]];
+    for (const name of names) {
+        const s = readState(projectPaths(ws, name));
+        const children = Object.values(s.children);
+        const done = children.filter((c) => c.phase === "done").length;
+        const failed = children.filter((c) => c.phase === "failed" || c.phase === "blocked").length;
+        const progress = children.length ? `${done}/${children.length} done${failed ? `, ${failed} failed/blocked` : ""}` : "-";
+        rows.push([name, s.status, progress, s.updatedAt]);
+    }
+    out(table(rows));
+    return 0;
+}
+export function cmdStatus(args, opts = {}) {
+    const ws = requireWorkspace();
+    if (!args[0])
+        return cmdList();
+    const name = validateProjectName(args[0]);
+    const p = projectPaths(ws, name);
+    const s = readState(p);
+    if (opts.json) {
+        out(JSON.stringify(s, null, 2));
+        return 0;
+    }
+    out(`Project ${name}: ${s.status}${s.completionMode ? ` (completion: ${s.completionMode})` : ""}`);
+    const children = Object.entries(s.children);
+    if (children.length) {
+        out("");
+        const rows = [["CHILD", "PHASE", "ROLE", "RETRIES", "BRANCH", "DEPENDS ON"]];
+        for (const [id, c] of children) {
+            rows.push([id, c.phase, c.role ?? "-", String(c.retries), c.branch ?? "-", c.dependsOn.join(",") || "-"]);
+        }
+        out(table(rows));
+    }
+    const open = s.questions.filter((q) => q.status === "open");
+    if (open.length) {
+        out("");
+        out("Open questions:");
+        for (const q of open)
+            out(`  [${q.id}] ${q.from}: ${q.text}`);
+    }
+    const events = readEvents(p);
+    out("");
+    out(`${events.length} events recorded${events.length ? `, last: ${events.at(-1).type} at ${events.at(-1).ts}` : ""}.`);
+    warnOverlaps(ws, name);
+    return 0;
+}
+export function cmdClean(args, opts = {}) {
+    const ws = requireWorkspace();
+    const name = validateProjectName(args[0]);
+    const p = projectPaths(ws, name);
+    const s = readState(p);
+    let failures = 0;
+    for (const [id, c] of Object.entries(s.children)) {
+        if (c.worktree && fs.existsSync(c.worktree)) {
+            const repoPath = c.repoPath ?? tryGit(c.worktree, ["rev-parse", "--path-format=absolute", "--git-common-dir"])?.trim().replace(/\/\.git$/, "");
+            try {
+                if (!repoPath)
+                    throw new Error("unknown source repo");
+                removeWorktree(repoPath, c.worktree, opts.force);
+                out(`Removed worktree ${c.worktree}`);
+                appendEvent(p, { actor: "cli", type: "worktree.removed", target: id, payload: { worktree: c.worktree } });
+            }
+            catch (err) {
+                failures++;
+                const msg = String(err.stderr ?? err.message).trim();
+                warn(`Could not remove worktree for ${id}: ${msg}${opts.force ? "" : " (use --force to discard uncommitted changes)"}`);
+                continue;
+            }
+        }
+        if (opts.branches && c.branch && c.repoPath) {
+            try {
+                deleteBranch(c.repoPath, c.branch, opts.force);
+                out(`Deleted branch ${c.branch} in ${c.repoPath}`);
+            }
+            catch (err) {
+                failures++;
+                const msg = String(err.stderr ?? err.message).trim();
+                warn(`Could not delete branch ${c.branch}: ${msg}`);
+            }
+        }
+    }
+    if (fs.existsSync(p.worktrees) && fs.readdirSync(p.worktrees).length === 0)
+        fs.rmdirSync(p.worktrees);
+    updateState(p, (st) => {
+        for (const c of Object.values(st.children)) {
+            if (c.worktree && !fs.existsSync(c.worktree))
+                delete c.worktree;
+        }
+    }, "cli");
+    out(failures ? `Cleaned ${name} with ${failures} problem(s).` : `Cleaned ${name}.`);
+    return failures ? 1 : 0;
+}

package/dist/commands/workspace.d.ts

@@ -0,0 +1,10 @@
+import { type Workspace } from "../workspace.js";
+export declare const WORKSPACE_GITIGNORE = "# Managed by OpenFleet\ncore/\nrepos/\nprojects/*/worktrees/\nprojects/*/patches/\nprojects/*/.events.seq\nprojects/*/.*.lock\n.hook-errors.log\n";
+export interface InitResult {
+    ws: Workspace;
+    created: boolean;
+}
+/** Scaffold `<root>/openfleet/` (idempotent) and install core. */
+export declare function initWorkspace(root: string): InitResult;
+export declare function cmdInit(): number;
+export declare function cmdUpdate(): number;

package/dist/commands/workspace.js

@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import path from "node:path";
+import { installCore, installedCoreVersion, packageVersion } from "../core.js";
+import { disableIncompatible, emptyLock } from "../extensions.js";
+import { realish, writeJson } from "../fsutil.js";
+import { emptyRepos } from "../repos.js";
+import { findWorkspace, requireWorkspace, workspaceAt } from "../workspace.js";
+import { out, warn } from "./output.js";
+export const WORKSPACE_GITIGNORE = `# Managed by OpenFleet
+core/
+repos/
+projects/*/worktrees/
+projects/*/patches/
+projects/*/.events.seq
+projects/*/.*.lock
+.hook-errors.log
+`;
+function ensureFile(file, write) {
+    if (fs.existsSync(file))
+        return false;
+    write();
+    return true;
+}
+/** Scaffold `<root>/openfleet/` (idempotent) and install core. */
+export function initWorkspace(root) {
+    const existing = findWorkspace(root);
+    if (existing && existing.root !== realish(root)) {
+        warn(`Already inside the OpenFleet workspace at ${existing.root}; initializing there.`);
+    }
+    const ws = existing ?? workspaceAt(realish(root));
+    const created = !existing;
+    fs.mkdirSync(ws.extensions, { recursive: true });
+    fs.mkdirSync(ws.projects, { recursive: true });
+    for (const dir of [ws.extensions, ws.projects]) {
+        ensureFile(path.join(dir, ".gitkeep"), () => fs.writeFileSync(path.join(dir, ".gitkeep"), ""));
+    }
+    ensureFile(ws.reposFile, () => writeJson(ws.reposFile, emptyRepos()));
+    ensureFile(ws.lockFile, () => writeJson(ws.lockFile, emptyLock()));
+    const gi = path.join(ws.dir, ".gitignore");
+    ensureFile(gi, () => fs.writeFileSync(gi, WORKSPACE_GITIGNORE));
+    installCore(ws, warn);
+    return { ws, created };
+}
+export function cmdInit() {
+    const { ws, created } = initWorkspace(process.cwd());
+    out(`${created ? "Created" : "Refreshed"} OpenFleet workspace at ${ws.dir} (core ${packageVersion()}).`);
+    out("");
+    out("Next:");
+    out("  npx openfleet new <project-name> \"<what you want to change>\"");
+    return 0;
+}
+export function cmdUpdate() {
+    const ws = requireWorkspace();
+    const before = installedCoreVersion(ws);
+    const version = packageVersion();
+    const disabled = disableIncompatible(ws, version);
+    for (const name of disabled) {
+        warn(`Disabled extension "${name}": not compatible with core ${version}. Update it, then \`npx openfleet add\` it again.`);
+    }
+    installCore(ws, warn);
+    out(`Updated OpenFleet core ${before ?? "(none)"} → ${version}.`);
+    return 0;
+}

package/dist/core.d.ts

@@ -0,0 +1,17 @@
+import type { CoreIndex } from "./coreindex.js";
+import type { Workspace } from "./workspace.js";
+/** Root of the installed @openfleet-tools/cli package (contains package.json, core/, dist/). */
+export declare function packageRoot(): string;
+export declare function packageVersion(): string;
+export declare function installedCoreVersion(ws: Workspace): string | undefined;
+/**
+ * Replace `<ws>/openfleet/core` with the assets shipped in this package plus
+ * a copy of the compiled library (used by hooks), then regenerate agents.
+ */
+export declare function installCore(ws: Workspace, warn?: (msg: string) => void): CoreIndex;
+/**
+ * Regenerate everything in core that depends on installed extensions:
+ * role agents (template + augment instructions), one agent per extension,
+ * command skills and `extensions.json`.
+ */
+export declare function syncExtensions(ws: Workspace, warn?: (msg: string) => void): CoreIndex;

package/dist/core.js

@@ -0,0 +1,139 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { qualifiedAgentName } from "./attribution.js";
+import { loadExtensions, permissionsOf, ROLES, SLOTS, toolsFor, } from "./extensions.js";
+import { copyDir, readJson, writeFileAtomic, writeJson } from "./fsutil.js";
+/** Root of the installed @openfleet-tools/cli package (contains package.json, core/, dist/). */
+export function packageRoot() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+}
+export function packageVersion() {
+    return readJson(path.join(packageRoot(), "package.json")).version;
+}
+export function installedCoreVersion(ws) {
+    try {
+        return fs.readFileSync(path.join(ws.core, "VERSION"), "utf8").trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+const AGENT_PREFIX = "openfleet-";
+const MAX_AGENT_PROMPT = 30_000;
+/**
+ * Replace `<ws>/openfleet/core` with the assets shipped in this package plus
+ * a copy of the compiled library (used by hooks), then regenerate agents.
+ */
+export function installCore(ws, warn = () => { }) {
+    const pkg = packageRoot();
+    const version = packageVersion();
+    const tmp = `${ws.core}.tmp-${process.pid}`;
+    fs.rmSync(tmp, { recursive: true, force: true });
+    copyDir(path.join(pkg, "core"), tmp);
+    copyDir(path.join(pkg, "dist"), path.join(tmp, "lib"), (rel) => rel.endsWith(".d.ts") || rel.endsWith(".map"));
+    writeJson(path.join(tmp, "package.json"), { name: "openfleet-core", private: true, type: "module", version });
+    fs.writeFileSync(path.join(tmp, "VERSION"), version + "\n");
+    fs.writeFileSync(path.join(tmp, "DO_NOT_EDIT.md"), "# Generated by @openfleet-tools/cli\n\nThis folder is fully replaced by `npx openfleet update`. Do not edit it.\n" +
+        "Customize OpenFleet with extensions in `openfleet/extensions/` instead.\n");
+    const pluginFile = path.join(tmp, "plugin.json");
+    const plugin = readJson(pluginFile);
+    writeJson(pluginFile, { ...plugin, version });
+    fs.rmSync(ws.core, { recursive: true, force: true });
+    fs.renameSync(tmp, ws.core);
+    return syncExtensions(ws, warn);
+}
+function frontmatter(fields) {
+    const lines = Object.entries(fields).map(([k, v]) => `${k}: ${JSON.stringify(v)}`);
+    return `---\n${lines.join("\n")}\n---\n`;
+}
+function readInstructions(ext) {
+    return fs.readFileSync(path.join(ext.dir, ext.manifest.instructions ?? "instructions.md"), "utf8").trim();
+}
+function extAgentName(ext) {
+    return `${AGENT_PREFIX}ext-${ext}`;
+}
+/**
+ * Regenerate everything in core that depends on installed extensions:
+ * role agents (template + augment instructions), one agent per extension,
+ * command skills and `extensions.json`.
+ */
+export function syncExtensions(ws, warn = () => { }) {
+    const coreVersion = installedCoreVersion(ws) ?? packageVersion();
+    const exts = loadExtensions(ws, warn);
+    const agentsDir = path.join(ws.core, "agents");
+    const skillsDir = path.join(ws.core, "skills");
+    const templates = path.join(ws.core, "templates", "agents");
+    fs.rmSync(agentsDir, { recursive: true, force: true });
+    fs.mkdirSync(agentsDir, { recursive: true });
+    for (const entry of fs.existsSync(skillsDir) ? fs.readdirSync(skillsDir) : []) {
+        if (entry.startsWith(`${AGENT_PREFIX}ext-`))
+            fs.rmSync(path.join(skillsDir, entry), { recursive: true, force: true });
+    }
+    const index = {
+        v: 1,
+        coreVersion,
+        slots: Object.fromEntries(SLOTS.map((s) => [s, []])),
+        augments: Object.fromEntries(ROLES.map((r) => [r, []])),
+        commands: {},
+    };
+    for (const role of ROLES) {
+        const file = `${AGENT_PREFIX}${role}.agent.md`;
+        let body = fs.readFileSync(path.join(templates, file), "utf8").trimEnd() + "\n";
+        for (const ext of exts) {
+            if (ext.manifest.mode !== "augment" || ext.manifest.role !== role)
+                continue;
+            body += `\n## Extension: ${ext.manifest.name}\n\n${readInstructions(ext)}\n`;
+            index.augments[role].push(ext.manifest.name);
+        }
+        if (body.length > MAX_AGENT_PROMPT) {
+            warn(`Agent ${file} is ${body.length} chars (Copilot limit ${MAX_AGENT_PROMPT}); augment extensions may be truncated.`);
+        }
+        writeFileAtomic(path.join(agentsDir, file), body);
+    }
+    for (const ext of exts) {
+        const m = ext.manifest;
+        const agent = extAgentName(m.name);
+        const perms = permissionsOf(m);
+        const needsAgent = m.mode === "phase" || Object.keys(m.commands ?? {}).length > 0;
+        if (needsAgent) {
+            const header = frontmatter({
+                name: agent,
+                description: m.description ?? `OpenFleet extension ${m.name}`,
+                tools: toolsFor(perms),
+            });
+            const role = m.mode === "phase"
+                ? `You are the OpenFleet extension **${m.name}**, running in the \`${m.slot}\` phase slot.`
+                : `You are the OpenFleet extension **${m.name}**, running one of its CLI commands.`;
+            const body = [
+                header,
+                role,
+                "",
+                `Declared permissions: ${perms.join(", ")}. Do not attempt actions outside these permissions.`,
+                "The OpenFleet workspace is the current working directory; project data lives in `openfleet/projects/<name>/`",
+                "(spec.md, state.json, events.jsonl, contracts/). Treat events.jsonl as append-only and never edit it.",
+                "When you finish, reply with a concise summary of what you produced.",
+                "",
+                m.mode === "phase" ? readInstructions(ext) : "",
+            ].join("\n");
+            writeFileAtomic(path.join(agentsDir, `${agent}.agent.md`), body.trimEnd() + "\n");
+        }
+        if (m.mode === "phase" && m.slot)
+            index.slots[m.slot].push({ extension: m.name, agent: qualifiedAgentName(agent) });
+        for (const [cmd, rel] of Object.entries(m.commands ?? {})) {
+            if (index.commands[cmd]) {
+                warn(`Command "${cmd}" from extension "${m.name}" shadows "${index.commands[cmd].extension}"; ignoring.`);
+                continue;
+            }
+            const skill = `${AGENT_PREFIX}ext-${m.name}-${cmd}`;
+            const content = fs.readFileSync(path.join(ext.dir, rel), "utf8").trim();
+            writeFileAtomic(path.join(skillsDir, skill, "SKILL.md"), frontmatter({ name: skill, description: `OpenFleet extension ${m.name}: \`openfleet ${cmd}\` command.` }) +
+                "\n" +
+                content +
+                "\n");
+            index.commands[cmd] = { extension: m.name, agent: qualifiedAgentName(agent), skill };
+        }
+    }
+    writeJson(path.join(ws.core, "extensions.json"), index);
+    return index;
+}

package/dist/coreindex.d.ts

@@ -0,0 +1,17 @@
+import type { ExtRole, Slot } from "./extensions.js";
+import type { Workspace } from "./workspace.js";
+export interface CoreIndex {
+    v: 1;
+    coreVersion: string;
+    slots: Record<Slot, {
+        extension: string;
+        agent: string;
+    }[]>;
+    augments: Record<ExtRole, string[]>;
+    commands: Record<string, {
+        extension: string;
+        agent: string;
+        skill: string;
+    }>;
+}
+export declare function readCoreIndex(ws: Workspace): CoreIndex | undefined;

package/dist/coreindex.js

@@ -0,0 +1,7 @@
+// Kept dependency-free: hooks import this from the copied core/lib.
+import path from "node:path";
+import { isFile, readJson } from "./fsutil.js";
+export function readCoreIndex(ws) {
+    const file = path.join(ws.core, "extensions.json");
+    return isFile(file) ? readJson(file) : undefined;
+}

package/dist/events.d.ts

@@ -0,0 +1,29 @@
+import type { ProjectPaths } from "./workspace.js";
+export declare const EVENT_SCHEMA_VERSION = 1;
+export declare const EVENT_TYPES: readonly ["project.created", "session.started", "session.ended", "agent.spawned", "agent.stopped", "message.sent", "file.added", "file.edited", "file.deleted", "worktree.snapshot", "worktree.created", "worktree.removed", "phase.changed", "question.asked", "question.answered", "contract.changed", "plan.submitted", "plan.validated", "plan.rejected", "test.run", "spec.written", "spec.approved", "assumption", "child.failed", "run.completed", "extension.ran"];
+export type KnownEventType = (typeof EVENT_TYPES)[number];
+/**
+ * Actor: `coordinator`, `<repo>/<role>` (repo may be `<repo>:<package>`),
+ * `ext:<name>`, `cli` or `user`.
+ */
+export interface EventInput {
+    actor: string;
+    type: KnownEventType | (string & {});
+    target?: string | null;
+    payload?: Record<string, unknown>;
+    /** Full patch text, stored as patches/<seq>.patch (redacted). */
+    patch?: string;
+    ts?: string;
+}
+export interface OpenFleetEvent {
+    v: typeof EVENT_SCHEMA_VERSION;
+    ts: string;
+    seq: number;
+    actor: string;
+    type: string;
+    target: string | null;
+    payload: Record<string, unknown>;
+}
+/** Append one event under the project's events lock. Returns the written event. */
+export declare function appendEvent(p: ProjectPaths, input: EventInput): OpenFleetEvent;
+export declare function readEvents(p: ProjectPaths): OpenFleetEvent[];

package/dist/events.js

@@ -0,0 +1,115 @@
+import fs from "node:fs";
+import path from "node:path";
+import { withLock } from "./lock.js";
+import { redact, redactString } from "./redact.js";
+export const EVENT_SCHEMA_VERSION = 1;
+export const EVENT_TYPES = [
+    "project.created",
+    "session.started",
+    "session.ended",
+    "agent.spawned",
+    "agent.stopped",
+    "message.sent",
+    "file.added",
+    "file.edited",
+    "file.deleted",
+    "worktree.snapshot",
+    "worktree.created",
+    "worktree.removed",
+    "phase.changed",
+    "question.asked",
+    "question.answered",
+    "contract.changed",
+    "plan.submitted",
+    "plan.validated",
+    "plan.rejected",
+    "test.run",
+    "spec.written",
+    "spec.approved",
+    "assumption",
+    "child.failed",
+    "run.completed",
+    "extension.ran",
+];
+function lastSeqFromLog(eventsFile) {
+    let content;
+    try {
+        content = fs.readFileSync(eventsFile, "utf8");
+    }
+    catch {
+        return 0;
+    }
+    const lines = content.trimEnd().split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        if (!line)
+            continue;
+        try {
+            const seq = JSON.parse(line).seq;
+            if (typeof seq === "number")
+                return seq;
+        }
+        catch {
+            // ignore torn/invalid line
+        }
+    }
+    return 0;
+}
+function readSeq(p) {
+    try {
+        const n = Number(fs.readFileSync(p.seq, "utf8").trim());
+        if (Number.isInteger(n) && n >= 0)
+            return n;
+    }
+    catch {
+        // fall through
+    }
+    return lastSeqFromLog(p.events);
+}
+/** Append one event under the project's events lock. Returns the written event. */
+export function appendEvent(p, input) {
+    fs.mkdirSync(p.dir, { recursive: true });
+    return withLock(p.eventsLock, () => {
+        const seq = readSeq(p) + 1;
+        const payload = redact({ ...(input.payload ?? {}) });
+        if (input.patch !== undefined && input.patch.length > 0) {
+            fs.mkdirSync(p.patches, { recursive: true });
+            const rel = path.posix.join("patches", `${seq}.patch`);
+            fs.writeFileSync(path.join(p.dir, rel), redactString(input.patch));
+            payload.patch = rel;
+        }
+        const event = {
+            v: EVENT_SCHEMA_VERSION,
+            ts: input.ts ?? new Date().toISOString(),
+            seq,
+            actor: input.actor,
+            type: input.type,
+            target: input.target ?? null,
+            payload,
+        };
+        fs.appendFileSync(p.events, JSON.stringify(event) + "\n");
+        fs.writeFileSync(p.seq, String(seq));
+        return event;
+    });
+}
+export function readEvents(p) {
+    let content;
+    try {
+        content = fs.readFileSync(p.events, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            // skip invalid line
+        }
+    }
+    return out;
+}