@llblab/pi-kit 0.10.8 → 0.11.1

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

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { lstatSync } from "node:fs";
 import { join } from "node:path";
-import { parseScopeProvenance, parseScopeStream, sessionRuntimePaths, temporalScopePaths, type SessionAddress } from "./durable.ts";
+import { classifyScopeStream, parseScopeProvenance, parseScopeStream, sessionRuntimePaths, temporalScopePaths, type SessionAddress } from "./durable.ts";
 import { parseArtifactProvenanceRegistry, pruneArtifactProvenance, type ArtifactProvenance, type ArtifactProvenanceRegistry } from "./artifact.ts";
 import { adoptFileStateToGit, initializeGitRepository, isLocalGitRepository, captureTemporalGitBase, loadLegacyStatesAtRevision, loadTemporalRevision, migrateHashedCwdAtHead, migrateHashedLayoutAtHead, migrateLegacyStorageToGit, publishTemporalStateToGit, type TemporalGitBase } from "./git.ts";
 import { captureTemporalFileBase, detectGitCapability, initializeFileStore, loadTemporalFileRevision, migrateLegacyStorageToFiles, publishTemporalStateToFiles, type TemporalFileBase } from "./storage.ts";
@@ -16,6 +16,12 @@ const SCOPES = ["global", "cwd", "session"] as const;
 const SHARED_SCOPES = ["global", "cwd"] as const;
 export type RuntimePublication = ReturnType<typeof publishTemporalStateToGit> & { revision?: string };
 
+interface SessionCopy {
+	stream: ScopeStream;
+	provenance: ArtifactProvenanceRegistry;
+	backend: "git" | "files";
+}
+
 function emptyProvenance(): Record<StateScope, ArtifactProvenanceRegistry> {
 	return { global: {}, cwd: {}, session: {} };
 }
@@ -33,10 +39,27 @@ function targetScopeConflict(scopes: readonly StateScope[]): Error {
 	return new Error(`State Flow cannot publish the ${labels.join(" and ")} patches because the live ${labels.join(" and ")} states advanced after this transition's selected basis. Refresh or reconcile the target scopes before retrying.`);
 }
 
