dsh-thinking-guard 0.1.19 → 0.1.21

package/lib/types/usage/call-index-wire.d.ts

@@ -0,0 +1,286 @@
+/**
+ * Browser-safe wire contract for the `callIndex` Remote namespace (D-026).
+ *
+ * This module is the single place both faces agree on. It is imported at
+ * RUNTIME by the browser contribution (`src/client/call-index-remote.ts`) and by
+ * the Host face (`src/usage/call-index-host-face.ts`), so it may only depend on
+ * `zod`; it must never runtime-import a Node module or `session-index.ts` (a
+ * type-only import is fine because it is erased before the browser bundle).
+ *
+ * @module dsh-thinking-guard/usage/call-index-wire
+ */
+import { z } from 'zod';
+/** Every reply kind on the `callIndex` wire. */
+export declare const CALL_INDEX_REPLY_KINDS: readonly ["status", "task", "summary", "sessions", "calls", "detail", "error"];
+export type CallIndexReplyKind = (typeof CALL_INDEX_REPLY_KINDS)[number];
+/** Stable failure codes; anything else normalizes to `internal-error`. */
+export declare const CALL_INDEX_ERROR_REASONS: readonly ["invalid-request", "scope-disabled", "persistence-unavailable", "cursor-stale", "query-capacity", "reply-too-large", "not-visible", "runtime-unavailable", "task-not-found", "internal-error"];
+export type CallIndexErrorReason = (typeof CALL_INDEX_ERROR_REASONS)[number];
+/** Call statuses mirrored from `CallIndexRow.outcome`. */
+export declare const CALL_INDEX_OUTCOMES: readonly ["success", "error", "cancelled", "unresolved", "unknown", "running"];
+export type CallIndexOutcome = (typeof CALL_INDEX_OUTCOMES)[number];
+/** Known call source categories (the core currently emits only `unknown`). */
+export declare const CALL_INDEX_SOURCE_KINDS: readonly ["mcp", "plugin-tool", "native", "skill", "unknown"];
+export type CallIndexSourceKind = (typeof CALL_INDEX_SOURCE_KINDS)[number];
+/** Shared literal bounds; Host and browser must agree. */
+export declare const CALL_INDEX_MAX_ID_LENGTH = 512;
+export declare const CALL_INDEX_MAX_CWD_LENGTH = 4096;
+export declare const CALL_INDEX_MAX_CURSOR_LENGTH = 256;
+export declare const CALL_INDEX_DEFAULT_LIMIT = 50;
+export declare const CALL_INDEX_MAX_LIMIT = 200;
+export declare const CALL_INDEX_DEFAULT_TTL_MS = 60000;
+export declare const CALL_INDEX_DEFAULT_MAX_VIEWS = 4;
+export declare const CALL_INDEX_DEFAULT_MAX_BYTES: number;
+export declare const CALL_INDEX_MAX_REPLY_BYTES: number;
+/**
+ * Reply envelope. Intentionally loose at the type level (`kind` + `data`) so
+ * the runtime owner can build `{ schemaVersion, ok, kind, data }` without
+ * importing every inner interface; the runtime guarantee comes from
+ * {@link callIndexReply}, which re-projects the value through closed schemas.
+ */
+export interface CallIndexReply {
+    readonly schemaVersion: 1;
+    readonly ok: boolean;
+    readonly kind: CallIndexReplyKind;
+    readonly data?: Record<string, unknown>;
+    readonly reason?: string;
+    readonly [key: string]: unknown;
+}
+/** Build a stable error reply; an unknown reason becomes `internal-error`. */
+export declare function callIndexError(reason: string): CallIndexReply;
+/** One filter shared by summary / list requests. Half-open `[fromMs, toMs)`. */
+export declare const callIndexQuerySchema: z.ZodObject<{
+    sessionId: z.ZodOptional<z.ZodString>;
+    toolName: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        success: "success";
+        error: "error";
+        cancelled: "cancelled";
+        unknown: "unknown";
+        unresolved: "unresolved";
+        running: "running";
+    }>>;
+    sourceKind: z.ZodOptional<z.ZodEnum<{
+        skill: "skill";
+        unknown: "unknown";
+        mcp: "mcp";
+        "plugin-tool": "plugin-tool";
+        native: "native";
+    }>>;
+    fromMs: z.ZodOptional<z.ZodNumber>;
+    toMs: z.ZodOptional<z.ZodNumber>;
+    includeInherited: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+/** Bounds for the client-supplied local-day offset (UTC-12:00 … UTC+14:00). */
+export declare const CALL_INDEX_MIN_DAY_OFFSET_MINUTES = -720;
+export declare const CALL_INDEX_MAX_DAY_OFFSET_MINUTES = 840;
+/** Hard cap on returned day buckets: one calendar year of daily rows. */
+export declare const CALL_INDEX_MAX_DAY_BUCKETS = 366;
+export declare const callIndexSummaryRequestSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodObject<{
+        sessionId: z.ZodOptional<z.ZodString>;
+        toolName: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+        outcome: z.ZodOptional<z.ZodEnum<{
+            success: "success";
+            error: "error";
+            cancelled: "cancelled";
+            unknown: "unknown";
+            unresolved: "unresolved";
+            running: "running";
+        }>>;
+        sourceKind: z.ZodOptional<z.ZodEnum<{
+            skill: "skill";
+            unknown: "unknown";
+            mcp: "mcp";
+            "plugin-tool": "plugin-tool";
+            native: "native";
+        }>>;
+        fromMs: z.ZodOptional<z.ZodNumber>;
+        toMs: z.ZodOptional<z.ZodNumber>;
+        includeInherited: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    snapshotId: z.ZodOptional<z.ZodString>;
+    dayOffsetMinutes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const callIndexListRequestSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodObject<{
+        sessionId: z.ZodOptional<z.ZodString>;
+        toolName: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+        outcome: z.ZodOptional<z.ZodEnum<{
+            success: "success";
+            error: "error";
+            cancelled: "cancelled";
+            unknown: "unknown";
+            unresolved: "unresolved";
+            running: "running";
+        }>>;
+        sourceKind: z.ZodOptional<z.ZodEnum<{
+            skill: "skill";
+            unknown: "unknown";
+            mcp: "mcp";
+            "plugin-tool": "plugin-tool";
+            native: "native";
+        }>>;
+        fromMs: z.ZodOptional<z.ZodNumber>;
+        toMs: z.ZodOptional<z.ZodNumber>;
+        includeInherited: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    snapshotId: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const callIndexDetailRequestSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    callSeq: z.ZodNumber;
+    snapshotId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** `startIndex(request?)`; the runtime owns the actual scan mode. */
+export declare const callIndexStartRequestSchema: z.ZodObject<{
+    mode: z.ZodOptional<z.ZodEnum<{
+        full: "full";
+        incremental: "incremental";
+    }>>;
+}, z.core.$strict>;
+/** `cancelIndex(request)`; `request` is required even when it carries nothing. */
+export declare const callIndexCancelRequestSchema: z.ZodObject<{
+    taskId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** Fixed metadata fields of one call row (mirrors `CallIndexRow`, never args). */
+export declare const callIndexWireRowSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    callSeq: z.ZodNumber;
+    callId: z.ZodString;
+    toolName: z.ZodString;
+    turn: z.ZodOptional<z.ZodNumber>;
+    step: z.ZodOptional<z.ZodNumber>;
+    startedAt: z.ZodNumber;
+    endedAt: z.ZodOptional<z.ZodNumber>;
+    resultSeq: z.ZodOptional<z.ZodNumber>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    outcome: z.ZodEnum<{
+        success: "success";
+        error: "error";
+        cancelled: "cancelled";
+        unknown: "unknown";
+        unresolved: "unresolved";
+        running: "running";
+    }>;
+    inherited: z.ZodBoolean;
+    sourceKind: z.ZodEnum<{
+        skill: "skill";
+        unknown: "unknown";
+        mcp: "mcp";
+        "plugin-tool": "plugin-tool";
+        native: "native";
+    }>;
+    layer: z.ZodString;
+}, z.core.$strip>;
+export declare const callIndexWireSessionSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    revision: z.ZodString;
+    cut: z.ZodNumber;
+    coverage: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+    }>;
+    stale: z.ZodBoolean;
+    reasons: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>;
+}, z.core.$strip>;
+/**
+ * Overview aggregates over the whole filtered set (never the current page).
+ *
+ * `bySource` always carries every source kind, including zeros, so a caller can
+ * distinguish "known to be zero" from "not reported". `byDay` is bounded and
+ * ordered oldest-first; a request whose span exceeds
+ * {@link CALL_INDEX_MAX_DAY_BUCKETS} fails with `reply-too-large` instead of
+ * silently truncating a trend line.
+ */
+/**
+ * Per-source counts. All five keys are always emitted by this Host, but a reply
+ * that omits one is still readable: the missing kind is 0 and the caller renders
+ * it as "not resolved" anyway (R-009 forbids reading 0 as "unused"). Rejecting
+ * the whole overview over one absent key was never worth it.
+ */
+export declare const callIndexSourceCountsSchema: z.ZodPipe<z.ZodObject<{
+    mcp: z.ZodOptional<z.ZodNumber>;
+    'plugin-tool': z.ZodOptional<z.ZodNumber>;
+    native: z.ZodOptional<z.ZodNumber>;
+    skill: z.ZodOptional<z.ZodNumber>;
+    unknown: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodTransform<{
+    mcp: number;
+    'plugin-tool': number;
+    native: number;
+    skill: number;
+    unknown: number;
+}, {
+    mcp?: number | undefined;
+    'plugin-tool'?: number | undefined;
+    native?: number | undefined;
+    skill?: number | undefined;
+    unknown?: number | undefined;
+}>>;
+export declare const callIndexAggregatesSchema: z.ZodObject<{
+    distinctTools: z.ZodNumber;
+    bySource: z.ZodPipe<z.ZodObject<{
+        mcp: z.ZodOptional<z.ZodNumber>;
+        'plugin-tool': z.ZodOptional<z.ZodNumber>;
+        native: z.ZodOptional<z.ZodNumber>;
+        skill: z.ZodOptional<z.ZodNumber>;
+        unknown: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodTransform<{
+        mcp: number;
+        'plugin-tool': number;
+        native: number;
+        skill: number;
+        unknown: number;
+    }, {
+        mcp?: number | undefined;
+        'plugin-tool'?: number | undefined;
+        native?: number | undefined;
+        skill?: number | undefined;
+        unknown?: number | undefined;
+    }>>;
+    byDay: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
+        day: z.ZodString;
+        calls: z.ZodOptional<z.ZodNumber>;
+        success: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodNumber>;
+        cancelled: z.ZodOptional<z.ZodNumber>;
+        unresolved: z.ZodOptional<z.ZodNumber>;
+        unknown: z.ZodOptional<z.ZodNumber>;
+        running: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodTransform<{
+        day: string;
+        calls: number;
+        success: number;
+        error: number;
+        cancelled: number;
+        unresolved: number;
+        unknown: number;
+        running: number;
+    }, {
+        day: string;
+        calls?: number | undefined;
+        success?: number | undefined;
+        error?: number | undefined;
+        cancelled?: number | undefined;
+        unresolved?: number | undefined;
+        unknown?: number | undefined;
+        running?: number | undefined;
+    }>>>>;
+    dayOffsetMinutes: z.ZodNumber;
+}, z.core.$strip>;
+/** Public, non-throwing projector used by the Host gateway and the client codec. */
+export declare function callIndexReply(value: unknown): CallIndexReply;
+/**
+ * Zod codec for replies. `.parse` always succeeds and returns the projected
+ * reply, so a malformed Host payload degrades to `internal-error` instead of a
+ * transport failure.
+ */
+export declare const callIndexReplySchema: z.ZodPipe<z.ZodAny, z.ZodTransform<CallIndexReply, any>>;
+//# sourceMappingURL=call-index-wire.d.ts.map

package/lib/types/usage/call-index-wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-index-wire.d.ts","sourceRoot":"","sources":["../../../src/usage/call-index-wire.ts"],"names":[],"mappings":"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"}

package/lib/types/usage/session-index.d.ts

@@ -0,0 +1,149 @@
+import { type CallIndexSourceResolver } from './call-index-core.ts';
+export interface SessionCallIndexOptions {
+    getMode: () => unknown;
+    getBackend: () => unknown;
+    /** Optional public SessionStore membership; it never supplies historical content. */
+    isLiveSession?: (id: string) => boolean;
+    pageSize?: number;
+    maxBytes?: number;
+    maxCalls?: number;
+    maxSessions?: number;
+    maxEventsPerSession?: number;
+    maxOrphans?: number;
+    maxLiveQueue?: number;
+    now?: () => number;
+    yield?: () => Promise<void>;
+    /**
+     * Provenance resolver built from trusted catalog evidence by the runtime.
+     *
+     * Absent means the Host has no capability service, so every row reports
+     * `unknown` provenance and `semanticCoverage.source` stays `unknown`.
+     */
+    resolveSource?: CallIndexSourceResolver;
+}
+export interface IndexScanOptions {
+    signal?: AbortSignal;
+    maxEvents?: number;
+    full?: boolean;
+}
+/**
+ * In-memory engine for N22. It is deliberately not mounted in the old Usage runtime.
+ * Scope is freshly resolved before AND after asynchronous service operations.
+ * Memory limits bound estimated retained index metadata, not backend decoding/RSS.
+ */
+export declare class SessionCallIndex {
+    private readonly options;
+    private readonly scopes;
+    private lastScope;
+    private token;
+    private ledger;
+    private readonly published;
+    private readonly stages;
+    private readonly live;
+    private readonly observedThrough;
+    private readonly visible;
+    private readonly pending;
+    private readonly failures;
+    private readonly reasons;
+    private task;
+    private aborter;
+    private fairCursor;
+    private generation;
+    private censusGeneration;
+    private asOf;
+    private enumerated;
+    private enumerationCurrent;
+    private listedCount;
+    private phase;
+    private liveCount;
+    private disposed;
+    private readonly limits;
+    constructor(options: SessionCallIndexOptions);
+    private gap;
+    private syncScope;
+    private guard;
+    private reserve;
+    private discard;
+    /** Immediate projection keeps raw events out of the bounded live queue. */
+    observeLive(sessionId: string, raw: unknown, inheritedEventCount: number): boolean;
+    /** One active task, including concurrent callers. Cancellation is not a second task. */
+    start(options?: IndexScanOptions): Promise<ReturnType<SessionCallIndex['snapshot']>>;
+    /** Host observation failures are fixed codes, never exception messages or raw payloads. */
+    markGap(reason: 'live-projection-failed' | 'live-timer-failed'): void;
+    /** Publish observed metadata only; never enumerate/open historical storage here. */
+    flushLive(): ReturnType<SessionCallIndex['snapshot']>;
+    /** Cheap authorization/data stamp; resolving it also notices live backend replacement. */
+    stamp(): {
+        epoch?: number;
+        generation: number;
+    };
+    cancel(): void;
+    dispose(): void;
+    private stage;
+    private mergeLive;
+    private publish;
+    private run;
+    snapshot(includeRows?: boolean): {
+        corpus: "persisted-plus-observed-live";
+        scope: import("./call-index-scope.ts").CallIndexScopeDescription;
+        generation: number;
+        censusGeneration: number;
+        asOf: number | undefined;
+        phase: "cancelled" | "complete" | "failed" | "running" | "idle";
+        coverage: "complete" | "partial" | "unknown";
+        eventCoverage: "complete" | "partial" | "unknown";
+        enumerationCoverage: "complete" | "partial" | "unknown";
+        semanticCoverage: {
+            source: "unknown" | "verified";
+            ptc: "unknown";
+            skillExecution: "unavailable";
+            denied: "unavailable";
+        };
+        listedSessions: number;
+        visibleSessions: number;
+        completedSessions: number;
+        pendingSessions: number;
+        failedSessions: number;
+        pendingLive: number;
+        declaredEvents: number;
+        readEvents: number;
+        estimatedBytes: number;
+        reasons: string[];
+        sessions: {
+            revision: string;
+            cut: number;
+            coverage: "complete" | "partial";
+            stale: boolean;
+            reasons: string[];
+            cwd?: string | undefined;
+            sessionId: string;
+        }[];
+        rows: {
+            sessionId: string;
+            callSeq: number;
+            callId: string;
+            toolName: string;
+            turn?: number;
+            step?: number;
+            startedAt: number;
+            endedAt?: number;
+            resultSeq?: number;
+            durationMs?: number;
+            outcome: "success" | "error" | "cancelled" | "unresolved" | "unknown" | "running";
+            inherited: boolean;
+            sourceKind: import("./call-index-wire.ts").CallIndexSourceKind;
+            layer: "unknown";
+        }[];
+        totals: {
+            calls: number;
+            succeeded: number;
+            failed: number;
+            unresolved: number;
+            unknown: number;
+            cancelled: number;
+            running: number;
+            inherited: number;
+        };
+    };
+}
+//# sourceMappingURL=session-index.d.ts.map

package/lib/types/usage/session-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-index.d.ts","sourceRoot":"","sources":["../../../src/usage/session-index.ts"],"names":[],"mappings":"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"}