dsh-brief-sidebar 0.3.0

package/lib/types/client/BriefIcon.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Tab glyph for the task board.
+ *
+ * Skin contract: plugin-drawn glyphs take their colour from the `--dsw-alias-*`
+ * tokens — no colour literals anywhere in this file.
+ */
+import type { ReactNode } from 'react';
+/**
+ * A checklist mark: three rows with ticks and text rails — the same status
+ * vocabulary the board paints.
+ * @param size - square edge in px (the host passes its own tab-icon size).
+ */
+export declare function BriefIcon(size: number): ReactNode;

package/lib/types/client/SummaryTab.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from 'react';
+import type { Context } from '@deepseek-ai/cordis';
+import type { TodoScope } from './TodoBoardTab';
+export interface SummaryTabProps {
+    /** The DSH locale lookup, passed down from `apply`. */
+    t: (key: string) => string;
+    /** The client root context (the tab body's only way to reach services). */
+    ctx?: Context;
+    /** The session this tab is scoped to. */
+    scope?: TodoScope;
+    /** Whether the tab is the active one AND the panel is open. */
+    visible?: boolean;
+}
+/**
+ * The summary tab.
+ * @param props - translation, client context, session scope, visibility.
+ */
+export declare function SummaryTab(props: SummaryTabProps): ReactNode;

package/lib/types/client/TodoBoardTab.d.ts

@@ -0,0 +1,31 @@
+import type { ReactNode } from 'react';
+import type { Context } from '@deepseek-ai/cordis';
+/** The session scope better-sidebar hands a tab body. */
+export interface TodoScope {
+    readonly sessionId?: string;
+}
+export interface TodoSectionProps {
+    /** The DSH locale lookup, passed down from `apply`. */
+    t: (key: string) => string;
+    /** The client root context (the tab body's only way to reach services). */
+    ctx?: Context;
+    /** The session this tab is scoped to. */
+    scope?: TodoScope;
+}
+/** Centred message block used by every non-list state. */
+export declare function Notice(props: {
+    title: string;
+    detail?: string;
+}): ReactNode;
+/**
+ * The progress section. The subscription is unconditional (a plain listener,
+ * not IO); the three-state contract of the projection is preserved verbatim.
+ * @param props - translation, client context, session scope.
+ */
+export declare function TodoSection(props: TodoSectionProps): ReactNode;
+/**
+ * Backwards-compatible alias for the pre-summary export name. The component
+ * no longer owns the full-height shell — that moved to `SummaryTab` — so the
+ * alias exists only to keep import sites honest during the transition.
+ */
+export declare const TodoBoardTab: typeof TodoSection;

package/lib/types/client/brief/board.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The `todos` projection — reading and classifying it.
+ *
+ * The Host computes this projection (`dsh-tool-todo` registers the key) and
+ * pushes finished whole values; the client never folds it. This module is the
+ * read side of that contract and is deliberately PURE — no React, no context,
+ * no IO — so the mapping can be tested directly.
+ */
+/** The projection's three-state lifecycle (`TodoItem` in `dsh-tool-todo`). */
+export type TodoStatus = 'pending' | 'in_progress' | 'completed';
+/** One entry of the `todos` projection. */
+export interface TodoItem {
+    readonly content: string;
+    readonly status: TodoStatus;
+}
+/** Locale key for one status label. */
+export declare function statusKey(status: TodoStatus): string;
+/**
+ * Narrow a raw projection value into a todo list.
+ *
+ * Three outcomes are kept apart on purpose, mirroring the store's own contract:
+ * - `undefined` — the capability is ABSENT (no session, the host unit is
+ *   unmounted, or no baseline/frame has carried the key yet);
+ * - `[]` — the projection is present and the list is empty (`null` on the wire);
+ * - a list — real entries.
+ *
+ * A malformed entry is dropped rather than thrown on: the projection is a
+ * trusted Host value, but a shape drift must not blank the whole board.
+ *
+ * @param value - the raw `unknown` snapshot of the `todos` face.
+ * @returns the validated list, or `undefined` when the capability is absent.
+ */
+export declare function readTodos(value: unknown): readonly TodoItem[] | undefined;
+/** Per-status counts over one list. */
+export interface TodoCounts {
+    readonly total: number;
+    readonly completed: number;
+    readonly inProgress: number;
+    readonly pending: number;
+}
+/** Count a todo list by status. */
+export declare function countTodos(todos: readonly TodoItem[]): TodoCounts;
+/** How many entries are not finished — the tab badge. */
+export declare function unfinishedCount(todos: readonly TodoItem[]): number;
+/**
+ * The one-line progress summary, composed from parts so no interpolation
+ * machinery is needed (the locale binder is a plain key → string lookup).
+ * Mirrors the official dock's own label.
+ */
+export declare function progressLine(counts: TodoCounts, t: (key: string) => string): string;

