@llblab/pi-kit 0.18.2 → 0.19.1

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

@@ -2,12 +2,10 @@ import { readFileSync } from "node:fs";
 import {
 	hashArtifactSource,
 	isArtifactHash,
-	type ArtifactMetadata,
 	type ArtifactProvenance,
 	type ArtifactRegistry,
 } from "./artifact.ts";
-import { canonicalJson, isObject, type JsonObject, type JsonValue } from "./json.ts";
-import type { MaterializedState } from "./state.ts";
+import { isObject } from "./json.ts";
 
 export const SKILL_ARTIFACT_COMPILER = "skill-artifact-v1";
 
@@ -46,52 +44,6 @@ export function hashSkillSource(source: string): string {
 	return hashArtifactSource(readFileSync(source));
 }
 
-function legacyCompilation(value: JsonValue): JsonObject | undefined {
-	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: MaterializedState,
-	hasher: SkillSourceHasher = hashSkillSource,
-): MaterializedState {
-	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: string;
-		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: ArtifactMetadata = {
-			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: unknown, args: unknown): string | undefined {
 	if (toolName !== "read" || !isObject(args) || typeof args.path !== "string") return undefined;
 	return /(^|[\\/])SKILL\.md$/.test(args.path) ? args.path : undefined;

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

@@ -1,9 +1,8 @@
 import { resolve } from "node:path";
 import { parseArtifactProvenanceRegistry, type ArtifactProvenanceRegistry } from "./artifact.ts";
-import { parseRemotePublicationPolicyDocument, serializeRemotePublicationPolicyDocument, type RemotePublicationPolicyDocument } from "./publication.ts";
+import { MAX_HISTORY_LIMIT } from "./history.ts";
 import { applyPatch, canonicalJson, containsNull, isJsonValue, isObject, type JsonObject } from "./json.ts";
 import { validateTemporalLineage, type TransitionBoundary } from "./temporal.ts";
-import { migrateLegacySkillCompilations } from "./skills.ts";
 import { isMaterializedState, type MaterializedState } from "./state.ts";
 const MAX_RESTORED_STEP = Number.MAX_SAFE_INTEGER - 1;
 const MAX_LEGACY_VALIDATION_ATTEMPT = 7;
@@ -15,11 +14,6 @@ export interface SnapshotConfig {
 	enabled: boolean;
 }
 
-export interface PendingPublicationState {
-	commit: string;
-	error: string;
-}
-
 interface LegacyValidationFeedback {
 	attempt: number;
 	error: string;
@@ -27,14 +21,11 @@ interface LegacyValidationFeedback {
 }
 
 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. */
@@ -47,17 +38,12 @@ 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[] };
 		[key: string]: unknown;
 	};
@@ -66,27 +52,26 @@ export interface SessionRuntime {
 export function validateSessionRuntime(value: unknown, cwd: string, sessionId: string): asserts value is SessionRuntime {
 	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")) 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 (version !== 1) throw new Error("Unsupported State Flow runtime provenance format");
 	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: Snapshot = {
+		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");
 	}
 }
@@ -96,19 +81,16 @@ export function createSessionRuntime(
 	cwd: string,
 	sessionId: string,
 	lineage: readonly TransitionBoundary[],
-	publication: SessionRuntime["meta"]["publication"] = "unconfirmed",
 	_artifacts: ArtifactProvenanceRegistry = {},
 ): SessionRuntime {
-	const { durableBase: _base, pendingPublication: _publication, ...fields } = snapshot.meta;
+	const fields = snapshot.meta;
 	const runtime: SessionRuntime = {
 		config: structuredClone(snapshot.config),
 		meta: {
-			...Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined)) as Omit<SnapshotMeta, "durableBase" | "pendingPublication">,
+			...Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined)) as SnapshotMeta,
 			version: 1,
 			identity: { cwd: resolve(cwd), sessionId },
 			lineage: structuredClone([...lineage]),
-			revision: "self",
-			publication,
 		},
 	};
 	validateSessionRuntime(runtime, cwd, sessionId);
