@vibefield/rosetta-room 0.0.0-stage → 0.1.0

package/dist/lib/transcript/collaboration.js

@@ -0,0 +1,423 @@
+import { linkedChildSessionIds } from "./ledger.js";
+import { canonicalText } from "./vocabulary.js";
+import { withinHistoryWindow } from "./history-window.js";
+/** Workflow workers belong to the workflow hierarchy even when pagination
+ * leaves their owning workflow row outside the loaded parent page. The title
+ * fallback keeps projections made before `workflow_run_id` was retained from
+ * leaking hundreds of legacy workflow workers into the parent timeline. */
+export function isWorkflowOwnedSession(session) {
+    if ((session.delegation?.workflow_run_id?.trim().length ?? 0) > 0)
+        return true;
+    return session.delegation !== null
+        && session.title?.trim().toLowerCase() === "workflow-subagent";
+}
+/** Only genuinely standalone workers may use the timestamp-based fallback.
+ * Workflow workers wait for their owning run and mount under their exact
+ * phase/worker row through `workerThreadLinks`. */
+export function standaloneWorkerSessions(children, links, indexedWorkflowChildren = new Set()) {
+    return children.filter((child) => !links.anchorRowByChild.has(child.id)
+        && !indexedWorkflowChildren.has(child.id)
+        && !isWorkflowOwnedSession(child));
+}
+const UNKNOWN_RUNTIME = {
+    basis: "unknown",
+    label: "runtime not recorded",
+    model: null,
+    effort: null,
+    profileCount: 0,
+};
+/** Response evidence wins over configuration. Split rows in one response are
+ * first joined by response id, then distinct model/effort pairs are counted. */
+export function runtimeProfile(rows, configuredModel, responseRuntimes = []) {
+    const responses = new Map();
+    for (const runtime of responseRuntimes) {
+        const current = responses.get(runtime.response_id) ?? { model: null, effort: null };
+        responses.set(runtime.response_id, {
+            model: current.model ?? runtime.model,
+            effort: current.effort ?? runtime.effort,
+        });
+    }
+    for (const row of rows) {
+        if (row.response === null || (row.model === null && row.effort === null))
+            continue;
+        const current = responses.get(row.response.id) ?? { model: null, effort: null };
+        responses.set(row.response.id, {
+            model: current.model ?? row.model,
+            effort: current.effort ?? row.effort,
+        });
+    }
+    const profiles = [
+        ...new Map([...responses.values()].map((profile) => [
+            `${profile.model ?? ""}\u0000${profile.effort ?? ""}`,
+            profile,
+        ])).values(),
+    ];
+    if (profiles.length > 1) {
+        return {
+            basis: "varies",
+            label: `varies · ${profiles.length} response profiles`,
+            model: null,
+            effort: null,
+            profileCount: profiles.length,
+        };
+    }
+    const observed = profiles[0];
+    if (observed !== undefined) {
+        const model = observed.model ?? "model unknown";
+        const effort = observed.effort === null ? "effort unknown" : `${observed.effort} effort`;
+        return {
+            basis: "observed",
+            label: `${model} · ${effort}`,
+            model: observed.model,
+            effort: observed.effort,
+            profileCount: 1,
+        };
+    }
+    if (configuredModel !== null) {
+        return {
+            basis: "configured",
+            label: `configured ${configuredModel} · effort unknown`,
+            model: configuredModel,
+            effort: null,
+            profileCount: 0,
+        };
+    }
+    return UNKNOWN_RUNTIME;
+}
+/** Direct child sessions that native evidence identifies as team members. */
+export function teamSessionIds(parentSessionId, directChildren, parentRows) {
+    const direct = new Map(directChildren
+        .filter((child) => child.parent_session_id === parentSessionId)
+        .map((child) => [child.id, child]));
+    const ids = new Set(directChildren
+        .filter((child) => child.parent_session_id === parentSessionId &&
+        (child.role === "team" || child.delegation?.team != null))
+        .map((child) => child.id));
+    for (const row of parentRows) {
+        if (row.body.type !== "tool_use")
+            continue;
+        const action = row.body.tool.action;
+        if (action.type !== "delegate" ||
+            action.team === null ||
+            action.child_session_id === null ||
+            !direct.has(action.child_session_id)) {
+            continue;
+        }
+        ids.add(action.child_session_id);
+    }
+    return [...ids].sort();
+}
+/** Roster facts and the start/add/resume operation for every proven team
+ * delegate row. The first observed member starts the team; subsequent rows add
+ * members unless the native request says resume. */
+export function teamMemberPresentations(rows, sessions, rowsBySession, responseRuntimesBySession = new Map(), historyComplete = true) {
+    const out = new Map();
+    const seenTeams = new Set();
+    for (const row of rows) {
+        if (row.body.type !== "tool_use")
+            continue;
+        const action = row.body.tool.action;
+        if (action.type !== "delegate" || action.team === null)
+            continue;
+        const session = action.child_session_id === null ? null : (sessions.get(action.child_session_id) ?? null);
+        const operation = action.resume_id !== null
+            ? "resume"
+            : seenTeams.has(action.team)
+                ? "add"
+                : historyComplete
+                    ? "start"
+                    : "known";
+        seenTeams.add(action.team);
+        const name = action.name ?? session?.title ?? action.agent_kind ?? session?.native_session_id ?? "teammate";
+        const memberRows = action.child_session_id === null ? [] : (rowsBySession.get(action.child_session_id) ?? []);
+        out.set(row.timeline_id, {
+            row,
+            session,
+            operation,
+            team: action.team,
+            name,
+            color: action.color ?? session?.delegation?.color ?? null,
+            objective: canonicalText(action.objective),
+            configuredModel: action.model ?? session?.delegation?.configured_model ?? null,
+            runtime: runtimeProfile(memberRows, action.model ?? session?.delegation?.configured_model ?? null, action.child_session_id === null
+                ? []
+                : (responseRuntimesBySession.get(action.child_session_id) ?? [])),
+        });
+    }
+    return out;
+}
+function participantKey(value) {
+    return value.trim().replace(/^@/, "").toLocaleLowerCase();
+}
+/** Resolve message senders back to roster facts. Names are native addresses;
+ * no timestamp or prose matching participates in this join. */
+export function teamParticipants(members, knownSessions = [], rowsBySession = new Map(), responseRuntimesBySession = new Map()) {
+    const out = new Map();
+    const bareTeam = new Map();
+    const ambiguous = new Set();
+    for (const member of members.values()) {
+        const presentation = {
+            color: member.color,
+            runtime: member.runtime,
+            sessionId: member.session?.id ?? null,
+        };
+        const names = [
+            member.name,
+            member.session?.title ?? null,
+            member.session?.native_session_id ?? null,
+        ];
+        for (const name of names) {
+            if (name === null || name.trim() === "")
+                continue;
+            const key = participantKey(name);
+            out.set(`${participantKey(member.team)}\u0000${key}`, presentation);
+            const previousTeam = bareTeam.get(key);
+            if (previousTeam === undefined && !ambiguous.has(key)) {
+                bareTeam.set(key, member.team);
+                out.set(key, presentation);
+            }
+            else if (previousTeam === member.team) {
+                out.set(key, presentation);
+            }
+            else {
+                bareTeam.delete(key);
+                ambiguous.add(key);
+                out.delete(key);
+            }
+        }
+    }
+    for (const session of knownSessions) {
+        const team = session.delegation?.team ?? null;
+        const name = session.title ?? session.native_session_id;
+        const presentation = {
+            color: session.delegation?.color ?? null,
+            runtime: runtimeProfile(rowsBySession.get(session.id) ?? [], session.delegation?.configured_model ?? null, responseRuntimesBySession.get(session.id) ?? []),
+            sessionId: session.id,
+        };
+        const key = participantKey(name);
+        if (team !== null)
+            out.set(`${participantKey(team)}\u0000${key}`, presentation);
+        if (!ambiguous.has(key)) {
+            const previousTeam = bareTeam.get(key);
+            const teamKey = team ?? "";
+            if (previousTeam === undefined || previousTeam === teamKey) {
+                bareTeam.set(key, teamKey);
+                out.set(key, presentation);
+            }
+            else {
+                bareTeam.delete(key);
+                ambiguous.add(key);
+                out.delete(key);
+            }
+        }
+    }
+    return out;
+}
+/** Native authored time is the shared-chronology stamp when present. The
+ * containing row time is an explicitly labelled observed-delivery fallback. */
+export function collaborationStamp(row) {
+    if (row.body.type !== "collaboration") {
+        return { at: row.at, basis: row.at === null ? "unknown" : "observed_arrival" };
+    }
+    if (row.body.event.authored_at !== null) {
+        return { at: row.body.event.authored_at, basis: "authored" };
+    }
+    return {
+        at: row.at,
+        basis: row.at === null ? "unknown" : "observed_arrival",
+    };
+}
+/** Add only delivered boundary events from team-member transcripts to the
+ * parent's chronology. The member's initial coordinator assignment stays
+ * private; later coordinator follow-ups are addressable team conversation and
+ * do interleave. A delivery id is the only cross-session dedupe key we trust;
+ * similar prose is never silently collapsed. Parent row order remains
+ * canonical, while child events enter the gap selected by native authored
+ * time, or their explicitly labelled observed-arrival fallback. */
+export function teamChronology(parentRows, rowsBySession, coverage) {
+    const seenTimelineIds = new Set(parentRows.map((row) => row.timeline_id));
+    const duplicateRepresentatives = new Map();
+    const candidates = [];
+    for (const rows of rowsBySession.values()) {
+        for (const row of rows) {
+            if (row.body.type !== "collaboration")
+                continue;
+            if (coverage !== undefined && (!coverage.ready ||
+                !withinHistoryWindow(collaborationStamp(row).at, parentRows, coverage.hasEarlier)))
+                continue;
+            if (row.body.event.channel === "coordinator" &&
+                row.body.event.kind === "assignment") {
+                continue;
+            }
+            if (seenTimelineIds.has(row.timeline_id))
+                continue;
+            seenTimelineIds.add(row.timeline_id);
+            candidates.push(row);
+        }
+    }
+    candidates.sort((left, right) => (collaborationStamp(left).at ?? Number.MAX_SAFE_INTEGER) -
+        (collaborationStamp(right).at ?? Number.MAX_SAFE_INTEGER) ||
+        left.session_id.localeCompare(right.session_id) ||
+        left.ordinal - right.ordinal ||
+        left.timeline_id.localeCompare(right.timeline_id));
+    // Delivered boundary evidence is the representative for a matching
+    // sender-side tool receipt. Parent boundary rows win over child copies;
+    // otherwise the earliest canonical child candidate wins. Text never participates.
+    const representativeByDelivery = new Map();
+    for (const row of [...parentRows, ...candidates]) {
+        if (row.body.type !== "collaboration")
+            continue;
+        const delivery = row.body.event.delivery_id;
+        if (delivery !== null && !representativeByDelivery.has(delivery)) {
+            representativeByDelivery.set(delivery, row);
+        }
+    }
+    const retainedParent = [];
+    for (const row of parentRows) {
+        const deliveryIds = row.body.type === "collaboration"
+            ? [row.body.event.delivery_id]
+            : row.body.type === "tool_use" && row.body.tool.action.type === "collaborate"
+                ? [
+                    row.body.tool.action.delivery_id,
+                    row.body.tool.correlation.key,
+                    row.body.tool.native.id,
+                ]
+                : [];
+        const representative = deliveryIds
+            .filter((value) => value !== null)
+            .map((delivery) => representativeByDelivery.get(delivery))
+            .find((candidate) => candidate !== undefined);
+        if (representative !== undefined && representative.timeline_id !== row.timeline_id) {
+            duplicateRepresentatives.set(row.timeline_id, representative.timeline_id);
+            continue;
+        }
+        retainedParent.push(row);
+    }
+    const additions = [];
+    for (const row of candidates) {
+        const delivery = row.body.type === "collaboration" ? row.body.event.delivery_id : null;
+        const representative = delivery === null ? undefined : representativeByDelivery.get(delivery);
+        if (representative !== undefined && representative.timeline_id !== row.timeline_id) {
+            duplicateRepresentatives.set(row.timeline_id, representative.timeline_id);
+            continue;
+        }
+        additions.push(row);
+    }
+    if (additions.length === 0) {
+        return {
+            rows: retainedParent.length === parentRows.length ? parentRows : retainedParent,
+            duplicateRepresentatives,
+        };
+    }
+    const buckets = Array.from({ length: retainedParent.length + 1 }, () => []);
+    // One bucket before each retained parent row and one after the last, so
+    // every index from 0 to retainedParent.length names a bucket.
+    const bucketAt = (index) => buckets[index];
+    for (const row of additions) {
+        const at = collaborationStamp(row).at;
+        const before = at === null
+            ? -1
+            : retainedParent.findIndex((parent) => parent.at !== null && parent.at > at);
+        bucketAt(before === -1 ? retainedParent.length : before).push(row);
+    }
+    const merged = [];
+    for (const [at, parent] of retainedParent.entries()) {
+        merged.push(...bucketAt(at), parent);
+    }
+    merged.push(...bucketAt(retainedParent.length));
+    return { rows: merged, duplicateRepresentatives };
+}
+export function interleaveTeamCollaboration(parentRows, rowsBySession) {
+    return teamChronology(parentRows, rowsBySession).rows;
+}
+export function participantPresentation(participants, sender, team = null) {
+    if (sender === null)
+        return null;
+    const key = participantKey(sender);
+    return ((team === null ? undefined : participants.get(`${participantKey(team)}\u0000${key}`)) ??
+        participants.get(key) ??
+        null);
+}
+/** Give an ordinary Agent worker exactly one subthread. The earliest proven
+ * invocation owns it; subsequent delegate/resume rows are links back to that
+ * same disclosure. Team children are excluded because their delivered speech
+ * belongs to the shared parent chronology instead. */
+export function workerThreadLinks(lines, parentSessionId, sessions, excludedSessionIds) {
+    const anchorRowByChild = new Map();
+    const childrenByRow = new Map();
+    const referencedChildIdsByRow = new Map();
+    for (const line of lines) {
+        const rowId = line.rows[0]?.timeline_id;
+        if (rowId === undefined)
+            continue;
+        const childIds = new Set(line.rows.flatMap((row) => linkedChildSessionIds(row)));
+        const nativeToolIds = new Set(line.rows.flatMap((row) => row.body.type === "tool_use"
+            ? [row.body.tool.correlation.key, row.body.tool.native.id].filter((value) => value !== null)
+            : []));
+        for (const child of sessions.values()) {
+            if (child.parent_session_id === parentSessionId &&
+                !excludedSessionIds.has(child.id) &&
+                child.delegation?.parent_tool_native_id != null &&
+                nativeToolIds.has(child.delegation.parent_tool_native_id)) {
+                childIds.add(child.id);
+            }
+        }
+        for (const childId of childIds) {
+            const child = sessions.get(childId);
+            if (child === undefined ||
+                child.parent_session_id !== parentSessionId ||
+                excludedSessionIds.has(child.id)) {
+                continue;
+            }
+            const anchor = anchorRowByChild.get(child.id);
+            if (anchor === undefined) {
+                anchorRowByChild.set(child.id, rowId);
+                const anchored = childrenByRow.get(rowId);
+                if (anchored === undefined)
+                    childrenByRow.set(rowId, [child]);
+                else
+                    anchored.push(child);
+            }
+            else if (anchor !== rowId) {
+                const references = referencedChildIdsByRow.get(rowId);
+                if (references === undefined)
+                    referencedChildIdsByRow.set(rowId, [child.id]);
+                else if (!references.includes(child.id))
+                    references.push(child.id);
+            }
+        }
+    }
+    return { anchorRowByChild, childrenByRow, referencedChildIdsByRow };
+}
+/** Recover report work only when canonical evidence names the exact source
+ * session and inclusive timeline bounds. A shared task id alone is not a
+ * safe range: teammates can overlap work on the same task. */
+export function taskBoundedReportWork(reportRow, sourceRows) {
+    if (reportRow.body.type !== "collaboration" ||
+        reportRow.body.event.kind !== "report" ||
+        reportRow.body.event.source_session_id === null ||
+        reportRow.body.event.source_response_id === null ||
+        reportRow.body.event.work_start_timeline_id === null ||
+        reportRow.body.event.work_end_timeline_id === null) {
+        return null;
+    }
+    const event = reportRow.body.event;
+    const ordered = [...sourceRows].sort((left, right) => left.ordinal - right.ordinal || left.timeline_id.localeCompare(right.timeline_id));
+    if (ordered.length === 0 ||
+        ordered.some((row) => row.session_id !== event.source_session_id)) {
+        return null;
+    }
+    const startAt = ordered.findIndex((row) => row.timeline_id === event.work_start_timeline_id);
+    const endAt = ordered.findIndex((row) => row.timeline_id === event.work_end_timeline_id);
+    if (startAt === -1 || endAt < startAt)
+        return null;
+    const rows = ordered.slice(startAt, endAt + 1);
+    if (!rows.some((row) => row.response?.id === event.source_response_id))
+        return null;
+    return {
+        rows,
+        actionCount: rows.filter((row) => row.body.type === "tool_use").length,
+        startedAt: rows.find((row) => row.at !== null)?.at ?? null,
+        endedAt: [...rows].reverse().find((row) => row.at !== null)?.at ?? null,
+    };
+}

