@agent-plan/server 0.4.1 → 0.4.3

package/dist/api-v1.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Read-only API v1 for programs outside Agent Plan (docs/api-v1.md).
+ *
+ * This is deliberately separate from the web UI's own routes in serve.ts: those
+ * change whenever the UI does, these are promised not to. Every reply is built
+ * from the plan-core contract mappers (never from raw stored objects) and is
+ * wrapped in `{ apiVersion, data }` or `{ apiVersion, error }`.
+ */
+import { Hono } from "hono";
+import { type PlanStore } from "@agent-plan/core";
+/** Mount point, fixed: the version is part of the URL so a future v2 can live beside it. */
+export declare const API_V1_BASE_PATH = "/api/v1";
+/** Routes are relative: mount the result at API_V1_BASE_PATH. */
+export declare function createApiV1App(store: PlanStore, isBusy?: () => boolean): Hono;
+//# sourceMappingURL=api-v1.d.ts.map

package/dist/api-v1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-v1.d.ts","sourceRoot":"","sources":["../src/api-v1.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,IAAI,EAAgB,MAAM,MAAM,CAAC;AAC1C,OAAO,EAQL,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAC;AAE1B,4FAA4F;AAC5F,eAAO,MAAM,gBAAgB,YAAY,CAAC;AAgE1C,iEAAiE;AACjE,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,MAAM,OAAO,GAAG,IAAI,CAyH7E"}

package/dist/api-v1.js