package/lib/types/client/brief/dock-shadow.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Hiding the official todo dock.
+ *
+ * `conversation.input.dock` is a LIST slot, and its cells are keyed by each
+ * entry's `id`. The slot core keeps one live entry per cell — entries are
+ * sorted by `priority` ascending (then by `order`) and the first live entry of
+ * a cell is the one the outlet renders, so a SECOND registration with the same
+ * `id` at a LOWER priority shadows the first. The official todo entry
+ * (`conversation-todo-dock` in `dsh-client-ui-conversation`) registers
+ * `{ id: 'todo', order: 0 }` with the default priority 0, so
+ * `{ id: 'todo', priority: -1 }` wins the cell and the official panel never
+ * renders while this plugin is mounted.
+ *
+ * This is the same mechanism `dsh-input-traffic` uses on the sibling `queue`
+ * cell (`{ id: 'queue', priority: -1 }`), so it is a proven seam on this host
+ * generation, not a guess.
+ *
+ * Binding to a built-in id is a real coupling: if upstream renames the cell,
+ * the shadow silently stops winning and the official dock simply reappears
+ * (fail-open — the data is still shown, just twice). `slots.inject` is used
+ * rather than a bare `register` because the slot is declared by a built-in
+ * entry whose lifetime we do not control: `inject` waits for the declaration
+ * and re-installs the entry if the declaration is ever recreated.
+ *
+ * Renders nothing on purpose: the todo UI now lives in this plugin's sidebar
+ * tab. Return a summary chip here instead to keep a one-line entry point in the
+ * composer band.
+ */
+import type { ReactNode } from 'react';
+import type { Context } from '@deepseek-ai/cordis';
+/** The built-in cell id of the official todo dock. */
+export declare const TODO_CELL_ID = "todo";
+/** Lower than the built-in's default 0 — the winner of the `todo` cell. */
+export declare const TODO_SHADOW_PRIORITY = -1;
+/** Structural view of the client slots service (avoids a second type graph). */
+export interface SlotsLike {
+    inject(key: string, callback: () => (() => void) | undefined): () => void;
+    register(options: Record<string, unknown>, component: (props: unknown) => ReactNode): () => void;
+}
+/**
+ * Register the shadowing entry.
+ *
+ * The caller wraps this in `ctx.effect(...)` so the returned disposer rides the
+ * plugin fiber: unloading the plugin restores the official dock.
+ *
+ * @param ctx - the client root context.
+ * @returns the disposer, or undefined when the slots service is unreachable.
+ */
+export declare function registerTodoDockShadow(ctx: Context): (() => void) | undefined;

package/lib/types/client/brief/use-todos.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { TodoItem } from './board';
+/** The projection key registered by `dsh-tool-todo`. */
+export declare const TODOS_KEY = "todos";
+/**
+ * Subscribe to one session's todo list.
+ *
+ * @param ctx - the client root context.
+ * @param sessionId - the session whose projection is shown.
+ * @returns the list, `[]` for a present-but-empty projection, or `undefined`
+ *   while the capability is absent.
+ */
+export declare function useTodos(ctx: Context | undefined, sessionId: string | undefined): readonly TodoItem[] | undefined;