+/** Disappearance invalidates a selected write target even though untouched scopes can adopt empty reality. */
+function removedTargetScopeConflict(scopes: readonly StateScope[]): Error {
+	const labels = scopes.map(scopeLabel);
+	if (labels.length === 1) {
+		return new Error(`State Flow cannot publish the ${labels[0]} patch because the live ${labels[0]} scope was removed after this transition's selected basis. Refresh or reconcile the target scope before retrying.`);
+	}
+	return new Error(`State Flow cannot publish the ${labels.join(" and ")} patches because the live ${labels.join(" and ")} scopes were removed after this transition's selected basis. Refresh or reconcile the target scopes before retrying.`);
+}
+
+function freshEmptyScopeStream(scope: StateScope, origin: string): ScopeStream {
+	return createTemporalState({ global: emptyState(), cwd: emptyState(), session: emptyState() }, origin).scopes[scope];
+}
+
+export class MissingSessionRuntimeError extends Error {
+	constructor() { super("Linked State Flow revision has no session runtime"); }
+}
+
 /** Immutable target validation is independent of acquiring the live publication basis. */
 export function inspectRuntimeRevision(cwd: string, sessionId: string, root: string, revision: string, sessionKey = sessionId) {
 	const loaded = loadTemporalRevision(cwd, sessionId, root, revision, sessionKey);
-	if (!loaded.runtime) throw new Error("Linked State Flow revision has no session runtime");
+	if (!loaded.runtime) throw new MissingSessionRuntimeError();
 	const resolved = resolveSessionRuntime(loaded.runtime.document, loaded.runtime.revision);
 	if (!loaded.scopes.global || !loaded.scopes.cwd || !loaded.scopes.session) throw new Error("Incomplete temporal scope cohort");
 	const view = { lineage: resolved.lineage, scopes: { global: loaded.scopes.global, cwd: loaded.scopes.cwd, session: loaded.scopes.session } };
@@ -71,6 +94,8 @@ export class TemporalRuntime {
 	private savedRuntime: string | undefined;
 	private backend: "git" | "files" | undefined;
 	private provenanceByScope: Record<StateScope, ArtifactProvenanceRegistry> = emptyProvenance();
+	/** Shared scopes whose wholly absent live basis was accepted after one stale-target refusal. */
+	private readonly absentSharedScopes = new Set<StateScope>();
 	readonly cwd: string;
 	private readonly session: SessionAddress;
 	readonly root: string;
@@ -109,6 +134,7 @@ export class TemporalRuntime {
 		this.backend = "git";
 		this.semanticRevision = result.revision;
 		this.savedRuntime = savedRuntime;
+		this.absentSharedScopes.clear();
 		return result;
 	}
 
@@ -138,8 +164,66 @@ export class TemporalRuntime {
 		return result;
 	}
 
-	restore(revision: string, legacySnapshot?: Snapshot): Snapshot {
+	/** Validate selection without installing state; only a matching immutable Git inspection is reusable. */
+	prepareRestore(revision: string, legacySnapshot?: Snapshot): { snapshot: Snapshot; restore: () => Snapshot } {
 		const inspected = inspectSnapshotRevision(this.cwd, this.sessionId, this.root, revision, legacySnapshot, this.sessionKey);
+		const selected = inspected.snapshot.meta.durableBase ?? revision;
+		let consumed = false;
+		return {
+			snapshot: structuredClone(inspected.snapshot),
+			restore: () => {
+				if (consumed) throw new Error("Prepared State Flow restore was already consumed");
+				consumed = true;
+				// File cohorts can expire; legacy migration and owner redirection keep their fresh-read path.
+				return inspected.temporal && selected === revision
+					? this.restoreInspected(revision, inspected)
+					: this.restore(selected, inspected.snapshot);
+			},
+		};
+	}
+
+	/** Copy only a proven source session stream; shared streams come from the child's fresh live basis. */
+	prepareFork(source: SessionAddress, revision: string): { snapshot: Snapshot; fork: () => { snapshot: Snapshot; publication: RuntimePublication } } {
+		const parent = Object.freeze({ ...source });
+		if (parent.id === this.sessionId || parent.key === this.sessionKey) throw new Error("State Flow fork requires a distinct session identity and key");
+		const inspect = () => inspectSnapshotRevision(this.cwd, parent.id, this.root, revision, undefined, parent.key);
+		const inspected = inspect();
+		const snapshot: Snapshot = {
+			config: structuredClone(inspected.snapshot.config),
+			meta: {
+				step: 0,
+				...(inspected.snapshot.meta.bootstrap === undefined ? {} : { bootstrap: inspected.snapshot.meta.bootstrap }),
+				...(inspected.snapshot.meta.remotePublication === undefined ? {} : { remotePublication: structuredClone(inspected.snapshot.meta.remotePublication) }),
+			},
+		};
+		let consumed = false;
+		return {
+			snapshot: { ...structuredClone(snapshot), meta: { ...structuredClone(snapshot.meta), durableBase: revision } },
+			fork: () => {
+				if (consumed) throw new Error("Prepared State Flow fork was already consumed");
+				consumed = true;
+				if (this.view) throw new Error("State Flow fork target already has session storage");
+				// Unlike immutable Git input, a file-only source must still match its complete cohort.
+				const current = inspected.file ? inspect() : inspected;
+				const selected = current.temporal ?? current.file;
+				if (!selected) throw new Error("State Flow fork requires a temporal session stream");
+				const publication = this.initializeOrigin(snapshot, { allowCreateCwd: false, copy: {
+					stream: selected.view.scopes.session,
+					provenance: selected.provenance.session,
+					backend: current.file ? "files" : "git",
+				} });
+				const ownedRevision = publication?.revision ?? publication?.commit;
+				if (!publication || !ownedRevision) throw new Error("State Flow fork requires existing shared scope storage");
+				return { snapshot: { ...structuredClone(snapshot), meta: { ...structuredClone(snapshot.meta), durableBase: ownedRevision } }, publication };
+			},
+		};
+	}
+
+	restore(revision: string, legacySnapshot?: Snapshot): Snapshot {
+		return this.restoreInspected(revision, inspectSnapshotRevision(this.cwd, this.sessionId, this.root, revision, legacySnapshot, this.sessionKey));
+	}
+
+	private restoreInspected(revision: string, inspected: ReturnType<typeof inspectSnapshotRevision>): Snapshot {
 		if (inspected.file) {
 			const savedRuntime = hashJson(createSessionRuntime(inspected.snapshot, this.cwd, this.sessionId, inspected.file.view.lineage, "files", inspected.file.provenance.session));
 			this.view = inspected.file.view;
@@ -148,6 +232,7 @@ export class TemporalRuntime {
 			this.provenanceByScope = structuredClone(inspected.file.provenance);
 			this.semanticRevision = revision;
 			this.savedRuntime = savedRuntime;
+			this.absentSharedScopes.clear();
 			return inspected.snapshot;
 		}
 		if (!inspected.temporal) {
@@ -201,20 +286,31 @@ export class TemporalRuntime {
 		this.provenanceByScope = structuredClone(loaded.provenance);
 		this.semanticRevision = semanticRevision;
 		this.savedRuntime = savedRuntime;
+		this.absentSharedScopes.clear();
 		return resolved.snapshot;
 	}
 
 	initialize(snapshot: Snapshot, allowCreateCwd: boolean, expectedShared?: Pick<ScopedStates, "global" | "cwd">, newSessionOrigin = false): RuntimePublication | undefined {
+		return this.initializeOrigin(snapshot, { allowCreateCwd, expectedShared, newSessionOrigin });
+	}
+
+	private initializeOrigin(snapshot: Snapshot, options: {
+		allowCreateCwd: boolean;
+		expectedShared?: Pick<ScopedStates, "global" | "cwd">;
+		newSessionOrigin?: boolean;
+		copy?: SessionCopy;
+	}): RuntimePublication | undefined {
+		const { allowCreateCwd, expectedShared, newSessionOrigin = false, copy } = options;
 		const hasCwd = hasCwdMaterialization(this.cwd, this.root);
 		if (!allowCreateCwd && !hasCwd) return undefined;
-		const backend = this.backend ?? (detectGitCapability() === "git" && lstatSync(join(this.root, ".git"), { throwIfNoEntry: false }) ? "git" : "files");
-		if (backend === "git") {
+		const backend = copy?.backend ?? this.backend ?? (detectGitCapability() === "git" && lstatSync(join(this.root, ".git"), { throwIfNoEntry: false }) ? "git" : "files");
+		if (!copy && backend === "git") {
 			if (!hasCwd) migrateHashedCwdAtHead(this.cwd, this.root);
 			if (hasLegacyStateSources(this.cwd, this.sessionId, this.root, this.sessionKey)) {
 				migrateLegacyStorageToGit(this.cwd, this.sessionId, this.root, this.sessionKey);
 			}
 		}
-		else {
+		else if (!copy) {
 			if (allowCreateCwd) initializeFileStore(this.root);
 			if (hasLegacyStateSources(this.cwd, this.sessionId, this.root, this.sessionKey)) {
 				migrateLegacyStorageToFiles(this.cwd, this.sessionId, this.root, this.sessionKey);
@@ -222,6 +318,15 @@ export class TemporalRuntime {
 		}
 		const base: TemporalGitBase = backend === "git" ? captureTemporalGitBase(this.cwd, this.sessionId, this.root, this.sessionKey) : captureTemporalFileBase(this.cwd, this.sessionId, this.root, this.sessionKey);
 		const files = new Map(base.files.map((file) => [file.path, file.content]));
+		if (copy) {
+			const session = temporalScopePaths(this.cwd, this.sessionId, "session", this.root, this.sessionKey);
+			const owned = [session.checkpoint, session.patches, session.meta, join(session.directory, "config.json"), join(session.directory, "state.json")];
+			const occupied = owned.some((path) => files.get(path) !== undefined);
+			const historical = !occupied && backend === "git" && base.head ? loadTemporalRevision(this.cwd, this.sessionId, this.root, base.head, this.sessionKey) : undefined;
+			if (occupied || historical?.runtime || historical?.scopes.session) {
+				throw new Error("State Flow fork target already has session storage");
+			}
+		}
 		if (SCOPES.some((scope) => {
 			const paths = temporalScopePaths(this.cwd, this.sessionId, scope, this.root, this.sessionKey);
 			return files.get(join(paths.directory, "state.json")) !== undefined;
@@ -231,11 +336,13 @@ export class TemporalRuntime {
 			return [scope, parseScopeStream(files.get(paths.checkpoint), files.get(paths.patches), scope, scope === "cwd" ? this.cwd : undefined)];
 		})) as Record<StateScope, TemporalState["scopes"][StateScope] | undefined>;
 		if (!streams.cwd && !allowCreateCwd) return undefined;
+		if (copy && !streams.global) throw new Error("State Flow fork requires existing shared scope storage");
 		const paths = sessionRuntimePaths(this.cwd, this.sessionId, this.root, this.sessionKey);
 		const existingRuntime = parseSessionRuntime(files.get(paths.config), files.get(paths.meta), this.cwd, this.sessionId);
 		if (existingRuntime && !snapshot.legacySession && !newSessionOrigin) throw new Error("Existing session runtime requires a branch revision pointer");
 		// Explicit start before any branch runtime is a new origin, never inheritance of a later session layer.
 		if (snapshot.legacySession || newSessionOrigin) streams.session = undefined;
+		if (copy) streams.session = copy.stream;
 		const fresh = createTemporalState({ global: emptyState(), cwd: emptyState(), session: snapshot.legacySession?.state ?? emptyState() }, randomUUID());
 		const candidate = new TemporalRuntime(this.cwd, this.session, this.root);
 		candidate.backend = backend;
@@ -246,18 +353,32 @@ export class TemporalRuntime {
 		candidate.provenanceByScope = {
 			global: parseScopeProvenance(files.get(globalMeta), globalMeta),
 			cwd: parseScopeProvenance(files.get(cwdMeta), cwdMeta),
-			session: streams.session === undefined ? {} : parseArtifactProvenanceRegistry(existingRuntime?.meta.artifacts, "State Flow session artifact provenance"),
+			session: copy ? structuredClone(copy.provenance) : streams.session === undefined ? {} : parseArtifactProvenanceRegistry(existingRuntime?.meta.artifacts, "State Flow session artifact provenance"),
 		};
 		if (expectedShared && (["global", "cwd"] as const).some((scope) => !sameJson(candidate.read(0, scope), expectedShared[scope]))) {
 			throw new Error("Legacy branch shared scopes diverged from the selected revision; migration cannot overwrite them");
 		}
-		const publication = candidate.publish(snapshot, true);
+		const publication = copy ? candidate.publishForkOrigin(snapshot) : candidate.publish(snapshot, true);
 		this.view = candidate.view;
 		this.base = candidate.base;
 		this.backend = backend;
 		this.provenanceByScope = structuredClone(candidate.provenanceByScope);
 		this.semanticRevision = candidate.semanticRevision;
 		this.savedRuntime = candidate.savedRuntime;
+		this.absentSharedScopes.clear();
+		return publication;
+	}
+
+	/** Initial copy owns only the new session files, without pruning or rewriting shared provenance. */
+	private publishForkOrigin(snapshot: Snapshot): RuntimePublication {
+		const runtime = createSessionRuntime(snapshot, this.cwd, this.sessionId, this.view!.lineage, this.backend === "files" ? "files" : "unconfirmed", this.provenanceByScope.session);
+		const result = this.backend === "files"
+			? publishTemporalStateToFiles(this.cwd, this.sessionId, this.view!, ["session"], this.base!, this.root, runtime, this.sessionKey, this.provenanceByScope)
+			: publishTemporalStateToGit(this.cwd, this.sessionId, this.view!, ["session"], this.base!, this.root, runtime, this.sessionKey, (snapshot.meta.remotePublication?.mode ?? "transition") === "transition", this.provenanceByScope);
+		const publication: RuntimePublication = result;
+		this.base = publication.base;
+		this.semanticRevision = publication.revision ?? publication.commit;
+		this.savedRuntime = hashJson(runtime);
 		return publication;
 	}
 
@@ -295,10 +416,23 @@ export class TemporalRuntime {
 		const provenance = structuredClone(this.provenanceByScope);
 		const adopted = new Map<StateScope, ScopeStream>();
 		const targets: StateScope[] = [];
+		const removedTargets: StateScope[] = [];
+		const absentScopes: StateScope[] = [];
+		const head = "head" in captured ? captured.head : undefined;
+		const reconciliation = `${head ?? "files"}:reconcile:${randomUUID()}`;
 		for (const scope of SHARED_SCOPES) {
 			const paths = temporalScopePaths(this.cwd, this.sessionId, scope, this.root, this.sessionKey);
-			const stream = parseScopeStream(liveFiles.get(paths.checkpoint)?.content, liveFiles.get(paths.patches)?.content, scope, scope === "cwd" ? this.cwd : undefined);
-			if (stream === undefined) throw new Error(`Live State Flow ${scope} scope storage is incomplete`);
+			const presence = classifyScopeStream(liveFiles.get(paths.checkpoint)?.content, liveFiles.get(paths.patches)?.content, scope, scope === "cwd" ? this.cwd : undefined);
+			if (presence.kind === "absent") {
+				absentScopes.push(scope);
+				provenance[scope] = {};
+				if (changedScopes.has(scope) && !this.absentSharedScopes.has(scope)) removedTargets.push(scope);
+				if (!this.absentSharedScopes.has(scope)) {
+					adopted.set(scope, freshEmptyScopeStream(scope, `${reconciliation}:${scope}:absent`));
+				}
+				continue;
+			}
+			const stream = presence.stream;
 			const liveProvenance = parseScopeProvenance(liveFiles.get(paths.meta)?.content, paths.meta);
 			const streamDrifted = !sameJson(stream, this.view!.scopes[scope]);
 			const provenanceDrifted = !sameJson(liveProvenance, this.provenanceByScope[scope]);
@@ -310,19 +444,20 @@ export class TemporalRuntime {
 			provenance[scope] = liveProvenance;
 			if (streamDrifted) adopted.set(scope, stream);
 		}
-		if (targets.length > 0) throw targetScopeConflict(targets);
-		if (adopted.size === 0) return { view: this.view!, base: captured, provenance };
-		const streams = {
+		const reconciledView = () => adopted.size === 0 ? this.view! : adoptTemporalStreams({
 			global: adopted.get("global") ?? structuredClone(this.view!.scopes.global),
 			cwd: adopted.get("cwd") ?? structuredClone(this.view!.scopes.cwd),
 			session: structuredClone(this.view!.scopes.session),
-		};
-		const head = "head" in captured ? captured.head : undefined;
-		return {
-			view: adoptTemporalStreams(streams, `${head ?? "unborn"}:reconcile:${randomUUID()}`),
-			base: captured,
-			provenance,
-		};
+		}, reconciliation);
+		if (removedTargets.length > 0) {
+			this.view = reconciledView();
+			this.base = captured;
+			this.provenanceByScope = provenance;
+			for (const scope of absentScopes) this.absentSharedScopes.add(scope);
+			throw removedTargetScopeConflict(removedTargets);
+		}
+		if (targets.length > 0) throw targetScopeConflict(targets);
+		return { view: reconciledView(), base: captured, provenance };
 	}
 
 	publish(
@@ -372,6 +507,7 @@ export class TemporalRuntime {
 			this.provenanceByScope = nextProvenance;
 			this.savedRuntime = fingerprint;
 			this.semanticRevision = result.revision;
+			if (semantic) this.absentSharedScopes.clear();
 			return { base: result.base, revision: result.revision };
 		}
 		if (!scopedWrite) {
@@ -395,6 +531,7 @@ export class TemporalRuntime {
 		this.provenanceByScope = nextProvenance;
 		this.savedRuntime = fingerprint;
 		if (scopedWrite && result.commit) this.semanticRevision = result.commit;
+		if (semantic) this.absentSharedScopes.clear();
 		return result;
 	}
 }

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

@@ -57,16 +57,11 @@ export function detailedStatus(snapshot: Snapshot, diagnostics: StatusDiagnostic
 		diagnostics.recent,
 	);
 	const available = diagnostics.temporal !== undefined && diagnostics.durableStateError === undefined;
-	const materialized = !available ? undefined : {
-		global: diagnostics.scopeStates.global,
-		cwd: diagnostics.scopeStates.cwd,
-		session: diagnostics.scopeStates.session,
-		effective: overlayStates(
-			diagnostics.scopeStates.global,
-			diagnostics.scopeStates.cwd,
-			diagnostics.scopeStates.session,
-		),
-	};
+	const materialized = !available ? undefined : overlayStates(
+		diagnostics.scopeStates.global,
+		diagnostics.scopeStates.cwd,
+		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
@@ -124,7 +119,7 @@ export function detailedStatus(snapshot: Snapshot, diagnostics: StatusDiagnostic
 		`Publication: ${publication}`,
 		...staleLines,
 		...(stateJson === undefined
-			? ["Materialized states: unavailable (global/CWD/session/effective)"]
-			: [`Materialized states (${Buffer.byteLength(stateJson, "utf8")} bytes; global/CWD/session Git-backed, effective overlay):`, "", stateJson]),
+			? ["Effective memory: unavailable"]
+			: [`Effective memory (${Buffer.byteLength(stateJson, "utf8")} JSON bytes; global → CWD → session overlay):`, "", stateJson]),
 	].join("\n");
 }

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

@@ -90,7 +90,8 @@ export function planTemporalPublication(
 		changedScopes.push(scope);
 	}
 	const provenanceUpdates: OwnedFileUpdate[] = [];
-	if (provenance !== undefined) {
+	// Shared provenance belongs to its semantic scopes, not the session config being saved.
+	if (!runtimeOnly && provenance !== undefined) {
 		for (const scope of ["global", "cwd"] as const) {
 			const paths = temporalScopePaths(cwd, sessionId, scope, root, sessionKey);
 			const registry = provenance[scope];

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

@@ -3,6 +3,7 @@ import {
 	ORDINARY_ARTIFACT_COMPILER,
 	validateArtifactMetadata,
 	validateArtifactRegistry,
+	validateModelArtifactPatch,
 	type ArtifactCompilerOutput,
 	type ArtifactProvenance,
 } from "./artifact.ts";
@@ -77,9 +78,6 @@ function compileReadSkills(
 		if (!isObject(output)) {
 			throw new Error(`Every successfully read Skill must have a CWD artifact compiler output at artifacts[exactReadPath]; missing: ${read.path}`);
 		}
-		if (Object.hasOwn(output, "hash") || Object.hasOwn(output, "compiler")) {
-			throw new Error(`Skill artifact compiler output at ${read.path} cannot set runtime-owned hash or compiler fields`);
-		}
 		if (typeof output.description !== "string" || output.description.trim().length === 0) {
 			throw new Error(`Skill artifact compiler output at ${read.path} must have a non-empty description`);
 		}
@@ -133,6 +131,7 @@ function validateScopePatch(scope: unknown, patch: unknown): asserts patch is Sc
 			throw new Error(`Scoped State Flow patch field ${key} must be a JSON object`);
 		}
 	}
+	if (isObject(patch.artifacts)) validateModelArtifactPatch(patch.artifacts);
 }
 
 function completePatch(patch: ScopePatch, response: string): StatePatch {

package/node_modules/@llblab/pi-state-flow/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-state-flow",
-  "version": "0.9.6",
+  "version": "0.10.1",
   "private": false,
   "description": "Incremental scoped state/context compiler for Pi, inspired by SKILL.state",
   "keywords": [
@@ -30,6 +30,7 @@
   "scripts": {
     "check": "node --experimental-strip-types -e \"await import('./index.ts')\"",
     "test": "node --experimental-strip-types --test tests/*.test.ts",
+    "benchmark": "node --experimental-strip-types benchmarks/benchmark.ts",
     "typecheck": "tsc --noEmit",
     "validate": "npm run typecheck && npm test && npm run check",
     "prepack": "npm run validate"
@@ -50,9 +51,9 @@
     "node": ">=22.19.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-agent-core": "^0.84.4",
-    "@earendil-works/pi-ai": "^0.84.4",
-    "@earendil-works/pi-coding-agent": "^0.84.4"
+    "@earendil-works/pi-agent-core": "^0.84.4 || ^0.85.1",
+    "@earendil-works/pi-ai": "^0.84.4 || ^0.85.1",
+    "@earendil-works/pi-coding-agent": "^0.84.4 || ^0.85.1"
   },
   "devDependencies": {
     "@types/node": "latest",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-kit",
-  "version": "0.10.8",
+  "version": "0.11.1",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -44,7 +44,7 @@
     "@llblab/pi-clean-room": "0.1.1",
     "@llblab/pi-codex-usage": "0.9.4",
     "@llblab/pi-grow-loop": "0.8.1",
-    "@llblab/pi-state-flow": "0.9.6",
+    "@llblab/pi-state-flow": "0.10.1",
     "@llblab/pi-telegram": "0.45.8",
     "@llblab/skills": "1.15.0"
   },