@jaybeeuu/agent-cortex 1.39.0 → 1.41.0

package/extensions/agent-modes/discover.test.ts

@@ -137,8 +137,8 @@ describe("discoverAgents (composable source format)", () => {
 
     // {{TOOL:bash}} → bash.
     assert.match(plan.prompt, /Run with bash\./);
-    // {{TOOL:ask_user}} → null for pi — token dropped (dangling prose is the author's
-    // responsibility per token-map.README), not left as literal token syntax.
+    // {{TOOL:ask_user}} → ask_questions (pi's native structured-questions tool).
+    assert.match(plan.prompt, /Ask the user with ask_questions\./);
     assert.doesNotMatch(plan.prompt, /\{\{TOOL:ask_user\}\}/);
     // Relative {{PATH:...}} resolves against the actual package root (dir of agents/).
     assert.match(plan.prompt, new RegExp(`Read the plan skill at ${escapeRegExp(fx.dir)}/skills/workflow/plan/SKILL\\.md\\.`));
@@ -147,7 +147,7 @@ describe("discoverAgents (composable source format)", () => {
     assert.doesNotMatch(plan.prompt, /\{\{/);
   });
 
-  it("drops null-mapped tools (ask_user, skill) from the PI tool set", () => {
+  it("maps ask_user → ask_questions and skill → read into the PI tool set", () => {
     const fx = track(makeFixture());
     writeComposableAgent(fx, "plan", {
       frontmatter: {
@@ -159,8 +159,30 @@ describe("discoverAgents (composable source format)", () => {
 
     const agents = discoverAgents(fx.agentsDir, REAL_TOKEN_MAP);
     assert.equal(agents.length, 1);
-    // ask_user → null (omitted), skill → null (omitted), web_fetch → fetch_content.
-    assert.deepEqual(agents[0].tools, ["bash", "fetch_content"]);
+    // ask_user → ask_questions, skill → read (pi reads skill files), web_fetch → fetch_content.
+    assert.deepEqual(agents[0].tools, ["ask_questions", "bash", "fetch_content", "read"]);
+  });
+
+  it("warns and omits a tool whose pi mapping is null", () => {
+    const fx = track(makeFixture());
+    const NULL_MAP = {
+      tools: { ask_user: { copilot: "ask_user", claude: "AskUserQuestion", pi: null } },
+      paths: {},
+    } as TokenMap;
+    writeComposableAgent(fx, "plan", {
+      frontmatter: {
+        name: "agent-cortex:plan",
+        description: "Planner",
+        tools: ["ask_user", "bash"],
+      },
+    });
+
+    const agents = discoverAgents(fx.agentsDir, NULL_MAP);
+    assert.equal(agents.length, 1);
+    // With a null pi column the entry is omitted (and warned about), per the contract.
+    // (bash survives so the result is observable — an all-dropped list would be
+    // normalised to DEFAULT_TOOLS, which is "no restriction", not the omit result.)
+    assert.deepEqual(agents[0].tools, ["bash"]);
   });
 
   it("uses the built-in fallback map when token-map.json is unavailable", () => {
@@ -230,8 +252,9 @@ describe("loadTokenMap", () => {
   it("reads the real token-map.json at the package root", () => {
     assert.ok(REAL_TOKEN_MAP);
     assert.equal(typeof REAL_TOKEN_MAP?.tools?.bash?.pi, "string");
-    // ask_user has no PI equivalent per the contract — must stay null.
-    assert.equal(REAL_TOKEN_MAP?.tools?.ask_user?.pi, null);
+    // ask_user → ask_questions (pi's native structured-questions tool); skill → read.
+    assert.equal(REAL_TOKEN_MAP?.tools?.ask_user?.pi, "ask_questions");
+    assert.equal(REAL_TOKEN_MAP?.tools?.skill?.pi, "read");
     assert.ok(REAL_TOKEN_MAP?.paths?.agents_dir);
   });
 });

package/extensions/agent-modes/discover.ts

@@ -120,7 +120,7 @@ function prettifyId(id: string): string {
  * Translate a frontmatter tool list into PI tool names.
  *
  * With token-map.json: canonical keys are translated via the pi column; a null
- * mapping means PI has no equivalent (ask_user, skill) and the entry is omitted;
+ * mapping means PI has no equivalent for that tool and the entry is omitted;
  * a name that is not a canonical key passes through untouched (it may be a
  * native PI tool such as `fetch_content`). Without the map, the built-in
  * COPILOT_TO_PI fallback applies and unknown names pass through.

package/extensions/agent-modes/index.test.ts

@@ -0,0 +1,208 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { type AgentDef, discoverAgents } from "./discover.ts";
+import agentModesExtension, { registerAgentFlag } from "./index.ts";
+
+const AGENTS_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "agents");
+
+// ─── Fixtures ─────────────────────────────────────────────────────────────────
+
+function agent(id: string): AgentDef {
+  return {
+    id,
+    name: `agent-cortex:${id}`,
+    description: `${id} agent`,
+    color: "accent",
+    tools: [],
+    prompt: "",
+  };
+}
+
+type RegisterFlagArgs = Parameters<ExtensionAPI["registerFlag"]>;
+/** A handler recorded from `pi.on`, invoked via Reflect.apply so its exact
+ *  overload signature does not leak into the fake. */
+type RecordedHandler = (...args: never[]) => unknown;
+
+interface FakeContext {
+  ui: {
+    statuses: Array<{ id: string; text: string | undefined }>;
+    notifications: Array<{ message: string; level: string }>;
+    setStatus(id: string, text: string | undefined): void;
+    notify(message: string, level: string): void;
+    theme: { fg(color: string, text: string): string };
+  };
+  sessionManager: { getEntries(): unknown[] };
+}
+
+interface FakePi {
+  pi: ExtensionAPI;
+  flags: RegisterFlagArgs[];
+  handlers: Map<string, RecordedHandler[]>;
+  setActiveToolsCalls: string[][];
+  /** Simulate pi dispatching an event to the handlers registered for it. */
+  fire(event: string, ...args: unknown[]): void;
+}
+
+/**
+ * Build a full ExtensionAPI test double that records the calls agent-modes
+ * makes. `getFlag` resolves against `flagValues`, and `getActiveTools` returns
+ * a fixed baseline so setActiveTools calls are observable.
+ */
+function createFakePi(flagValues: Record<string, boolean | string> = {}): FakePi {
+  const flags: RegisterFlagArgs[] = [];
+  const handlers = new Map<string, RecordedHandler[]>();
+  const setActiveToolsCalls: string[][] = [];
+  const values = new Map<string, boolean | string>(Object.entries(flagValues));
+  const baselineTools = ["read", "bash"];
+
+  const pi: ExtensionAPI = {
+    on: (event: string, handler: RecordedHandler) => {
+      const list = handlers.get(event) ?? [];
+      list.push(handler);
+      handlers.set(event, list);
+    },
+    registerFlag: (name, options) => {
+      flags.push([name, options]);
+    },
+    getFlag: (name) => values.get(name),
+    getActiveTools: () => [...baselineTools],
+    setActiveTools: (toolNames) => {
+      setActiveToolsCalls.push(toolNames);
+    },
+    registerCommand: () => {},
+    registerShortcut: () => {},
+    registerTool: () => {},
+    registerMessageRenderer: () => {},
+    registerProvider: () => {},
+    unregisterProvider: () => {},
+    sendMessage: () => {},
+    sendUserMessage: () => {},
+    appendEntry: () => {},
+    setSessionName: () => {},
+    getSessionName: () => undefined,
+    setLabel: () => {},
+    exec: async () => {
+      throw new Error("not implemented");
+    },
+    getAllTools: () => [],
+    getCommands: () => [],
+    setModel: async () => false,
+    getThinkingLevel: () => "off",
+    setThinkingLevel: () => {},
+    events: { on: () => () => {}, emit: () => {} },
+  };
+
+  return {
+    pi,
+    flags,
+    handlers,
+    setActiveToolsCalls,
+    fire(event, ...args) {
+      for (const handler of handlers.get(event) ?? []) {
+        Reflect.apply(handler, undefined, args);
+      }
+    },
+  };
+}
+
+function createFakeContext(): FakeContext {
+  return {
+    ui: {
+      statuses: [],
+      notifications: [],
+      setStatus(id, text) {
+        this.statuses.push({ id, text });
+      },
+      notify(message, level) {
+        this.notifications.push({ message, level });
+      },
+      theme: { fg: (_color, text) => text },
+    },
+    sessionManager: { getEntries: () => [] },
+  };
+}
+
+// ─── registerAgentFlag ───────────────────────────────────────────────────────
+
+describe("registerAgentFlag", () => {
+  it("registers --agent as a string flag listing the discovered agent ids", () => {
+    const calls: RegisterFlagArgs[] = [];
+    const pi: Pick<ExtensionAPI, "registerFlag"> = {
+      registerFlag: (...args) => calls.push(args),
+    };
+
+    registerAgentFlag(pi, [
+      agent("ralph"),
+      agent("ralph-plan"),
+      agent("plan"),
+      agent("strategy"),
+    ]);
+
+    assert.equal(calls.length, 1);
+    const [name, options] = calls[0];
+    assert.equal(name, "agent");
+    assert.equal(options.type, "string");
+    assert.equal(
+      options.description,
+      "Start in a specific agent mode (ralph, ralph-plan, plan, strategy)",
+    );
+  });
+});
+
+// ─── Registration timing ─────────────────────────────────────────────────────
+
+describe("agentModesExtension flag registration", () => {
+  it("registers --agent during load, before any session event fires", () => {
+    const fake = createFakePi();
+
+    agentModesExtension(fake.pi);
+
+    // The flag must exist straight after the factory returns: pi validates CLI
+    // flags against extensions loaded at startup, so registering it from the
+    // session_start handler would be too late and `pi --agent <name>` would fail.
+    assert.equal(fake.flags.length, 1);
+    const [name, options] = fake.flags[0];
+    assert.equal(name, "agent");
+    assert.equal(options.type, "string");
+    assert.match(options.description ?? "", /^Start in a specific agent mode \(/);
+  });
+});
+
+// ─── --agent flag contract ───────────────────────────────────────────────────
+
+describe("agentModesExtension --agent flag", () => {
+  it("activates the named agent on session start", () => {
+    const fake = createFakePi({ agent: "plan" });
+    const ctx = createFakeContext();
+
+    agentModesExtension(fake.pi);
+    fake.fire("session_start", {}, ctx);
+
+    const plan = discoverAgents(AGENTS_DIR).find((a) => a.id === "plan");
+    assert.ok(plan, "the plan agent should be discoverable");
+    assert.deepEqual(fake.setActiveToolsCalls.at(-1), plan.tools);
+    assert.ok(
+      ctx.ui.statuses.some((s) => s.id === "agent-mode" && s.text?.includes("plan")),
+      "the status indicator should show the active agent",
+    );
+  });
+
+  it("falls back to default mode for an unknown agent and leaves tools untouched", () => {
+    const fake = createFakePi({ agent: "does-not-exist" });
+    const ctx = createFakeContext();
+
+    agentModesExtension(fake.pi);
+    fake.fire("session_start", {}, ctx);
+
+    // Unknown flag → default mode: baseline tools restored, no agent status.
+    assert.deepEqual(fake.setActiveToolsCalls.at(-1), ["read", "bash"]);
+    assert.ok(
+      ctx.ui.statuses.every((s) => !s.text?.includes("agent:")),
+      "no agent mode should be reported",
+    );
+  });
+});

package/extensions/agent-modes/index.ts

@@ -37,6 +37,27 @@ interface OriginalState {
 
 const PERSIST_KEY = "agent-modes-state";
 
+// ─── CLI flag ────────────────────────────────────────────────────────────────
+
+/**
+ * Register the `--agent <name>` CLI flag.
+ *
+ * This must run while the extension is loading (i.e. from the factory), not
+ * from a `session_start` handler: PI matches CLI flags against the extensions
+ * loaded at startup, so a flag registered during `session_start` arrives after
+ * the CLI has already been parsed and `pi --agent <name>` fails with
+ * `Unknown option: --agent`.
+ */
+export function registerAgentFlag(
+  pi: Pick<ExtensionAPI, "registerFlag">,
+  agents: AgentDef[],
+): void {
+  pi.registerFlag("agent", {
+    description: `Start in a specific agent mode (${agents.map((a) => a.id).join(", ")})`,
+    type: "string",
+  });
+}
+
 // ─── Extension ───────────────────────────────────────────────────────────────
 
 export default function agentModesExtension(pi: ExtensionAPI): void {
@@ -47,6 +68,8 @@ export default function agentModesExtension(pi: ExtensionAPI): void {
     return;
   }
 
+  registerAgentFlag(pi, agents);
+
   let activeAgentIndex = agents.length; // default mode is beyond the last agent
   let originalState: OriginalState | undefined;
   let baselineTools: string[] = [];
@@ -186,12 +209,6 @@ export default function agentModesExtension(pi: ExtensionAPI): void {
       },
     });
 
-    // --agent CLI flag
-    pi.registerFlag("agent", {
-      description: `Start in a specific agent mode (${agents.map((a) => a.id).join(", ")})`,
-      type: "string",
-    });
-
     // inject agent prompt before each agent start
     pi.on("before_agent_start", async (event) => {
       const agent = getActiveAgent();

package/extensions/agent-modes/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "test": "node --test --import tsx/esm discover.test.ts",
+    "test": "node --test --import tsx/esm discover.test.ts index.test.ts",
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {

package/extensions/skill-stats/index.test.ts

@@ -331,17 +331,18 @@ describe("loadStore / saveStore", () => {
     const file = join(tmpDir, "test-store.json");
     const original = freshStore();
     original.totalTurns = 42;
+    const recentTs = new Date(Date.now() - 60 * 24 * 60 * 60 * 1000).toISOString();
     original.skills["test-skill"] = {
       loadedCount: 5,
       invokedCount: 2,
       readCount: 3,
-      lastUsed: "2026-06-07T12:00:00.000Z",
+      lastUsed: recentTs,
       byProject: {
         "/project/a": {
           loadedCount: 3,
           invokedCount: 1,
           readCount: 2,
-          lastUsed: "2026-06-07T12:00:00.000Z",
+          lastUsed: recentTs,
         },
       },
     };

package/lib/cli.mjs

@@ -5,9 +5,11 @@ const SUPPORTED_HARNESSES = ["copilot", "claude", "pi"];
 // malformed options surface as `optionError` on the parsed result; the CLI
 // prints them and exits 1.
 const INSTALL_OPTIONS = {
-  "--dry-run": { key: "dryRun" },
+  "--dry-run": { key: "dryRun", boolean: true },
   "--output": { key: "output" },
   "--plugin-root": { key: "pluginRoot" },
+  "--require-register": { key: "requireRegister", boolean: true },
+  "--no-provision": { key: "noProvision", boolean: true },
 };
 
 export function parseArgs(argv) {
@@ -34,8 +36,8 @@ export function parseArgs(argv) {
       if (!spec) {
         return { command: "install", harness, optionError: `Unknown option "${arg}". Run "agent-cortex --help" for usage.` };
       }
-      if (spec.key === "dryRun") {
-        options.dryRun = true;
+      if (spec.boolean) {
+        options[spec.key] = true;
         continue;
       }
       if (inlineValue !== null) {
@@ -66,15 +68,26 @@ Commands:
   install <harness>   Install agent-cortex for a harness
                       Supported harnesses: ${SUPPORTED_HARNESSES.join(", ")}
                       Options (claude):
-                        (no --output)   Generate the plugin subtree AND register it
-                                        with Claude Code via the "claude plugin" CLI
-                                        (marketplace add → install → update) — requires
-                                        the plugin CLI (Claude Code v2+)
-                        --output <dir>  Write the plugin subtree to <dir> only — no
-                                        runtime registration (default: <package
-                                        root>/claude)
+                        (no --output)   Materialise the plugin into
+                                        ~/.agent-cortex/claude, write the
+                                        marketplace manifest at
+                                        ~/.agent-cortex/.claude-plugin/
+                                        marketplace.json, and register it with
+                                        Claude Code via the "claude plugin" CLI
+                                        (marketplace add → install → update,
+                                        idempotent by state: a re-run is the
+                                        update path, repeat install a no-op;
+                                        requires the plugin CLI, v2+)
+                        --output <dir>  Write the plugin subtree to <dir> only —
+                                        no marketplace manifest or registration
+                                        (default: ~/.agent-cortex/claude)
                         --dry-run       Print what would be generated/registered
                                         without writing
+                        --require-register
+                                        Fail the install when Claude Code
+                                        registration cannot run (missing CLI,
+                                        pre-v2 build); default warns and prints
+                                        the manual registration commands
                       Options (copilot):
                         --output <dir>   Write the flat *.agent.md files to <dir>
                                          (default: <package root>/agents — the dir
@@ -82,10 +95,15 @@ Commands:
                         --dry-run        Print what would be generated without writing
                       Options (pi):
                         --dry-run             Show what would be installed without writing
-                        --output <dir>        Install into <dir>/agents and <dir>/skills
-                                              (default: ~/.pi/agent)
+                        --output <dir>        Install into <dir> — agents/, skills/,
+                                              settings.json (merged, packages managed)
+                                              and keybindings.json (default: ~/.pi/agent)
                         --plugin-root <dir>   Override the plugin root used for {{PATH:...}}
                                               tokens (default: token-map.json's pi value)
+                        --no-provision        Skip installing the third-party pi packages
+                                              declared in the package manifest (e.g.
+                                              pi-questions, pi-web-access). They are
+                                              installed by default on a real install.
   --help, -h          Show this help text`;
 }
 

package/lib/pi-packages.mjs

@@ -0,0 +1,169 @@
+// Pi third-party package provisioning.
+//
+// agent-cortex's pi harness needs tools that live in third-party pi packages:
+// ask_questions comes from pi-questions, fetch_content from pi-web-access (see
+// token-map.json notes and docs/ideas/extension-manifests.md). Those packages
+// are declared in the package manifest — package.json → pi.packages — and this
+// module makes them real: `agent-cortex install pi` reads the declaration and
+// installs any package the pi user scope is missing.
+//
+// Provisioning goes through the pi CLI (`pi install <source>`), which both
+// installs the package under ~/.pi/agent/npm and declares it in
+// ~/.pi/agent/settings.json — the same store pi loads packages from. It is
+// opt-in (installPi option `provisionPackages`) and idempotent: a package that
+// is already declared and installed is skipped. A failed install warns and the
+// rest continue, so an offline machine never breaks the agent install.
+
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+
+const DEFAULT_WARN = (msg) => console.warn(`[pi-packages] ${msg}`);
+
+/**
+ * Read the pi package sources agent-cortex declares it needs.
+ *
+ * @param {string} root Package root containing package.json
+ * @returns {Promise<string[]>} Declared sources, e.g. ["npm:pi-questions"]
+ */
+export async function loadRequiredPackages(root) {
+  const manifest = JSON.parse(await readFile(join(root, "package.json"), "utf-8"));
+  const packages = manifest?.pi?.packages;
+  return Array.isArray(packages) ? packages.filter((entry) => typeof entry === "string") : [];
+}
+
+/**
+ * Extract the npm package name from a pi source string.
+ *
+ * @param {string} source e.g. "npm:pi-web-access@0.10.7", "npm:@scope/pkg"
+ * @returns {string | null} The name, or null for sources we cannot inspect locally
+ */
+export function npmSourceName(source) {
+  if (typeof source !== "string" || !source.startsWith("npm:")) return null;
+  const spec = source.slice("npm:".length);
+  const at = spec.lastIndexOf("@");
+  return at > 0 ? spec.slice(0, at) : spec;
+}
+
+/**
+ * Decide which required packages still need installing.
+ *
+ * A package is satisfied only when it is both declared in settings (so pi loads
+ * it) and present in the npm store (so it is installed) — otherwise it needs a
+ * `pi install` to reconcile.
+ *
+ * @param {string[]} required
+ * @param {{ declaredSources: string[], installedNames: string[] }} state
+ * @returns {string[]} The sources still to install
+ */
+export function planPackageInstalls(required, { declaredSources, installedNames }) {
+  const declared = new Set(declaredSources.map(npmSourceName).filter(Boolean));
+  const installed = new Set(installedNames);
+  return required.filter((source) => {
+    const name = npmSourceName(source);
+    return name === null || !declared.has(name) || !installed.has(name);
+  });
+}
+
+/**
+ * Install every required package the pi user scope is missing.
+ *
+ * @param {object} options
+ * @param {string[]} options.required        Declared pi sources (see loadRequiredPackages)
+ * @param {string} options.piRoot            Pi user scope dir (default ~/.pi/agent)
+ * @param {boolean} [options.dryRun]         Report the plan without installing
+ * @param {(source: string) => Promise<{ok: boolean, error: string | null}>} [options.runInstall]
+ * @param {(msg: string) => void} [options.warn]
+ * @returns {Promise<{planned: string[], installed: string[], failed: {source: string, error: string}[]}>}
+ */
+export async function provisionPiPackages({
+  required,
+  piRoot,
+  dryRun = false,
+  runInstall = runPiInstall,
+  warn = DEFAULT_WARN,
+}) {
+  const declaredSources = await readDeclaredSources(join(piRoot, "settings.json"));
+  const installedNames = await readInstalledNames(join(piRoot, "npm", "node_modules"));
+  const planned = planPackageInstalls(required, { declaredSources, installedNames });
+
+  if (dryRun) return { planned, installed: [], failed: [] };
+
+  const installed = [];
+  const failed = [];
+  for (const source of planned) {
+    const result = await runInstall(source);
+    if (result.ok) {
+      installed.push(source);
+    } else {
+      failed.push({ source, error: result.error });
+      warn(`could not install pi package ${source}: ${result.error}`);
+    }
+  }
+  return { planned, installed, failed };
+}
+
+/** Install one pi package source through the pi CLI. */
+export function runPiInstall(source) {
+  return new Promise((resolve) => {
+    const child = spawn("pi", ["install", source], { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    child.stdout.resume(); // drain; only failures are interesting
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (err) => {
+      resolve({
+        ok: false,
+        error: err.code === "ENOENT" ? "pi CLI not found on PATH" : err.message,
+      });
+    });
+    child.on("close", (code) => {
+      resolve({
+        ok: code === 0,
+        error: code === 0 ? null : stderr.trim() || `pi install exited with code ${code}`,
+      });
+    });
+  });
+}
+
+// ─── Pi user-scope inspection ────────────────────────────────────────────────
+
+/** Read the package sources declared in a pi settings.json (missing or unreadable → none). */
+async function readDeclaredSources(settingsPath) {
+  let settings;
+  try {
+    settings = JSON.parse(await readFile(settingsPath, "utf-8"));
+  } catch {
+    // Nothing declared yet, or a file pi itself owns and repairs. Provisioning is
+    // a non-essential step — it must never fail the agent install.
+    return [];
+  }
+  const packages = Array.isArray(settings?.packages) ? settings.packages : [];
+  return packages
+    .map((entry) => (typeof entry === "string" ? entry : entry?.source))
+    .filter((source) => typeof source === "string");
+}
+
+/** List installed package names in the pi npm store (missing dir → none). */
+async function readInstalledNames(nodeModulesDir) {
+  let entries;
+  try {
+    entries = await readdir(nodeModulesDir, { withFileTypes: true });
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  const names = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (!entry.name.startsWith("@")) {
+      names.push(entry.name);
+      continue;
+    }
+    for (const scoped of await readdir(join(nodeModulesDir, entry.name), { withFileTypes: true })) {
+      if (scoped.isDirectory()) names.push(`${entry.name}/${scoped.name}`);
+    }
+  }
+  return names;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaybeeuu/agent-cortex",
-  "version": "1.39.0",
+  "version": "1.41.0",
   "description": "Personal PI package with custom agents, skills, and extensions",
   "keywords": [
     "pi-package"
@@ -24,17 +24,21 @@
     ],
     "skills": [
       "./skills"
+    ],
+    "packages": [
+      "npm:pi-questions",
+      "npm:pi-web-access@0.10.7"
     ]
   },
   "scripts": {
     "build": "echo 'Build complete — no compilation needed for PI package'",
-    "lint": "pnpm typecheck",
+    "lint": "pnpm typecheck && pnpm check:sync",
+    "check:sync": "node scripts/check-no-sync.mjs",
     "test": "node --test test/*.test.mjs && pnpm -r test",
     "typecheck": "pnpm -r typecheck",
-    "build:claude": "node bin/agent-cortex.mjs install claude --output claude",
     "build:copilot": "node scripts/build-copilot-agents.mjs",
     "changeset": "changeset",
-    "version-packages": "changeset version && bash scripts/sync-plugin-version.sh && pnpm build:claude && pnpm build:copilot",
+    "version-packages": "changeset version && bash scripts/sync-plugin-version.sh && pnpm build:copilot",
     "publish-package": "TARBALL=$(pnpm pack | tail -n 1) && npm publish \"$TARBALL\" --provenance --access public",
     "release": "changeset publish",
     "postinstall": "bash scripts/install-instructions.sh"