package/lib/types/client/file-open.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Opening a produced file's preview in the right Sidebar — the same channel
+ * the conversation flow uses for its produced-file chips and inline mentions
+ * (ui-chat `openFile` → `ctx.sidebarRight.openResource` with a
+ * `dsh-resource://file/…` address).
+ *
+ * The address grammar is ported verbatim from the harness's browser-safe
+ * `@deepseek-ai/dsh-util-workspace-path` (`file-address.ts` / `index.ts`),
+ * because the plugin does not compile against that package: a relative path,
+ * or an absolute path inside the session's workspace, is addressed under the
+ * session's scope (`dsh-resource://file/session/<id>/<path>`); an absolute
+ * path elsewhere keeps its absolute spelling in the same session's address.
+ * Which tab type claims the address is the Sidebar's decision, not ours.
+ *
+ * The `sidebarRight` service is consumed structurally and treated as OPTIONAL:
+ * where it is absent the section renders plain rows instead of links, the same
+ * graceful degradation as the deliverables projection itself.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Structural view of the right-Sidebar service this plugin needs. */
+export interface SidebarRightLike {
+    openResource(url: string, options?: {
+        params?: {
+            line?: number;
+        };
+    }): void;
+}
+/**
+ * Whether a path is absolute in either spelling the Host accepts: POSIX (`/a/b`)
+ * or Windows drive or UNC.
+ */
+export declare function isAbsoluteWorkspacePath(path: string): boolean;
+/**
+ * The address for a path as a caller holds it.
+ * @param sessionId - the Session the path is read in.
+ * @param cwd - that Session's workspace root, when known.
+ * @param path - absolute or workspace-relative path, in either separator spelling.
+ */
+export declare function fileAddressFor(sessionId: string, cwd: string | undefined, path: string): string;
+/**
+ * Build a sidebar file opener for one session, or `undefined` when the
+ * environment cannot open previews (no `sidebarRight` service, no session).
+ * The cwd is re-read per call inside the opener, so a workspace switch between
+ * renders is picked up on the next click.
+ *
+ * @param ctx - the client root context.
+ * @param sessionId - the session whose workspace resolves paths.
+ * @returns an opener that routes a produced path to the Sidebar preview.
+ */
+export declare function sidebarFileOpener(ctx: Context | undefined, sessionId: string | undefined): ((path: string) => void) | undefined;

package/lib/types/client/index.d.ts

@@ -0,0 +1,23 @@
+import type { Context } from '@deepseek-ai/cordis';
+/**
+ * Tab type id. Package-prefixed so it cannot collide with a built-in type.
+ * Unchanged since the 0.1.0 board tab: the summary tab REPLACES the board tab
+ * in place, so an opened or pinned tab survives the upgrade.
+ */
+export declare const TAB_ID = "dsh-brief-sidebar:board";
+/**
+ * Position in the host's new-tab guide.
+ *
+ * Built-ins on this host generation sit at editor 10 / git 20 / subagent 30 /
+ * sidechat 35 / terminal 40 / browser 50. 15 places a per-session task board
+ * right after the editor, which is where a reader looks for session state.
+ */
+export declare const TAB_ORDER = 15;
+/** Services required before `apply` runs. */
+export declare const inject: string[];
+/**
+ * Browser-face apply.
+ *
+ * @param ctx - the client root context.
+ */
+export declare function apply(ctx: Context): void;

package/lib/types/client/locales.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Plugin-owned i18n dictionaries.
+ *
+ * Consumer plugins must NOT reach into better-sidebar's internal `t()` or its
+ * `betterSidebar` dictionary namespace, so this plugin registers its own
+ * namespace through the DSH `locale` service. `dsh-brief-sidebar` is outside the
+ * `LocaleNamespaceMap` merge table, which is exactly what the untyped
+ * `register(ns, dicts)` overload is for — but the dictionaries themselves stay
+ * strictly paired: `zh` is the key-set source of truth and `en` is typed as
+ * `Record<keyof typeof zh, string>`, so a missing or extra English key is a
+ * COMPILE error rather than a runtime fallback to the raw key.
+ *
+ * Every key referenced anywhere in `src/**` must exist in both dictionaries;
+ * `tests/purity.spec.ts` asserts that, so a typo in a `t('…')` call cannot
+ * ship as an untranslated literal.
+ */
+/** The namespace owned by this plugin (own vocabulary, own lifecycle). */
+export declare const NS = "dsh-brief-sidebar";
+/** Simplified Chinese dictionary — the key-set source of truth. */
+export declare const zh: {
+    'tab.title': string;
+    'tab.desc': string;
+    'section.progress': string;
+    'section.deliverables': string;
+    'board.empty': string;
+    'board.emptyHint': string;
+    'board.unavailable': string;
+    'board.unavailableHint': string;
+    'status.pending': string;
+    'status.inProgress': string;
+    'status.completed': string;
+    'deliverables.empty': string;
+    'deliverables.emptyHint': string;
+    'deliverables.sessionTotal': string;
+    'deliverable.codeplanTag': string;
+};
+/** The key union: what a `t('…')` call may name inside this namespace. */
+export type BriefKey = keyof typeof zh;
+/** English dictionary, checked complete against the zh key set. */
+export declare const en: Record<BriefKey, string>;
+/**
+ * Both locales in the shape the locale service consumes. Registered in ONE
+ * call: the registry rejects a duplicate `(namespace, locale)` pair and the
+ * per-locale form would leave a half-registered namespace if the second call
+ * threw.
+ */
+export declare const dictionaries: Record<string, Record<string, string>>;
+/**
+ * Expand the one `{count}` placeholder the deliverables totals line uses. The
+ * locale binder is a plain key → string lookup (no interpolation machinery),
+ * mirroring how `progressLine` composes its summary from parts.
+ */
+export declare function expandCount(template: string, count: number): string;