@@ -0,0 +1,181 @@
+/**
+ * Read-only API v1 for programs outside Agent Plan (docs/api-v1.md).
+ *
+ * This is deliberately separate from the web UI's own routes in serve.ts: those
+ * change whenever the UI does, these are promised not to. Every reply is built
+ * from the plan-core contract mappers (never from raw stored objects) and is
+ * wrapped in `{ apiVersion, data }` or `{ apiVersion, error }`.
+ */
+import { Hono } from "hono";
+import { API_V1_VERSION, PlanStoreError, PlanWriterBusyError, apiV1Envelope, apiV1Error, buildApiV1Model, } from "@agent-plan/core";
+/** Mount point, fixed: the version is part of the URL so a future v2 can live beside it. */
+export const API_V1_BASE_PATH = "/api/v1";
+/** Fields dropped by `?compact=true` so long lists stay small. */
+const COMPACT_FIELDS = ["description", "content", "guidelines", "decision", "rationale", "implementationNotes"];
+async function loadModel(store) {
+    const [project, features, phases, ideas] = await Promise.all([
+        store.loadProject(),
+        store.loadFeatures(),
+        store.loadAllPhases(),
+        store.loadIdeas(),
+    ]);
+    return buildApiV1Model({ project, features: features.features, phases, ideas: ideas.ideas });
+}
+/** `P002(F001)` -> `P002`; `P002(F001)/T005` -> `P002/T005`. */
+function withoutFeature(ref) {
+    return ref.replace(/\(F\d+\)/i, "");
+}
+/** Exact lookup by id, composite ref, short id, or the ref without its feature. No fuzzy title matching: a stable API never guesses. */
+function findByRef(items, rawRef) {
+    const ref = rawRef.trim().toLowerCase();
+    if (!ref)
+        return undefined;
+    const isTaskSuffix = /^t\d+$/.test(ref);
+    return items.find((item) => {
+        const itemRef = item.ref.toLowerCase();
+        return item.id.toLowerCase() === ref
+            || itemRef === ref
+            || withoutFeature(itemRef) === ref
+            || (item.shortId ? item.shortId.toLowerCase() === ref : false)
+            // A task number is unique across the project, so `T005` alone is unambiguous.
+            || (isTaskSuffix && itemRef.endsWith(`/${ref}`));
+    });
+}
+function compact(view) {
+    const copy = { ...view };
+    for (const field of COMPACT_FIELDS)
+        if (field in copy)
+            delete copy[field];
+    return copy;
+}
+function maybeCompact(c, items) {
+    return c.req.query("compact") === "true" ? items.map(compact) : items;
+}
+/** The path after the mount point, decoded, so refs like `P002(F001)/T005` (which contain `/`) work. */
+function refFromPath(c, collection) {
+    const path = c.req.path;
+    const start = path.indexOf(`${API_V1_BASE_PATH}/${collection}/`);
+    const raw = start === -1 ? "" : path.slice(start + API_V1_BASE_PATH.length + collection.length + 2);
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+/** Routes are relative: mount the result at API_V1_BASE_PATH. */
+export function createApiV1App(store, isBusy) {
+    const app = new Hono();
+    const notFound = (c, what, ref) => c.json(apiV1Error("NOT_FOUND", `${what} not found: ${ref}`), 404);
+    app.onError((err, c) => {
+        if (err instanceof PlanWriterBusyError)
+            return c.json(apiV1Error("PLAN_BUSY", err.message), 503);
+        if (err instanceof PlanStoreError || /ENOENT|read failed/i.test(err.message)) {
+            return c.json(apiV1Error("NOT_FOUND", err.message), 404);
+        }
+        return c.json(apiV1Error("INTERNAL", err instanceof Error ? err.message : String(err)), 500);
+    });
+    app.use("*", async (c, next) => {
+        if (c.req.method !== "GET") {
+            c.header("Allow", "GET");
+            return c.json(apiV1Error("METHOD_NOT_ALLOWED", "API v1 is read-only. Use GET."), 405);
+        }
+        // While an agent is writing .planner/ files, a read could see a half-written state.
+        if (isBusy?.())
+            return c.json(apiV1Error("PLAN_BUSY", "Plan files are being updated. Retry shortly."), 503);
+        await next();
+    });
+    app.get("/", (c) => c.json(apiV1Envelope({
+        apiVersion: API_V1_VERSION,
+        links: {
+            project: `${API_V1_BASE_PATH}/project`,
+            features: `${API_V1_BASE_PATH}/features`,
+            phases: `${API_V1_BASE_PATH}/phases`,
+            tasks: `${API_V1_BASE_PATH}/tasks`,
+            decisions: `${API_V1_BASE_PATH}/decisions`,
+            handoffs: `${API_V1_BASE_PATH}/handoffs`,
+            ideas: `${API_V1_BASE_PATH}/ideas`,
+        },
+    })));
+    app.get(`/project`, async (c) => c.json(apiV1Envelope((await loadModel(store)).project)));
+    app.get(`/features`, async (c) => {
+        const { features } = await loadModel(store);
+        const status = c.req.query("status");
+        return c.json(apiV1Envelope(maybeCompact(c, status ? features.filter((feature) => feature.status === status) : features)));
+    });
+    app.get(`/features/*`, async (c) => {
+        const ref = refFromPath(c, "features");
+        const feature = findByRef((await loadModel(store)).features, ref);
+        return feature ? c.json(apiV1Envelope(feature)) : notFound(c, "Feature", ref);
+    });
+    app.get(`/phases`, async (c) => {
+        const model = await loadModel(store);
+        let phases = model.phases;
+        const featureRef = c.req.query("feature");
+        if (featureRef) {
+            const feature = findByRef(model.features, featureRef);
+            if (!feature)
+                return notFound(c, "Feature", featureRef);
+            phases = phases.filter((phase) => phase.featureRef === feature.ref);
+        }
+        const status = c.req.query("status");
+        if (status)
+            phases = phases.filter((phase) => phase.status === status);
+        return c.json(apiV1Envelope(maybeCompact(c, phases)));
+    });
+    app.get(`/phases/*`, async (c) => {
+        const ref = refFromPath(c, "phases");
+        const phase = findByRef((await loadModel(store)).phases, ref);
+        return phase ? c.json(apiV1Envelope(phase)) : notFound(c, "Phase", ref);
+    });
+    app.get(`/tasks`, async (c) => {
+        const model = await loadModel(store);
+        let tasks = model.tasks;
+        const phaseRef = c.req.query("phase");
+        if (phaseRef) {
+            const phase = findByRef(model.phases, phaseRef);
+            if (!phase)
+                return notFound(c, "Phase", phaseRef);
+            tasks = tasks.filter((task) => task.phaseRef === phase.ref);
+        }
+        const status = c.req.query("status");
+        if (status)
+            tasks = tasks.filter((task) => task.status === status);
+        return c.json(apiV1Envelope(maybeCompact(c, tasks)));
+    });
+    app.get(`/tasks/*`, async (c) => {
+        const ref = refFromPath(c, "tasks");
+        const task = findByRef((await loadModel(store)).tasks, ref);
+        return task ? c.json(apiV1Envelope(task)) : notFound(c, "Task", ref);
+    });
+    app.get(`/decisions`, async (c) => {
+        const { decisions } = await loadModel(store);
+        const owner = c.req.query("owner");
+        const filtered = !owner
+            ? decisions
+            : decisions.filter((decision) => owner.toLowerCase() === "project"
+                ? decision.owner.kind === "project"
+                : decision.owner.ref !== null && (decision.owner.ref.toLowerCase() === owner.toLowerCase()
+                    || withoutFeature(decision.owner.ref).toLowerCase() === owner.toLowerCase()));
+        return c.json(apiV1Envelope(maybeCompact(c, filtered)));
+    });
+    app.get(`/handoffs`, async (c) => {
+        const { handoffs } = await loadModel(store);
+        return c.json(apiV1Envelope(maybeCompact(c, handoffs)));
+    });
+    app.get(`/handoffs/*`, async (c) => {
+        const ref = refFromPath(c, "handoffs");
+        const { handoffs, phases } = await loadModel(store);
+        const phase = findByRef(phases, ref);
+        const handoff = phase ? handoffs.find((entry) => entry.phaseRef === phase.ref) : undefined;
+        return handoff ? c.json(apiV1Envelope(handoff)) : notFound(c, "Handoff", ref);
+    });
+    app.get(`/ideas`, async (c) => c.json(apiV1Envelope(maybeCompact(c, (await loadModel(store)).ideas))));
+    app.get(`/ideas/*`, async (c) => {
+        const ref = refFromPath(c, "ideas");
+        const idea = findByRef((await loadModel(store)).ideas, ref);
+        return idea ? c.json(apiV1Envelope(idea)) : notFound(c, "Idea", ref);
+    });
+    app.all("*", (c) => c.json(apiV1Error("NOT_FOUND", `No such API v1 route: ${c.req.path}`), 404));
+    return app;
+}

package/dist/entity-events.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Change detector for the `entity-changed` live event (docs/api-v1.md).
+ *
+ * Agents write to `.planner/` from other processes (the MCP server), so route
+ * handlers in this process never see those writes. Only the folder watcher and
+ * `/internal/notify` do, and they only say "something changed". This detector
+ * turns that signal into exact answers: it keeps a fingerprint of every API v1
+ * view, reloads the plan on each signal, and reports which entities were
+ * created, updated or deleted.
+ */
+import { API_V1_VERSION, type ApiV1EntityEntry, type ApiV1EntityKind, type PlanStore } from "@agent-plan/core";
+export type EntityChangeOp = "created" | "updated" | "deleted";
+export interface EntityChangedData {
+    apiVersion: typeof API_V1_VERSION;
+    kind: ApiV1EntityKind;
+    ref: string;
+    id: string;
+    op: EntityChangeOp;
+    parents: {
+        featureRef?: string;
+        phaseRef?: string;
+    };
+}
+interface Fingerprint {
+    kind: ApiV1EntityKind;
+    id: string;
+    ref: string;
+    parents: ApiV1EntityEntry["parents"];
+    hash: string;
+}
+export type EntitySnapshot = ReadonlyMap<string, Fingerprint>;
+export declare function snapshotOf(entries: readonly ApiV1EntityEntry[]): EntitySnapshot;
+/** Exactly what differs between two snapshots, one change per entity. */
+export declare function diffSnapshots(previous: EntitySnapshot, next: EntitySnapshot): EntityChangedData[];
+export interface EntityEventDetectorOptions {
+    /** Wait this long after the last signal before reloading, so one burst of writes is one pass. */
+    debounceMs?: number;
+    /** Wait before retrying when the plan could not be loaded (for example mid-write). */
+    retryMs?: number;
+    maxRetries?: number;
+}
+export declare class EntityEventDetector {
+    private readonly store;
+    private readonly emit;
+    private snapshot;
+    private timer;
+    private running;
+    private dirty;
+    private retries;
+    private closed;
+    private readonly debounceMs;
+    private readonly retryMs;
+    private readonly maxRetries;
+    constructor(store: PlanStore, emit: (change: EntityChangedData) => void, options?: EntityEventDetectorOptions);
+    private currentSnapshot;
+    /** Record the starting state. If it cannot be read yet, the first successful pass only records and never reports. */
+    prime(): Promise<void>;
+    /** Something in `.planner/` may have changed. */
+    signal(): void;
+    private schedule;
+    private run;
+    close(): void;
+}
+export {};
+//# sourceMappingURL=entity-events.d.ts.map

package/dist/entity-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-events.d.ts","sourceRoot":"","sources":["../src/entity-events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EACL,cAAc,EAGd,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAC;AAE1B,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAE/D,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,OAAO,cAAc,CAAC;IAClC,IAAI,EAAE,eAAe,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,cAAc,CAAC;IACnB,OAAO,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACrD;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,eAAe,CAAC;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAC;IACrC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;AAE9D,wBAAgB,UAAU,CAAC,OAAO,EAAE,SAAS,gBAAgB,EAAE,GAAG,cAAc,CAY/E;AAMD,yEAAyE;AACzE,wBAAgB,aAAa,CAAC,QAAQ,EAAE,cAAc,EAAE,IAAI,EAAE,cAAc,GAAG,iBAAiB,EAAE,CAWjG;AAED,MAAM,WAAW,0BAA0B;IACzC,iGAAiG;IACjG,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sFAAsF;IACtF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,mBAAmB;IAY5B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAZvB,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,KAAK,CAA8C;IAC3D,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAGjB,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,CAAC,MAAM,EAAE,iBAAiB,KAAK,IAAI,EAC1D,OAAO,GAAE,0BAA+B;YAO5B,eAAe;IAU7B,qHAAqH;IAC/G,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B,iDAAiD;IACjD,MAAM,IAAI,IAAI;IAMd,OAAO,CAAC,QAAQ;YAQF,GAAG;IA2BjB,KAAK,IAAI,IAAI;CAKd"}

package/dist/entity-events.js

@@ -0,0 +1,133 @@
+/**
+ * Change detector for the `entity-changed` live event (docs/api-v1.md).
+ *
+ * Agents write to `.planner/` from other processes (the MCP server), so route
+ * handlers in this process never see those writes. Only the folder watcher and
+ * `/internal/notify` do, and they only say "something changed". This detector
+ * turns that signal into exact answers: it keeps a fingerprint of every API v1
+ * view, reloads the plan on each signal, and reports which entities were
+ * created, updated or deleted.
+ */
+import { createHash } from "node:crypto";
+import { API_V1_VERSION, buildApiV1Model, listApiV1Entities, } from "@agent-plan/core";
+export function snapshotOf(entries) {
+    const snapshot = new Map();
+    for (const entry of entries) {
+        snapshot.set(`${entry.kind}:${entry.key}`, {
+            kind: entry.kind,
+            id: entry.id,
+            ref: entry.ref,
+            parents: entry.parents,
+            hash: createHash("sha1").update(JSON.stringify(entry.view)).digest("hex"),
+        });
+    }
+    return snapshot;
+}
+function changeOf(fingerprint, op) {
+    return { apiVersion: API_V1_VERSION, kind: fingerprint.kind, ref: fingerprint.ref, id: fingerprint.id, op, parents: fingerprint.parents };
+}
+/** Exactly what differs between two snapshots, one change per entity. */
+export function diffSnapshots(previous, next) {
+    const changes = [];
+    for (const [key, fingerprint] of next) {
+        const before = previous.get(key);
+        if (!before)
+            changes.push(changeOf(fingerprint, "created"));
+        else if (before.hash !== fingerprint.hash)
+            changes.push(changeOf(fingerprint, "updated"));
+    }
+    for (const [key, fingerprint] of previous) {
+        if (!next.has(key))
+            changes.push(changeOf(fingerprint, "deleted"));
+    }
+    return changes;
+}
+export class EntityEventDetector {
+    store;
+    emit;
+    snapshot = null;
+    timer = null;
+    running = false;
+    dirty = false;
+    retries = 0;
+    closed = false;
+    debounceMs;
+    retryMs;
+    maxRetries;
+    constructor(store, emit, options = {}) {
+        this.store = store;
+        this.emit = emit;
+        this.debounceMs = options.debounceMs ?? 100;
+        this.retryMs = options.retryMs ?? 300;
+        this.maxRetries = options.maxRetries ?? 10;
+    }
+    async currentSnapshot() {
+        const [project, features, phases, ideas] = await Promise.all([
+            this.store.loadProject(),
+            this.store.loadFeatures(),
+            this.store.loadAllPhases(),
+            this.store.loadIdeas(),
+        ]);
+        return snapshotOf(listApiV1Entities(buildApiV1Model({ project, features: features.features, phases, ideas: ideas.ideas })));
+    }
+    /** Record the starting state. If it cannot be read yet, the first successful pass only records and never reports. */
+    async prime() {
+        try {
+            this.snapshot = await this.currentSnapshot();
+        }
+        catch {
+            this.snapshot = null;
+        }
+    }
+    /** Something in `.planner/` may have changed. */
+    signal() {
+        if (this.closed)
+            return;
+        this.retries = 0;
+        this.schedule(this.debounceMs);
+    }
+    schedule(delayMs) {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            void this.run();
+        }, delayMs);
+    }
+    async run() {
+        if (this.running) {
+            this.dirty = true;
+            return;
+        }
+        this.running = true;
+        try {
+            const next = await this.currentSnapshot();
+            const previous = this.snapshot;
+            this.snapshot = next;
+            if (previous)
+                for (const change of diffSnapshots(previous, next))
+                    this.emit(change);
+            this.retries = 0;
+        }
+        catch {
+            // A writer is mid-update. Try again shortly instead of waiting for another signal.
+            if (!this.closed && this.retries < this.maxRetries) {
+                this.retries += 1;
+                this.schedule(this.retryMs);
+            }
+        }
+        finally {
+            this.running = false;
+            if (this.dirty && !this.closed) {
+                this.dirty = false;
+                this.schedule(this.debounceMs);
+            }
+        }
+    }
+    close() {
+        this.closed = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+    }
+}

