@magnitudedev/pi-extension 0.0.1-alpha.2 → 0.0.1-alpha.4

package/README.md

@@ -17,8 +17,9 @@ are needed. If Magnitude is missing, accepting setup installs the CLI with
 `npm install --global @magnitudedev/cli` before opening onboarding. Pi stays visible with its native
 spinner: “Installing Magnitude…”. Installer output is suppressed; failures
 show a concise diagnostic. Escape cancels preparation, and `/magnitude-setup` retries.
-An existing CLI is preserved and must support hosted setup; an incompatible version reports an
-update requirement rather than being silently replaced.
+An existing CLI is preserved. The extension invokes `magnitude setup --host pi`; `--host` is hidden from help.
+If an older CLI does not recognize that option, update it explicitly and retry; it is never silently
+replaced.
 
 No or Escape leaves “You can set up local models anytime with `/magnitude-setup`.” in the conversation.
 The offer is remembered per Pi profile across restarts, reloads, and package updates. Existing
@@ -43,7 +44,7 @@ does all connection configuration and can be run safely after a standalone packa
 
 The extension bundles Magnitude's private SDK. Model status, loading, and stopping use the existing
 RPC endpoint at port 10100. When necessary the SDK runs `magnitude service start`; it does not use
-CLI output as a model API. If `/load-model` or `/stop-model` encounters a protocol mismatch, the
+CLI output as a model API. If `/stop-model` encounters a protocol mismatch, the
 extension runs `magnitude connections sync pi` once to install the exact plugin version selected by
 the installed CLI, then reloads Pi. Retry your model command after reload; it is never replayed
 automatically. Failed sync reports the error without reloading or looping. Manually owned incompatible
@@ -56,7 +57,6 @@ latency, and token-weighted generation throughput. Pi extensions execute with yo
 Commands:
 
 - `/magnitude-setup` — open Magnitude's graphical model setup inside Pi
-- `/load-model [model-id]` — load an installed model
 - `/stop-model` — stop the active model
 
 Installed Magnitude models appear in Pi's built-in `/model` selector. To discover, compare, install,

package/dist/magnitude-plugin.json

@@ -1,11 +1,11 @@
 {
   "name": "@magnitudedev/pi-extension",
-  "version": "0.0.1-alpha.2",
+  "version": "0.0.1-alpha.4",
   "rpcVersion": 1,
-  "contentFingerprint": "5661646da7080511725cdef888b7ce04148c99b56fbe6454619754ebc5235718",
+  "contentFingerprint": "d8a654678e1244761397d9bb6f30765c9d2a9c7813fdea7b024f4076dab494ef",
   "files": {
-    "README.md": "0334364928717efd1b146486d6dc2d9ff0f28b77ff28b162d04351738170b581",
-    "dist/magnitude.js": "915f1d6bb080180a774b1bd009b3d7bc6c5cbab94fd7ab067dd3345d638538ad",
+    "README.md": "26fa7e5b56c9b171946b7efec036703e258ab51607d1e20f00c45d6e96133a29",
+    "dist/magnitude.js": "b21c625dd7e2c0f00c6992845dad09cd753b4e85cf5b258d334ba4a4c6d065c3",
     "dist/skills/magnitude/SKILL.md": "37de67f0c7b831415f6298c8785b7ae97d5cfe454dc778651d96114840d2ace2"
   }
 }

package/dist/magnitude.js

