@llblab/pi-kit 0.18.1 → 0.19.0

package/node_modules/@llblab/pi-state-flow/dist/lib/skills.d.ts

@@ -1,11 +1,8 @@
 import { type ArtifactProvenance, type ArtifactRegistry } from "./artifact.ts";
-import type { MaterializedState } from "./state.ts";
 export declare const SKILL_ARTIFACT_COMPILER = "skill-artifact-v1";
 export declare function hasCompiledSkillArtifact(artifacts: ArtifactRegistry, provenance: ArtifactProvenance | undefined, source: string, expectedHash?: string): boolean;
 export type SkillSourceHasher = (source: string) => string;
 export declare function hashSkillSource(source: string): string;
-/** Move the retired contract store into source-addressed Skill artifacts. */
-export declare function migrateLegacySkillCompilations(state: MaterializedState, hasher?: SkillSourceHasher): MaterializedState;
 export declare function skillPathFromRead(toolName: unknown, args: unknown): string | undefined;
 export interface SuccessfulSkillRead {
     path: string;

package/node_modules/@llblab/pi-state-flow/dist/lib/skills.js

@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
 import { hashArtifactSource, isArtifactHash, } from "./artifact.js";
-import { canonicalJson, isObject } from "./json.js";
+import { isObject } from "./json.js";
 export const SKILL_ARTIFACT_COMPILER = "skill-artifact-v1";
 function hasContent(value) {
     if (typeof value === "string")
@@ -31,52 +31,6 @@ export function hasCompiledSkillArtifact(artifacts, provenance, source, expected
 export function hashSkillSource(source) {
     return hashArtifactSource(readFileSync(source));
 }
-function legacyCompilation(value) {
-    if (!hasContent(value))
-        return undefined;
-    return isObject(value) ? structuredClone(value) : { value: structuredClone(value) };
-}
-/** Move the retired contract store into source-addressed Skill artifacts. */
-export function migrateLegacySkillCompilations(state, hasher = hashSkillSource) {
-    if (!isObject(state.contract.compiled_skills))
-        return structuredClone(state);
-    const legacy = state.contract.compiled_skills;
-    const next = structuredClone(state);
-    delete next.contract.compiled_skills;
-    for (const [source, value] of Object.entries(legacy)) {
-        const compilation = legacyCompilation(value);
-        if (!compilation)
-            continue;
-        let hash;
-        let verified = true;
-        try {
-            hash = hasher(source);
-            if (!isArtifactHash(hash))
-                throw new Error("invalid source hash");
-        }
-        catch {
-            // Preserve useful legacy behavior while ensuring a later observable source
-            // identity normally invalidates this explicitly unverified fallback.
-            hash = hashArtifactSource(canonicalJson({ source, compilation }));
-            verified = false;
-        }
-        const metadata = {
-            description: `Compiled operational guidance for the Skill at ${source}`,
-            hash,
-            compiler: SKILL_ARTIFACT_COMPILER,
-            kind: "skill",
-            compilation,
-            ...(verified ? {} : { source_hash_verified: false }),
-        };
-        Object.defineProperty(next.artifacts, source, {
-            value: metadata,
-            enumerable: true,
-            configurable: true,
-            writable: true,
-        });
-    }
-    return next;
-}
 export function skillPathFromRead(toolName, args) {
     if (toolName !== "read" || !isObject(args) || typeof args.path !== "string")
         return undefined;

package/node_modules/@llblab/pi-state-flow/dist/lib/snapshot.d.ts

@@ -1,5 +1,4 @@
 import { type ArtifactProvenanceRegistry } from "./artifact.ts";
-import { type RemotePublicationPolicyDocument } from "./publication.ts";
 import { type JsonObject } from "./json.ts";
 import { type TransitionBoundary } from "./temporal.ts";
 /** Missing operational capability is not evidence that a checkpoint target is invalid. */
@@ -8,24 +7,17 @@ export declare class RevisionUnavailableError extends Error {
 export interface SnapshotConfig {
     enabled: boolean;
 }
-export interface PendingPublicationState {
-    commit: string;
-    error: string;
-}
 interface LegacyValidationFeedback {
     attempt: number;
     error: string;
     instruction: string;
 }
 export interface SnapshotMeta {
-    durableBase?: string;
-    pendingPublication?: PendingPublicationState;
     step: number;
     specification?: string;
     /** Read-only compatibility/recovery diagnostic; 0.7 never schedules terminal-envelope retries. */
     validation?: LegacyValidationFeedback;
     bootstrap?: boolean;
-    remotePublication?: RemotePublicationPolicyDocument;
 }
 /** In-memory runtime config/provenance; durable config/meta and scope files own restoration. */
 export interface StateFlowSnapshot {
@@ -35,20 +27,15 @@ export interface StateFlowSnapshot {
 export type Snapshot = StateFlowSnapshot;
 export interface SessionRuntime {
     config: SnapshotConfig;
-    meta: Omit<SnapshotMeta, "durableBase" | "pendingPublication"> & {
+    meta: SnapshotMeta & {
         version: 1;
         identity: {
             cwd: string;
             sessionId: string;
         };
         lineage: TransitionBoundary[];
-        /** Runtime-owned artifact freshness evidence; never projected as semantic state. */
+        /** Runtime-owned artifact compilation evidence; never projected as semantic state. */
         artifacts?: ArtifactProvenanceRegistry;
-        /** Resolved against the commit that last wrote this runtime record, not arbitrary HEAD. */
-        revision: "self";
-        temporalRevision?: "self" | string;
-        /** Durable intent survives a crash before the push result can be observed. */
-        publication: "unconfirmed" | "files";
         temporal?: {
             checkpoint: TransitionBoundary;
             patches: TransitionBoundary[];
@@ -57,32 +44,28 @@ export interface SessionRuntime {
     };
 }
 export declare function validateSessionRuntime(value: unknown, cwd: string, sessionId: string): asserts value is SessionRuntime;
-export declare function createSessionRuntime(snapshot: Snapshot, cwd: string, sessionId: string, lineage: readonly TransitionBoundary[], publication?: SessionRuntime["meta"]["publication"], _artifacts?: ArtifactProvenanceRegistry): SessionRuntime;
+export declare function createSessionRuntime(snapshot: Snapshot, cwd: string, sessionId: string, lineage: readonly TransitionBoundary[], _artifacts?: ArtifactProvenanceRegistry): SessionRuntime;
 export declare function serializeSessionRuntime(runtime: SessionRuntime, cwd: string, sessionId: string): {
     config: string;
     runtime: string;
 };
-export declare function parseSessionRuntime(config: string | undefined, runtimeSource: string | undefined, cwd: string, sessionId: string, legacyMetaSource?: string): SessionRuntime | undefined;
-export declare function resolveSessionRuntime(runtime: SessionRuntime, revision: string): {
-    snapshot: Snapshot;
-    lineage: TransitionBoundary[];
-    publicationTarget: string;
-    artifacts: ArtifactProvenanceRegistry;
-};
-export declare function resolveFileSessionRuntime(runtime: SessionRuntime, revision: string): Snapshot;
+export declare function parseSessionRuntime(config: string | undefined, runtimeSource: string | undefined, cwd: string, sessionId: string): SessionRuntime | undefined;
 export declare function emptySnapshot(enabled?: boolean): Snapshot;
-export type PiCheckpoint = {
-    revision: string;
-} | {
+export type RetainedBoundaryCheckpoint = {
+    boundary: string;
+    enabled: boolean;
+    step: number;
+    bootstrap?: true;
+    specification?: string;
+};
+export type RetainedPiCheckpoint = RetainedBoundaryCheckpoint | {
     disabled: true;
 };
 export type FileRevision = `file:${string}`;
 export declare function isFileRevision(value: unknown): value is FileRevision;
-export declare function isDurableRevision(value: unknown): value is string;
-export declare function isExactRevision(value: unknown): value is string;
-export declare function persistableSnapshot(snapshot: Snapshot): PiCheckpoint;
-/** Pi checkpoints admit only strict revision pointers or the disabled marker. */
-export declare function parsePiCheckpoint(value: unknown): PiCheckpoint;
+/** Encode branch lifecycle against one retained temporal identity without semantic or backup data. */
+export declare function retainedBoundaryCheckpoint(snapshot: Snapshot, boundary: string): RetainedBoundaryCheckpoint;
+/** Decode the 0.17 retained-window checkpoint contract. */
+export declare function parseRetainedPiCheckpoint(value: unknown): RetainedPiCheckpoint;
 export declare function migrationFailure(data: JsonObject, error: string): Snapshot;
-export declare function migrateSnapshot(value: unknown): Snapshot;
 export {};

package/node_modules/@llblab/pi-state-flow/dist/lib/snapshot.js

@@ -1,6 +1,6 @@
 import { resolve } from "node:path";
 import { parseArtifactProvenanceRegistry } from "./artifact.js";
-import { parseRemotePublicationPolicyDocument, serializeRemotePublicationPolicyDocument } from "./publication.js";
+import { MAX_HISTORY_LIMIT } from "./history.js";
 import { canonicalJson, isJsonValue, isObject } from "./json.js";
 import { validateTemporalLineage } from "./temporal.js";
 const MAX_RESTORED_STEP = Number.MAX_SAFE_INTEGER - 1;
@@ -12,38 +12,35 @@ export function validateSessionRuntime(value, cwd, sessionId) {
     if (!isJsonValue(value) || !isObject(value) || Object.keys(value).sort().join(",") !== "config,meta"
         || !isObject(value.config) || !isObject(value.meta))
         throw new Error("Invalid State Flow session runtime envelope");
-    const { version, identity, lineage, revision, temporalRevision, publication, artifacts, temporal: _temporalScope, ...fields } = value.meta;
+    const { version, identity, lineage, artifacts, temporal: _temporalScope, ...fields } = value.meta;
     if (artifacts !== undefined)
         parseArtifactProvenanceRegistry(artifacts, "State Flow session artifact provenance");
-    if (temporalRevision !== undefined && temporalRevision !== "self"
-        && !isExactRevision(temporalRevision))
-        throw new Error("Invalid temporal revision reference");
-    if (version !== 1 || revision !== "self" || (publication !== "unconfirmed" && publication !== "files"))
+    if (version !== 1)
         throw new Error("Unsupported State Flow runtime provenance format");
-    if (publication === "files" && temporalRevision !== undefined && temporalRevision !== "self")
-        throw new Error("File runtime cannot select a historical temporal revision");
     if (!isObject(identity) || Object.keys(identity).sort().join(",") !== "cwd,sessionId"
         || identity.cwd !== resolve(cwd) || identity.sessionId !== sessionId || sessionId.trim().length === 0 || sessionId !== sessionId.trim()) {
         throw new Error("State Flow runtime scope identity mismatch");
     }
-    validateTemporalLineage(lineage);
-    const known = new Set(["step", "specification", "validation", "bootstrap", "remotePublication"]);
+    validateTemporalLineage(lineage, MAX_HISTORY_LIMIT);
+    const known = new Set(["step", "specification", "validation", "bootstrap"]);
     if (Object.keys(fields).some((key) => ["state", "contract", "working", "response"].includes(key))) {
         throw new Error("Semantic state does not belong in State Flow runtime metadata");
     }
     const runtimeFields = Object.fromEntries(Object.entries(fields).filter(([key]) => known.has(key)));
-    const { transitionWindow: _retiredWindow, ...supportedConfig } = value.config;
-    const normalized = migrateSnapshot({ config: supportedConfig, meta: runtimeFields });
+    const normalized = {
+        config: { enabled: value.config.enabled === true },
+        meta: restoredMeta(runtimeFields),
+    };
     if (runtimeFields.bootstrap === false)
         normalized.meta.bootstrap = false;
     if (runtimeFields.step === Number.MAX_SAFE_INTEGER)
         normalized.meta.step = Number.MAX_SAFE_INTEGER;
-    if (canonicalJson({ config: normalized.config, meta: normalized.meta }) !== canonicalJson({ config: supportedConfig, meta: runtimeFields })) {
+    if (canonicalJson({ config: normalized.config, meta: normalized.meta }) !== canonicalJson({ config: value.config, meta: runtimeFields })) {
         throw new Error("Invalid State Flow runtime configuration or counters");
     }
 }
-export function createSessionRuntime(snapshot, cwd, sessionId, lineage, publication = "unconfirmed", _artifacts = {}) {
-    const { durableBase: _base, pendingPublication: _publication, ...fields } = snapshot.meta;
+export function createSessionRuntime(snapshot, cwd, sessionId, lineage, _artifacts = {}) {
+    const fields = snapshot.meta;
     const runtime = {
         config: structuredClone(snapshot.config),
         meta: {
@@ -51,8 +48,6 @@ export function createSessionRuntime(snapshot, cwd, sessionId, lineage, publicat
             version: 1,
             identity: { cwd: resolve(cwd), sessionId },
             lineage: structuredClone([...lineage]),
-            revision: "self",
-            publication,
         },
     };
     validateSessionRuntime(runtime, cwd, sessionId);
@@ -63,37 +58,14 @@ export function serializeSessionRuntime(runtime, cwd, sessionId) {
     const { temporal: _retiredTemporal, artifacts: _legacyArtifacts, ...runtimeMeta } = runtime.meta;
     return { config: `${canonicalJson(runtime.config)}\n`, runtime: `${canonicalJson(runtimeMeta)}\n` };
 }
-export function parseSessionRuntime(config, runtimeSource, cwd, sessionId, legacyMetaSource) {
-    let selected = runtimeSource;
-    if (selected === undefined && legacyMetaSource !== undefined) {
-        let legacy;
-        try {
-            legacy = JSON.parse(legacyMetaSource);
-        }
-        catch {
-            throw new Error("State Flow session runtime contains invalid JSON");
-        }
-        if (isObject(legacy) && (Object.hasOwn(legacy, "identity") || Object.hasOwn(legacy, "lineage")))
-            selected = legacyMetaSource;
-    }
-    if (config === undefined && selected === undefined)
+export function parseSessionRuntime(config, runtimeSource, cwd, sessionId) {
+    if (config === undefined && runtimeSource === undefined)
         return undefined;
-    if (config === undefined && selected !== undefined) {
-        let document;
-        try {
-            document = JSON.parse(selected);
-        }
-        catch {
-            throw new Error("State Flow session runtime contains invalid JSON");
-        }
-        if (isObject(document) && !Object.hasOwn(document, "identity") && !Object.hasOwn(document, "lineage"))
-            return undefined;
-    }
-    if (config === undefined || selected === undefined)
+    if (config === undefined || runtimeSource === undefined)
         throw new Error("Incomplete State Flow config/runtime pair");
     let runtime;
     try {
-        runtime = { config: JSON.parse(config), meta: JSON.parse(selected) };
+        runtime = { config: JSON.parse(config), meta: JSON.parse(runtimeSource) };
     }
     catch {
         throw new Error("State Flow session runtime contains invalid JSON");
@@ -102,38 +74,6 @@ export function parseSessionRuntime(config, runtimeSource, cwd, sessionId, legac
     const { temporal: _legacyTemporal, ...runtimeMeta } = runtime.meta;
     return { config: { enabled: runtime.config.enabled }, meta: runtimeMeta };
 }
-export function resolveSessionRuntime(runtime, revision) {
-    validateSessionRuntime(runtime, runtime.meta.identity.cwd, runtime.meta.identity.sessionId);
-    if (!isExactRevision(revision) || runtime.meta.publication !== "unconfirmed")
-        throw new Error("Runtime self reference requires its exact Git revision and Git publication provenance");
-    const { version: _version, identity: _identity, lineage, revision: _self, temporalRevision: _temporal, publication: _intent, artifacts, ...fields } = runtime.meta;
-    return {
-        snapshot: { config: structuredClone(runtime.config), meta: { ...structuredClone(fields), durableBase: revision } },
-        lineage: structuredClone(lineage),
-        publicationTarget: revision,
-        artifacts: structuredClone(artifacts ?? {}),
-    };
-}
-export function resolveFileSessionRuntime(runtime, revision) {
-    validateSessionRuntime(runtime, runtime.meta.identity.cwd, runtime.meta.identity.sessionId);
-    if (!isFileRevision(revision) || runtime.meta.publication !== "files")
-        throw new Error("File runtime requires its exact file revision and file publication provenance");
-    const { version: _version, identity: _identity, lineage: _lineage, revision: _self, temporalRevision: _temporal, publication: _intent, ...fields } = runtime.meta;
-    return { config: structuredClone(runtime.config), meta: { ...structuredClone(fields), durableBase: revision } };
-}
-function isLegacyTwoPartState(value) {
-    return isObject(value)
-        && isObject(value.contract)
-        && isObject(value.working)
-        && Object.keys(value).every((key) => key === "contract" || key === "working");
-}
-function isLegacyThreePartState(value) {
-    return isObject(value)
-        && isObject(value.contract)
-        && isObject(value.working)
-        && typeof value.response === "string"
-        && Object.keys(value).every((key) => key === "contract" || key === "working" || key === "response");
-}
 function restoredStep(value) {
     return typeof value === "number"
         && Number.isSafeInteger(value)
@@ -156,37 +96,14 @@ function restoredValidation(value) {
         instruction: value.instruction,
     };
 }
-function restoredPendingPublication(value) {
-    if (!isObject(value)
-        || typeof value.commit !== "string"
-        || !/^[0-9a-f]{40,64}$/.test(value.commit)
-        || typeof value.error !== "string"
-        || value.error.trim().length === 0)
-        return undefined;
-    return { commit: value.commit, error: value.error };
-}
 function restoredMeta(value, legacy = {}) {
     const meta = isObject(value) ? value : legacy;
-    const pendingPublication = restoredPendingPublication(meta.pendingPublication);
     const validation = restoredValidation(meta.validation);
-    let remotePublication;
-    try {
-        if (meta.remotePublication !== undefined)
-            remotePublication = serializeRemotePublicationPolicyDocument(parseRemotePublicationPolicyDocument(meta.remotePublication, { legacyRuntime: false }));
-    }
-    catch {
-        remotePublication = undefined;
-    }
     return {
-        ...(isDurableRevision(meta.durableBase)
-            ? { durableBase: meta.durableBase }
-            : {}),
-        ...(pendingPublication === undefined ? {} : { pendingPublication }),
         step: restoredStep(meta.step),
         ...(typeof meta.specification === "string" ? { specification: meta.specification } : {}),
         ...(validation === undefined ? {} : { validation }),
         ...(meta.bootstrap === true ? { bootstrap: true } : {}),
-        ...(remotePublication === undefined ? {} : { remotePublication }),
     };
 }
 function envelope(enabled, meta) {
@@ -198,36 +115,41 @@ export function emptySnapshot(enabled = false) {
 export function isFileRevision(value) {
     return typeof value === "string" && /^file:[0-9a-f]{64}$/.test(value);
 }
-export function isDurableRevision(value) {
-    return isExactRevision(value) || isFileRevision(value);
-}
-export function isExactRevision(value) {
-    return typeof value === "string" && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(value);
-}
-export function persistableSnapshot(snapshot) {
-    if (snapshot.meta.durableBase !== undefined) {
-        if (!isDurableRevision(snapshot.meta.durableBase))
-            throw new Error("Checkpoint requires an exact Git revision or file reference");
-        return { revision: snapshot.meta.durableBase };
-    }
-    if (snapshot.config.enabled)
-        throw new Error("Enabled checkpoint requires a durable runtime revision");
-    return { disabled: true };
+/** Encode branch lifecycle against one retained temporal identity without semantic or backup data. */
+export function retainedBoundaryCheckpoint(snapshot, boundary) {
+    if (typeof boundary !== "string" || boundary.trim().length === 0)
+        throw new Error("Checkpoint requires a retained temporal boundary identity");
+    const checkpoint = {
+        boundary,
+        enabled: snapshot.config.enabled,
+        step: snapshot.meta.step,
+        ...(snapshot.meta.bootstrap === true ? { bootstrap: true } : {}),
+        ...(snapshot.meta.specification === undefined ? {} : { specification: snapshot.meta.specification }),
+    };
+    return parseRetainedPiCheckpoint(checkpoint);
 }
-/** Pi checkpoints admit only strict revision pointers or the disabled marker. */
-export function parsePiCheckpoint(value) {
+/** Decode the 0.17 retained-window checkpoint contract. */
+export function parseRetainedPiCheckpoint(value) {
     if (!isObject(value))
-        throw new Error("Invalid State Flow checkpoint");
-    if (Object.hasOwn(value, "revision") || Object.hasOwn(value, "disabled")) {
-        if (Object.keys(value).length === 1) {
-            if (isDurableRevision(value.revision))
-                return { revision: value.revision };
-            if (value.disabled === true)
-                return { disabled: true };
-        }
-        throw new Error("Invalid State Flow checkpoint pointer or disabled marker");
+        throw new Error("Invalid State Flow retained-boundary checkpoint");
+    if (Object.keys(value).length === 1 && value.disabled === true)
+        return { disabled: true };
+    const allowed = new Set(["boundary", "enabled", "step", "bootstrap", "specification"]);
+    if (Object.keys(value).some((key) => !allowed.has(key))
+        || typeof value.boundary !== "string" || value.boundary.trim().length === 0
+        || typeof value.enabled !== "boolean"
+        || !Number.isSafeInteger(value.step) || value.step < 0 || value.step > MAX_RESTORED_STEP
+        || (value.bootstrap !== undefined && value.bootstrap !== true)
+        || (value.specification !== undefined && typeof value.specification !== "string")) {
+        throw new Error("Invalid State Flow retained-boundary checkpoint");
     }
-    throw new Error("Unrecognized State Flow checkpoint");
+    return {
+        boundary: value.boundary,
+        enabled: value.enabled,
+        step: value.step,
+        ...(value.bootstrap === true ? { bootstrap: true } : {}),
+        ...(typeof value.specification === "string" ? { specification: value.specification } : {}),
+    };
 }
 export function migrationFailure(data, error) {
     const meta = restoredMeta(data.meta, data);
@@ -238,14 +160,3 @@ export function migrationFailure(data, error) {
     };
     return envelope(false, meta);
 }
-export function migrateSnapshot(value) {
-    if (!isObject(value))
-        return emptySnapshot();
-    const isEnvelope = Object.hasOwn(value, "config") || Object.hasOwn(value, "meta");
-    const config = isEnvelope && isObject(value.config) ? value.config : value;
-    const meta = restoredMeta(isEnvelope ? value.meta : undefined, value);
-    const enabled = config.enabled === true;
-    if (Object.hasOwn(value, "state") || Object.hasOwn(value, "stateBasis") || Object.hasOwn(value, "previousStatePatch"))
-        return envelope(false, meta);
-    return envelope(enabled, meta);
-}

package/node_modules/@llblab/pi-state-flow/dist/lib/state.d.ts

@@ -1,14 +1,13 @@
-import { type ArtifactCompilationUpdate, type ArtifactRegistry } from "./artifact.ts";
-import { type JsonObject, type JsonValue } from "./json.ts";
+import { type ArtifactCompilationUpdate, type ArtifactModelHints, type ArtifactRegistry } from "./artifact.ts";
+import { type JsonObject } from "./json.ts";
 /** The canonical semantic state shape shared by global, CWD, and session scopes. */
 export type MaterializedState = JsonObject & {
-    artifacts: ArtifactRegistry;
+    intents: JsonObject;
     contract: JsonObject;
     working: JsonObject;
-    intents: JsonObject;
+    artifacts: ArtifactRegistry;
     response: string;
-    /** Absent is the canonical empty lazy plane and preserves predecessor-store compatibility. */
-    lazy?: JsonValue;
+    lazy: JsonObject;
 };
 /** Compatibility name for callers that still treat materialized state as a document. */
 export type StateDocument = MaterializedState;
@@ -19,6 +18,7 @@ export interface StatePatch extends JsonObject {
     working: JsonObject;
     intents: JsonObject;
     response: string;
+    lazy: JsonObject;
 }
 export type StateScope = "global" | "cwd" | "session";
 /** A model-authored patch for one scope. Response is captured by the runtime in session state. */
@@ -27,7 +27,7 @@ export interface ScopePatch {
     contract?: JsonObject;
     working?: JsonObject;
     intents?: JsonObject;
-    lazy?: JsonValue;
+    lazy?: JsonObject;
 }
 export interface ScopedPatch {
     scope: StateScope;
@@ -53,11 +53,16 @@ export interface ScopedStates {
 export declare function emptyState(): MaterializedState;
 export declare function isMaterializedState(value: unknown): value is MaterializedState;
 export declare const isStateDocument: typeof isMaterializedState;
-/** Upgrade one exact pre-intents materialized state without inferring commitments. */
-export declare function migratePreIntentState(value: unknown): MaterializedState | undefined;
 /** Atomically replace compiled and removed artifacts inside one materialized scope. */
 export declare function updateMaterializedArtifacts(state: MaterializedState, updates: readonly ArtifactCompilationUpdate[], removed?: readonly string[]): MaterializedState;
 /** Overlay lower-to-higher scopes without mutating any scope document. */
 export declare function overlayStates(...scopes: readonly MaterializedState[]): MaterializedState;
-/** Model-visible projection: runtime artifact bookkeeping never reaches ordinary context. */
-export declare function projectStateForModel(state: MaterializedState): MaterializedState;
+export type ModelState = JsonObject & {
+    intents: JsonObject;
+    contract: JsonObject;
+    working: JsonObject;
+    artifacts: ArtifactRegistry;
+    response: string;
+};
+/** Model-visible projection: lazy bodies and runtime artifact bookkeeping stay out of ordinary context. */
+export declare function projectStateForModel(state: MaterializedState, artifactHints?: ArtifactModelHints): ModelState;

package/node_modules/@llblab/pi-state-flow/dist/lib/state.js

@@ -1,7 +1,7 @@
 import { isArtifactRegistry, projectArtifactsForModel, updateArtifactRegistry, } from "./artifact.js";
-import { applyPatch, isJsonValue, isObject } from "./json.js";
+import { applyPatch, isObject } from "./json.js";
 export function emptyState() {
-    return { artifacts: {}, contract: {}, working: {}, intents: {}, response: "" };
+    return { intents: {}, contract: {}, working: {}, artifacts: {}, response: "", lazy: {} };
 }
 export function isMaterializedState(value) {
     return isObject(value)
@@ -10,17 +10,10 @@ export function isMaterializedState(value) {
         && isObject(value.working)
         && isObject(value.intents)
         && typeof value.response === "string"
-        && (!Object.hasOwn(value, "lazy") || (isJsonValue(value.lazy) && value.lazy !== null))
+        && isObject(value.lazy)
         && Object.keys(value).every((key) => key === "artifacts" || key === "contract" || key === "working" || key === "intents" || key === "response" || key === "lazy");
 }
 export const isStateDocument = isMaterializedState;
-/** Upgrade one exact pre-intents materialized state without inferring commitments. */
-export function migratePreIntentState(value) {
-    if (!isObject(value) || Object.hasOwn(value, "intents"))
-        return undefined;
-    const candidate = { ...structuredClone(value), intents: {} };
-    return isMaterializedState(candidate) ? candidate : undefined;
-}
 /** Atomically replace compiled and removed artifacts inside one materialized scope. */
 export function updateMaterializedArtifacts(state, updates, removed = []) {
     if (!isMaterializedState(state))
@@ -34,8 +27,14 @@ export function overlayStates(...scopes) {
         return applyPatch(effective, scope);
     }, emptyState());
 }
-/** Model-visible projection: runtime artifact bookkeeping never reaches ordinary context. */
-export function projectStateForModel(state) {
-    const { lazy: _lazy, ...hot } = structuredClone(state);
-    return { ...hot, artifacts: projectArtifactsForModel(state.artifacts) };
+/** Model-visible projection: lazy bodies and runtime artifact bookkeeping stay out of ordinary context. */
+export function projectStateForModel(state, artifactHints = {}) {
+    const cloned = structuredClone(state);
+    return {
+        intents: cloned.intents,
+        contract: cloned.contract,
+        working: cloned.working,
+        artifacts: projectArtifactsForModel(cloned.artifacts, artifactHints),
+        response: cloned.response,
+    };
 }

package/node_modules/@llblab/pi-state-flow/dist/lib/status.d.ts

@@ -1,6 +1,5 @@
 import type { ArtifactInvalidationReason } from "./artifact.ts";
 import { type RecentTransitionWindow } from "./history.ts";
-import type { PublicationQueueState } from "./publication.ts";
 import type { Snapshot } from "./snapshot.ts";
 import { type ScopedStates, type StateScope } from "./state.ts";
 import type { TransitionBoundary } from "./temporal.ts";
@@ -12,27 +11,20 @@ export interface StaleArtifactDiagnostic {
     path: string;
     reason: StaleArtifactReason;
 }
-export interface PendingPublicationDiagnostic {
-    commit: string;
-    error: string;
-}
 export interface StatusDiagnostics {
     repositoryRoot: string;
     cwdScopeKey: string;
     sessionScopeKey: string;
     scopeStates: ScopedStates;
     recent: RecentTransitionWindow;
+    historyLimit: number;
     temporal?: {
         head: TransitionBoundary;
         historyDepth: number;
         tailCounts: Record<StateScope, number>;
     };
     staleArtifacts: readonly StaleArtifactDiagnostic[];
-    artifactFreshnessError?: string;
     durableStateError?: string;
-    pendingPublication?: PendingPublicationDiagnostic;
-    publicationQueue?: PublicationQueueState;
-    publicationQueueError?: string;
 }
 export declare function compactStatus(snapshot: Snapshot, colorize: Colorize): string | undefined;
 export declare function detailedStatus(snapshot: Snapshot, diagnostics: StatusDiagnostics): string;