@av-pi-studio/server 0.0.72 → 0.0.74

package/dist/extensions/extensions-state.d.ts

@@ -0,0 +1,490 @@
+import { z } from "zod";
+import type { PersistedConfig } from "../config/daemon-config.js";
+declare const extensionsStateSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodLiteral<1>>;
+    piHomes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        offered: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        failures: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        lastSync: z.ZodOptional<z.ZodObject<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        offered: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        failures: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        lastSync: z.ZodOptional<z.ZodObject<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        offered: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        failures: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        lastSync: z.ZodOptional<z.ZodObject<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">>>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    version: z.ZodDefault<z.ZodLiteral<1>>;
+    piHomes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        offered: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        failures: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        lastSync: z.ZodOptional<z.ZodObject<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        offered: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        failures: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        lastSync: z.ZodOptional<z.ZodObject<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        offered: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        failures: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        lastSync: z.ZodOptional<z.ZodObject<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">>>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    version: z.ZodDefault<z.ZodLiteral<1>>;
+    piHomes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        offered: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        failures: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        lastSync: z.ZodOptional<z.ZodObject<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        offered: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        failures: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        lastSync: z.ZodOptional<z.ZodObject<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        offered: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+            installedSpec: z.ZodString;
+            /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+            atVersion: z.ZodString;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        failures: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            message: z.ZodString;
+            attempts: z.ZodNumber;
+            at: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>>;
+        lastSync: z.ZodOptional<z.ZodObject<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            at: z.ZodString;
+            outcome: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">>>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type ExtensionsState = z.infer<typeof extensionsStateSchema>;
+/** Per-pi-home slice — the sync planner's `state` input (task 004). */
+export type PiHomeState = ExtensionsState["piHomes"][string];
+export declare function extensionsStatePath(home: string): string;
+/**
+ * Load `extensions-state.json`. Absent file → a valid empty state (`version: 1`, no pi-homes).
+ * Malformed JSON or a schema mismatch → the literal string `"unreadable"`, **never** an empty
+ * state and **never** a rewrite of the file — callers apply the spec's fail-safe (treat every
+ * manifest identity as already offered; wrong-and-quiet beats wrong-and-mutating).
+ */
+export declare function loadExtensionsState(home: string): Promise<ExtensionsState | "unreadable">;
+export declare function saveExtensionsState(home: string, state: ExtensionsState): Promise<void>;
+/**
+ * The directory spawned agents actually receive as `PI_CODING_AGENT_DIR` — the state key
+ * everything in this feature is keyed on. Delegates entirely to {@link resolvePiAgentDir} (the one
+ * shared derivation with the spawn path in `agent/pi-home.ts`, which itself `~`-expands
+ * and absolutizes both non-default branches) and applies Pi's own default when neither an override
+ * nor `daemon.piHome` is set. No `resolve()` here: re-resolving an already-absolute path is a
+ * no-op for the two real branches, and applying it only to the default branch (as this function
+ * used to do to *both*) is exactly what let this key diverge from the spawn path for a relative or
+ * `~`-prefixed `daemon.piHome` — the two must derive from the same already-absolute value, not
+ * each apply their own normalization.
+ */
+export declare function effectivePiHomeKey(config: PersistedConfig): string;
+/**
+ * Pi's global `settings.json` at `<piHomeKey>/settings.json` — read-only, never written; every
+ * mutation goes through `pi install`. Absent file ⇒ empty `packages`. `ok: false` ⇒ malformed
+ * JSON, the caller must not act on a reality it can't read. Shared by `ExtensionsService` (the
+ * daemon path) and the CLI's `extensions list --local` (sprint-057/task-005) — one implementation,
+ * so the two can never read `settings.json` differently.
+ */
+export declare function readPiSettingsPackages(piHomeKey: string): Promise<{
+    packages: unknown[];
+    ok: boolean;
+}>;
+export {};
+//# sourceMappingURL=extensions-state.d.ts.map

package/dist/extensions/extensions-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions-state.d.ts","sourceRoot":"","sources":["../../src/extensions/extensions-state.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAkDlE,QAAA,MAAM,qBAAqB;;;;YAjCvB,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;YAF/F,yFAAyF;;YAEzF,+FAA+F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAoCnF,CAAC;AAEjB,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,uEAAuE;AACvE,MAAM,MAAM,WAAW,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,YAAY,CAAC,CAa/F;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAE7F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAElE;AAED;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAC1C,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;IAAC,EAAE,EAAE,OAAO,CAAA;CAAE,CAAC,CAS/C"}

package/dist/extensions/extensions-state.js

