@magnitudedev/pi-extension 0.0.1-alpha.0 → 0.0.1-alpha.1

package/README.md

@@ -3,15 +3,36 @@
 This Pi package adds Magnitude model management commands and live local-inference progress to Pi's
 built-in working row above the editor.
 
-Requires Pi 0.83.0 or newer and a matching Magnitude CLI. Install a local model, then run:
+Requires Pi 0.83.0 or newer. Install from your terminal:
+
+```sh
+pi install npm:@magnitudedev/pi-extension
+```
+
+On the next fresh interactive Pi launch, Magnitude asks **“Set up local models with Magnitude now?”**
+Yes sends this prompt to your current Pi agent and starts onboarding:
+
+> Set up local models for me with the Magnitude CLI. Install it with `npm i -g @magnitudedev/cli` (or my package manager), then run `magnitude docs onboarding` and follow the instructions.
+
+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
+Magnitude model configurations, non-interactive modes, conversations, and startup prompts are left
+alone. Run `/magnitude-setup` whenever you want to start onboarding yourself.
+
+The package includes the Magnitude usage skill; an already-loaded skill of that name takes
+precedence without a collision warning. `--no-skills` disables this fallback too. The CLI is not
+an npm dependency and is not required to load the extension. Your Pi agent needs a working model
+and credentials to carry out onboarding.
+
+If you already have Magnitude and a local model, connect directly:
 
 ```sh
 magnitude connections add pi
 ```
 
 Restart Pi or run `/reload` after connecting. `PI_CODING_AGENT_DIR`, if set, is honored.
-Installing the package directly with `pi install` does not configure provider models,
-install the Magnitude CLI, start its service, or install its agent skill; the connection command
+Installing the package directly does not configure provider models,
+install the Magnitude CLI, or start its service; the connection command
 does all connection configuration and can be run safely after a standalone package install.
 
 The extension bundles Magnitude's private SDK. Model status, loading, and stopping use the existing
@@ -28,6 +49,7 @@ latency, and token-weighted generation throughput. Pi extensions execute with yo
 
 Commands:
 
+- `/magnitude-setup` — ask your current agent to set up Magnitude local models
 - `/load-model [model-id]` — load an installed model
 - `/stop-model` — stop the active model
 

package/dist/magnitude-plugin.json

@@ -1,10 +1,11 @@
 {
   "name": "@magnitudedev/pi-extension",
-  "version": "0.0.1-alpha.0",
+  "version": "0.0.1-alpha.1",
   "rpcVersion": 1,
-  "contentFingerprint": "0cae890db353d9f063a1298bd0f770259d18a27692c4c392fd7561c031e5792c",
+  "contentFingerprint": "292fa6fd784d957591e91f9a67c2460b7cf503149b66cdfe22ecd68ab33ca87d",
   "files": {
-    "README.md": "345dccd4bee3706cb2647d10185acd0a79de61baf002f9cfce587b35376d5b19",
-    "dist/magnitude.js": "0d59abfd9a959d5ea4a066a39bcb1cc072c957c778edcd7bd702cc5878a8403f"
+    "README.md": "098773e588d568025e90b7aaa716879ddb7e8e2e87492fe86042fce856f66520",
+    "dist/magnitude.js": "968f6bf0f605a4500cab5e4852edb5f8c67d1d4dd16d0574e13f1ac922d93522",
+    "dist/skills/magnitude/SKILL.md": "37de67f0c7b831415f6298c8785b7ae97d5cfe454dc778651d96114840d2ace2"
   }
 }

package/dist/magnitude.js

@@ -3364,13 +3364,14 @@ var makeClient = (options) => Effect6.gen(function* () {
       yield* Deferred2.fail(active, new ConnectionClosed({}));
   })).pipe(Effect6.zipRight(Scope2.close(scope, Exit.void))));
   const unavailable = (message) => new ServiceUnavailable({ origin, message });
