@llblab/pi-kit 0.1.0

package/node_modules/@llblab/pi-actors/dist/lib/review-diagnostics.js

@@ -0,0 +1,148 @@
+/**
+ * Automatic recipe-review diagnostics.
+ * Zones: bounded draft/tool cycle evidence, lineage summaries, revision snapshot inventory
+ * Owns read-only diagnostic projection; schedulers and transactions own mutation.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import * as Paths from "./paths.js";
+const MAX_FILE_BYTES = 1024 * 1024;
+const MAX_ENTRIES = 100;
+function readJson(path) {
+    if (!path || !existsSync(path) || statSync(path).size > MAX_FILE_BYTES)
+        return undefined;
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        return value && typeof value === "object" && !Array.isArray(value)
+            ? value
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function text(value, limit = 240) {
+    if (typeof value !== "string")
+        return undefined;
+    return value.length > limit ? `${value.slice(0, limit - 1)}…` : value;
+}
+function strings(value, limit = 20) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string").slice(-limit)
+        : [];
+}
+function cycleState(state) {
+    if (!state)
+        return { phase: "idle" };
+    return {
+        phase: text(state.phase) ?? "unknown",
+        attempts: state.attempts,
+        failed_stage: text(state.failedStage),
+        last_error: text(state.lastError, 500),
+        next_action: text(state.nextAction, 500),
+        processing_attempts: state.processingAttempts,
+        batch_id: text(state.batchId),
+        review_id: text(state.reviewId),
+        run_id: text(state.runId),
+        sources: Array.isArray(state.sourcePaths) ? state.sourcePaths.length : undefined,
+        tools: Array.isArray(state.toolNames) ? state.toolNames.length : undefined,
+        updated_at: text(state.updatedAt),
+    };
+}
+function draftEvidence(state) {
+    const evidence = readJson(text(state?.evidencePath, 4096));
+    if (!evidence)
+        return undefined;
+    const decisions = Array.isArray(evidence.decisions)
+        ? evidence.decisions
+        : [];
+    const garbage = evidence.garbageCollection;
+    return {
+        actions: Object.fromEntries(["promote", "discard"].map((action) => [
+            action,
+            decisions.filter((decision) => decision.action === action).length,
+        ])),
+        garbage_collection: garbage
+            ? { reviewed_sources: garbage.reviewedSources, status: garbage.status }
+            : undefined,
+        reviewed_sources: decisions.length,
+    };
+}
+function toolEvidence(state) {
+    const approved = readJson(text(state?.approvedPath, 4096));
+    if (!approved)
+        return undefined;
+    const decisions = Array.isArray(approved.decisions)
+        ? approved.decisions
+        : [];
+    return {
+        actions: Object.fromEntries(["keep", "evolve", "replace", "demote", "merge", "split"].map((action) => [
+            action,
+            decisions.filter((decision) => decision.action === action).length,
+        ])),
+        lineage_phase: readJson(text(state?.lineageJournalPath, 4096))?.phase,
+        review_id: text(approved.reviewId),
+        sources: Array.isArray(approved.sources) ? approved.sources.length : 0,
+        targets: Array.isArray(approved.targets) ? approved.targets.length : 0,
+        transaction_phase: readJson(join(dirname(text(state?.approvedPath, 4096)), "journal.json"))?.phase,
+    };
+}
+function lineageSummaries(recipeRoot) {
+    const root = join(recipeRoot, ".usage", "recipes");
+    if (!existsSync(root))
+        return [];
+    return readdirSync(root, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+        .map((entry) => join(root, entry.name))
+        .sort()
+        .slice(0, MAX_ENTRIES)
+        .flatMap((path) => {
+        const record = readJson(path);
+        if (!record)
+            return [];
+        return [{
+                current_path: text(record.current_path),
+                demoted_at: text(record.demoted_at),
+                demoted_from_revision: record.demoted_from_revision,
+                lifetime_calls: record.lifetime_calls,
+                name: text(record.lineage_name) ?? basename(path, ".json"),
+                review_epochs: strings(record.review_epochs, 5),
+                revision: record.revision,
+                revision_calls: record.revision_calls,
+                rollback_of_revision: record.rollback_of_revision,
+            }];
+    });
+}
+function snapshotCount(recipeRoot) {
+    const root = join(recipeRoot, ".usage", "revisions");
+    if (!existsSync(root))
+        return 0;
+    let count = 0;
+    for (const lineage of readdirSync(root, { withFileTypes: true }).slice(0, MAX_ENTRIES)) {
+        if (!lineage.isDirectory())
+            continue;
+        count += readdirSync(join(root, lineage.name), { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .length;
+    }
+    return count;
+}
+export function readAutomaticReviewDiagnostics(options = {}) {
+    const recipeRoot = options.recipeRoot ?? Paths.getRecipeRoot();
+    const draftState = readJson(options.draftStatePath ?? Paths.getDraftSleepStatePath());
+    const toolState = readJson(options.toolStatePath ?? Paths.getToolReviewStatePath());
+    const lineages = lineageSummaries(recipeRoot);
+    return {
+        draft_review: {
+            ...cycleState(draftState),
+            evidence: draftEvidence(draftState),
+        },
+        lineage_count: lineages.length,
+        lineages,
+        revision_snapshots: snapshotCount(recipeRoot),
+        tool_review: {
+            ...cycleState(toolState),
+            evidence: toolEvidence(toolState),
+        },
+    };
+}

package/node_modules/@llblab/pi-actors/dist/lib/review-projection.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Automatic recipe-review confidentiality projection.
+ * Owns: value-free model inputs derived from trusted immutable draft/tool captures.
+ */
+import type { DraftReviewInput, DraftReviewResult } from "./draft-review.ts";
+import type { ToolReviewInput, ToolReviewResult } from "./tool-review.ts";
+export declare const draftReviewIdentity: (index: number) => string;
+export declare const toolReviewIdentity: (index: number) => string;
+export declare function draftReviewRevision(input: DraftReviewInput, index: number): string;
+export declare function toolReviewRevision(input: ToolReviewInput, index: number): string;
+export declare function projectDraftReviewInput(input: DraftReviewInput): Record<string, unknown>;
+export declare function restoreDraftReviewResult(input: DraftReviewInput, result: DraftReviewResult): DraftReviewResult;
+export declare function projectToolReviewInput(input: ToolReviewInput): Record<string, unknown>;
+export declare function restoreToolReviewResult(input: ToolReviewInput, result: ToolReviewResult): ToolReviewResult;