@@ -124,24 +106,13 @@ export function serializeSessionRuntime(
 }
 
 export function parseSessionRuntime(
-	config: string | undefined, runtimeSource: string | undefined, cwd: string, sessionId: string, legacyMetaSource?: string,
+	config: string | undefined, runtimeSource: string | undefined, cwd: string, sessionId: string,
 ): SessionRuntime | undefined {
-	let selected = runtimeSource;
-	if (selected === undefined && legacyMetaSource !== undefined) {
-		let legacy: unknown;
-		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) return undefined;
-	if (config === undefined && selected !== undefined) {
-		let document: unknown;
-		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) throw new Error("Incomplete State Flow config/runtime pair");
+	if (config === undefined && runtimeSource === undefined) return undefined;
+	if (config === undefined || runtimeSource === undefined) throw new Error("Incomplete State Flow config/runtime pair");
 	let runtime: unknown;
 	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");
 	}
@@ -150,40 +121,6 @@ export function parseSessionRuntime(
 	return { config: { enabled: runtime.config.enabled }, meta: runtimeMeta };
 }
 
-export function resolveSessionRuntime(runtime: SessionRuntime, revision: string): { snapshot: Snapshot; lineage: TransitionBoundary[]; publicationTarget: string; artifacts: ArtifactProvenanceRegistry } {
-	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: SessionRuntime, revision: string): Snapshot {
-	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: unknown): value is { contract: JsonObject; working: JsonObject } {
-	return isObject(value)
-		&& isObject(value.contract)
-		&& isObject(value.working)
-		&& Object.keys(value).every((key) => key === "contract" || key === "working");
-}
-
-function isLegacyThreePartState(value: unknown): value is { contract: JsonObject; working: JsonObject; response: string } {
-	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: unknown): number {
 	return typeof value === "number"
 		&& Number.isSafeInteger(value)
@@ -207,37 +144,14 @@ function restoredValidation(value: unknown): LegacyValidationFeedback | undefine
 	};
 }
 
-function restoredPendingPublication(value: unknown): PendingPublicationState | undefined {
-	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: unknown, legacy: JsonObject = {}): SnapshotMeta {
 	const meta = isObject(value) ? value : legacy;
-	const pendingPublication = restoredPendingPublication(meta.pendingPublication);
 	const validation = restoredValidation(meta.validation);
-	let remotePublication: RemotePublicationPolicyDocument | undefined;
-	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 }),
 	};
 }
 
@@ -249,41 +163,53 @@ export function emptySnapshot(enabled = false): Snapshot {
 	return envelope(enabled, { step: 0 });
 }
 
-export type PiCheckpoint = { revision: string } | { disabled: true };
+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 function isFileRevision(value: unknown): value is FileRevision {
 	return typeof value === "string" && /^file:[0-9a-f]{64}$/.test(value);
 }
 
-export function isDurableRevision(value: unknown): value is string {
-	return isExactRevision(value) || isFileRevision(value);
-}
-
-export function isExactRevision(value: unknown): value is string {
-	return typeof value === "string" && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(value);
-}
-
-export function persistableSnapshot(snapshot: Snapshot): PiCheckpoint {
-	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 };
-}
-
-/** Pi checkpoints admit only strict revision pointers or the disabled marker. */
-export function parsePiCheckpoint(value: unknown): PiCheckpoint {
-	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");
+/** Encode branch lifecycle against one retained temporal identity without semantic or backup data. */
+export function retainedBoundaryCheckpoint(snapshot: Snapshot, boundary: string): RetainedBoundaryCheckpoint {
+	if (typeof boundary !== "string" || boundary.trim().length === 0) throw new Error("Checkpoint requires a retained temporal boundary identity");
+	const checkpoint: RetainedBoundaryCheckpoint = {
+		boundary,
+		enabled: snapshot.config.enabled,
+		step: snapshot.meta.step,
+		...(snapshot.meta.bootstrap === true ? { bootstrap: true as const } : {}),
+		...(snapshot.meta.specification === undefined ? {} : { specification: snapshot.meta.specification }),
+	};
+	return parseRetainedPiCheckpoint(checkpoint) as RetainedBoundaryCheckpoint;
+}
+
+/** Decode the 0.17 retained-window checkpoint contract. */
+export function parseRetainedPiCheckpoint(value: unknown): RetainedPiCheckpoint {
+	if (!isObject(value)) 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 as number) < 0 || (value.step as number) > 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 as number,
+		...(value.bootstrap === true ? { bootstrap: true } : {}),
+		...(typeof value.specification === "string" ? { specification: value.specification } : {}),
+	};
 }
 
 export function migrationFailure(data: JsonObject, error: string): Snapshot {
@@ -295,13 +221,3 @@ export function migrationFailure(data: JsonObject, error: string): Snapshot {
 	};
 	return envelope(false, meta);
 }
