@loompad/cli 0.1.0 → 1.1.2

package/dist/daemon/team-brain.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Team Brain — one project's share of the team's memory (Loom Teams, Phase 3,
+ * "one brain"; docs/teams-architecture.md D40–D51).
+ *
+ * What it does, and the decision each part serves:
+ *   - publishes this project's durable memories to the hub, sealed under the
+ *     team key with an HMAC so exact twins merge as confirmations (D13, D41).
+ *     Untrusted (D43) and private (D13) memories stay home; an author's edit is
+ *     an update, a local forget is a withdrawal (D40)
+ *   - holds the team's memories for this repo — snapshot, then the stream (D50)
+ *     — and the canon from AGENTS.md on origin's default branch (D44)
+ *   - builds the tiered pool every briefing ranks: canon > confirmed > own >
+ *     a teammate's proposal (D42), for this repo only (D51)
+ *   - keeps an inbox of what needs a human: contradictions, near-duplicates,
+ *     corrections awaiting resolution, untrusted memories, promotion candidates
+ *   - promotes memories to canon through one rolling `loom/canon` PR (D45, D46)
+ *   - writes the live team context block for briefings (D48)
+ */
+import { type Memory, type MemoryKind } from "../core/brain.js";
+import { type CanonEntry } from "../core/team-canon.js";
+import { type TeamKey } from "../core/team-crypto.js";
+import { type FeedEvent, type HubClient, type Lease, type TeamMemory } from "../core/team-hub.js";
+import type { TieredMemory } from "../core/team-memory.js";
+import type { ProjectRuntime } from "./runtime.js";
+export interface TeamBrainDeps {
+    hub(): HubClient | null;
+    deviceId(): string | null;
+    github(): string | null;
+    share(rt: ProjectRuntime): Promise<{
+        teamId: string;
+        repo: string;
+    } | null>;
+    keys(teamId: string): TeamKey[];
+    feed(teamId: string): FeedEvent[];
+    leases(teamId: string): Lease[];
+    /** Run a command in a directory (git, gh). Tests swap in fakes for `gh`. */
+    exec?(cmd: string, args: string[], cwd: string): Promise<string>;
+}
+export declare const CANON_BRANCH = "loom/canon";
+export interface InboxItem {
+    id: string;
+    type: "contradiction" | "duplicate" | "correction" | "untrusted" | "promote";
+    detail: string;
+    a: MemoryView;
+    b?: MemoryView;
+}
+export interface MemoryView {
+    id: string;
+    text: string;
+    kind: MemoryKind;
+    tier: TieredMemory["tier"];
+    author: string | null;
+    confirmedBy: string[];
+    mine: boolean;
+    untrusted?: boolean;
+}
+export declare function shareable(m: Memory): boolean;
+export declare class TeamBrain {
+    private rt;
+    private deps;
+    /** Every team memory for this repo, every state (history too — D47 keeps losers). */
+    private cache;
+    private opened;
+    private canon;
+    private share;
+    private syncing;
+    private timer;
+    private unsub;
+    /** Last error from a publish/sync, for the UI. */
+    lastError: string | null;
+    constructor(rt: ProjectRuntime, deps: TeamBrainDeps);
+    stop(): void;
+    private exec;
+    private soon;
+    get teamId(): string | null;
+    /** One pass: learn the share, backfill the team's memories once, publish ours, refresh canon. */
+    sync(): Promise<void>;
+    private doSync;
+    /** A hub event about a memory in our team. */
+    onMemory(m: TeamMemory): void;
+    private key;
+    private open;
+    /**
+     * Make the hub agree with this project's brain, idempotently and without any
+     * local bookkeeping: the cache says what the team already has.
+     */
+    private publish;
+    /** Publish one correction to a teammate's memory (D40): a new memory that supersedes theirs. */
+    correct(targetId: string, text: string): Promise<TeamMemory>;
+    /** Settle a contradiction or a correction (D47): the loser is kept, superseded, linked. */
+    resolve(winnerId: string, loserId: string, reason: string): Promise<void>;
+    /** A local-only memory that's about to be resolved has to exist on the hub first. */
+    private ensurePublished;
+    private defaultBranch;
+    /** D44: canon is what AGENTS.md on origin's default branch says. */
+    loadCanon(): Promise<CanonEntry[]>;
+    canonEntries(): CanonEntry[];
+    /**
+     * D45: put memories up for canon on the one rolling `loom/canon` PR. Built
+     * fresh from the default branch each time — its canon, plus what's already
+     * pending on the branch, plus these — so a merged PR never leaves the branch
+     * behind, and the PR always shows exactly what isn't canon yet.
+     */
+    promote(ids: string[]): Promise<{
+        branch: string;
+        prUrl: string | null;
+        added: number;
+        note?: string;
+    }>;
+    private announce;
+    /**
+     * Canon, the team's live memories and this project's own, as one tiered
+     * pool — or null when the project isn't shared (the solo brain applies).
+     */
+    pool(own?: Memory[]): TieredMemory[] | null;
+    /** One memory as the UI shows it, from any tier. */
+    view(id: string): MemoryView | null;
+    /** Every live team memory plus the canon, for the Team view (D49). */
+    memories(opts?: {
+        history?: boolean;
+    }): Array<MemoryView & {
+        state: TeamMemory["state"];
+        supersedes?: string;
+        supersededBy?: string;
+        resolvedBy?: string;
+        resolvedReason?: string;
+    }>;
+    inbox(): InboxItem[];
+    /**
+     * What teammates are doing near this work, right now: their leases on these
+     * paths, open PRs that change them, failing checks, predicted conflicts.
+     * ≤1.5k chars; "" when there's nothing near.
+     */
+    context(files?: string[]): string;
+    status(): Record<string, unknown>;
+}