package/lib/types/client/summary/DeliverablesSection.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from 'react';
+import type { Context } from '@deepseek-ai/cordis';
+export interface DeliverablesSectionProps {
+    /** The DSH locale lookup, passed down from `apply`. */
+    t: (key: string) => string;
+    /** The client root context (the tab body's only way to reach services). */
+    ctx?: Context;
+    /** The session this tab is scoped to. */
+    scope?: {
+        readonly sessionId?: string;
+    };
+}
+/**
+ * The deliverables section. The subscription is unconditional (a plain
+ * listener, not IO).
+ * @param props - translation, client context, session scope.
+ */
+export declare function DeliverablesSection(props: DeliverablesSectionProps): ReactNode;

package/lib/types/client/summary/deliverables.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The `dshSummaryDeliverables` projection — reading and classifying it.
+ *
+ * The Host computes this projection (this plugin's own node half registers the
+ * unit) and pushes finished whole values; the client never folds it. This
+ * module is the read side of that contract and is deliberately PURE — no
+ * React, no context, no IO — so the narrowing and the codeplan classification
+ * can be tested directly.
+ */
+import type { DeliverablesView } from '../../projection/keys';
+/**
+ * Narrow a raw projection value into a deliverables view.
+ *
+ * Two outcomes are kept apart on purpose, mirroring the store's contract:
+ * - `undefined` — the capability is ABSENT (the host half never registered —
+ *   e.g. an older composition — or no frame carried the key yet);
+ * - a view — the projection is live. A view with `latest: null` and
+ *   `sessionTotal: 0` IS the empty state; the fold starts publishing as soon
+ *   as the unit registers, so "present but empty" is a real value here, not a
+ *   sentinel.
+ *
+ * @param value - the raw `unknown` snapshot of the deliverables face.
+ * @returns the validated view, or `undefined` when the capability is absent.
+ */
+export declare function readDeliverables(value: unknown): DeliverablesView | undefined;
+/** Whether a produced path is a codeplan artifact. */
+export declare function isCodeplanPath(path: string): boolean;
+/**
+ * Split a codeplan path into its task name and file name.
+ *
+ * @param path - a produced path; need not actually be a codeplan artifact.
+ * @returns task and file names, or `null` when the path is not under the
+ *   codeplan plans directory (or names no file beneath the task folder).
+ */
+export declare function splitCodeplanPath(path: string): {
+    task: string;
+    file: string;
+} | null;
+/** The final path segment, under either separator. */
+export declare function basename(path: string): string;

package/lib/types/client/use-projection.d.ts