@@ -0,0 +1,114 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { atomicWriteJson } from "../persistence/atomic-store.js";
+import { resolvePiAgentDir } from "../agent/pi-home.js";
+/**
+ * `$PI_STUDIO_HOME/extensions-state.json` — per-pi-home sync bookkeeping
+ * (swe/features/preinstalled-extensions.md § State file), plus the shared "effective pi-home"
+ * derivation the sync planner/executor key their state on.
+ *
+ * `offered` records intent, not presence: an identity enters it only after a successful
+ * `pi install`, and once present is never installed again (tenet 1 — a user's later `pi remove`
+ * sticks forever). `failures` survives restarts so `failed` + `reason` stay reportable after a
+ * reboot; it is diagnostics, never a retry gate.
+ */
+const offeredEntrySchema = z
+    .object({
+    /** What sync last wrote, verbatim — the byte-compare ancestor for the ownership rule. */
+    installedSpec: z.string(),
+    /** Aligned workspace version at install time (diagnostics only; sync never branches on it). */
+    atVersion: z.string(),
+    at: z.string(),
+})
+    .passthrough();
+const failureEntrySchema = z
+    .object({
+    source: z.string(),
+    reason: z.string(),
+    message: z.string(),
+    attempts: z.number(),
+    at: z.string(),
+})
+    .passthrough();
+const lastSyncSummarySchema = z
+    .object({
+    at: z.string(),
+    outcome: z.string(),
+})
+    .passthrough();
+const piHomeStateSchema = z
+    .object({
+    offered: z.record(z.string(), offeredEntrySchema).default({}),
+    failures: z.record(z.string(), failureEntrySchema).default({}),
+    lastSync: lastSyncSummarySchema.optional(),
+})
+    .passthrough();
+const extensionsStateSchema = z
+    .object({
+    version: z.literal(1).default(1),
+    piHomes: z.record(z.string(), piHomeStateSchema).default({}),
+})
+    .passthrough();
+export function extensionsStatePath(home) {
+    return join(home, "extensions-state.json");
+}
+/**
+ * Load `extensions-state.json`. Absent file → a valid empty state (`version: 1`, no pi-homes).
+ * Malformed JSON or a schema mismatch → the literal string `"unreadable"`, **never** an empty
+ * state and **never** a rewrite of the file — callers apply the spec's fail-safe (treat every
+ * manifest identity as already offered; wrong-and-quiet beats wrong-and-mutating).
+ */
+export async function loadExtensionsState(home) {
+    const path = extensionsStatePath(home);
+    if (!existsSync(path))
+        return extensionsStateSchema.parse({});
+    let raw;
+    try {
+        raw = JSON.parse(await readFile(path, "utf8"));
+    }
+    catch {
+        return "unreadable";
+    }
+    const parsed = extensionsStateSchema.safeParse(raw);
+    return parsed.success ? parsed.data : "unreadable";
+}
+export async function saveExtensionsState(home, state) {
+    await atomicWriteJson(extensionsStatePath(home), state, extensionsStateSchema);
+}
+/**
+ * The directory spawned agents actually receive as `PI_CODING_AGENT_DIR` — the state key
+ * everything in this feature is keyed on. Delegates entirely to {@link resolvePiAgentDir} (the one
+ * shared derivation with the spawn path in `agent/pi-home.ts`, which itself `~`-expands
+ * and absolutizes both non-default branches) and applies Pi's own default when neither an override
+ * nor `daemon.piHome` is set. No `resolve()` here: re-resolving an already-absolute path is a
+ * no-op for the two real branches, and applying it only to the default branch (as this function
+ * used to do to *both*) is exactly what let this key diverge from the spawn path for a relative or
+ * `~`-prefixed `daemon.piHome` — the two must derive from the same already-absolute value, not
+ * each apply their own normalization.
+ */
+export function effectivePiHomeKey(config) {
+    return resolvePiAgentDir(config) ?? join(homedir(), ".pi", "agent");
+}
+/**
+ * Pi's global `settings.json` at `<piHomeKey>/settings.json` — read-only, never written; every
+ * mutation goes through `pi install`. Absent file ⇒ empty `packages`. `ok: false` ⇒ malformed
+ * JSON, the caller must not act on a reality it can't read. Shared by `ExtensionsService` (the
+ * daemon path) and the CLI's `extensions list --local` (sprint-057/task-005) — one implementation,
+ * so the two can never read `settings.json` differently.
+ */
+export async function readPiSettingsPackages(piHomeKey) {
+    const path = join(piHomeKey, "settings.json");
+    if (!existsSync(path))
+        return { packages: [], ok: true };
+    try {
+        const raw = JSON.parse(await readFile(path, "utf8"));
+        return { packages: Array.isArray(raw.packages) ? raw.packages : [], ok: true };
+    }
+    catch {
+        return { packages: [], ok: false };
+    }
+}
+//# sourceMappingURL=extensions-state.js.map

package/dist/extensions/extensions-state.js.map

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

package/dist/extensions/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./curated-packs.js";
+export * from "./sync-planner.js";
+export * from "./extensions-state.js";
+export * from "./wire.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extensions/index.ts"],"names":[],"mappings":"AAKA,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,WAAW,CAAC"}

package/dist/extensions/index.js

@@ -0,0 +1,10 @@
+// Preinstalled-extensions sync engine: the pure planning surface (manifest, planner, state
+// reader). Deliberately does NOT re-export `extensions-service.ts` (orchestration: mutex, config
+// persistence, logging) or `sync-executor.ts` (spawns `pi install`) — those are daemon-only. This
+// barrel is what the CLI's `extensions list --local` (sprint-057/task-005) consumes: read-only,
+// no process spawns, no writes.
+export * from "./curated-packs.js";
+export * from "./sync-planner.js";
+export * from "./extensions-state.js";
+export * from "./wire.js";
+//# sourceMappingURL=index.js.map

package/dist/extensions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/extensions/index.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,iGAAiG;AACjG,kGAAkG;AAClG,gGAAgG;AAChG,gCAAgC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,WAAW,CAAC"}