package/dist/lib/transcript/families.d.ts

@@ -0,0 +1,212 @@
+import type { ParticipantColor, ResourceRef, TaskSnapshotItem, ToolAction } from "@vibefield/rosetta-protocol";
+import type { CanonicalDocument, CollaboratorRef, DisplayField, FileDelta, FindingItem, NativeToolRef, SourceLocation, UserAnswer, UserQuestion } from "./protocol.js";
+import type { LedgerContext, LedgerGlyph, ObjectPart, ToolFamily } from "./vocabulary.js";
+/** One pressable path in a detail — pre-split so the list draws like a line. */
+export interface PathFact {
+    readonly label: string;
+    readonly dir: string;
+    readonly name: string;
+    readonly resource: ResourceRef;
+    /** A read target's own source range, drawn beside that file in its detail. */
+    readonly range?: string;
+    /** Present only when this path is an exact file target of a canonical row.
+     * It is an address into that row, not a renderer-supplied filesystem path,
+     * so the daemon can reopen the recorded file without widening its read
+     * authority. */
+    readonly read?: {
+        readonly sessionId: string;
+        readonly timelineId: string;
+        readonly targetIndex: number;
+    };
+}
+/** A web result. The protocol keeps url and title only; the HOST is derived,
+ * and it is the key the renderer caches `https://<host>/favicon.ico` under. */
+export interface SourceFact {
+    readonly url: string;
+    readonly title: string | null;
+    readonly host: string | null;
+}
+/** A fetch's honest triple: final url, title, status — never the body. */
+export interface FetchFact {
+    readonly url: string | null;
+    readonly title: string | null;
+    readonly status: number | null;
+    readonly host: string | null;
+}
+/** One command inside a `command` or `code` detail. A fold carries several. */
+export interface CommandFact {
+    readonly command: string;
+    readonly cwd: string | null;
+    /** Whether this command ran at the session's settled root. */
+    readonly cwdIsSessionRoot: boolean;
+    readonly language: string | null;
+    readonly background: boolean;
+    readonly sourceTruncated: boolean;
+    readonly sessionId: string | null;
+    readonly timelineId: string | null;
+}
+/** The command row is a glanceable label, not a second source viewer. Keep
+ * its omission marker inside the 42-character contract. `Array.from` counts
+ * Unicode code points, matching Rust's projection boundary. */
+export declare const COMMAND_PREVIEW_CHARACTER_LIMIT = 42;
+export declare function commandPreviewText(text: string, sourceTruncated: boolean): string;
+export interface CommandDirectoryContext {
+    readonly label: string;
+    readonly title: string;
+}
+/** Directory context gets one compact badge on the detail frame. A mixed fold
+ * is named honestly rather than borrowing the first command's cwd for every
+ * member. */
+export declare function commandDirectoryContext(commands: readonly CommandFact[]): CommandDirectoryContext | null;
+/** `+18 −4` across however many files the one row changed. */
+export interface Diffstat {
+    readonly added: number | null;
+    readonly removed: number | null;
+    readonly fileCount: number;
+}
+/** Everything the delegate line knows before the child session is resolved. */
+export interface DelegateFact {
+    readonly childSessionId: string | null;
+    readonly agentKind: string | null;
+    readonly name: string | null;
+    readonly model: string | null;
+    /** Named only when native evidence proves persistent team membership. */
+    readonly team: string | null;
+    readonly color: ParticipantColor | null;
+    readonly resumeId: string | null;
+    readonly objective: string;
+    readonly background: boolean;
+    /** The child was never indexed; the record says draw its summary as prose. */
+    readonly orphanSummary: string | null;
+}
+export type WorkflowAction = Extract<ToolAction, {
+    readonly type: "workflow";
+}>;
+/** The durable Workflow document plus the exact file addresses exposed by
+ * the row. The first path, when present, is the workflow script; remaining
+ * paths are result resources discovered in the sidecar/callback. */
+export interface WorkflowFact {
+    readonly action: WorkflowAction;
+    readonly objective: string | null;
+    readonly script: PathFact | null;
+    readonly resources: readonly PathFact[];
+}
+/** The one task mutation this historical board is explaining. */
+export type TaskChange = "added" | "started" | "done" | "reopened" | "failed" | "cancelled" | "updated";
+/** The open task row is a status glimpse first; the reader can disclose the
+ * complete recorded board without turning every task event into a wall. */
+export declare const TASK_PREVIEW_LIMIT = 3;
+/** Pin the task this event changed to the bottom, where the eye lands after
+ * reading the board. The compact form keeps its two nearest preceding peers
+ * above it (filling from following peers only at the start of a board); the
+ * full form retains every other recorded task in its original relative order. */
+export declare function taskDisplayRows(tasks: readonly TaskSnapshotItem[], changedTaskId: string | null, full: boolean): TaskSnapshotItem[];
+/**
+ * What a ledger line opens into (§04's last column). `none` means the line has
+ * nothing honest to show. A read keeps no content in SQLite but does retain
+ * its target addresses; an `unknown` row keeps nothing at all.
+ */
+export type LedgerDetail = {
+    readonly kind: "none";
+} | {
+    readonly kind: "paths";
+    readonly paths: readonly PathFact[];
+    readonly total: number;
+    readonly description?: string;
+} | {
+    readonly kind: "locations";
+    readonly locations: readonly SourceLocation[];
+    readonly total: number;
+} | {
+    readonly kind: "sources";
+    readonly sources: readonly SourceFact[];
+    readonly total: number | null;
+} | {
+    readonly kind: "fetch";
+    readonly fetch: FetchFact;
+} | {
+    readonly kind: "fetches";
+    readonly fetches: readonly FetchFact[];
+} | {
+    readonly kind: "diff";
+    readonly deltas: readonly FileDelta[];
+    readonly diffstat: Diffstat;
+} | {
+    readonly kind: "command";
+    readonly commands: readonly CommandFact[];
+} | {
+    readonly kind: "code";
+    readonly commands: readonly CommandFact[];
+} | {
+    readonly kind: "names";
+    readonly names: readonly string[];
+    readonly total: number;
+} | {
+    readonly kind: "tasks";
+    readonly tasks: readonly TaskSnapshotItem[];
+    readonly total: number;
+    readonly changedTaskId: string | null;
+    readonly change: TaskChange | null;
+} | {
+    readonly kind: "text";
+    readonly text: string;
+} | {
+    readonly kind: "questions";
+    readonly questions: readonly UserQuestion[];
+    readonly answers: readonly UserAnswer[];
+} | {
+    readonly kind: "findings";
+    readonly findings: readonly FindingItem[];
+    readonly total: number;
+} | {
+    readonly kind: "document";
+    readonly document: CanonicalDocument;
+} | {
+    readonly kind: "fields";
+    readonly fields: readonly DisplayField[];
+    readonly resources: readonly PathFact[];
+} | {
+    readonly kind: "delegate";
+    readonly delegate: DelegateFact;
+} | {
+    readonly kind: "workflow";
+    readonly workflow: WorkflowFact;
+} | {
+    readonly kind: "participants";
+    readonly participants: readonly CollaboratorRef[];
+    readonly total: number;
+    readonly body: string | null;
+} | {
+    readonly kind: "diagnostic";
+    readonly diagnostic: string;
+};
+export type DetailKind = LedgerDetail["kind"];
+export interface FamilyProjection {
+    readonly family: ToolFamily;
+    readonly glyph: LedgerGlyph;
+    readonly verb: string;
+    readonly object: readonly ObjectPart[];
+    /** The family's own outcome sentence, before status and failure have their
+     * say. Null when the family has no outcome to state. */
+    readonly result: string | null;
+    /** `trace unavailable` and its kin: an outcome that IS the absence of one. */
+    readonly resultMuted: boolean;
+    readonly detail: LedgerDetail;
+    /** §04: a question, a finding and a structured document open by default —
+     * a question is conversation, and a finding is the point of the run. */
+    readonly openByDefault: boolean;
+}
+/**
+ * The §04 table as one function. `native` is only read by the `unknown` family,
+ * whose whole point is to name the tool the projector could not read.
+ */
+export declare function projectAction(action: ToolAction, native: NativeToolRef, context?: LedgerContext, source?: {
+    readonly sessionId: string;
+    readonly timelineId: string;
+} | null): FamilyProjection;
+/**
+ * `+18 −4`, and `+412` when nothing was removed — the record never writes a
+ * zero it did not measure. Null when the source kept no counts at all, which
+ * the caller renders as `no diff recorded`.
+ */
+export declare function diffstatText(added: number | null, removed: number | null): string | null;