@@ -0,0 +1,54 @@
+import type { Context } from '@deepseek-ai/cordis';
+/** Structural view of a projection face (`ObservableSnapshot<unknown>`). */
+export interface ProjectionFace {
+    getSnapshot(): unknown;
+    subscribe(listener: () => void): () => void;
+}
+/** Structural view of one session binding's projection store. */
+export interface ProjectionsLike {
+    faceOf(key: string): ProjectionFace;
+}
+/** Structural view of the client Session Controller face this plugin uses. */
+export interface SessionsLike {
+    binding(id: string): {
+        readonly session: {
+            readonly projections: ProjectionsLike;
+        };
+    } | undefined;
+}
+/**
+ * Resolve one projection face for one session.
+ *
+ * `ctx.get('sessions')` is the safe accessor (a direct `ctx.sessions` read can
+ * throw on a context that does not carry the service yet).
+ *
+ * @param ctx - the client root context handed to the tab body.
+ * @param sessionId - the tab's session scope; undefined means "no session".
+ * @param key - the projection key to resolve.
+ * @returns the projection face, or {@link ABSENT} when unreachable.
+ */
+export declare function resolveFace(ctx: Context | undefined, sessionId: string | undefined, key: string): ProjectionFace;
+/**
+ * Read one frame of a projection without subscribing.
+ *
+ * The one-shot sibling of {@link useProjectionValue}, for consumers that are
+ * not React components — the tab badge is a plain function called on every
+ * tab-bar render, so it must neither hold a subscription nor allocate one.
+ *
+ * @param ctx - the client root context.
+ * @param sessionId - the session whose projection is read.
+ * @param key - the projection key to read.
+ * @returns the raw snapshot: `undefined` while the capability is absent; the
+ *   semantics of any other value belong to the projection's own contract.
+ */
+export declare function projectionSnapshot(ctx: Context | undefined, sessionId: string | undefined, key: string): unknown;
+/**
+ * Subscribe to one session projection by key.
+ *
+ * @param ctx - the client root context.
+ * @param sessionId - the session whose projection is shown.
+ * @param key - the projection key to subscribe to.
+ * @returns the raw snapshot value, identity-stable across frames the host did
+ *   not change. Narrowing is the caller's job.
+ */
+export declare function useProjectionValue(ctx: Context | undefined, sessionId: string | undefined, key: string): unknown;

package/lib/types/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Node half of the brief sidebar plugin.
+ *
+ * The Cordis loader needs an entry point for the profile row; the browser half
+ * (`./client`, served by `dsh-client-modules`) renders the summary tab.
+ *
+ * Since the summary upgrade, this half owns ONE behaviour: contributing the
+ * `dshSummaryDeliverables` projection unit (see `./projection/register`), which
+ * folds successful mutation calls into a live produced-file feed. The
+ * contribution is optional — `registerDeliverablesProjection` waits for the
+ * `sessionProjections` service via `ctx.inject`, so a composition without the
+ * registry still loads this profile row and simply hides the deliverables
+ * section client-side.
+ *
+ * In particular this half still never touches the filesystem at load time: a
+ * profile row is instantiated on the boot path, and a synchronous read there
+ * would delay the host's startup. The fold is event-driven and stores paths
+ * only.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Profile row identity. */
+export declare const name = "dsh-brief-sidebar";
+/**
+ * Node-face apply.
+ * @param ctx - the host context the loader hands this profile row.
+ */
+export declare function apply(ctx: Context): void;

