monomind 2.7.12 → 2.7.13

package/packages/@monomind/cli/dist/src/orgrt/broker.js

@@ -1,73 +0,0 @@
-// packages/@monomind/cli/src/orgrt/broker.ts
-// monolean: file-based local broker for cross-process org discovery (different
-// `monomind org` processes / project directories, same machine). Upgrade path:
-// a real network registry when cross-machine discovery is needed.
-import { mkdirSync, writeFileSync, readFileSync, unlinkSync, renameSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-const SAFE_NAME = /^[a-z0-9][a-z0-9_-]*$/i;
-const DEFAULT_STALE_MS = 90_000;
-export function defaultRegistryDir() {
-    return process.env.MONOMIND_ORGRT_BROKER_DIR || join(homedir(), '.monomind', 'orgrt-broker');
-}
-function entryPath(name, dir) {
-    if (!SAFE_NAME.test(name))
-        throw new Error(`invalid org name for broker registry: ${name}`);
-    return join(dir, `${name}.json`);
-}
-/** Publish that this process hosts org `name`, reachable via `url`. Call again periodically (heartbeat) — see BrokerLease.
- *  Writes via tmp+rename (same-directory rename is atomic on POSIX/NTFS) so a concurrent lookupOrg() never observes a
- *  partially-written entry — this file is rewritten every heartbeat (default 20s) while other processes may read it. */
-export function registerOrg(name, url, dir = defaultRegistryDir()) {
-    mkdirSync(dir, { recursive: true });
-    const entry = { url, pid: process.pid, updatedAt: Date.now() };
-    const dest = entryPath(name, dir);
-    const tmp = `${dest}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify(entry));
-    renameSync(tmp, dest);
-}
-/** Remove this process's registration for `name` (best effort). */
-export function unregisterOrg(name, dir = defaultRegistryDir()) {
-    try {
-        unlinkSync(entryPath(name, dir));
-    }
-    catch { /* already gone */ }
-}
-/** Find which process (if any) currently hosts org `name`. Null if never registered or the registration is stale (owner crashed without cleanup). */
-export function lookupOrg(name, dir = defaultRegistryDir(), staleMs = DEFAULT_STALE_MS) {
-    try {
-        const entry = JSON.parse(readFileSync(entryPath(name, dir), 'utf8'));
-        if (Date.now() - entry.updatedAt >= staleMs)
-            return null;
-        return entry;
-    }
-    catch {
-        return null;
-    }
-}
-/** Keeps a broker registration alive with periodic heartbeats until stop() is called. */
-export class BrokerLease {
-    name;
-    url;
-    dir;
-    intervalMs;
-    timer = null;
-    constructor(name, url, dir = defaultRegistryDir(), intervalMs = 20_000) {
-        this.name = name;
-        this.url = url;
-        this.dir = dir;
-        this.intervalMs = intervalMs;
-    }
-    start() {
-        registerOrg(this.name, this.url, this.dir);
-        this.timer = setInterval(() => registerOrg(this.name, this.url, this.dir), this.intervalMs);
-        this.timer.unref?.();
-    }
-    stop() {
-        if (this.timer)
-            clearInterval(this.timer);
-        this.timer = null;
-        unregisterOrg(this.name, this.dir);
-    }
-}
-//# sourceMappingURL=broker.js.map

package/packages/@monomind/cli/dist/src/orgrt/bus.d.ts

@@ -1,27 +0,0 @@
-import type { BusEvent } from './types.js';
-type Listener = (e: BusEvent) => void;
-/**
- * Ground-truth event log for one org run. Append-only JSONL + in-process fanout.
- * Every message, tool decision, asset, and usage record flows through here.
- */
-export declare class OrgBus {
-    readonly org: string;
-    readonly run: string;
-    readonly dir: string;
-    private listeners;
-    private seq;
-    private pending;
-    readonly file: string;
-    constructor(org: string, run: string, dir: string);
-    subscribe(fn: Listener): () => void;
-    emit(partial: Omit<BusEvent, 'id' | 'ts' | 'org' | 'run'>): BusEvent;
-    /** Await all queued disk writes (tests, shutdown). Listeners registered via subscribe() run
-     *  synchronously inside emit() — flush() has no visibility into any async work they schedule
-     *  off of that (e.g. the forwarder's HTTP POSTs). A caller that needs an async subscriber's
-     *  work to have settled too must await that subscriber's own completion signal separately
-     *  (see daemon.ts stopOrg(), which awaits forwarder.settle() alongside bus.flush()). */
-    flush(): Promise<void>;
-    static readHistory(dir: string): BusEvent[];
-}
-export {};
-//# sourceMappingURL=bus.d.ts.map

package/packages/@monomind/cli/dist/src/orgrt/bus.js

@@ -1,71 +0,0 @@
-// packages/@monomind/cli/src/orgrt/bus.ts
-import { appendFile, mkdir } from 'node:fs/promises';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-/**
- * Ground-truth event log for one org run. Append-only JSONL + in-process fanout.
- * Every message, tool decision, asset, and usage record flows through here.
- */
-export class OrgBus {
-    org;
-    run;
-    dir;
-    listeners = new Set();
-    seq = 0;
-    pending = Promise.resolve();
-    file;
-    constructor(org, run, dir) {
-        this.org = org;
-        this.run = run;
-        this.dir = dir;
-        this.file = join(dir, 'bus.jsonl');
-    }
-    subscribe(fn) {
-        this.listeners.add(fn);
-        return () => this.listeners.delete(fn);
-    }
-    emit(partial) {
-        const e = {
-            id: `${this.run}-${Date.now()}-${this.seq++}`,
-            ts: Date.now(),
-            org: this.org,
-            run: this.run,
-            ...partial,
-        };
-        // serialize writes; never block emitters
-        this.pending = this.pending.then(async () => {
-            await mkdir(this.dir, { recursive: true });
-            await appendFile(this.file, JSON.stringify(e) + '\n', 'utf8');
-        }).catch((err) => {
-            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                console.error('[org-bus] event write failed:', err);
-        });
-        for (const fn of this.listeners) {
-            try {
-                fn(e);
-            }
-            catch { /* listener errors never break the bus */ }
-        }
-        return e;
-    }
-    /** Await all queued disk writes (tests, shutdown). Listeners registered via subscribe() run
-     *  synchronously inside emit() — flush() has no visibility into any async work they schedule
-     *  off of that (e.g. the forwarder's HTTP POSTs). A caller that needs an async subscriber's
-     *  work to have settled too must await that subscriber's own completion signal separately
-     *  (see daemon.ts stopOrg(), which awaits forwarder.settle() alongside bus.flush()). */
-    flush() { return this.pending; }
-    static readHistory(dir) {
-        const f = join(dir, 'bus.jsonl');
-        if (!existsSync(f))
-            return [];
-        return readFileSync(f, 'utf8').trim().split('\n').filter(Boolean)
-            .map(l => { try {
-            return JSON.parse(l);
-        }
-        catch {
-            return null;
-        } })
-            .filter((e) => e !== null);
-    }
-}
-//# sourceMappingURL=bus.js.map

package/packages/@monomind/cli/dist/src/orgrt/daemon.d.ts

@@ -1,175 +0,0 @@
-import { OrgBus } from './bus.js';
-import { PolicyEngine } from './policy.js';
-import { Mailbox } from './mailbox.js';
-import { type OrgDef, type BusEvent } from './types.js';
-import type { query } from '@anthropic-ai/claude-agent-sdk';
-interface AgentRuntime {
-    mailbox: Mailbox;
-    policy: PolicyEngine;
-    done: Promise<void>;
-    /** 'running' until the session promise settles; 'crashed' if it rejected (see error). */
-    status: 'running' | 'ended' | 'crashed';
-    error?: string;
-}
-export interface RunningOrg {
-    def: OrgDef;
-    run: string;
-    bus: OrgBus;
-    agents: Map<string, AgentRuntime>;
-    busEvents: () => BusEvent[];
-}
-export interface DaemonOpts {
-    queryFn?: typeof query;
-    forward?: boolean;
-    controlJson?: string;
-    /** Enables cross-process inter-org routing: on a local delivery miss, ask the
-     *  machine-local broker whether another `monomind org` process (e.g. a
-     *  different project directory) hosts the target org, and deliver over HTTP
-     *  if so. Off by default — tests and single-process runs don't need it. */
-    crossProcess?: boolean;
-    /** Base URL at which OTHER processes can reach this daemon's inbox (see
-     *  server.ts POST /api/xdeliver). Set this to make orgs hosted here
-     *  discoverable; omit for outbound-only cross-process delivery. */
-    inboxUrl?: string;
-    /** Override the broker's file registry directory (tests only). */
-    brokerDir?: string;
-    /** Override how long stopOrg() waits for agent sessions before proceeding anyway (tests only; default 15000ms). */
-    stopWaitMs?: number;
-}
-export declare class OrgDaemon {
-    private root;
-    private opts;
-    private orgs;
-    private waking;
-    private globalSubscribers;
-    private leases;
-    private forwarders;
-    private watchdogs;
-    private stopping;
-    constructor(root: string, opts?: DaemonOpts);
-    /** Publish this daemon's inbox so orgs started AFTER this call register with the broker. */
-    setInboxUrl(url: string): void;
-    /** subscribe to events from ALL running orgs (dashboard server uses this) */
-    subscribe(fn: (e: BusEvent) => void): () => void;
-    listOrgs(): RunningOrg[];
-    getOrg(name: string): RunningOrg | undefined;
-    /** Names of the orgs this daemon currently has running. Snapshot — safe to
-     *  iterate while stopOrg() mutates the underlying map. */
-    listRunning(): string[];
-    startOrg(name: string, taskOverride?: string): Promise<RunningOrg>;
-    /** A role that failed its resource gate at boot isn't abandoned — keep polling
-     *  for capacity in the background (bounded) and spawn it the moment resources
-     *  free up, instead of silently running the org shorthanded for its whole life.
-     *  Bails quietly if the org is stopped (or restarted under the same name)
-     *  before capacity returns; `running` is compared by identity, not `name`,
-     *  so a stale retry can never spawn into a different run. */
-    private scheduleDeferredSpawn;
-    /**
-     * Resolves an org_send `to` address ("role" for same-org, "org:role" for
-     * cross-org) into its parts. Centralizes the one addressing rule that
-     * matters (an "own-org:role" self-prefix is intra-org, not cross-org) so
-     * deliver()/deliverRemote() don't each re-derive it — the qualified `to`
-     * string returned is always the canonical display form for that address.
-     */
-    private resolveAddress;
-    /** Route a message. to = "role" (same org) or "org:role" (cross-org). Returns a receipt string. */
-    deliver(fromOrg: string, fromRole: string, to: string, subject: string, body: string): Promise<string>;
-    /** Cross-process leg of deliver(): ask the machine-local broker who hosts targetOrgName, then POST over HTTP.
-     *  `to` here is always the fully-qualified "org:role" display form (resolveAddress already normalized it). */
-    private deliverRemote;
-    /** Inbound handler for cross-process delivery — called by the server's POST /api/xdeliver route
-     *  when ANOTHER process's deliverRemote() reaches this daemon. Pushes straight into the target
-     *  agent's mailbox; the agent picks it up on its own next turn (see Mailbox — never interrupts). */
-    receiveRemote(toOrg: string, toRole: string, fromQualified: string, subject: string, body: string): {
-        ok: true;
-        receipt: string;
-    } | {
-        ok: false;
-        error: string;
-    };
-    private hasOrgDef;
-    private questionsPath;
-    private readQuestions;
-    private writeQuestions;
-    /** Agent-initiated human question (ask_human tool). Persists to questions.json (survives
-     *  process/dashboard restarts) and emits a 'question' BusEvent so the dashboard's SSE
-     *  stream and global inbox pick it up in real time. Returns a receipt string for the tool call. */
-    askHuman(org: string, role: string, question: string): Promise<string>;
-    /** Delivers a human's answer to a pending ask_human question. If the org is still
-     *  running, pushes straight into the role's live mailbox (picked up on its very next
-     *  generator tick — see Mailbox.stream()). If the org has since stopped, queues the
-     *  answer via the same offline fallback deliver()/receiveRemote() already use
-     *  (inbox.ts + autoWake) and it's delivered when the org next starts.
-     *
-     *  PERSIST-AFTER-DELIVERY: questions.json is only marked answered once delivery has
-     *  actually happened (mailbox push, or the message landing in inbox.jsonl). Marking it
-     *  first meant a rejected delivery — unknown role, mailbox closed mid-shutdown, a
-     *  queueMessage that threw on a full/read-only disk — left the question recorded as
-     *  answered while nobody ever received the answer, and the `already answered` guard
-     *  then refused every retry. The answer was simply gone. The inverse failure (crash
-     *  between delivery and the write) merely re-shows the question as pending, which a
-     *  human can act on; a silently swallowed answer is not recoverable. */
-    answerQuestion(org: string, role: string, questionId: string, answer: string): Promise<{
-        ok: true;
-    } | {
-        ok: false;
-        error: string;
-    }>;
-    /** Start an offline org in the background so queued messages get drained.
-     *  Fire-and-forget — errors are logged but don't propagate to the sender. */
-    private autoWake;
-    stopOrg(name: string): Promise<void>;
-    private finishStop;
-    stopAll(): Promise<void>;
-    private orgMemoryNamespace;
-    /** Store dir for org cross-run memory — inside the org root so the bridge's
-     *  path guard accepts it when the daemon runs from the project (the normal
-     *  case) and test roots stay isolated. */
-    private orgMemoryDbPath;
-    /** The memory bridge's traversal guard silently redirects out-of-tree paths
-     *  to the per-project default store. For an org rooted outside cwd (tests,
-     *  unusual daemon setups) that redirect would write into the WRONG project's
-     *  memory — verify the guard kept our path, and skip org memory otherwise. */
-    private orgMemoryUsable;
-    /** Namespace for a role's PRIVATE memories, inside the org memory DB. */
-    private agentMemoryNamespace;
-    /** org_remember implementation: a deliberate write to org-shared or
-     *  role-private memory (both in the org memory DB, split by namespace). */
-    private rememberOrgMemory;
-    /** Entry IDs served by org_recall during the current run, per org. This is
-     *  the usage record the run-outcome auto-rating consumes (cognee's
-     *  used_graph_element_ids pattern) — recall renders text to the agent, so
-     *  the IDs must be captured here or they're gone. */
-    private recallUsage;
-    /** org_recall implementation: search the org's memory namespace via the
-     *  memory bridge (semantic when the local model is available, tokenized
-     *  keyword otherwise). Failures return a message, never throw into the tool. */
-    private recallOrgMemory;
-    /** knowledge_search implementation for org agents: the user's Second Brain
-     *  (this project's documents + the personal global brain), merged with the
-     *  same project-first ranking every other surface uses. Failures return a
-     *  message, never throw into the tool call. */
-    searchProjectKnowledge(query: string): Promise<{
-        text: string;
-        hits: number;
-    }>;
-    /** org_learn implementation: merge coordinator-extracted entities/relations/
-     *  rules into the org's knowledge graph (LLM extraction happens inside the
-     *  agent's own subscription-auth SDK session — no separate LLM call here). */
-    private orgLearnedRuns;
-    private learnOrgKnowledge;
-    /** Persist the run's outcome into cross-run org memory so org_recall (and
-     *  future runs) can find it by meaning, not just recency. Best-effort. */
-    private storeRunMemory;
-    private persistState;
-    /** Mark every currently-running org as crashed in runtime.json.
-     *  Called from process-level crash handlers — must be synchronous and best-effort. */
-    persistCrashStateAll(): void;
-    private heartbeatPath;
-    /** Write a heartbeat file so `org status` can distinguish "daemon alive" from
-     *  "daemon gone" even when runtime.json still says running. */
-    writeHeartbeat(): void;
-    clearHeartbeat(): void;
-}
-export {};
-//# sourceMappingURL=daemon.d.ts.map