+  const decodeHealth = Schema47.decodeUnknown(Schema47.Union(MagnitudeHealthResponseSchema, AcnHealthResponseSchema));
   const probe = http.get(`${origin}/health`).pipe(Effect6.timeoutFail({
     duration: "2 seconds",
     onTimeout: () => unavailable("Magnitude service health timed out")
   }), Effect6.mapError((error) => error instanceof ServiceUnavailable ? error : unavailable("Magnitude service is unavailable")), Effect6.flatMap((response) => response.status !== 200 && response.status !== 503 ? Effect6.fail(new InvalidServiceResponse({
     origin,
     message: `Health returned HTTP ${response.status}`
-  })) : response.json.pipe(Effect6.flatMap(Schema47.decodeUnknown(MagnitudeHealthResponseSchema)), Effect6.mapError(() => new InvalidServiceResponse({
+  })) : response.json.pipe(Effect6.flatMap(decodeHealth), Effect6.map((health) => ("rpcVersion" in health) ? health : { ...health, rpcVersion: 0 }), Effect6.mapError(() => new InvalidServiceResponse({
     origin,
     message: "Invalid Magnitude health response"
   })))));
@@ -3391,36 +3392,35 @@ var makeClient = (options) => Effect6.gen(function* () {
     version: health.version,
     rpcVersion: health.rpcVersion
   });
+  const startService = (start2) => Effect6.scoped(Effect6.gen(function* () {
+    yield* report({ _tag: "Starting", phase: "PreparingAcn" });
+    yield* probe.pipe(Effect6.flatMap((health) => Option13.match(serviceProgressFromHealth(health.state), {
+      onNone: () => Effect6.void,
+      onSome: report
+    })), Effect6.ignore, Effect6.zipRight(Effect6.sleep("250 millis")), Effect6.forever, Effect6.forkScoped);
+    yield* start2.pipe(Stream4.runForEach(report));
+  }));
   const acquire = Effect6.gen(function* () {
     let started = false;
     while (true) {
-      const observed = yield* Effect6.either(probe);
-      if (observed._tag === "Left") {
-        if (observed.left._tag !== "ServiceUnavailable")
-          return yield* observed.left;
-        if (!started && Option13.isSome(starter)) {
-          started = true;
-          yield* report({ _tag: "Starting", phase: "PreparingAcn" });
-          yield* Effect6.scoped(Effect6.gen(function* () {
-            yield* probe.pipe(Effect6.flatMap((health) => Option13.match(serviceProgressFromHealth(health.state), {
-              onNone: () => Effect6.void,
-              onSome: report
-            })), Effect6.ignore, Effect6.zipRight(Effect6.sleep("250 millis")), Effect6.forever, Effect6.forkScoped);
-            yield* starter.value.start.pipe(Stream4.runForEach(report));
-          }));
-          continue;
-        }
-        if (!started)
-          return yield* observed.left;
-      } else {
-        const health = observed.right;
-        const service = yield* validate(health);
+      const observed = yield* Effect6.either(probe.pipe(Effect6.flatMap((health) => validate(health).pipe(Effect6.map((service) => ({ health, service }))))));
+      if (observed._tag === "Right") {
+        const { health, service } = observed.right;
         if (health.state._tag === "Ready")
           return service;
         yield* Option13.match(serviceProgressFromHealth(health.state), {
           onNone: () => Effect6.void,
           onSome: report
         });
+      } else if (started) {
+        if (observed.left._tag !== "ServiceUnavailable")
+          return yield* observed.left;
+      } else if (Option13.isSome(starter)) {
+        started = true;
+        yield* startService(starter.value.start);
+        continue;
+      } else {
+        return yield* observed.left;
       }
       yield* Effect6.sleep("250 millis");
     }
@@ -5841,8 +5841,73 @@ var registerMagnitudeCommands = (pi, sdk = clientLayer2()) => {
   };
 };
 
+// extensions/onboarding.ts
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as NodeFileSystem2 from "@effect/platform-node/NodeFileSystem";
+import { getAgentDir, parseArgs } from "@earendil-works/pi-coding-agent";
+import { Effect as Effect11, Exit as Exit3, Scope as Scope4 } from "effect";
+import { fileURLToPath } from "node:url";
+var SETUP_PROMPT = "Set up local models for me with the Magnitude CLI. Install it with `npm i -g @magnitudedev/cli` (or my package manager), then run `magnitude docs onboarding` and follow the instructions.";
+var SETUP_QUESTION = "Set up local models with Magnitude now?";
+var SETUP_REMINDER = "You can set up local models anytime with `/magnitude-setup`.";
+var claimSetupOffer = (agentDir) => Effect11.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const directory = `${agentDir}/magnitude`;
+  yield* fs.makeDirectory(directory, { recursive: true });
+  return yield* fs.writeFileString(`${directory}/setup-offered`, "", { flag: "wx" }).pipe(Effect11.as(true), Effect11.catchTag("SystemError", (error) => error.reason === "AlreadyExists" ? Effect11.succeed(false) : Effect11.fail(error)));
+});
+function canOfferSetup(ctx, argv) {
+  if (ctx.mode !== "tui" || !ctx.isIdle() || ctx.hasPendingMessages() || ctx.ui.getEditorText().trim())
+    return false;
+  if (ctx.sessionManager.getEntries().some((entry) => entry.type === "message"))
+    return false;
+  if (ctx.modelRegistry.getAll().some((model2) => model2.provider === "magnitude"))
+    return false;
+  const args = parseArgs([...argv]);
+  return args.messages.length === 0 && args.fileArgs.length === 0;
+}
+var offerSetup = (pi, ctx, agentDir, signal) => Effect11.gen(function* () {
+  if (!(yield* claimSetupOffer(agentDir)) || signal.aborted)
+    return;
+  const accepted = yield* Effect11.tryPromise(() => ctx.ui.confirm(SETUP_QUESTION, "", { signal }));
+  if (signal.aborted)
+    return;
+  if (accepted && ctx.isIdle() && !ctx.hasPendingMessages())
+    pi.sendUserMessage(SETUP_PROMPT);
+  else
+    pi.sendMessage({ customType: "magnitude-setup", content: SETUP_REMINDER, display: true });
+});
+function registerMagnitudeOnboarding(pi) {
+  const abort = new AbortController;
+  const scope = Effect11.runSync(Scope4.make());
+  pi.registerCommand("magnitude-setup", {
+    description: "Set up local models with Magnitude",
+    handler: async (_args, ctx) => {
+      if (!ctx.isIdle() || ctx.hasPendingMessages()) {
+        ctx.ui.notify("Wait for the current task to finish, then run /magnitude-setup.", "warning");
+        return;
+      }
+      pi.sendUserMessage(SETUP_PROMPT);
+    }
+  });
+  pi.on("resources_discover", () => {
+    if (parseArgs(process.argv.slice(2)).noSkills || pi.getCommands().some((command) => command.source === "skill" && command.name === "skill:magnitude"))
+      return;
+    return { skillPaths: [fileURLToPath(new URL("./skills/magnitude/SKILL.md", import.meta.url))] };
+  });
+  pi.on("session_start", (event, ctx) => {
+    if (event.reason !== "startup" || !canOfferSetup(ctx, process.argv.slice(2)))
+      return;
+    Effect11.runFork(Effect11.forkIn(offerSetup(pi, ctx, getAgentDir(), abort.signal).pipe(Effect11.provide(NodeFileSystem2.layer), Effect11.catchAll(() => Effect11.sync(() => ctx.ui.notify(`Magnitude setup could not open. ${SETUP_REMINDER}`, "warning")))), scope));
+  });
+  return () => {
+    abort.abort();
+    return Effect11.runPromise(Scope4.close(scope, Exit3.void));
+  };
+}
+
 // extensions/observing-fetch.ts
-import { Effect as Effect11, Either as Either3, Schema as Schema52 } from "effect";
+import { Effect as Effect12, Either as Either3, Schema as Schema52 } from "effect";
 
 // extensions/protocol.ts
 import { Either as Either2, Schema as Schema51 } from "effect";
@@ -5913,21 +5978,21 @@ class SseDataParser {
       observe(decoded.right);
   }
 }