package/lib/types/projection/deliverables-fold.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Host-side fold of produced-file facts — the projection unit state for
+ * `dshSummaryDeliverables`.
+ *
+ * The vocabulary is the one the harness's own deliverables experience uses
+ * (`ui-deliverables/turn-deliverables.ts`): the arguments of successful
+ * first-party mutation calls (`write`, `edit`, and the mutating
+ * `str_replace_editor` commands), never presentation data or prose. Reads,
+ * deletes, unsupported tools, malformed calls, and failed results contribute
+ * nothing; a file written and then edited in the same turn is one entry, in
+ * first-seen order.
+ *
+ * This module is deliberately PURE — no cordis, no zod, no IO — so the fold
+ * can be tested directly against hand-written event fixtures. The projection
+ * registry drives it once per committed `session/event`, which is what makes
+ * the produced list update mid-turn, the gap the official turn-tail row has.
+ */
+/** One bucket: the paths produced so far in one turn, first-seen order. */
+export interface DeliverablesTurnBucket {
+    readonly turn: number;
+    readonly paths: readonly string[];
+}
+/** Fold state. Plain JSON, so the projection cache can persist it. */
+export interface DeliverablesState {
+    /** Turn number of the open (or latest seen) turn; 0 before the first turn. */
+    readonly turn: number;
+    /** Open turn's `callId → mutation path` map (`null` = not a mutation call). */
+    readonly calls: Readonly<Record<string, {
+        readonly turn: number;
+        readonly path: string | null;
+    }>>;
+    /** Paths accumulated in the latest turn so far (`null` before the first turn). */
+    readonly latest: DeliverablesTurnBucket | null;
+    /** Every distinct produced path, most-recent-first, capped (see CAPS). */
+    readonly sessionPaths: readonly string[];
+    /** Distinct produced paths over the whole session, uncapped. */
+    readonly sessionTotal: number;
+}
+/**
+ * Wire-view capacity bounds. The projection rides every event frame, so the
+ * lists are capped; the uncapped `sessionTotal` keeps the summary truthful
+ * beyond the cap.
+ */
+export declare const CAPS: {
+    /** Latest-turn paths kept in the wire view. */
+    readonly latest: 50;
+    /** Session-wide paths kept in the wire view (most recent win). */
+    readonly session: 100;
+};
+/** The fold's initial state: nothing has happened yet. */
+export declare function initDeliverablesState(): DeliverablesState;
+/**
+ * Structural view of one committed session event. The registry hands the
+ * host's discriminated union; the fold only needs `type` and `data`, and the
+ * tool-event shapes mirror `dsh-session` types: `tool/call` carries
+ * `{ turn, step, callId, name, arguments }`, `tool/result` carries
+ * `{ turn, step, message: { content: [{ isError? }], source: { callId } } }`,
+ * `turn/start` carries `{ turn }`.
+ */
+export interface FoldEvent {
+    readonly type: string;
+    readonly data: unknown;
+}
+/**
+ * The next state after one committed event. Events the fold does not own
+ * return the SAME reference — an unchanged reference produces zero downstream
+ * work in the registry's `Object.is` drive.
+ *
+ * @param state - the state covering all prior events.
+ * @param event - the next committed session event.
+ * @returns the next state (same reference when nothing the fold tracks moved).
+ */
+export declare function applyDeliverablesEvent(state: DeliverablesState, event: FoldEvent): DeliverablesState;
+/**
+ * Extract the path from a supported first-party mutation call.
+ *
+ * Ported from the harness deliverables fold so both carriers agree on what a
+ * "produced file" is. Session `tool/call` events are root calls; PTC dispatch
+ * children do not enter this fold independently.
+ *
+ * @param name - wire tool name.
+ * @param argsRaw - model-produced JSON arguments.
+ * @returns the mutation path, or null when the call is not a supported mutation.
+ */
+export declare function mutationPath(name: string, argsRaw: string): string | null;

package/lib/types/projection/keys.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The projection key this plugin contributes to the session-projection
+ * registry, and its wire view.
+ *
+ * The key is namespaced with the plugin name on purpose: the registry refuses
+ * to share a key across differing `stateVersion`s, so a collision with a
+ * future host-side deliverables unit would be a hard load error, not a silent
+ * shadow. The view type is declared structurally (the plugin has no compile
+ * dependency on `@deepseek-ai/dsh-session-projection`); the registry accepts
+ * any string key at runtime.
+ */
+/** The projection key registered by this plugin's host half. */
+export declare const DELIVERABLES_KEY = "dshSummaryDeliverables";
+/** Client view of the produced-file fold (JSON-safe). */
+export interface DeliverablesView {
+    /** Paths produced in the latest turn, first-seen order (capped). */
+    readonly latest: {
+        readonly turn: number;
+        readonly paths: readonly string[];
+    } | null;
+    /** Distinct produced paths session-wide, most-recent-first (capped). */
+    readonly sessionPaths: readonly string[];
+    /** Distinct produced paths session-wide, uncapped — the truthful total. */
+    readonly sessionTotal: number;
+}

package/lib/types/projection/register.d.ts

@@ -0,0 +1,9 @@
+import type { Context } from '@deepseek-ai/cordis';
+/**
+ * Register the deliverables projection as an optional contribution.
+ *
+ * @param ctx - the host context the plugin's `apply` receives.
+ * @returns nothing; the registration's disposer rides the injected fiber, so
+ *   unloading the plugin removes the key (clients then read capability absence).
+ */
+export declare function registerDeliverablesProjection(ctx: Context): void;