package/node_modules/@llblab/pi-actors/dist/lib/review-projection.js

@@ -0,0 +1,166 @@
+/**
+ * Automatic recipe-review confidentiality projection.
+ * Owns: value-free model inputs derived from trusted immutable draft/tool captures.
+ */
+function occurrenceId(prefix, index) {
+    return `${prefix}_${String(index + 1).padStart(2, "0")}`;
+}
+export const draftReviewIdentity = (index) => occurrenceId("draft", index);
+export const toolReviewIdentity = (index) => occurrenceId("tool", index);
+function contentGroups(hashes) {
+    const groups = new Map();
+    return hashes.map((hash) => {
+        let group = groups.get(hash);
+        if (!group) {
+            group = occurrenceId("content_group", groups.size);
+            groups.set(hash, group);
+        }
+        return group;
+    });
+}
+function draftContentGroups(input) {
+    return contentGroups([
+        ...input.activeTools.map((tool) => tool.sha256),
+        ...input.drafts.map((draft) => draft.sha256),
+    ]);
+}
+export function draftReviewRevision(input, index) {
+    return draftContentGroups(input)[input.activeTools.length + index];
+}
+export function toolReviewRevision(input, index) {
+    return contentGroups(input.tools.map((tool) => tool.sha256))[index];
+}
+function countArray(value) {
+    return Array.isArray(value) ? value.length : 0;
+}
+function countRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? Object.keys(value).length
+        : 0;
+}
+function templateShape(value) {
+    if (typeof value === "string")
+        return { kind: "command", nodes: 1 };
+    if (Array.isArray(value)) {
+        return {
+            branches: value.length,
+            kind: "sequence",
+            nodes: 1 + value.reduce((total, child) => total + Number(templateShape(child).nodes ?? 0), 0),
+        };
+    }
+    if (!value || typeof value !== "object")
+        return { kind: "invalid", nodes: 0 };
+    const record = value;
+    const children = Array.isArray(record.template)
+        ? record.template
+        : record.template === undefined
+            ? []
+            : [record.template];
+    return {
+        branches: children.length,
+        conditional: record.when !== undefined,
+        kind: record.parallel === true ? "parallel" : "object",
+        repeat: record.repeat !== undefined,
+        retry: record.retry !== undefined,
+        nodes: 1 + children.reduce((total, child) => total + Number(templateShape(child).nodes ?? 0), 0),
+    };
+}
+function contractShape(recipe) {
+    if (!recipe)
+        return undefined;
+    return {
+        argument_count: countArray(recipe.args),
+        artifact_count: countRecord(recipe.artifacts),
+        async: recipe.async === true,
+        default_count: countRecord(recipe.defaults),
+        import_count: countRecord(recipe.imports),
+        control_action_count: countArray(recipe.control),
+        template_shape: templateShape(recipe.template),
+    };
+}
+function usageShape(usage) {
+    const numeric = (key) => {
+        const value = usage?.[key];
+        return typeof value === "number" && Number.isFinite(value) && value >= 0
+            ? value
+            : 0;
+    };
+    return {
+        lifetime_calls: numeric("lifetime_calls") || numeric("calls"),
+        revision: numeric("revision"),
+        revision_calls: numeric("revision_calls"),
+    };
+}
+export function projectDraftReviewInput(input) {
+    return {
+        activeTools: input.activeTools.map((_tool, index) => ({
+            name: occurrenceId("active_tool", index),
+            sha256: draftContentGroups(input)[index],
+        })),
+        batchId: input.batchId,
+        createdAt: input.createdAt,
+        drafts: input.drafts.map((draft, index) => ({
+            contract: contractShape(draft.recipe),
+            draft: draftReviewIdentity(index),
+            riskLabels: [...draft.riskLabels],
+            sha256: draftReviewRevision(input, index),
+            usage: usageShape(draft.usage),
+            valid: draft.valid,
+        })),
+    };
+}
+export function restoreDraftReviewResult(input, result) {
+    const drafts = new Map(input.drafts.map((draft, index) => [draftReviewIdentity(index), {
+            draft,
+            revision: draftReviewRevision(input, index),
+        }]));
+    return {
+        ...result,
+        decisions: result.decisions.map((decision) => {
+            const captured = drafts.get(decision.draft);
+            return {
+                ...decision,
+                draft: captured?.draft.path ?? `unknown:${decision.draft}`,
+                sha256: captured && decision.sha256 === captured.revision
+                    ? captured.draft.sha256
+                    : `invalid:${decision.sha256}`,
+            };
+        }),
+    };
+}
+export function projectToolReviewInput(input) {
+    return {
+        createdAt: input.createdAt,
+        reviewId: input.reviewId,
+        tools: input.tools.map((tool, index) => ({
+            contract: contractShape(tool.recipe),
+            name: toolReviewIdentity(index),
+            riskLabels: [...tool.riskLabels],
+            sha256: toolReviewRevision(input, index),
+            usage: usageShape(tool.usage),
+            valid: tool.valid,
+        })),
+    };
+}
+export function restoreToolReviewResult(input, result) {
+    const tools = new Map(input.tools.map((tool, index) => [toolReviewIdentity(index), {
+            revision: toolReviewRevision(input, index),
+            tool,
+        }]));
+    return {
+        ...result,
+        decisions: result.decisions.map((decision) => {
+            const captured = tools.get(decision.source);
+            return {
+                ...decision,
+                sha256: captured && decision.sha256 === captured.revision
+                    ? captured.tool.sha256
+                    : `invalid:${decision.sha256}`,
+                source: captured?.tool.name ?? `unknown:${decision.source}`,
+                ...(decision.target
+                    ? { target: tools.get(decision.target)?.tool.name ?? decision.target }
+                    : {}),
+            };
+        }),
+    };
+}