-
-export function migrateSnapshot(value: unknown): Snapshot {
-	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/lib/state.ts

@@ -3,19 +3,19 @@ import {
 	projectArtifactsForModel,
 	updateArtifactRegistry,
 	type ArtifactCompilationUpdate,
+	type ArtifactModelHints,
 	type ArtifactRegistry,
 } from "./artifact.ts";
-import { applyPatch, isJsonValue, isObject, type JsonObject, type JsonValue } from "./json.ts";
+import { applyPatch, isObject, 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. */
@@ -28,6 +28,7 @@ export interface StatePatch extends JsonObject {
 	working: JsonObject;
 	intents: JsonObject;
 	response: string;
+	lazy: JsonObject;
 }
 
 export type StateScope = "global" | "cwd" | "session";
@@ -38,7 +39,7 @@ export interface ScopePatch {
 	contract?: JsonObject;
 	working?: JsonObject;
 	intents?: JsonObject;
-	lazy?: JsonValue;
+	lazy?: JsonObject;
 }
 
 export interface ScopedPatch {
@@ -68,7 +69,7 @@ export interface ScopedStates {
 }
 
 export function emptyState(): MaterializedState {
-	return { artifacts: {}, contract: {}, working: {}, intents: {}, response: "" } as MaterializedState;
+	return { intents: {}, contract: {}, working: {}, artifacts: {}, response: "", lazy: {} };
 }
 
 export function isMaterializedState(value: unknown): value is MaterializedState {
@@ -78,19 +79,12 @@ export function isMaterializedState(value: unknown): value is MaterializedState
 		&& 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: unknown): MaterializedState | undefined {
-	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: MaterializedState,
@@ -109,8 +103,22 @@ export function overlayStates(...scopes: readonly MaterializedState[]): Material
 	}, emptyState());
 }
 
-/** Model-visible projection: runtime artifact bookkeeping never reaches ordinary context. */
-export function projectStateForModel(state: MaterializedState): MaterializedState {
-	const { lazy: _lazy, ...hot } = structuredClone(state);
-	return { ...hot, artifacts: projectArtifactsForModel(state.artifacts) } as 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 function projectStateForModel(state: MaterializedState, artifactHints: ArtifactModelHints = {}): ModelState {
+	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/lib/status.ts

@@ -1,7 +1,6 @@
 import type { ArtifactInvalidationReason } from "./artifact.ts";
-import { projectRecentTransitionsWithLimit, RECENT_TRANSITION_LIMIT, type RecentTransitionWindow } from "./history.ts";
-import { inspectMemoryPromotions, retainedMemoryScopes } from "./memory.ts";
-import type { PublicationQueueState } from "./publication.ts";
+import { projectRecentTransitionsWithLimit, type RecentTransitionWindow } from "./history.ts";
+import { retainedMemoryScopes } from "./memory.ts";
 import type { Snapshot } from "./snapshot.ts";
 import { overlayStates, type ScopedStates, type StateScope } from "./state.ts";
 import type { TransitionBoundary } from "./temporal.ts";
@@ -18,24 +17,16 @@ export interface StaleArtifactDiagnostic {
 	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 function compactStatus(snapshot: Snapshot, colorize: Colorize): string | undefined {
@@ -47,13 +38,9 @@ function countArtifacts(states: ScopedStates, scope: StateScope): number {
 	return Object.keys(states[scope].artifacts).length;
 }
 
-function abbreviatedCommit(commit: string): string {
-	return commit.length > 12 ? commit.slice(0, 12) : commit;
-}
-
 export function detailedStatus(snapshot: Snapshot, diagnostics: StatusDiagnostics): string {
 	const projectedRecent = projectRecentTransitionsWithLimit(
-		RECENT_TRANSITION_LIMIT,
+		diagnostics.historyLimit,
 		diagnostics.recent,
 	);
 	const available = diagnostics.temporal !== undefined && diagnostics.durableStateError === undefined;
@@ -63,61 +50,36 @@ export function detailedStatus(snapshot: Snapshot, diagnostics: StatusDiagnostic
 		diagnostics.scopeStates.session,
 	);
 	const stateJson = materialized === undefined ? undefined : JSON.stringify(materialized, null, 2);
-	const freshnessError = diagnostics.artifactFreshnessError ?? (available ? undefined : "temporal global artifact registry is unavailable");
-	const stale = freshnessError === undefined
-		? String(diagnostics.staleArtifacts.length)
-		: "unknown";
-	const publication = diagnostics.pendingPublication === undefined
-		? "idle"
-		: `pending ${abbreviatedCommit(diagnostics.pendingPublication.commit)} — ${diagnostics.pendingPublication.error}`;
-	const staleLines = freshnessError !== undefined
-		? [`Artifact freshness unavailable: ${freshnessError}`]
-		: diagnostics.staleArtifacts.length === 0
-			? ["Stale artifacts: none"]
-			: [
-				"Stale artifacts:",
-				...diagnostics.staleArtifacts.map(({ scope, path, reason }) => `- [${scope}] ${path} — ${reason}`),
-			];
+	const invalidated = available ? String(diagnostics.staleArtifacts.length) : "unavailable";
+	const invalidationLines = diagnostics.staleArtifacts.length === 0
+		? ["Pending artifact invalidations: none"]
+		: [
+			"Pending artifact invalidations:",
+			...diagnostics.staleArtifacts.map(({ scope, path, reason }) => `- [${scope}] ${path} — ${reason}`),
+		];
 	const temporal = available ? diagnostics.temporal : undefined;
 	const temporalLines = temporal === undefined
 		? [`Temporal materialization unavailable: ${diagnostics.durableStateError ?? "no selected branch runtime"}`,
-			"Hot history: unavailable; offsets beyond 7 require explicit cold Git inspection",
+			`Hot history: unavailable; configured maximum depth ${diagnostics.historyLimit}`,
 			"Retained patch tails: unavailable"]
 		: [`Temporal head: ${JSON.stringify(temporal.head.id)}; branch-local position ${temporal.head.position}`,
-			`Hot history: offsets 0..${temporal.historyDepth}; maximum depth 7`,
+			`Hot history: offsets 0..${temporal.historyDepth}; maximum depth ${diagnostics.historyLimit}`,
 			`Retained patch tails: global ${temporal.tailCounts.global}; CWD ${temporal.tailCounts.cwd}; session ${temporal.tailCounts.session}`];
 	const artifacts = (scope: StateScope) => available ? countArtifacts(diagnostics.scopeStates, scope) : "unknown";
-	const promotions = available ? inspectMemoryPromotions(diagnostics.scopeStates.global) : [];
-	const promotionCounts = Object.fromEntries(["pending", "accepted", "failed", "unknown", "invalid"].map((status) => [status, promotions.filter((entry) => entry.status === status).length]));
 	const memoryScopes = available ? retainedMemoryScopes(diagnostics.scopeStates) : undefined;
-	const oneLine = (value: string) => value.replace(/\s+/g, " ").slice(0, 240);
-	const promotionLines = !available || promotions.length === 0 ? [] : [
-		"Memory promotions:",
-		...promotions.map((entry) => `- ${oneLine(entry.id)} — ${entry.status}; owner ${oneLine(entry.owner ?? "unavailable")}${entry.pointer ? `; pointer ${oneLine(entry.pointer)}` : ""}${entry.revision ? `; revision ${oneLine(entry.revision)}` : ""}${entry.error ? `; error ${oneLine(entry.error)}` : ""}`),
-	];
 
 	return [
 		`State Flow diagnostics — config.enabled=${snapshot.config.enabled}; branch mode=${snapshot.config.enabled ? "active" : "inactive"}`,
 		`Repository: ${diagnostics.repositoryRoot}`,
 		`Scope keys: CWD ${diagnostics.cwdScopeKey}; session ${diagnostics.sessionScopeKey}`,
 		"Session files: config.json owns behavior; runtime.json owns branch recovery; meta.json owns scope provenance",
-		`Runtime metadata: step #${snapshot.meta.step}; active revision ${snapshot.meta.durableBase ?? "none"}; bootstrap ${snapshot.meta.bootstrap === true}`,
-		`Remote publication policy: ${snapshot.meta.remotePublication?.mode ?? "legacy-transition"}`,
-		diagnostics.publicationQueueError !== undefined
-			? `Remote queue: unavailable; error ${diagnostics.publicationQueueError}`
-			: diagnostics.publicationQueue === undefined
-			? "Remote queue: idle"
-			: `Remote queue: ${diagnostics.publicationQueue.status}; target ${abbreviatedCommit(diagnostics.publicationQueue.target)}; confirmed ${diagnostics.publicationQueue.confirmed ? abbreviatedCommit(diagnostics.publicationQueue.confirmed) : "none"}; attempt ${diagnostics.publicationQueue.attempt}${diagnostics.publicationQueue.error ? `; error ${diagnostics.publicationQueue.error}` : ""}`,
+		`Runtime metadata: step #${snapshot.meta.step}; bootstrap ${snapshot.meta.bootstrap === true}`,
 		"Memory: owner state-flow; global retention enabled; global fallback active",
 		`Memory-bearing scopes: global ${memoryScopes?.global ?? "unknown"}; CWD ${memoryScopes?.cwd ?? "unknown"}; session ${memoryScopes?.session ?? "unknown"}`,
-		`Promotion status: pending ${promotionCounts.pending}; accepted ${promotionCounts.accepted}; failed ${promotionCounts.failed}; unknown ${promotionCounts.unknown}; invalid ${promotionCounts.invalid}`,
-		...promotionLines,
 		...temporalLines,
-		`Artifacts: global ${artifacts("global")}; CWD ${artifacts("cwd")}; session ${artifacts("session")}; stale ${stale}`,
+		`Artifacts: global ${artifacts("global")}; CWD ${artifacts("cwd")}; session ${artifacts("session")}; pending invalidations ${invalidated}`,
 		available ? `Recent transitions: global ${diagnostics.recent.filter(({ transitions }) => transitions.some(({ scope }) => scope === "global")).length}; CWD ${diagnostics.recent.filter(({ transitions }) => transitions.some(({ scope }) => scope === "cwd")).length}; session ${diagnostics.recent.filter(({ transitions }) => transitions.some(({ scope }) => scope === "session")).length}; active ${projectedRecent.length}` : "Recent transitions: unavailable",
-		`Publication policy: ${snapshot.meta.remotePublication?.mode ?? "legacy-unresolved"}`,
-		`Publication: ${publication}`,
-		...staleLines,
+		...invalidationLines,
 		...(stateJson === undefined
 			? ["Effective memory: unavailable"]
 			: [`Effective memory (${Buffer.byteLength(stateJson, "utf8")} JSON bytes; global → CWD → session overlay):`, "", stateJson]),