@@ -17,7 +17,7 @@ var __export = (target, all) => {
 import { openAICompletionsApi } from "@earendil-works/pi-ai/compat";
 
 // extensions/commands.ts
-import { Context as Context6, Effect as Effect10, Exit as Exit2, Fiber, Layer as Layer5, ManagedRuntime, Match as Match2, Option as Option16, Ref, Schema as Schema50, Scope as Scope3 } from "effect";
+import { Context as Context6, Effect as Effect10, Exit as Exit2, Fiber, Layer as Layer5, ManagedRuntime, Ref, Schema as Schema50, Scope as Scope3 } from "effect";
 import { FetchHttpClient } from "@effect/platform";
 import * as NodeCommandExecutor from "@effect/platform-node/NodeCommandExecutor";
 import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
@@ -1366,10 +1366,6 @@ var LowMemoryModelInstanceFailureSchema = Schema20.TaggedStruct("LowMemory", {
 });
 var ModelInstanceFailureSchema = Schema20.Union(ModelFailureSchema, LowMemoryModelInstanceFailureSchema);
 var ModelVariantLabelSchema = NonEmptyString.pipe(Schema20.brand("ModelVariantLabel"));
-var formatModelDisplayName = (displayName, variantLabel) => Option5.match(variantLabel, {
-  onNone: () => displayName,
-  onSome: (label) => `${displayName} (${label})`
-});
 var ModelLoadPlanSchema = Schema20.Struct({
   contextWindowTokens: PositiveSafeInteger2,
   parallelSequences: PositiveSafeInteger2,
@@ -1552,7 +1548,6 @@ var LocalModelAcquisitionStateSchema = Schema20.Union(Schema20.TaggedStruct("Not
   ...InstalledModelFields,
   failure: ModelFailureSchema
 }));
-var installedAcquisition = (state) => state._tag === "Installed" || state._tag === "UpdateAvailable" || state._tag === "Updating" || state._tag === "UpdateFailed" || state._tag === "Removing" || state._tag === "RemoveFailed" ? state : undefined;
 var ProviderModelDisabledReasonSchema2 = Schema20.Literal("insufficient_resources", "provider_unavailable", "model_unavailable", "installation_unavailable", "incompatible_runtime", "invalid_configuration");
 var ProviderModelCatalogEntrySchema = Schema20.Struct({
   providerId: ProviderIdSchema,
@@ -2082,7 +2077,6 @@ var ChangeSchema = Schema25.Struct({
 import { Option as Option6 } from "effect";
 // ../../packages/acn-protocol/src/schemas/local-model-projection.ts
 import { Option as Option7 } from "effect";
-var localModelIsInstalled = (model) => model._tag === "Discovered" ? true : installedAcquisition(model.acquisitionState) !== undefined;
 // ../../packages/acn-protocol/src/schemas/inference-projection.ts
 import { Data, Effect, Match, Option as Option8 } from "effect";
 class InferenceHardwareProjectionError extends Data.TaggedError("InferenceHardwareProjectionError") {
@@ -5714,52 +5708,10 @@ var commandFailure = (error) => Schema50.is(ProtocolMismatch)(error) ? error : n
 var ModelCommands = Context6.GenericTag("pi/ModelCommands");
 var commandsLayer = Layer5.effect(ModelCommands, Effect10.gen(function* () {
   const client = yield* MagnitudeClient;
-  const [cached, invalidate] = yield* Effect10.cachedInvalidateWithTTL(client.models.getCatalog({}).pipe(Effect10.mapError(commandFailure)), "30 seconds");
   return {
-    status: (fresh) => Effect10.gen(function* () {
-      if (fresh)
-        yield* invalidate;
-      const result = yield* cached.pipe(Effect10.tapError(() => invalidate));
-      if (result._tag === "Initializing")
-        yield* invalidate;
-      return result;
-    }),
-    load: (input) => Schema50.decodeUnknown(ModelIdSchema)(input).pipe(Effect10.flatMap((modelId) => client.models.load({ modelId }).pipe(Effect10.as(modelId))), Effect10.tap(() => invalidate), Effect10.mapError(commandFailure)),
-    stop: client.models.stop({}).pipe(Effect10.tap(() => invalidate), Effect10.asVoid, Effect10.mapError(commandFailure))
+    stop: client.models.stop({}).pipe(Effect10.asVoid, Effect10.mapError(commandFailure))
   };
 }));
-var displayName = (model2) => formatModelDisplayName(model2.presentation.displayName, Option16.some(model2.presentation.variantLabel));
-var residencyLabel = (state) => Match2.value(state).pipe(Match2.tagsExhaustive({
-  Unloaded: () => "unloaded",
-  Requested: () => "loading",
-  Loading: () => "loading",
-  Ready: () => "ready",
-  Stopping: () => "stopping",
-  Failed: () => "failed"
-}));
-var stateLabel = (model2) => Match2.value(model2).pipe(Match2.tagsExhaustive({
-  Discovered: ({ state }) => Match2.value(state).pipe(Match2.tagsExhaustive({
-    Ready: ({ residencyState }) => residencyLabel(residencyState),
-    Unavailable: () => "unavailable"
-  })),
-  Catalog: ({ acquisitionState }) => Match2.value(acquisitionState).pipe(Match2.tagsExhaustive({
-    NotInstalled: () => "not installed",
-    Installing: () => "installing",
-    InstallFailed: () => "installation failed",
-    Installed: ({ residencyState }) => residencyLabel(residencyState),
-    UpdateAvailable: ({ residencyState }) => residencyLabel(residencyState),
-    Updating: ({ residencyState }) => residencyLabel(residencyState),
-    UpdateFailed: ({ residencyState }) => residencyLabel(residencyState),
-    Removing: () => "removing",
-    RemoveFailed: () => "removal failed"
-  }))
-}));
-var loadable = (catalog) => catalog._tag === "Initializing" ? [] : catalog.models.flatMap((entry) => {
-  if (entry._tag !== "Local")
-    return [];
-  const model2 = entry.product;
-  return localModelIsInstalled(model2) && (model2._tag === "Discovered" ? model2.state._tag === "Ready" : model2.acquisitionState._tag !== "Removing" && model2.acquisitionState._tag !== "RemoveFailed") ? [model2] : [];
-}).sort((a, b) => displayName(a).localeCompare(displayName(b)) || a.modelId.localeCompare(b.modelId));
 var magnitudeExecutable = () => process.env.MAGNITUDE_CLI?.trim() || "magnitude";
 var clientLayer2 = () => MagnitudeClient.layer().pipe(Layer5.provide([
   FetchHttpClient.layer,
@@ -5794,39 +5746,6 @@ var registerMagnitudeCommands = (pi, sdk = clientLayer2()) => {
     if (reload)
       await ctx.reload();
   };
-  pi.registerCommand("load-model", {
-    description: "Load a Magnitude model",
-    getArgumentCompletions: (prefix) => run(Effect10.gen(function* () {
-      const commands = yield* ModelCommands;
-      const status = yield* commands.status(false);
-      return loadable(status).filter((model2) => model2.modelId.toLowerCase().includes(prefix.trim().toLowerCase())).map((model2) => ({ value: model2.modelId, label: displayName(model2), description: stateLabel(model2) }));
-    }).pipe(Effect10.catchAll(() => Effect10.succeed(null)))),
-    handler: (args, ctx) => invoke(ctx, Effect10.gen(function* () {
-      const commands = yield* ModelCommands;
-      let modelId = args.trim();
-      if (!modelId) {
-        const status = yield* commands.status(true);
-        if (status._tag === "Initializing") {
-          yield* Effect10.sync(() => ctx.ui.notify("Magnitude is discovering local models. Try again shortly.", "info"));
-          return;
-        }
-        const eligible = loadable(status);
-        if (!eligible.length) {
-          yield* Effect10.sync(() => ctx.ui.notify("No installed Magnitude models are available.", "info"));
-          return;
-        }
-        const labels = eligible.map((model2) => `${displayName(model2)} · ${stateLabel(model2)} · ${model2.modelId}`);
-        const selected = yield* Effect10.promise(() => ctx.ui.select("Load Magnitude model", labels));
-        if (selected === undefined)
-          return;
-        modelId = eligible[labels.indexOf(selected)]?.modelId ?? "";
-      }
-      if (!modelId)
-        return;
-      const loaded = yield* commands.load(modelId);
-      yield* Effect10.sync(() => ctx.ui.notify(`Loaded ${loaded}.`, "info"));
-    }))
-  });
   pi.registerCommand("stop-model", {
     description: "Stop the active Magnitude model",
     handler: (_args, ctx) => invoke(ctx, Effect10.gen(function* () {
@@ -5853,14 +5772,15 @@ import * as Command2 from "@effect/platform/Command";
 import * as CommandExecutor3 from "@effect/platform/CommandExecutor";
 import * as FileSystem from "@effect/platform/FileSystem";
 import * as NodeContext from "@effect/platform-node/NodeContext";
+import { FetchHttpClient as FetchHttpClient2 } from "@effect/platform";
 import { delimiter, join } from "node:path";
 import { stripVTControlCharacters } from "node:util";
-import { Context as Context7, Effect as Effect12, Exit as Exit3, Fiber as Fiber2, Layer as Layer6, ManagedRuntime as ManagedRuntime2, Schema as Schema53, Scope as Scope4, Stream as Stream7 } from "effect";
+import { Context as Context7, Effect as Effect12, Exit as Exit3, Fiber as Fiber2, Layer as Layer6, ManagedRuntime as ManagedRuntime2, Schema as Schema52, Scope as Scope4, Stream as Stream7 } from "effect";
 import { CancellableLoader } from "@earendil-works/pi-tui";
 
 // ../../packages/utils/src/process/interactive-process.ts
 import { spawn } from "node:child_process";
-import { Deferred as Deferred3, Duration as Duration2, Effect as Effect11, Option as Option17, Schema as Schema51 } from "effect";
+import { Deferred as Deferred3, Duration as Duration2, Effect as Effect11, Option as Option16, Schema as Schema51 } from "effect";
 
 class InteractiveProcessFailed extends Schema51.TaggedError()("InteractiveProcessFailed", {
   operation: Schema51.Literal("spawn", "run"),
@@ -5952,7 +5872,7 @@ var terminateAndReap = ({ child, termination }) => Effect11.gen(function* () {
     } catch {}
   });
   const graceful = yield* Deferred3.await(termination).pipe(Effect11.ignore, Effect11.timeoutOption(Duration2.seconds(2)));
-  if (Option17.isSome(graceful))
+  if (Option16.isSome(graceful))
     return;
   yield* Effect11.sync(() => {
     try {
@@ -5962,22 +5882,9 @@ var terminateAndReap = ({ child, termination }) => Effect11.gen(function* () {
   yield* Deferred3.await(termination).pipe(Effect11.ignore, Effect11.timeout(Duration2.seconds(2)), Effect11.ignore);
 });
 var runInteractiveProcess = (input) => Effect11.acquireUseRelease(acquireInteractiveProcess(input), awaitWithSignalForwarding, terminateAndReap);
-// ../../packages/client-common/src/harness-connections/hosted-setup.ts
-import { Schema as Schema52 } from "effect";
-var HOSTED_SETUP_PROTOCOL_VERSION = 1;
-var HOSTED_SETUP_MAX_RESULT_BYTES = 16 * 1024;
-var HostedSetupCapability = Schema52.Struct({
-  protocolVersion: Schema52.Literal(HOSTED_SETUP_PROTOCOL_VERSION)
-});
-var version = Schema52.Literal(HOSTED_SETUP_PROTOCOL_VERSION);
-var HostedSetupResult = Schema52.Union(Schema52.TaggedStruct("Completed", { protocolVersion: version, modelId: ModelIdSchema }), Schema52.TaggedStruct("Cancelled", { protocolVersion: version }), Schema52.TaggedStruct("Failed", {
-  protocolVersion: version,
-  message: Schema52.String.pipe(Schema52.filter((message) => new TextEncoder().encode(message).length <= 4096))
-}));
-
 // extensions/setup.ts
-class PiSetupFailed extends Schema53.TaggedError()("PiSetupFailed", {
-  message: Schema53.String
+class PiSetupFailed extends Schema52.TaggedError()("PiSetupFailed", {
+  message: Schema52.String
 }) {
 }
 var failure = (message) => new PiSetupFailed({ message });
@@ -5986,17 +5893,16 @@ var prepareMagnitudeCli = (cwd, setMessage = () => Effect12.void) => Effect12.ge
   const override = process.env.MAGNITUDE_CLI?.trim();
   const executable = override || "magnitude";
   const probe = Effect12.scoped(Effect12.gen(function* () {
-    const child = yield* Command2.make(executable, "setup", "--host-protocol").pipe(Command2.start);
-    const [code, output, stderr] = yield* Effect12.all([
+    const child = yield* Command2.make(executable, "--version").pipe(Command2.start);
+    const [code, , stderr] = yield* Effect12.all([
       child.exitCode,
-      child.stdout.pipe(Stream7.decodeText(), Stream7.runFold("", (text2, part) => (text2 + part).slice(0, 4097))),
+      Stream7.runDrain(child.stdout),
       child.stderr.pipe(Stream7.decodeText(), Stream7.runFold("", (text2, part) => (text2 + part).slice(-4096)))
     ], { concurrency: "unbounded" });
-    if (code !== 0 || output.length > 4096)
-      return yield* failure(`Magnitude's setup capability check failed at ${executable} (exit ${code}). ${stripVTControlCharacters(stderr).trim().slice(-600)}${override ? " Check MAGNITUDE_CLI." : ""}`);
-    return output;
+    if (code !== 0)
+      return yield* failure(`Magnitude could not run at ${executable} (exit ${code}). ${stripVTControlCharacters(stderr).trim().slice(-600)}${override ? " Check MAGNITUDE_CLI." : ""}`);
   }));
-  const capability = yield* probe.pipe(Effect12.catchIf((error) => !override && error._tag === "SystemError" && error.reason === "NotFound", (error) => Effect12.gen(function* () {
+  yield* probe.pipe(Effect12.catchIf((error) => !override && error._tag === "SystemError" && error.reason === "NotFound", (error) => Effect12.gen(function* () {
     for (const directory of (process.env.PATH ?? "").split(delimiter)) {
       if (yield* fs.exists(join(directory || cwd, executable)))
         return yield* error;
@@ -6014,7 +5920,6 @@ var prepareMagnitudeCli = (cwd, setMessage = () => Effect12.void) => Effect12.ge
     }));
     return yield* probe;
   })), Effect12.timeout("10 minutes"), Effect12.mapError((error) => error instanceof PiSetupFailed ? error : failure(`Could not prepare Magnitude: ${String(error)}. Run /magnitude-setup to retry${override ? ", or check MAGNITUDE_CLI" : ""}.`)));
-  yield* Schema53.decodeUnknown(Schema53.parseJson(HostedSetupCapability))(capability).pipe(Effect12.mapError(() => failure(`The Magnitude CLI at ${executable} does not support hosted setup. Update @magnitudedev/cli${override ? ", or check MAGNITUDE_CLI" : ""}.`)));
   return executable;
 });
 var withPiPreparation = (ctx, work) => Effect12.acquireUseRelease(Effect12.async((resume, signal) => {
@@ -6060,39 +5965,38 @@ var withPiTerminal = (ctx, work) => Effect12.acquireUseRelease(Effect12.async((r
     finish();
   }
 }).pipe(Effect12.zipRight(Effect12.promise(closed))));
-var validateSetupTermination = (result, termination) => {
-  if (termination._tag !== "Exited" || termination.code === 0 !== (result._tag !== "Failed")) {
-    return Effect12.fail(failure("Magnitude setup exited without a consistent completion result. Run /magnitude-setup to retry."));
+var validateSetupTermination = (termination) => {
+  if (termination._tag === "Signaled") {
+    return termination.signal === "SIGINT" ? Effect12.succeed(false) : Effect12.fail(failure(`Magnitude setup stopped unexpectedly (${termination.signal}). Run /magnitude-setup to retry.`));
   }
-  return result._tag === "Failed" ? Effect12.fail(failure(result.message)) : Effect12.succeed(result);
+  if (termination.code === 130)
+    return Effect12.succeed(false);
+  return termination.code === 0 ? Effect12.succeed(true) : Effect12.fail(failure(`Magnitude setup failed (exit ${termination.code}). Check the terminal error above; if setup --host pi is unsupported, update @magnitudedev/cli. Run /magnitude-setup to retry.`));
 };
+var readSetupModel = Effect12.gen(function* () {
+  const client = yield* MagnitudeClient;
+  const { slots } = yield* client.models.getSlots({}).pipe(Effect12.mapError((error) => failure(`Magnitude setup completed, but the selected model could not be read: ${error._tag === "RpcClientError" ? error.message : formatConnectionError(error)}. Run /reload and select it with /model.`)));
+  if (slots.primary._tag !== "ConfiguredLocal")
+    return yield* failure("Magnitude setup completed, but no local primary model is configured. Run /reload and select a Magnitude model with /model.");
+  return slots.primary.selection.providerModelId;
+});
 var PiSetup = Context7.GenericTag("pi/PiSetup");
 var PiSetupLive = Layer6.effect(PiSetup, Effect12.gen(function* () {
   const fs = yield* FileSystem.FileSystem;
   const executor = yield* CommandExecutor3.CommandExecutor;
   return {
     run: (ctx) => Effect12.scoped(Effect12.gen(function* () {
-      const directory = yield* fs.makeTempDirectoryScoped({ prefix: "magnitude-pi-setup-" });
-      const resultPath = `${directory}/result.json`;
       const executable = yield* withPiPreparation(ctx, (setMessage) => prepareMagnitudeCli(ctx.cwd, setMessage));
       const termination = yield* withPiTerminal(ctx, runInteractiveProcess({
         executable,
-        args: ["setup", "--host", "pi", "--result-file", resultPath],
+        args: ["setup", "--host", "pi"],
         environment: process.env,
         workingDirectory: ctx.cwd
       }));
-      if (termination._tag === "Signaled" && termination.signal === "SIGINT") {
-        return { protocolVersion: HOSTED_SETUP_PROTOCOL_VERSION, _tag: "Cancelled" };
-      }
-      if (termination._tag === "Signaled") {
-        return yield* failure(`Magnitude setup stopped unexpectedly (${termination.signal}). Run /magnitude-setup to retry.`);
-      }
-      const stat = yield* fs.stat(resultPath).pipe(Effect12.mapError(() => failure("Magnitude setup exited without a completion result. Run /magnitude-setup to retry.")));
-      if (stat.type !== "File" || stat.size > BigInt(HOSTED_SETUP_MAX_RESULT_BYTES)) {
-        return yield* failure("Magnitude setup returned an invalid or oversized result");
-      }
-      const result = yield* fs.readFileString(resultPath).pipe(Effect12.flatMap(Schema53.decodeUnknown(Schema53.parseJson(HostedSetupResult))), Effect12.mapError(() => failure("Magnitude setup did not return a valid completion result. Run /magnitude-setup to retry.")));
-      return yield* validateSetupTermination(result, termination);
+      if (!(yield* validateSetupTermination(termination)))
+        return { _tag: "Cancelled" };
+      const modelId = yield* readSetupModel.pipe(Effect12.provide(MagnitudeClient.layer({ autoStart: false }).pipe(Layer6.provide(FetchHttpClient2.layer))));
+      return { _tag: "Completed", modelId };
     })).pipe(Effect12.provideService(CommandExecutor3.CommandExecutor, executor), Effect12.provideService(FileSystem.FileSystem, fs), Effect12.mapError((error) => error instanceof PiSetupFailed ? error : failure(`Magnitude setup could not finish: ${String(error)}`)))
   };
 }));
@@ -6198,15 +6102,15 @@ function registerMagnitudeOnboarding(pi) {
 }
 
 // extensions/observing-fetch.ts
-import { Effect as Effect14, Either as Either3, Schema as Schema55 } from "effect";
+import { Effect as Effect14, Either as Either3, Schema as Schema54 } from "effect";
 
 // extensions/protocol.ts
-import { Either as Either2, Schema as Schema54 } from "effect";
-var ProgressChunkSchema = Schema54.Struct({ progress: MagnitudeProgressSchema });
-var TimingsChunkSchema = Schema54.Struct({ timings: MagnitudeTimingsSchema });
+import { Either as Either2, Schema as Schema53 } from "effect";
+var ProgressChunkSchema = Schema53.Struct({ progress: MagnitudeProgressSchema });
+var TimingsChunkSchema = Schema53.Struct({ timings: MagnitudeTimingsSchema });
 var decodeMagnitudeObservation = (value) => {
-  const progress = Schema54.decodeUnknownEither(ProgressChunkSchema)(value);
-  const timings = Schema54.decodeUnknownEither(TimingsChunkSchema)(value);
+  const progress = Schema53.decodeUnknownEither(ProgressChunkSchema)(value);
+  const timings = Schema53.decodeUnknownEither(TimingsChunkSchema)(value);
   if (Either2.isLeft(progress) && Either2.isLeft(timings))
     return;
   return {
@@ -6217,7 +6121,7 @@ var decodeMagnitudeObservation = (value) => {
 
 // extensions/observing-fetch.ts
 var MAGNITUDE_PROGRESS_HEADER = "Magnitude-Include-Progress";
-var JsonDocumentSchema = Schema55.parseJson(Schema55.Unknown);
+var JsonDocumentSchema = Schema54.parseJson(Schema54.Unknown);
 
 class SseDataParser {
   #buffer = "";
@@ -6264,7 +6168,7 @@ class SseDataParser {
     this.#dataLines = [];
     if (data === "[DONE]")
       return;
-    const decoded = Schema55.decodeUnknownEither(JsonDocumentSchema)(data);
+    const decoded = Schema54.decodeUnknownEither(JsonDocumentSchema)(data);
     if (Either3.isRight(decoded))
       observe(decoded.right);
   }
@@ -6335,9 +6239,9 @@ var makeObservingFetch = (fetchImplementation, begin, scope) => {
 
 // extensions/progress.ts
 import { Text } from "@earendil-works/pi-tui";
-import { Data as Data3, Effect as Effect15, Fiber as Fiber3, Option as Option18, Queue, Schema as Schema56 } from "effect";
+import { Data as Data3, Effect as Effect15, Fiber as Fiber3, Option as Option17, Queue, Schema as Schema55 } from "effect";
 var MAGNITUDE_SUMMARY_WIDGET_KEY = "magnitude-inference-summary";
-var RequestId = Schema56.Number.pipe(Schema56.int(), Schema56.brand("ProgressRequestId"));
+var RequestId = Schema55.Number.pipe(Schema55.int(), Schema55.brand("ProgressRequestId"));
 
 class Observing extends Data3.TaggedClass("Observing") {
 }
@@ -6409,14 +6313,14 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect15.gen(fu
   const finalize = Effect15.gen(function* () {
     if (state._tag !== "Settled")
       return;
-    if ([...state.run.responses.values()].some(Option18.isNone))
+    if ([...state.run.responses.values()].some(Option17.isNone))
       return;
     if ([...state.run.requests.values()].some((r) => r._tag === "Observing"))
       return;
     const settled = state;
     state = runMachine.transition(settled, "Idle", {});
     const timings = [...settled.run.completed.entries()].filter(([id]) => settled.run.accepted.has(id)).sort(([a], [b]) => a - b).map(([, value]) => value);
-    if ([...settled.run.responses.values()].some((outcome) => !Option18.getOrElse(outcome, () => false)) || timings.length === 0) {
+    if ([...settled.run.responses.values()].some((outcome) => !Option17.getOrElse(outcome, () => false)) || timings.length === 0) {
       yield* clearSummary;
       return;
     }
@@ -6471,12 +6375,12 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect15.gen(fu
       const run = state._tag === "Working" ? state.run : undefined;
       const responseId = ++nextResponseId;
       const requests = [];
-      run?.responses.set(responseId, Option18.none());
+      run?.responses.set(responseId, Option17.none());
       const belongs = () => run !== undefined && (state._tag === "Working" || state._tag === "Settled") && state.run === run;
       const end = (successful) => Effect15.gen(function* () {
-        if (!belongs() || Option18.isSome(run.responses.get(responseId)))
+        if (!belongs() || Option17.isSome(run.responses.get(responseId)))
           return;
-        run.responses.set(responseId, Option18.some(successful));
+        run.responses.set(responseId, Option17.some(successful));
         const last = requests.at(-1);
         if (successful && last !== undefined)
           run.accepted.add(last);
@@ -6496,13 +6400,13 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect15.gen(fu
         yield* finalize;
       });
       const begin = Effect15.gen(function* () {
-        if (!belongs() || Option18.isSome(run.responses.get(responseId)))
+        if (!belongs() || Option17.isSome(run.responses.get(responseId)))
           return { observe: () => Effect15.void, finish: Effect15.void, fail: Effect15.void };
         const id = RequestId.make(++nextId);
         requests.push(id);
         latest = id;
         active = undefined;
-        run?.requests.set(id, new Observing({ timings: Option18.none() }));
+        run?.requests.set(id, new Observing({ timings: Option17.none() }));
         yield* resetRow;
         const close = (failed) => Effect15.gen(function* () {
           if (!belongs())
@@ -6514,7 +6418,7 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect15.gen(fu
             run.requests.set(id, requestMachine.transition(request, "Closed", {}));
           else {
             run.requests.set(id, requestMachine.transition(request, "Observed", {}));
-            if (Option18.isSome(request.timings))
+            if (Option17.isSome(request.timings))
               run.completed.set(id, request.timings.value);
           }
           if (latest === id) {
@@ -6531,7 +6435,7 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect15.gen(fu
             if (request._tag !== "Observing")
               return;
             if (observation.timings)
-              run.requests.set(id, requestMachine.hold(request, { timings: Option18.some(observation.timings) }));
+              run.requests.set(id, requestMachine.hold(request, { timings: Option17.some(observation.timings) }));
             if (latest !== id || !observation.progress)
               return;
             const progress = observation.progress;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magnitudedev/pi-extension",
-  "version": "0.0.1-alpha.2",
+  "version": "0.0.1-alpha.4",
   "description": "Magnitude model controls and inference progress for Pi",
   "type": "module",
   "license": "MIT",