package/node_modules/@llblab/pi-actors/dist/lib/run-evidence-policy.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Pure bounded Run-evidence policy.
+ * Zones: Trace retention, compaction accounting, Control capacity and admission
+ * Owns deterministic limits policy; journal I/O, locks, lifecycle authorization, and projection stay in adapters.
+ * Trace keeps the newest physical suffix because semantic priority would silently
+ * redefine causal history. Admitted Controls never expire: only a real terminal
+ * transition or generation replacement proves that durable work is finished.
+ */
+export declare const TRACE_COMPACTION_KIND = "runtime.trace_compacted";
+export declare const TRACE_COMPACTION_VERSION = 1;
+export type TraceJournalUsage = {
+    bytes: number;
+    events: number;
+};
+export type TraceRetentionCandidate<T> = {
+    encodedBytes: number;
+    value: T;
+};
+export type TraceRetentionSelection<T> = {
+    droppedEvents: number;
+    retained: TraceRetentionCandidate<T>[];
+    retainedBytes: number;
+    retainedEvents: number;
+};
+export interface TraceCompactionData {
+    version: typeof TRACE_COMPACTION_VERSION;
+    compactions_total: number;
+    dropped_valid_events_total: number;
+    dropped_malformed_lines_total: number;
+    dropped_bytes_total: number;
+    dropped_event_count_exact: boolean;
+    retained_events: number;
+    retained_bytes: number;
+    history_complete: false;
+}
+export interface TraceCompactionDelta {
+    dropped_valid_events: number;
+    dropped_malformed_lines: number;
+    dropped_bytes: number;
+    dropped_event_count_exact: boolean;
+    retained_events: number;
+    retained_bytes: number;
+}
+export type RunControlStatus = "queued" | "delivered" | "claimed" | "handled" | "failed";
+export type RunControlCapacity = {
+    available: number;
+    backpressured: boolean;
+    limit: number;
+    oldest_pending_at?: string;
+    pending: number;
+};
+export type RunControlAdmissionIntegrity = "valid" | "unreadable" | "malformed" | "noncanonical" | "invalid_record" | "invalid_status_timestamp" | "generation_mismatch" | "journal_bytes";
+export interface RunControlAdmissionErrorDetails {
+    reason: "control_backpressure" | "control_journal_integrity";
+    pending: number;
+    limit: number;
+    journal_bytes: number;
+    journal_limit: number;
+    oldest_pending_at?: string;
+    run_instance_id: string;
+    next_actions: string[];
+    integrity_reason?: string;
+}
+export type RunControlAdmissionDecision = {
+    admitted: true;
+    capacity: RunControlCapacity;
+} | {
+    admitted: false;
+    capacity: RunControlCapacity;
+    error: RunControlAdmissionErrorDetails;
+};
+export type RunControlAdmissionInput = {
+    integrity: RunControlAdmissionIntegrity;
+    journalBytes: number;
+    newRecordBytes: number;
+    records: readonly unknown[];
+    retainedJournalBytes: number;
+    runInstanceId: string;
+    capacity?: RunControlCapacity;
+};
+export declare function traceAppendFits(usage: TraceJournalUsage, encodedEventBytes: number): boolean;
+export declare function selectNewestTraceSuffix<T>(candidates: readonly TraceRetentionCandidate<T>[], reserve?: {
+    bytes?: number;
+    events?: number;
+}): TraceRetentionSelection<T>;
+export declare function accumulateTraceCompactionStatistics(previous: TraceCompactionData | undefined, delta: TraceCompactionDelta): TraceCompactionData;
+export declare function traceCompactionMarkerInput(data: TraceCompactionData): {
+    data: TraceCompactionData;
+    kind: typeof TRACE_COMPACTION_KIND;
+    level: "warning";
+};
+export declare function classifyRunControlRecord(value: unknown): "pending" | "terminal" | undefined;
+export declare function runControlStatusTimestamp(record: Record<string, unknown>, status: RunControlStatus): unknown;
+export declare function computeRunControlCapacity(records: readonly unknown[]): RunControlCapacity;
+export declare function decideRunControlAdmission(input: RunControlAdmissionInput): RunControlAdmissionDecision;