-var observeResponse = (response, request, signal) => Effect11.scoped(Effect11.gen(function* () {
+var observeResponse = (response, request, signal) => Effect12.scoped(Effect12.gen(function* () {
   if (!response.ok || response.body === null) {
     yield* request.fail;
     return;
   }
-  const reader = yield* Effect11.acquireRelease(Effect11.sync(() => response.body.getReader()), (reader2) => Effect11.promise(() => reader2.cancel()).pipe(Effect11.interruptible, Effect11.timeout("100 millis"), Effect11.ignore, Effect11.ensuring(Effect11.sync(() => reader2.releaseLock()))));
+  const reader = yield* Effect12.acquireRelease(Effect12.sync(() => response.body.getReader()), (reader2) => Effect12.promise(() => reader2.cancel()).pipe(Effect12.interruptible, Effect12.timeout("100 millis"), Effect12.ignore, Effect12.ensuring(Effect12.sync(() => reader2.releaseLock()))));
   if (signal.aborted) {
     yield* request.fail;
     return;
   }
   const decoder = new TextDecoder;
   const parser = new SseDataParser;
-  const drain = Effect11.gen(function* () {
+  const drain = Effect12.gen(function* () {
     while (true) {
-      const result = yield* Effect11.tryPromise(() => reader.read());
+      const result = yield* Effect12.tryPromise(() => reader.read());
       if (result.done)
         break;
       const values = [];
@@ -5940,35 +6005,35 @@ var observeResponse = (response, request, signal) => Effect11.scoped(Effect11.ge
     }
     yield* request.finish;
   });
-  const aborted = Effect11.async((resume) => {
-    const abort = () => resume(Effect11.interrupt);
+  const aborted = Effect12.async((resume) => {
+    const abort = () => resume(Effect12.interrupt);
     signal.addEventListener("abort", abort, { once: true });
     if (signal.aborted)
       abort();
-    return Effect11.sync(() => signal.removeEventListener("abort", abort));
+    return Effect12.sync(() => signal.removeEventListener("abort", abort));
   });
-  yield* Effect11.raceFirst(drain, aborted).pipe(Effect11.onError(() => request.fail));
-})).pipe(Effect11.catchAllCause(() => Effect11.void));
+  yield* Effect12.raceFirst(drain, aborted).pipe(Effect12.onError(() => request.fail));
+})).pipe(Effect12.catchAllCause(() => Effect12.void));
 var makeObservingFetch = (fetchImplementation, begin, scope) => {
   const observingFetch = async (input, init) => {
     const request = new Request(input, init);
     request.headers.set(MAGNITUDE_PROGRESS_HEADER, "true");
-    const progress = Effect11.runSync(Effect11.suspend(begin).pipe(Effect11.catchAllCause(() => Effect11.succeed({
-      observe: () => Effect11.void,
-      finish: Effect11.void,
-      fail: Effect11.void
+    const progress = Effect12.runSync(Effect12.suspend(begin).pipe(Effect12.catchAllCause(() => Effect12.succeed({
+      observe: () => Effect12.void,
+      finish: Effect12.void,
+      fail: Effect12.void
     }))));
     try {
       const response = await fetchImplementation(request);
       try {
         const observation = observeResponse(response.clone(), progress, request.signal);
-        Effect11.runFork(Effect11.forkIn(observation, scope));
+        Effect12.runFork(Effect12.forkIn(observation, scope));
       } catch {
-        Effect11.runSync(progress.fail.pipe(Effect11.catchAllCause(() => Effect11.void)));
+        Effect12.runSync(progress.fail.pipe(Effect12.catchAllCause(() => Effect12.void)));
       }
       return response;
     } catch (error) {
-      Effect11.runSync(progress.fail.pipe(Effect11.catchAllCause(() => Effect11.void)));
+      Effect12.runSync(progress.fail.pipe(Effect12.catchAllCause(() => Effect12.void)));
       throw error;
     }
   };
@@ -5979,7 +6044,7 @@ var makeObservingFetch = (fetchImplementation, begin, scope) => {
 
 // extensions/progress.ts
 import { Text } from "@earendil-works/pi-tui";
-import { Data as Data3, Effect as Effect12, Fiber as Fiber2, Option as Option17, Queue, Schema as Schema53 } from "effect";
+import { Data as Data3, Effect as Effect13, Fiber as Fiber2, Option as Option17, Queue, Schema as Schema53 } from "effect";
 var MAGNITUDE_SUMMARY_WIDGET_KEY = "magnitude-inference-summary";
 var RequestId = Schema53.Number.pipe(Schema53.int(), Schema53.brand("ProgressRequestId"));
 
@@ -6036,21 +6101,21 @@ var formatLiveProgress = ({ progress, modelName, startedAt }, now) => {
     }
   }
 };
-var makeProgressTracker = (ui, now = () => performance.now()) => Effect12.gen(function* () {
+var makeProgressTracker = (ui, now = () => performance.now()) => Effect13.gen(function* () {
   let state = new Idle2;
   let nextId = 0;
   let active;
   let latest;
   let nextResponseId = 0;
   const wake = yield* Queue.sliding(1);
-  const present = (f) => Effect12.sync(f).pipe(Effect12.catchAllCause(() => Effect12.void));
+  const present = (f) => Effect13.sync(f).pipe(Effect13.catchAllCause(() => Effect13.void));
   const clearSummary = present(() => ui.setWidget(MAGNITUDE_SUMMARY_WIDGET_KEY, undefined));
   const resetRow = present(() => ui.setWorkingMessage());
   const render2 = present(() => {
     if (active)
       ui.setWorkingMessage(formatLiveProgress(active.phase, now()));
   });
-  const finalize = Effect12.gen(function* () {
+  const finalize = Effect13.gen(function* () {
     if (state._tag !== "Settled")
       return;
     if ([...state.run.responses.values()].some(Option17.isNone))
@@ -6069,7 +6134,7 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect12.gen(fu
     const summary = `● ${settled.run.modelName} worked for ${duration(settled.settledAt - settled.run.startedAt)}` + ` · ${seconds(timings[0].time_to_first_token_ms)} TTFT` + (decodeMs > 0 && tokens > 0 ? ` · ${(tokens * 1000 / decodeMs).toFixed(1)} tok/s` : "");
     yield* present(() => ui.setWidget(MAGNITUDE_SUMMARY_WIDGET_KEY, (_tui, theme) => new Text(theme.fg("muted", summary), 0, 0)));
   });
-  const clear = Effect12.gen(function* () {
+  const clear = Effect13.gen(function* () {
     if (state._tag === "Disposed")
       return;
     if (state._tag !== "Idle")
@@ -6079,7 +6144,7 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect12.gen(fu
     yield* resetRow;
     yield* clearSummary;
   });
-  const startRun = (modelName) => Effect12.gen(function* () {
+  const startRun = (modelName) => Effect13.gen(function* () {
     if (state._tag === "Disposed")
       return;
     if (state._tag === "Settled")
@@ -6089,14 +6154,14 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect12.gen(fu
     state = runMachine.transition(state, "Working", { run: { startedAt: now(), modelName, requests: new Map, completed: new Map, responses: new Map, accepted: new Set } });
     yield* clearSummary;
   });
-  const timer = yield* Effect12.forever(Effect12.gen(function* () {
+  const timer = yield* Effect13.forever(Effect13.gen(function* () {
     yield* Queue.take(wake);
     while (active) {
-      yield* Effect12.sleep("100 millis");
+      yield* Effect13.sleep("100 millis");
       yield* render2;
     }
-  })).pipe(Effect12.forkScoped);
-  yield* Effect12.addFinalizer(() => Effect12.gen(function* () {
+  })).pipe(Effect13.forkScoped);
+  yield* Effect13.addFinalizer(() => Effect13.gen(function* () {
     yield* clear;
     if (state._tag !== "Disposed")
       state = runMachine.transition(state, "Disposed", {});
@@ -6105,19 +6170,19 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect12.gen(fu
   return {
     startRun,
     clear,
-    settleRun: Effect12.gen(function* () {
+    settleRun: Effect13.gen(function* () {
       if (state._tag === "Working")
         state = runMachine.transition(state, "Settled", { settledAt: now() });
       yield* finalize;
     }),
-    beginResponse: (modelName) => Effect12.gen(function* () {
+    beginResponse: (modelName) => Effect13.gen(function* () {
       yield* startRun(modelName);
       const run = state._tag === "Working" ? state.run : undefined;
       const responseId = ++nextResponseId;
       const requests = [];
       run?.responses.set(responseId, Option17.none());
       const belongs = () => run !== undefined && (state._tag === "Working" || state._tag === "Settled") && state.run === run;
-      const end = (successful) => Effect12.gen(function* () {
+      const end = (successful) => Effect13.gen(function* () {
         if (!belongs() || Option17.isSome(run.responses.get(responseId)))
           return;
         run.responses.set(responseId, Option17.some(successful));
@@ -6139,16 +6204,16 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect12.gen(fu
         }
         yield* finalize;
       });
-      const begin = Effect12.gen(function* () {
+      const begin = Effect13.gen(function* () {
         if (!belongs() || Option17.isSome(run.responses.get(responseId)))
-          return { observe: () => Effect12.void, finish: Effect12.void, fail: Effect12.void };
+          return { observe: () => Effect13.void, finish: Effect13.void, fail: Effect13.void };
         const id = RequestId.make(++nextId);
         requests.push(id);
         latest = id;
         active = undefined;
         run?.requests.set(id, new Observing({ timings: Option17.none() }));
         yield* resetRow;
-        const close = (failed) => Effect12.gen(function* () {
+        const close = (failed) => Effect13.gen(function* () {
           if (!belongs())
             return;
           const request = run.requests.get(id);
@@ -6168,7 +6233,7 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect12.gen(fu
           yield* finalize;
         });
         return {
-          observe: (observation) => Effect12.gen(function* () {
+          observe: (observation) => Effect13.gen(function* () {
             if (!belongs())
               return;
             const request = run.requests.get(id);
@@ -6199,34 +6264,35 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect12.gen(fu
 });
 
 // extensions/magnitude.ts
-import { Effect as Effect13, Exit as Exit3, Scope as Scope5 } from "effect";
+import { Effect as Effect14, Exit as Exit4, Scope as Scope6 } from "effect";
 function magnitudeExtension(pi) {
   const completions = openAICompletionsApi();
   let tracker;
   let scope;
   const disposeCommands = registerMagnitudeCommands(pi);
-  const perform = (effect) => Effect13.runSync((effect ?? Effect13.void).pipe(Effect13.catchAllCause(() => Effect13.void)));
+  const disposeOnboarding = registerMagnitudeOnboarding(pi);
+  const perform = (effect) => Effect14.runSync((effect ?? Effect14.void).pipe(Effect14.catchAllCause(() => Effect14.void)));
   pi.registerProvider("magnitude", {
     api: "openai-completions",
     streamSimple: (model2, context, options) => {
       if (model2.api !== "openai-completions") {
         throw new Error(`Magnitude for Pi requires openai-completions, received ${model2.api}`);
       }
-      const response = tracker && Effect13.runSync(tracker.beginResponse(model2.name));
+      const response = tracker && Effect14.runSync(tracker.beginResponse(model2.name));
       const stream = completions.streamSimple(model2, context, {
         ...options,
-        fetch: scope ? makeObservingFetch(options?.fetch ?? globalThis.fetch, () => response?.begin ?? Effect13.succeed({ observe: () => Effect13.void, finish: Effect13.void, fail: Effect13.void }), scope) : options?.fetch ?? globalThis.fetch
+        fetch: scope ? makeObservingFetch(options?.fetch ?? globalThis.fetch, () => response?.begin ?? Effect14.succeed({ observe: () => Effect14.void, finish: Effect14.void, fail: Effect14.void }), scope) : options?.fetch ?? globalThis.fetch
       });
       if (response && scope)
-        Effect13.runFork(Effect13.forkIn(Effect13.tryPromise(() => stream.result()).pipe(Effect13.flatMap((message) => response.end(message.stopReason !== "error" && message.stopReason !== "aborted")), Effect13.catchAllCause(() => response.end(false))), scope));
+        Effect14.runFork(Effect14.forkIn(Effect14.tryPromise(() => stream.result()).pipe(Effect14.flatMap((message) => response.end(message.stopReason !== "error" && message.stopReason !== "aborted")), Effect14.catchAllCause(() => response.end(false))), scope));
       return stream;
     }
   });
   pi.on("session_start", async (_event, ctx) => {
     if (scope)
-      await Effect13.runPromise(Scope5.close(scope, Exit3.void));
-    scope = Effect13.runSync(Scope5.make());
-    tracker = await Effect13.runPromise(makeProgressTracker(ctx.ui).pipe(Scope5.extend(scope)));
+      await Effect14.runPromise(Scope6.close(scope, Exit4.void));
+    scope = Effect14.runSync(Scope6.make());
+    tracker = await Effect14.runPromise(makeProgressTracker(ctx.ui).pipe(Scope6.extend(scope)));
   });
   pi.on("model_select", (event) => {
     if (event.model.provider !== "magnitude")
@@ -6238,8 +6304,9 @@ function magnitudeExtension(pi) {
   });
   pi.on("agent_settled", () => perform(tracker?.settleRun));
   pi.on("session_shutdown", async () => {
+    await disposeOnboarding();
     if (scope)
-      await Effect13.runPromise(Scope5.close(scope, Exit3.void));
+      await Effect14.runPromise(Scope6.close(scope, Exit4.void));
     tracker = undefined;
     scope = undefined;
     await disposeCommands();

package/dist/skills/magnitude/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: magnitude
+description: Set up and operate Magnitude local inference through its CLI, recommend hardware-fit local models, monitor acquisition and loading, and connect an agent harness. Use for Magnitude service, model, catalog, setup, or harness requests.
+---
+
+# Magnitude
+
+Magnitude profiles the local machine, assesses compatible model configurations, acquires and runs
+selected models, and connects them to supported agent harnesses.
+
+For agent-guided setup, read `magnitude docs onboarding` completely and follow it. It contains the
+current CLI-only workflow, model-selection evidence, progress semantics, and harness connection
+rules.
+
+For the general non-interactive command contract, read `magnitude docs cli`. Command output is
+designed to be read directly by both agents and people.

package/package.json

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