package/dist/index.d.ts

@@ -2,4 +2,6 @@ export { serve } from "./serve.js";
 export { WsHub } from "./ws-hub.js";
 export type { ServeOptions, ServeHandle, UiConfig, ShortcutConfigSpec } from "./serve.js";
 export type { WsEvent } from "./ws-hub.js";
+export { readLiveServerRecord, serverRecordPath } from "./server-record.js";
+export type { ServerRecord, ServerKind } from "./server-record.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC1F,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC1F,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -1,2 +1,3 @@
 export { serve } from "./serve.js";
 export { WsHub } from "./ws-hub.js";
+export { readLiveServerRecord, serverRecordPath } from "./server-record.js";

package/dist/serve.d.ts

@@ -1,4 +1,5 @@
 import { WsHub } from "./ws-hub.js";
+import { type ServerKind } from "./server-record.js";
 export interface ShortcutConfigSpec {
     key: string;
     primary?: boolean;
@@ -26,6 +27,10 @@ export interface ServeOptions {
     quiet?: boolean;
     uiConfig?: UiConfig | undefined;
     isBusy?: (() => boolean) | undefined;
+    /** Write `.planner/.local/server.json` so other programs can find this server. Default true. */
+    recordServer?: boolean;
+    /** `standalone` only for `agent-plan serve`, where the process exists just to run this server. Default `embedded`. */
+    serverKind?: ServerKind;
 }
 export interface ServeHandle {
     url: string;

package/dist/serve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../src/serve.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAyJpC,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,OAAO,GAAG,KAAK,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B;AAED,MAAM,WAAW,QAAQ;IACvB,SAAS,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC;IACzF,MAAM,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;CACrC;AA+6CD,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC,MAAM,CAAC,EAAE,CAAC,MAAM,OAAO,CAAC,GAAG,SAAS,CAAC;CACtC;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,IAAI,EAAE,OAAO,GAAG,KAAK,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,KAAK,CAAC;IACX,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAED,wBAAsB,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CA6EvE"}
+{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../src/serve.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGpC,OAAO,EAAyC,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAmJ5F,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,OAAO,GAAG,KAAK,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B;AAED,MAAM,WAAW,QAAQ;IACvB,SAAS,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC;IACzF,MAAM,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;CACrC;AAw7CD,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC,MAAM,CAAC,EAAE,CAAC,MAAM,OAAO,CAAC,GAAG,SAAS,CAAC;IACrC,gGAAgG;IAChG,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,sHAAsH;IACtH,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,IAAI,EAAE,OAAO,GAAG,KAAK,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,KAAK,CAAC;IACX,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAED,wBAAsB,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAmGvE"}

package/dist/serve.js

@@ -7,10 +7,12 @@ import { fileURLToPath } from "node:url";
 import { createAdaptorServer } from "@hono/node-server";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
-import { ExportService, PlanStore, PlanStoreError, PlanStaleWriteError, PlanWriterBusyError, createFeatureId, createPhaseId, createChecklistItemId, createRequirementId, createTaskId, findPhaseByRef, normalizeSlug, withFeatureLock, needsMotivation, checkExplicitTaskStart, recommendNextTask, recommendNextWork, reconcileRequirementMacroTasks, RequirementMacroTaskError, packageVersionFromModule, ACCEPTED_DECISION_RAW_REPLACEMENT_DISABLED_MESSAGE, ACCEPTED_DECISION_SEMANTIC_MUTATION_REQUIRED_ERROR_CODE, deleteFeatureCascade, nowISO, applyTaskLifecycleDates, resolveAcceptedDecisionTarget } from "@agent-plan/core";
+import { API_V1_VERSION, ExportService, PlanStore, PlanStoreError, PlanStaleWriteError, PlanWriterBusyError, createFeatureId, createPhaseId, createChecklistItemId, createRequirementId, createTaskId, findPhaseByRef, normalizeSlug, withFeatureLock, needsMotivation, checkExplicitTaskStart, recommendNextTask, recommendNextWork, reconcileRequirementMacroTasks, RequirementMacroTaskError, packageVersionFromModule, ACCEPTED_DECISION_RAW_REPLACEMENT_DISABLED_MESSAGE, ACCEPTED_DECISION_SEMANTIC_MUTATION_REQUIRED_ERROR_CODE, deleteFeatureCascade, nowISO, applyTaskLifecycleDates, resolveAcceptedDecisionTarget } from "@agent-plan/core";
 import { WsHub } from "./ws-hub.js";
+import { API_V1_BASE_PATH, createApiV1App } from "./api-v1.js";
+import { EntityEventDetector } from "./entity-events.js";
+import { removeServerRecord, writeServerRecord } from "./server-record.js";
 // ─── Watcher ────────────────────────────────────────────────────────────
-let watcherAbort = null;
 const SERVER_PACKAGE = packageVersionFromModule(import.meta.url, "@agent-plan/server");
 /** Resolve requirement phase refs before persistence so requirements never dangle. */
 async function resolveRequirementPhaseIds(store, linkedPhaseIds) {
@@ -112,16 +114,16 @@ function phaseGovernanceReady(phase) {
 function fromWebUi(c) {
     return c.req.header("X-Planner-Source") === "web-ui";
 }
-function startWatcher(planRoot, hubRef) {
-    stopWatcher();
+/** Watch the planner folder. Returns a function that stops this watcher only, so several servers in one process never stop each other's. */
+function startWatcher(planRoot, hubRef, onChange) {
     if (!existsSync(planRoot))
-        return;
+        return () => { };
     const ac = new AbortController();
-    watcherAbort = ac;
     try {
         const watcher = watch(planRoot, { recursive: true, signal: ac.signal }, (_event, filename) => {
             if (filename && !filename.includes(".tmp.")) {
                 hubRef.current?.broadcast({ type: "file-changed", data: { filename } });
+                onChange();
             }
         });
         watcher.on("error", () => {
@@ -132,12 +134,9 @@ function startWatcher(planRoot, hubRef) {
     catch {
         // recursive watch may fail on some systems
     }
+    return () => ac.abort();
 }
-function stopWatcher() {
-    watcherAbort?.abort();
-    watcherAbort = null;
-}
-function createApiApp(store, hubRef, apiPrefix = "", uiConfig, isBusy) {
+function createApiApp(store, hubRef, apiPrefix = "", uiConfig, isBusy, onExternalChange) {
     const hub = () => hubRef.current;
     const route = (path) => `${apiPrefix}${path}`;
     const app = new Hono();
@@ -171,8 +170,12 @@ function createApiApp(store, hubRef, apiPrefix = "", uiConfig, isBusy) {
     app.post(route("/internal/notify"), (c) => {
         hub()?.broadcast({ type: "plan-rendered", data: {} });
         hub()?.broadcast({ type: "file-changed", data: { filename: "external-notify" } });
+        onExternalChange?.();
         return c.json({ ok: true });
     });
+    // The outside API has its own versioned contract and its own busy/error replies,
+    // so it is mounted before the web UI's busy middleware below.
+    app.route(API_V1_BASE_PATH, createApiV1App(store, isBusy));
     // While the agent is mutating .planner/ files, avoid serving possibly-inconsistent data.
     // GET requests get a 503 busy signal the UI retries; mutations are rejected.
     app.use("*", async (c, next) => {
@@ -1572,13 +1575,18 @@ function createApiApp(store, hubRef, apiPrefix = "", uiConfig, isBusy) {
         return c.json({ cleared: true });
     });
     // ── Health ───────────────────────────────────────────────────────
-    app.get(route("/health"), (c) => c.json({ status: "ok", root: store.root }));
+    const health = (c) => c.json({ status: "ok", root: store.root, apiVersion: API_V1_VERSION, pid: process.pid, version: SERVER_PACKAGE.version });
+    app.get(route("/health"), health);
+    // With the web UI bundled the API sits under /api and unknown paths fall through to the UI,
+    // so a program probing the server must also find /health at the root.
+    if (apiPrefix)
+        app.get("/health", health);
     app.get(route("/ui-config"), (c) => c.json(uiConfig ?? {}));
     return app;
 }
 // ─── Serve static files (SPA) ────────────────────────────────────────────
-function createSpaApp(store, hubRef, staticDir, uiConfig, isBusy) {
-    const app = createApiApp(store, hubRef, staticDir ? "/api" : "", uiConfig, isBusy);
+function createSpaApp(store, hubRef, staticDir, uiConfig, isBusy, onExternalChange) {
+    const app = createApiApp(store, hubRef, staticDir ? "/api" : "", uiConfig, isBusy, onExternalChange);
     if (!staticDir) {
         return app;
     }
@@ -1655,7 +1663,7 @@ function resolveBundledStaticDir() {
     }
 }
 export async function serve(options) {
-    const { port = 3030, planRoot, host = "127.0.0.1" } = options;
+    const { port = 3030, planRoot, host = "127.0.0.1", recordServer = true, serverKind = "embedded" } = options;
     const store = new PlanStore(planRoot);
     const runtimeUiConfig = { ...(options.uiConfig ?? {}) };
     if (!(await store.exists())) {
@@ -1668,7 +1676,10 @@ export async function serve(options) {
     // Default to the bundled web UI when the caller doesn't pass staticDir. Pass
     // an empty string ("") to force API-only even when the bundle is present.
     const staticDir = options.staticDir ?? resolveBundledStaticDir();
-    const app = createSpaApp(store, hubRef, staticDir, runtimeUiConfig, options.isBusy);
+    // Detects exactly which entities changed, including writes by other processes (MCP).
+    const detector = new EntityEventDetector(store, (change) => hubRef.current?.broadcast({ type: "entity-changed", data: change }));
+    await detector.prime();
+    const app = createSpaApp(store, hubRef, staticDir, runtimeUiConfig, options.isBusy, () => detector.signal());
     return new Promise((resolve, reject) => {
         // Create the Node HTTP server without listening yet
         const server = createAdaptorServer({ fetch: app.fetch, hostname: host });
@@ -1701,8 +1712,8 @@ export async function serve(options) {
                 if (lanUrl)
                     console.log(`[plan-server] lan url: ${lanUrl}`);
             }
-            startWatcher(planRoot, hubRef);
-            resolve({
+            const stopWatcher = startWatcher(planRoot, hubRef, () => detector.signal());
+            const handle = {
                 url: localUrl,
                 localUrl,
                 lanUrl,
@@ -1711,6 +1722,9 @@ export async function serve(options) {
                 hub,
                 close: async () => {
                     stopWatcher();
+                    detector.close();
+                    if (recordServer)
+                        await removeServerRecord(store.root, { pid: process.pid, localUrl });
                     hub.close();
                     // Force-close any lingering sockets (browser WebSocket / keep-alive),
                     // otherwise server.close() hangs until the kernel times them out.
@@ -1718,7 +1732,24 @@ export async function serve(options) {
                     anyServer.closeAllConnections?.();
                     await new Promise((r) => anyServer.close(() => r()));
                 },
-            });
+            };
+            if (!recordServer) {
+                resolve(handle);
+                return;
+            }
+            void writeServerRecord(store.root, {
+                kind: serverKind,
+                pid: process.pid,
+                url: handle.url,
+                localUrl: handle.localUrl,
+                lanUrl: handle.lanUrl ?? null,
+                host: handle.bindHost,
+                port: actualPort,
+                root: store.root,
+                startedAt: new Date().toISOString(),
+                version: SERVER_PACKAGE.version,
+                apiVersion: API_V1_VERSION,
+            }).finally(() => resolve(handle));
         });
     });
 }

package/dist/server-record.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The record of a running planner server: `<planner folder>/.local/server.json`.
+ *
+ * Several things start a server (`agent-plan serve`, the MCP `planner-web` and
+ * `planner-load`, the Pi adapter) and until now nothing said that one was
+ * already running for a folder. serve() writes this record, so every starter
+ * gets it, and a program that wants to reuse a server reads it with
+ * readLiveServerRecord(). The first live server owns the record.
+ */
+/**
+ * How the server was started. `standalone` is `agent-plan serve`: the whole
+ * process is the server, so it is safe to stop by signalling its pid.
+ * `embedded` is a server inside another program (an agent's MCP server, the Pi
+ * adapter): signalling that pid would kill the host, so only its owner stops it.
+ */
+export type ServerKind = "standalone" | "embedded";
+export interface ServerRecord {
+    kind: ServerKind;
+    pid: number;
+    url: string;
+    localUrl: string;
+    lanUrl: string | null;
+    host: string;
+    port: number;
+    root: string;
+    startedAt: string;
+    version: string;
+    apiVersion: string;
+}
+export declare function serverRecordPath(planRoot: string): string;
+/** The record of a server that is really running for this folder, or null. A stale record is deleted. */
+export declare function readLiveServerRecord(planRoot: string): Promise<ServerRecord | null>;
+/**
+ * Write the record unless another live server already owns it. Never throws:
+ * a folder that cannot be written must not stop the server from running.
+ * Returns true when this server now owns the record.
+ */
+export declare function writeServerRecord(planRoot: string, record: ServerRecord): Promise<boolean>;
+/** Remove the record, but only when it describes this very server (pid and address). Never throws. */
+export declare function removeServerRecord(planRoot: string, owner: {
+    pid: number;
+    localUrl: string;
+}): Promise<void>;
+//# sourceMappingURL=server-record.d.ts.map

package/dist/server-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-record.d.ts","sourceRoot":"","sources":["../src/server-record.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,YAAY,GAAG,UAAU,CAAC;AAEnD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,UAAU,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAKD,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEzD;AAuCD,yGAAyG;AACzG,wBAAsB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAMzF;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAchG;AAED,sGAAsG;AACtG,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAOlH"}

package/dist/server-record.js

@@ -0,0 +1,97 @@
+/**
+ * The record of a running planner server: `<planner folder>/.local/server.json`.
+ *
+ * Several things start a server (`agent-plan serve`, the MCP `planner-web` and
+ * `planner-load`, the Pi adapter) and until now nothing said that one was
+ * already running for a folder. serve() writes this record, so every starter
+ * gets it, and a program that wants to reuse a server reads it with
+ * readLiveServerRecord(). The first live server owns the record.
+ */
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+/** How long a liveness check waits for /health before calling the record stale. */
+const HEALTH_TIMEOUT_MS = 1000;
+export function serverRecordPath(planRoot) {
+    return join(planRoot, ".local", "server.json");
+}
+function isServerRecord(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const record = value;
+    return typeof record.pid === "number" && typeof record.localUrl === "string" && typeof record.root === "string"
+        && (record.kind === "standalone" || record.kind === "embedded");
+}
+async function readRecordFile(planRoot) {
+    try {
+        const parsed = JSON.parse(await readFile(serverRecordPath(planRoot), "utf-8"));
+        return isServerRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function processExists(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // EPERM means the process exists but belongs to someone else.
+        return error.code === "EPERM";
+    }
+}
+async function answersHealth(record) {
+    try {
+        const response = await fetch(`${record.localUrl.replace(/\/$/, "")}/health`, { signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS) });
+        if (!response.ok)
+            return false;
+        const body = (await response.json());
+        return typeof body.root === "string" && resolve(body.root) === resolve(record.root);
+    }
+    catch {
+        return false;
+    }
+}
+/** The record of a server that is really running for this folder, or null. A stale record is deleted. */
+export async function readLiveServerRecord(planRoot) {
+    const record = await readRecordFile(planRoot);
+    if (!record)
+        return null;
+    if (processExists(record.pid) && (await answersHealth(record)))
+        return record;
+    await rm(serverRecordPath(planRoot), { force: true }).catch(() => { });
+    return null;
+}
+/**
+ * Write the record unless another live server already owns it. Never throws:
+ * a folder that cannot be written must not stop the server from running.
+ * Returns true when this server now owns the record.
+ */
+export async function writeServerRecord(planRoot, record) {
+    try {
+        const existing = await readLiveServerRecord(planRoot);
+        // Compare the address, not the pid: one process can run several servers.
+        if (existing && existing.localUrl !== record.localUrl)
+            return false;
+        const path = serverRecordPath(planRoot);
+        await mkdir(dirname(path), { recursive: true });
+        const temporary = `${path}.${process.pid}.tmp`;
+        await writeFile(temporary, `${JSON.stringify(record, null, 2)}\n`);
+        await rename(temporary, path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Remove the record, but only when it describes this very server (pid and address). Never throws. */
+export async function removeServerRecord(planRoot, owner) {
+    try {
+        const record = await readRecordFile(planRoot);
+        if (record?.pid === owner.pid && record.localUrl === owner.localUrl)
+            await rm(serverRecordPath(planRoot), { force: true });
+    }
+    catch {
+        // Nothing useful to do: the record is advisory.
+    }
+}

package/dist/ws-hub.d.ts

@@ -5,6 +5,7 @@
  * All plan mutations broadcast events so connected clients stay in sync.
  */
 import type { Server } from "node:http";
+import type { EntityChangedData } from "./entity-events.js";
 export type WsEvent = {
     type: "file-changed";
     data: {
@@ -35,6 +36,9 @@ export type WsEvent = {
     data: {
         phaseId: string;
     };
+} | {
+    type: "entity-changed";
+    data: EntityChangedData;
 };
 export declare class WsHub {
     private wss;

package/dist/ws-hub.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ws-hub.d.ts","sourceRoot":"","sources":["../src/ws-hub.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GACpD;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,sBAAsB,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC3C;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GACrD;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAE1D,qBAAa,KAAK;IAChB,OAAO,CAAC,GAAG,CAAkB;IAC7B,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,KAAK,CAAU;gBAEX,MAAM,EAAE,MAAM,EAAE,KAAK,UAAQ,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI;IA0CzE,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAa/B,KAAK,IAAI,IAAI;CASd"}
+{"version":3,"file":"ws-hub.d.ts","sourceRoot":"","sources":["../src/ws-hub.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE5D,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GACpD;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,sBAAsB,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC3C;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GACrD;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GACrD;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAExD,qBAAa,KAAK;IAChB,OAAO,CAAC,GAAG,CAAkB;IAC7B,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,KAAK,CAAU;gBAEX,MAAM,EAAE,MAAM,EAAE,KAAK,UAAQ,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI;IA0CzE,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAa/B,KAAK,IAAI,IAAI;CASd"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-plan/server",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "private": false,
   "description": "Local HTTP/WebSocket server for Agent Plan dashboards and planner APIs.",
   "license": "MIT",
@@ -41,7 +41,7 @@
     "@hono/node-server": "^1.14.0",
     "hono": "^4.7.0",
     "ws": "^8.18.0",
-    "@agent-plan/core": "0.4.1"
+    "@agent-plan/core": "0.4.3"
   },
   "devDependencies": {
     "@types/ws": "^8.18.0"