package/node_modules/@llblab/pi-actors/dist/lib/run-evidence-policy.js

@@ -0,0 +1,177 @@
+/**
+ * Pure bounded Run-evidence policy.
+ * Zones: Trace retention, compaction accounting, Control capacity and admission
+ * Owns deterministic limits policy; journal I/O, locks, lifecycle authorization, and projection stay in adapters.
+ * Trace keeps the newest physical suffix because semantic priority would silently
+ * redefine causal history. Admitted Controls never expire: only a real terminal
+ * transition or generation replacement proves that durable work is finished.
+ */
+import * as Limits from "./limits.js";
+export const TRACE_COMPACTION_KIND = "runtime.trace_compacted";
+export const TRACE_COMPACTION_VERSION = 1;
+const PENDING_CONTROL_STATUSES = new Set(["queued", "delivered", "claimed"]);
+const TERMINAL_CONTROL_STATUSES = new Set(["handled", "failed"]);
+const CONTROL_ADMISSION_NEXT_ACTIONS = [
+    "inspect target=run:<id> view=control",
+    "inspect target=runtime view=triage",
+];
+function isCount(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+function assertCount(value, name) {
+    if (!isCount(value))
+        throw new RangeError(`${name} must be a non-negative safe integer`);
+}
+function boundedAdd(left, right) {
+    return Math.min(Number.MAX_SAFE_INTEGER, left + right);
+}
+export function traceAppendFits(usage, encodedEventBytes) {
+    if (!isCount(usage.events) || !isCount(usage.bytes) || !isCount(encodedEventBytes))
+        return false;
+    return usage.events + 1 <= Limits.TRACE_JOURNAL_MAX_EVENTS &&
+        usage.bytes + encodedEventBytes <= Limits.TRACE_JOURNAL_MAX_BYTES;
+}
+export function selectNewestTraceSuffix(candidates, reserve = {}) {
+    const reservedBytes = reserve.bytes ?? 0;
+    const reservedEvents = reserve.events ?? 0;
+    assertCount(reservedBytes, "reserved Trace bytes");
+    assertCount(reservedEvents, "reserved Trace events");
+    const byteBudget = Math.max(0, Limits.TRACE_JOURNAL_TARGET_BYTES - reservedBytes);
+    const eventBudget = Math.max(0, Limits.TRACE_JOURNAL_TARGET_EVENTS - reservedEvents);
+    let retainedBytes = 0;
+    let start = candidates.length;
+    while (start > 0 && candidates.length - start < eventBudget) {
+        const candidate = candidates[start - 1];
+        assertCount(candidate.encodedBytes, "encoded Trace bytes");
+        if (retainedBytes + candidate.encodedBytes > byteBudget)
+            break;
+        retainedBytes += candidate.encodedBytes;
+        start -= 1;
+    }
+    const retained = candidates.slice(start);
+    return {
+        droppedEvents: candidates.length - retained.length,
+        retained,
+        retainedBytes,
+        retainedEvents: retained.length,
+    };
+}
+export function accumulateTraceCompactionStatistics(previous, delta) {
+    for (const [name, value] of Object.entries(delta)) {
+        if (name !== "dropped_event_count_exact")
+            assertCount(value, name);
+    }
+    const prior = previous ?? {
+        compactions_total: 0,
+        dropped_bytes_total: 0,
+        dropped_event_count_exact: true,
+        dropped_malformed_lines_total: 0,
+        dropped_valid_events_total: 0,
+    };
+    const eventCountOverflow = prior.dropped_valid_events_total +
+        delta.dropped_valid_events > Number.MAX_SAFE_INTEGER;
+    return {
+        version: TRACE_COMPACTION_VERSION,
+        compactions_total: boundedAdd(prior.compactions_total, 1),
+        dropped_valid_events_total: boundedAdd(prior.dropped_valid_events_total, delta.dropped_valid_events),
+        dropped_malformed_lines_total: boundedAdd(prior.dropped_malformed_lines_total, delta.dropped_malformed_lines),
+        dropped_bytes_total: boundedAdd(prior.dropped_bytes_total, delta.dropped_bytes),
+        dropped_event_count_exact: prior.dropped_event_count_exact &&
+            delta.dropped_event_count_exact && !eventCountOverflow,
+        retained_events: delta.retained_events,
+        retained_bytes: delta.retained_bytes,
+        history_complete: false,
+    };
+}
+export function traceCompactionMarkerInput(data) {
+    return { data, kind: TRACE_COMPACTION_KIND, level: "warning" };
+}
+export function classifyRunControlRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const status = value.status;
+    if (PENDING_CONTROL_STATUSES.has(status))
+        return "pending";
+    if (TERMINAL_CONTROL_STATUSES.has(status))
+        return "terminal";
+    return undefined;
+}
+export function runControlStatusTimestamp(record, status) {
+    if (status === "failed")
+        return record.failed_at;
+    if (status === "handled")
+        return record.handled_at;
+    if (status === "claimed")
+        return record.claimed_at;
+    if (status === "delivered")
+        return record.delivered_at;
+    return record.queued_at;
+}
+export function computeRunControlCapacity(records) {
+    let oldest;
+    let pending = 0;
+    for (const value of records) {
+        if (classifyRunControlRecord(value) !== "pending")
+            continue;
+        pending += 1;
+        const record = value;
+        const timestamp = runControlStatusTimestamp(record, record.status);
+        const timestampMs = typeof timestamp === "string" ? Date.parse(timestamp) : Number.NaN;
+        if (typeof timestamp === "string" && Number.isFinite(timestampMs) &&
+            (!oldest || timestampMs < oldest.timestampMs)) {
+            oldest = { timestamp, timestampMs };
+        }
+    }
+    return {
+        available: Math.max(0, Limits.RUN_CONTROL_PENDING_LIMIT - pending),
+        backpressured: pending >= Limits.RUN_CONTROL_PENDING_LIMIT,
+        limit: Limits.RUN_CONTROL_PENDING_LIMIT,
+        ...(oldest ? { oldest_pending_at: oldest.timestamp } : {}),
+        pending,
+    };
+}
+export function decideRunControlAdmission(input) {
+    const capacity = input.capacity ?? computeRunControlCapacity(input.records);
+    const reject = (reason, integrityReason) => ({
+        admitted: false,
+        capacity,
+        error: {
+            reason,
+            pending: capacity.pending,
+            limit: capacity.limit,
+            journal_bytes: input.journalBytes,
+            journal_limit: Limits.RUN_CONTROL_JOURNAL_MAX_BYTES,
+            ...(capacity.oldest_pending_at ? { oldest_pending_at: capacity.oldest_pending_at } : {}),
+            run_instance_id: input.runInstanceId,
+            next_actions: [...CONTROL_ADMISSION_NEXT_ACTIONS],
+            ...(integrityReason ? { integrity_reason: integrityReason } : {}),
+        },
+    });
+    if (input.integrity !== "valid")
+        return reject("control_journal_integrity", input.integrity);
+    if (!isCount(input.journalBytes) || !isCount(input.retainedJournalBytes) ||
+        !isCount(input.newRecordBytes) ||
+        input.journalBytes > Limits.RUN_CONTROL_JOURNAL_MAX_BYTES) {
+        return reject("control_journal_integrity", "journal_bytes");
+    }
+    for (const value of input.records) {
+        const classification = classifyRunControlRecord(value);
+        if (!classification)
+            return reject("control_journal_integrity", "invalid_record");
+        if (classification !== "pending")
+            continue;
+        const record = value;
+        const timestamp = runControlStatusTimestamp(record, record.status);
+        if (typeof timestamp !== "string" || !Number.isFinite(Date.parse(timestamp))) {
+            return reject("control_journal_integrity", "invalid_status_timestamp");
+        }
+        if (record.run_instance_id !== input.runInstanceId) {
+            return reject("control_journal_integrity", "generation_mismatch");
+        }
+    }
+    if (capacity.backpressured ||
+        input.retainedJournalBytes + input.newRecordBytes > Limits.RUN_CONTROL_JOURNAL_MAX_BYTES) {
+        return reject("control_backpressure");
+    }
+    return { admitted: true, capacity };
+}

package/node_modules/@llblab/pi-actors/dist/lib/run-ui-runtime.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Ambient run observability runtime.
+ * Zones: run watcher lifecycle, terminal reconciliation, status animation, shutdown teardown
+ * Owns event-driven run UI coordination without owning actor execution semantics.
+ */
+import * as Pi from "./pi.ts";
+export interface RunUiRuntime {
+    close(): void;
+    shutdown(eventReason: string, ctx: Pi.ExtensionContext): void;
+    start(ctx: Pi.ExtensionContext): void;
+}
+export interface RunUiRuntimeDeps {
+    getActiveContext(): Pi.ExtensionContext | undefined;
+    getRunOwnerId(ctx: Pi.ExtensionContext): string;
+    onRunEvent(): void;
+    pi: Pi.ExtensionAPI;
+}
+export declare function createRunUiRuntime(deps: RunUiRuntimeDeps): RunUiRuntime;