@aerovato/operator-helper 1.6.1 → 1.7.0

package/README.md

@@ -32,9 +32,6 @@ operator-helper install pi
 
 # DeepSeek Harness
 operator-helper install deepseek
-
-# Code Puppy
-operator-helper install code-puppy
 ```
 
 Restart the harness, then run `/operator:user-init` in a new conversation to begin setup.
@@ -52,7 +49,6 @@ operator-helper install opencode
 operator-helper install opencode-v2
 operator-helper install pi
 operator-helper install deepseek
-operator-helper install code-puppy
 ```
 
 Operator Helper automatically checks for and installs updates when commands run. If it cannot determine whether Bun or npm owns the global installation, it asks for a manual update using the original installation method.

package/dist/index.js

@@ -15319,7 +15319,7 @@ var log = (...args) => consoleWith((console2) => sync(() => {
 // package.json
 var package_default = {
   name: "@aerovato/operator-helper",
-  version: "1.6.1",
+  version: "1.7.0",
   description: "Installation and setup CLI for Operator Memory",
   license: "BSD-3-Clause",
   author: "Aerovato Research",
@@ -15368,6 +15368,8 @@ var package_default = {
   type: "module"
 };
 
+// src/commands/common.ts
+import { lstat, readFile as readFile3 } from "node:fs/promises";
 // src/utils.ts
 function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -15467,6 +15469,69 @@ function walkFiles(root, directory) {
   });
 }
 
+// src/commands/common.ts
+function fileFailure(error) {
+  return { exitCode: 1, output: fileErrorMessage(error) };
+}
+function fileErrorMessage(error) {
+  if (error instanceof PathKindError) {
+    return `✗ ${error.path}: Expected a ${error.expected}, found ${error.actual}`;
+  }
+  const path = error.reason instanceof SystemError ? `${error.reason.pathOrDescriptor}: ` : "";
+  return `✗ ${path}${error.reason.description ?? error.message}`;
+}
+function runProcess(executable, arguments_, cwd, environment) {
+  return gen2(function* () {
+    const spawner = yield* ChildProcessSpawner;
+    const command = make10(executable, [...arguments_], {
+      cwd,
+      env: environment ?? undefined,
+      extendEnv: true
+    });
+    const execution = yield* scoped2(gen2(function* () {
+      const handle = yield* spawner.spawn(command);
+      const [stdout, stderr, exitCode] = yield* all2([
+        handle.stdout.pipe(decodeText(), mkString),
+        handle.stderr.pipe(decodeText(), mkString),
+        handle.exitCode
+      ], { concurrency: "unbounded" });
+      return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode: Number(exitCode) };
+    })).pipe(result2);
+    if (isFailure2(execution)) {
+      const error = execution.failure instanceof PlatformError ? execution.failure.reason.description ?? execution.failure.message : getErrorMessage(execution.failure);
+      return { ok: false, error };
+    }
+    return {
+      ok: true,
+      ...execution.success,
+      output: [execution.success.stdout, execution.success.stderr].filter(Boolean).join(`
+`)
+    };
+  });
+}
+async function pathKind(path) {
+  try {
+    const info = await lstat(path);
+    return info.isFile() ? "file" : info.isDirectory() ? "directory" : "other";
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT")
+      return "missing";
+    throw error;
+  }
+}
+async function readOptionalFile(path) {
+  try {
+    return await readFile3(path, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
 // src/output.ts
 var import_cli_table3 = __toESM(require_table(), 1);
 var BORDERLESS = {
@@ -15825,9 +15890,6 @@ operator-helper install pi
 
 # Install DeepSeek Harness plugin
 operator-helper install deepseek
-
-# Install Code Puppy plugin
-operator-helper install code-puppy
 \`\`\`
 `;
 
@@ -16153,70 +16215,6 @@ function readTemplate(path) {
   return TEMPLATES[path];
 }
 
-// src/commands/common.ts
-import { lstat, readFile as readFile3 } from "node:fs/promises";
-function fileFailure(error) {
-  return { exitCode: 1, output: fileErrorMessage(error) };
-}
-function fileErrorMessage(error) {
-  if (error instanceof PathKindError) {
-    return `✗ ${error.path}: Expected a ${error.expected}, found ${error.actual}`;
-  }
-  const path = error.reason instanceof SystemError ? `${error.reason.pathOrDescriptor}: ` : "";
-  return `✗ ${path}${error.reason.description ?? error.message}`;
-}
-function runProcess(executable, arguments_, cwd, environment) {
-  return gen2(function* () {
-    const spawner = yield* ChildProcessSpawner;
-    const command = make10(executable, [...arguments_], {
-      cwd,
-      env: environment ?? undefined,
-      extendEnv: true
-    });
-    const execution = yield* scoped2(gen2(function* () {
-      const handle = yield* spawner.spawn(command);
-      const [stdout, stderr, exitCode] = yield* all2([
-        handle.stdout.pipe(decodeText(), mkString),
-        handle.stderr.pipe(decodeText(), mkString),
-        handle.exitCode
-      ], { concurrency: "unbounded" });
-      return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode: Number(exitCode) };
-    })).pipe(result2);
-    if (isFailure2(execution)) {
-      const error = execution.failure instanceof PlatformError ? execution.failure.reason.description ?? execution.failure.message : getErrorMessage(execution.failure);
-      return { ok: false, error };
-    }
-    return {
-      ok: true,
-      ...execution.success,
-      output: [execution.success.stdout, execution.success.stderr].filter(Boolean).join(`
-`)
-    };
-  });
-}
-async function pathKind(path) {
-  try {
-    const info = await lstat(path);
-    return info.isFile() ? "file" : info.isDirectory() ? "directory" : "other";
-  } catch (error) {
-    if (isNodeError(error) && error.code === "ENOENT")
-      return "missing";
-    throw error;
-  }
-}
-async function readOptionalFile(path) {
-  try {
-    return await readFile3(path, "utf8");
-  } catch (error) {
-    if (isNodeError(error) && error.code === "ENOENT")
-      return null;
-    throw error;
-  }
-}
-function isNodeError(error) {
-  return error instanceof Error && "code" in error;
-}
-
 // src/commands/index/init.ts
 var PARTITION_ROOTS = [".operator-shared", ".operator"];
 var indexInit = fn2("indexInit")((context) => gen2(function* () {
@@ -16424,83 +16422,62 @@ var indexLint = fn2("indexLint")(function* (context) {
   };
 });
 
-// src/commands/install/code-puppy.ts
-import { randomUUID } from "node:crypto";
-import { mkdir as mkdir2, readFile as readFile4, rename as rename3, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join2 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-var CODE_PUPPY_MARKER = `Operator Memory managed Code Puppy plugin.
-`;
-var CODE_PUPPY_MARKER_FILE = ".operator-managed";
-var installCodePuppy = fn2("installCodePuppy")(function* (context) {
-  return yield* promise2(async () => {
-    try {
-      const source = await readFile4(await codePuppyAdapterPath(), "utf8");
-      const plugins = join2(context.home, ".code_puppy", "plugins");
-      const target = join2(plugins, "operator");
-      const marker = join2(target, CODE_PUPPY_MARKER_FILE);
-      const callbacks = join2(target, "register_callbacks.py");
-      const targetKind = await pathKind(target);
-      if (targetKind === "missing") {
-        await mkdir2(plugins, { recursive: true });
-        const staged = `${target}.tmp-${randomUUID()}`;
-        try {
-          await mkdir2(staged);
-          await writeFile3(join2(staged, CODE_PUPPY_MARKER_FILE), CODE_PUPPY_MARKER);
-          await writeFile3(join2(staged, "register_callbacks.py"), source);
-          await rename3(staged, target);
-        } finally {
-          await rm2(staged, { recursive: true, force: true });
-        }
-        return { exitCode: 0, output: "✓ Code Puppy plugin installed" };
-      }
-      if (targetKind !== "directory" || await pathKind(marker) !== "file" || await readOptionalFile(marker) !== CODE_PUPPY_MARKER) {
-        return {
-          exitCode: 1,
-          output: `✗ Preserved unmanaged Code Puppy plugin at ${target}`
-        };
-      }
-      if (await readOptionalFile(callbacks) === source) {
-        return { exitCode: 0, output: "✓ Code Puppy plugin is current" };
-      }
-      const staged = `${callbacks}.tmp-${randomUUID()}`;
-      try {
-        await writeFile3(staged, source);
-        await rename3(staged, callbacks);
-      } finally {
-        await rm2(staged, { force: true });
-      }
-      return { exitCode: 0, output: "✓ Code Puppy plugin updated" };
-    } catch (error) {
-      return {
-        exitCode: 1,
-        output: `✗ Could not install Code Puppy plugin: ${getErrorMessage(error)}`
-      };
-    }
-  });
-});
-async function codePuppyAdapterPath() {
-  const candidates = [
-    new URL("./code-puppy/register_callbacks.py", import.meta.url),
-    new URL("../../../../code-puppy/operator/register_callbacks.py", import.meta.url)
+// src/commands/install/claude-code.ts
+var PLUGIN_ID = "operator@operator-memory";
+var installClaudeCode = fn2("installClaudeCode")(function* (context) {
+  const helper = yield* runProcess("operator-helper", ["help"], context.cwd, null);
+  const helperFailure = commandFailure(helper, "Operator Helper must be available on PATH");
+  if (helperFailure !== null)
+    return helperFailure;
+  const commands = [
+    ["plugin", "marketplace", "add", "aerovato/operator-memory"],
+    ["plugin", "install", PLUGIN_ID],
+    ["plugin", "update", PLUGIN_ID]
   ];
-  for (const candidate of candidates) {
-    const path = fileURLToPath2(candidate);
-    if (await pathKind(path) === "file") {
-      return path;
-    }
+  for (const arguments_ of commands) {
+    const result = yield* runProcess("claude", arguments_, context.cwd, null);
+    const failure = commandFailure(result, "Claude Code plugin installation failed");
+    if (failure !== null)
+      return failure;
+  }
+  const status = yield* runProcess("claude", ["plugin", "list", "--json"], context.cwd, null);
+  const statusFailure = commandFailure(status, "Could not verify Claude Code plugin installation");
+  if (statusFailure !== null)
+    return statusFailure;
+  if (!(status.ok && isInstalledAndEnabled(status.stdout))) {
+    return {
+      exitCode: 1,
+      output: "✗ Claude Code plugin installation finished but the plugin is not installed and enabled"
+    };
+  }
+  return {
+    exitCode: 0,
+    output: `✓ Claude Code plugin installed and enabled
+Start a new Claude Code session.`
+  };
+});
+function isInstalledAndEnabled(output) {
+  try {
+    const plugins = JSON.parse(output);
+    return Array.isArray(plugins) && plugins.some((plugin) => typeof plugin === "object" && plugin !== null && ("id" in plugin) && plugin.id === PLUGIN_ID && ("enabled" in plugin) && plugin.enabled === true);
+  } catch {
+    return false;
   }
-  throw new Error("bundled Code Puppy adapter is missing");
+}
+function commandFailure(result, fallback) {
+  if (!result.ok)
+    return { exitCode: 1, output: `✗ ${fallback}: ${result.error}` };
+  return result.exitCode === 0 ? null : { exitCode: result.exitCode, output: result.output || fallback };
 }
 
 // src/commands/install/codex.ts
-import { mkdir as mkdir3, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { mkdir as mkdir2, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join2 } from "node:path";
 var MARKETPLACE_MARKER = `Operator Memory managed Codex marketplace.
 `;
 var MARKETPLACE_NAME = "operator-memory";
 var PLUGIN_NAME = "aerovato";
-var PLUGIN_ID = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+var PLUGIN_ID2 = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
 var MARKETPLACE = `${JSON.stringify({
   name: MARKETPLACE_NAME,
   plugins: [
@@ -16524,20 +16501,20 @@ var installCodex = fn2("installCodex")(function* (context) {
   if (!addMarketplace.ok && isMissingBinary(addMarketplace.error)) {
     return yield* registerDesktopMarketplace(context, marketplace.path);
   }
-  const addFailure = commandFailure(addMarketplace, "Codex marketplace installation failed");
+  const addFailure = commandFailure2(addMarketplace, "Codex marketplace installation failed");
   if (addFailure !== null)
     return addFailure;
-  const install = yield* runProcess("codex", ["plugin", "add", PLUGIN_ID, "--json"], context.cwd, {
+  const install = yield* runProcess("codex", ["plugin", "add", PLUGIN_ID2, "--json"], context.cwd, {
     NPM_CONFIG_MIN_RELEASE_AGE: "0"
   });
-  const installFailure = commandFailure(install, "Codex plugin installation failed");
+  const installFailure = commandFailure2(install, "Codex plugin installation failed");
   if (installFailure !== null)
     return installFailure;
   const status = yield* runProcess("codex", ["plugin", "list", "--marketplace", MARKETPLACE_NAME, "--json"], context.cwd, { NPM_CONFIG_MIN_RELEASE_AGE: "0" });
-  const statusFailure = commandFailure(status, "Could not verify Codex plugin installation");
+  const statusFailure = commandFailure2(status, "Could not verify Codex plugin installation");
   if (statusFailure !== null)
     return statusFailure;
-  if (!(status.ok && isInstalledAndEnabled(status.stdout))) {
+  if (!(status.ok && isInstalledAndEnabled2(status.stdout))) {
     return {
       exitCode: 1,
       output: "✗ Codex plugin installation finished but the plugin is not installed and enabled"
@@ -16554,9 +16531,9 @@ var installCodex = fn2("installCodex")(function* (context) {
 });
 function writeMarketplace(home) {
   return promise2(async () => {
-    const root = join3(home, ".operator-helper", "codex-marketplace");
-    const marker = join3(root, ".operator-managed");
-    const marketplace = join3(root, ".agents", "plugins", "marketplace.json");
+    const root = join2(home, ".operator-helper", "codex-marketplace");
+    const marker = join2(root, ".operator-managed");
+    const marketplace = join2(root, ".agents", "plugins", "marketplace.json");
     try {
       const kind = await pathKind(root);
       if (kind !== "missing" && (kind !== "directory" || await readOptionalFile(marker) !== MARKETPLACE_MARKER)) {
@@ -16568,9 +16545,9 @@ function writeMarketplace(home) {
           }
         };
       }
-      await mkdir3(join3(root, ".agents", "plugins"), { recursive: true });
-      await writeFile4(marker, MARKETPLACE_MARKER);
-      await writeFile4(marketplace, MARKETPLACE);
+      await mkdir2(join2(root, ".agents", "plugins"), { recursive: true });
+      await writeFile3(marker, MARKETPLACE_MARKER);
+      await writeFile3(marketplace, MARKETPLACE);
       return { ok: true, path: root };
     } catch (error) {
       return {
@@ -16588,12 +16565,12 @@ function isMissingBinary(error) {
 }
 function registerDesktopMarketplace(context, marketplacePath) {
   return promise2(async () => {
-    const codexHome = process.env.CODEX_HOME || join3(context.home, ".codex");
-    const config = join3(codexHome, "config.toml");
+    const codexHome = process.env.CODEX_HOME || join2(context.home, ".codex");
+    const config = join2(codexHome, "config.toml");
     try {
       const content = await readOptionalFile(config);
-      await mkdir3(codexHome, { recursive: true });
-      await writeFile4(config, upsertMarketplaceTable(content, marketplacePath));
+      await mkdir2(codexHome, { recursive: true });
+      await writeFile3(config, upsertMarketplaceTable(content, marketplacePath));
     } catch (error) {
       return {
         exitCode: 1,
@@ -16645,18 +16622,18 @@ ${block}`;
 `), ...lines.slice(end)].join(`
 `);
 }
-function isInstalledAndEnabled(output) {
+function isInstalledAndEnabled2(output) {
   try {
     const value = JSON.parse(output);
     if (typeof value !== "object" || value === null || !("installed" in value))
       return false;
     const installed = value.installed;
-    return Array.isArray(installed) && installed.some((plugin) => typeof plugin === "object" && plugin !== null && ("pluginId" in plugin) && plugin.pluginId === PLUGIN_ID && ("installed" in plugin) && plugin.installed === true && ("enabled" in plugin) && plugin.enabled === true);
+    return Array.isArray(installed) && installed.some((plugin) => typeof plugin === "object" && plugin !== null && ("pluginId" in plugin) && plugin.pluginId === PLUGIN_ID2 && ("installed" in plugin) && plugin.installed === true && ("enabled" in plugin) && plugin.enabled === true);
   } catch {
     return false;
   }
 }
-function commandFailure(result, fallback) {
+function commandFailure2(result, fallback) {
   if (!result.ok)
     return { exitCode: 1, output: `✗ Could not run codex: ${result.error}` };
   return result.exitCode === 0 ? null : { exitCode: result.exitCode, output: result.output || fallback };
@@ -16750,7 +16727,7 @@ var installPi = fn2("installPi")(function* (context) {
 import { resolve as resolve2 } from "node:path";
 
 // ../core/src/memory/project.ts
-import { extname, join as join4, relative, sep } from "node:path";
+import { extname, join as join3, relative, sep } from "node:path";
 
 // ../core/src/utils.ts
 function success(value) {
@@ -16775,17 +16752,17 @@ function readString(value, key) {
 
 // ../core/src/memory/common.ts
 import { constants as constants2 } from "node:fs";
-import { access as access3, readdir, readFile as readFile5, stat as stat3 } from "node:fs/promises";
+import { access as access3, readdir, readFile as readFile4, stat as stat3 } from "node:fs/promises";
 async function readOptionalContent(path) {
   try {
-    return success(await readFile5(path, "utf8"));
+    return success(await readFile4(path, "utf8"));
   } catch (cause) {
     return hasNodeErrorCode(cause, "ENOENT") ? success(null) : failure({ path, cause });
   }
 }
 async function readContent(path) {
   try {
-    return success(await readFile5(path, "utf8"));
+    return success(await readFile4(path, "utf8"));
   } catch (cause) {
     return failure({ path, cause });
   }
@@ -16864,13 +16841,13 @@ async function loadProjectPartition(root, loadFiles) {
     return hasNodeErrorCode(directory.error.cause, "ENOENT") ? success(loadFiles ? { exists: false, operatorInstructions: null, catalog: null, indexes: [] } : { exists: false }) : directory;
   }
   if (!loadFiles) {
-    for (const path of [join4(root, "operator.md"), join4(root, "catalog.md")]) {
+    for (const path of [join3(root, "operator.md"), join3(root, "catalog.md")]) {
       const file = await checkOptionalReadableFile(path);
       if (!file.ok) {
         return file;
       }
     }
-    const indexRoot = join4(root, "index");
+    const indexRoot = join3(root, "index");
     const indexPaths = await listMarkdownFiles(indexRoot, indexRoot);
     if (!indexPaths.ok) {
       return indexPaths;
@@ -16883,15 +16860,15 @@ async function loadProjectPartition(root, loadFiles) {
     }
     return success({ exists: true });
   }
-  const operatorInstructions = await readOptionalContent(join4(root, "operator.md"));
+  const operatorInstructions = await readOptionalContent(join3(root, "operator.md"));
   if (!operatorInstructions.ok) {
     return operatorInstructions;
   }
-  const catalog = await readOptionalContent(join4(root, "catalog.md"));
+  const catalog = await readOptionalContent(join3(root, "catalog.md"));
   if (!catalog.ok) {
     return catalog;
   }
-  const indexes = await readIndexes(join4(root, "index"));
+  const indexes = await readIndexes(join3(root, "index"));
   if (!indexes.ok) {
     return indexes;
   }
@@ -16929,7 +16906,7 @@ async function listMarkdownFiles(root, directory) {
   }
   const paths = [];
   for (const entry of entries.value) {
-    const path = join4(directory, entry.name);
+    const path = join3(directory, entry.name);
     if (entry.isDirectory()) {
       const nestedPaths = await listMarkdownFiles(root, path);
       if (!nestedPaths.ok) {
@@ -16950,14 +16927,14 @@ function compareStrings2(left, right) {
 }
 
 // ../core/src/memory/user.ts
-import { join as join5 } from "node:path";
+import { join as join4 } from "node:path";
 async function loadUserPartition(root, loadFiles) {
   if (!loadFiles) {
     const directory = await readDirectory2(root);
     if (!directory.ok) {
       return hasNodeErrorCode(directory.error.cause, "ENOENT") ? success({ exists: false }) : directory;
     }
-    for (const path of [join5(root, "operator.md"), join5(root, "catalog.md")]) {
+    for (const path of [join4(root, "operator.md"), join4(root, "catalog.md")]) {
       const file = await checkOptionalReadableFile(path);
       if (!file.ok) {
         return file;
@@ -16965,11 +16942,11 @@ async function loadUserPartition(root, loadFiles) {
     }
     return success({ exists: true });
   }
-  const operatorInstructions = await readOptionalContent(join5(root, "operator.md"));
+  const operatorInstructions = await readOptionalContent(join4(root, "operator.md"));
   if (!operatorInstructions.ok) {
     return operatorInstructions;
   }
-  const catalog = await readOptionalContent(join5(root, "catalog.md"));
+  const catalog = await readOptionalContent(join4(root, "catalog.md"));
   if (!catalog.ok) {
     return catalog;
   }
@@ -17647,103 +17624,6 @@ var describeFile = fn2("describeFile")(function* (cwd, root, file, label) {
   ];
 });
 
-// src/commands/user/common.ts
-var USER_ROOT = "~/.operator/user";
-var USER_FILES = ["operator.md", "catalog.md"];
-
-// src/commands/user/init.ts
-var userInit = fn2("userInit")((context) => gen2(function* () {
-  const pathService = yield* Path;
-  const root = pathService.join(context.home, ".operator", "user");
-  yield* ensurePrivateDirectory(pathService.join(context.home, ".operator"));
-  const templates = {
-    "operator.md": readTemplate("user/operator.md" /* UserOperator */),
-    "catalog.md": readTemplate("user/catalog.md" /* UserCatalog */)
-  };
-  const rows = [];
-  let failed = false;
-  for (const file of USER_FILES) {
-    const written = yield* writeTextIfMissing(pathService.join(root, file), templates[file]).pipe(result2);
-    if (isFailure2(written)) {
-      failed = true;
-      rows.push(["Failed", `${USER_ROOT}/${file}: ${fileErrorMessage(written.failure)}`]);
-    } else {
-      rows.push([
-        written.success === "created" ? "Created" : "Preserved",
-        `${USER_ROOT}/${file}`
-      ]);
-    }
-  }
-  return {
-    exitCode: failed ? 1 : 0,
-    output: `✓ User Partition Initialized
-${renderTable(rows)}`
-  };
-}).pipe(catch_2((error) => succeed6(fileFailure(error))), map3((result) => ({
-  ...result,
-  output: `${result.output}
-
-Follow the agent instructions below to complete User Setup.
-
-${readTemplate("user/setup.md" /* UserSetup */)}`
-}))));
-
-// src/commands/user/status.ts
-var INIT_HINT = [
-  "For Users: Run `/operator:user-init` in your harness to initialize.",
-  "For Agents: Run `operator-helper user init` and follow the guide in its output."
-];
-var userStatus = fn2("userStatus")(function* (context) {
-  const pathService = yield* Path;
-  const root = pathService.join(context.home, ".operator", "user");
-  const kind = yield* inspectPath(root);
-  if (kind === "missing") {
-    return {
-      exitCode: 0,
-      output: [
-        `User Partition: ${USER_ROOT}`,
-        "",
-        "⚠ User Partition Missing",
-        renderTable([["Expected Location", `${USER_ROOT}/`]]),
-        "",
-        ...INIT_HINT
-      ].join(`
-`)
-    };
-  }
-  if (kind !== "directory") {
-    return yield* new PathKindError({
-      path: root,
-      expected: "directory",
-      actual: kind
-    });
-  }
-  const rows = [];
-  let missingCore = false;
-  for (const [file, label] of [
-    ["operator.md", "User Instructions"],
-    ["catalog.md", "User Catalog"]
-  ]) {
-    const content = yield* readOptionalText(pathService.join(root, file));
-    if (content === null) {
-      missingCore = true;
-    }
-    rows.push([
-      label,
-      content === null ? `Missing (${USER_ROOT}/${file})` : `${USER_ROOT}/${file} (${Buffer.byteLength(content)} bytes)`
-    ]);
-  }
-  const files = yield* listFiles(root);
-  const freeform = files.filter((file) => file.relativePath !== "operator.md" && file.relativePath !== "catalog.md");
-  rows.push(["Freeform Content", `${freeform.length} files`]);
-  const lines = [`User Partition: ${USER_ROOT}`, "", "✓ User Partition Found", renderTable(rows)];
-  if (missingCore) {
-    lines.push("", ...INIT_HINT);
-  }
-  return { exitCode: 0, output: lines.join(`
-`) };
-});
-
 // src/update.ts
 import { realpathSync } from "node:fs";
 import { sep as sep2 } from "node:path";
@@ -17897,6 +17777,103 @@ var upgrade = fn2("upgrade")(function* (context) {
   }
 });
 
+// src/commands/user/common.ts
+var USER_ROOT = "~/.operator/user";
+var USER_FILES = ["operator.md", "catalog.md"];
+
+// src/commands/user/init.ts
+var userInit = fn2("userInit")((context) => gen2(function* () {
+  const pathService = yield* Path;
+  const root = pathService.join(context.home, ".operator", "user");
+  yield* ensurePrivateDirectory(pathService.join(context.home, ".operator"));
+  const templates = {
+    "operator.md": readTemplate("user/operator.md" /* UserOperator */),
+    "catalog.md": readTemplate("user/catalog.md" /* UserCatalog */)
+  };
+  const rows = [];
+  let failed = false;
+  for (const file of USER_FILES) {
+    const written = yield* writeTextIfMissing(pathService.join(root, file), templates[file]).pipe(result2);
+    if (isFailure2(written)) {
+      failed = true;
+      rows.push(["Failed", `${USER_ROOT}/${file}: ${fileErrorMessage(written.failure)}`]);
+    } else {
+      rows.push([
+        written.success === "created" ? "Created" : "Preserved",
+        `${USER_ROOT}/${file}`
+      ]);
+    }
+  }
+  return {
+    exitCode: failed ? 1 : 0,
+    output: `✓ User Partition Initialized
+${renderTable(rows)}`
+  };
+}).pipe(catch_2((error) => succeed6(fileFailure(error))), map3((result) => ({
+  ...result,
+  output: `${result.output}
+
+Follow the agent instructions below to complete User Setup.
+
+${readTemplate("user/setup.md" /* UserSetup */)}`
+}))));
+
+// src/commands/user/status.ts
+var INIT_HINT = [
+  "For Users: Run `/operator:user-init` in your harness to initialize.",
+  "For Agents: Run `operator-helper user init` and follow the guide in its output."
+];
+var userStatus = fn2("userStatus")(function* (context) {
+  const pathService = yield* Path;
+  const root = pathService.join(context.home, ".operator", "user");
+  const kind = yield* inspectPath(root);
+  if (kind === "missing") {
+    return {
+      exitCode: 0,
+      output: [
+        `User Partition: ${USER_ROOT}`,
+        "",
+        "⚠ User Partition Missing",
+        renderTable([["Expected Location", `${USER_ROOT}/`]]),
+        "",
+        ...INIT_HINT
+      ].join(`
+`)
+    };
+  }
+  if (kind !== "directory") {
+    return yield* new PathKindError({
+      path: root,
+      expected: "directory",
+      actual: kind
+    });
+  }
+  const rows = [];
+  let missingCore = false;
+  for (const [file, label] of [
+    ["operator.md", "User Instructions"],
+    ["catalog.md", "User Catalog"]
+  ]) {
+    const content = yield* readOptionalText(pathService.join(root, file));
+    if (content === null) {
+      missingCore = true;
+    }
+    rows.push([
+      label,
+      content === null ? `Missing (${USER_ROOT}/${file})` : `${USER_ROOT}/${file} (${Buffer.byteLength(content)} bytes)`
+    ]);
+  }
+  const files = yield* listFiles(root);
+  const freeform = files.filter((file) => file.relativePath !== "operator.md" && file.relativePath !== "catalog.md");
+  rows.push(["Freeform Content", `${freeform.length} files`]);
+  const lines = [`User Partition: ${USER_ROOT}`, "", "✓ User Partition Found", renderTable(rows)];
+  if (missingCore) {
+    lines.push("", ...INIT_HINT);
+  }
+  return { exitCode: 0, output: lines.join(`
+`) };
+});
+
 // src/commands/version.ts
 var version = fn2("version")(function* (context) {
   const latest = yield* checkForUpdate(context.version).pipe(catch_2((error) => succeed6({ status: "failed", message: error.message })));
@@ -17928,7 +17905,7 @@ ${renderTable([
   ["install opencode-v2", "Install or update the OpenCode V2 plugin"],
   ["install deepseek", "Install or update the DeepSeek Harness plugin"],
   ["install pi", "Install or update the Pi plugin"],
-  ["install code-puppy", "Install or update the Code Puppy plugin"]
+  ["install claude-code", "Install or update the Claude Code plugin"]
 ])}
 
 AGENT COMMANDS
@@ -17979,6 +17956,8 @@ function runCli(arguments_, context) {
         return yield* memoryCheck(context);
       case "install codex":
         return yield* installCodex(context);
+      case "install claude-code":
+        return yield* installClaudeCode(context);
       case "install opencode":
         return yield* installOpenCode(context);
       case "install opencode-v2":
@@ -17987,8 +17966,6 @@ function runCli(arguments_, context) {
         return yield* installDeepSeek(context);
       case "install pi":
         return yield* installPi(context);
-      case "install code-puppy":
-        return yield* installCodePuppy(context);
       case "user guide":
       case "project guide":
       case "index guide":
@@ -18027,4 +18004,4 @@ var main = gen2(function* () {
 }).pipe(provide4(LiveLayers));
 runMain2(main);
 
-//# debugId=EB111CCB847C680664756E2164756E21
+//# debugId=FB1D99D1EABA3A2364756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aerovato/operator-helper",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "description": "Installation and setup CLI for Operator Memory",
   "license": "BSD-3-Clause",
   "author": "Aerovato Research",

package/dist/code-puppy/register_callbacks.py

@@ -1,407 +0,0 @@
-"""Operator Memory integration for Code Puppy."""
-
-from __future__ import annotations
-
-import asyncio
-import importlib.metadata
-import os
-import subprocess
-import threading
-from collections.abc import AsyncGenerator
-from contextlib import asynccontextmanager, suppress
-from typing import Any
-
-from code_puppy.callbacks import register_callback
-from code_puppy.config import get_current_session_name
-from code_puppy.messaging import emit_warning
-from code_puppy.tools.subagent_context import get_conversation_root_id
-from pydantic_ai import ModelRequest, RunContext, UserPromptPart
-from pydantic_ai.messages import ModelMessage, ModelResponse
-from pydantic_ai.models import (
-    KnownModelName,
-    Model,
-    ModelRequestParameters,
-    StreamedResponse,
-)
-from pydantic_ai.models.wrapper import WrapperModel
-from pydantic_ai.settings import ModelSettings
-
-_MARKER_KEY = "operator_memory"
-_MARKER_VALUE = "synthetic-preamble-v1"
-_MODEL_MESSAGE_TRANSFORM_VERSION = (0, 0, 753)
-
-try:
-    from code_puppy.callbacks import CustomCommandResult
-except ImportError:
-    try:
-        # Code Puppy < 0.0.698 exposes the same contract in the
-        # customizable-commands plugin.
-        from code_puppy.plugins.customizable_commands.register_callbacks import (
-            MarkdownCommandResult as CustomCommandResult,
-        )
-    except ImportError:
-        CustomCommandResult = None
-
-_RENDER_TIMEOUT_SECONDS = 30
-_render_tasks: dict[str, asyncio.Task[str]] = {}
-_update_launched = False
-
-_COMMANDS = {
-    "operator:user-init": (
-        "Initialize Operator User Instructions",
-        "user init",
-        "Follow the User Setup guide in its output, including when initialization reports failures.",
-    ),
-    "operator:project-init": (
-        "Initialize Operator Project",
-        "project init",
-        "Follow the Project Setup guide in its output, including when initialization reports failures.",
-    ),
-    "operator:index": (
-        "Build or refresh the Operator Project Index",
-        "index init",
-        "Follow the Project Index Setup guide in its output, including when inspection reports failures.",
-    ),
-    "operator:repair": (
-        "Repair Operator",
-        "memory check",
-        "If no issues are detected, stop. Otherwise, repair only the reported load "
-        "failures without initializing absent partitions. Rerun `operator-helper memory "
-        "check` to confirm the repair, then read the applicable Operator memory documents.",
-    ),
-}
-
-
-class OperatorModel(WrapperModel):
-    """Inject an immutable Operator preamble into final model requests."""
-
-    def __init__(self, wrapped: Model[Any] | KnownModelName, conversation_key: str):
-        super().__init__(wrapped)
-        self._conversation_key = conversation_key
-
-    async def request(
-        self,
-        messages: list[ModelMessage],
-        model_settings: ModelSettings | None,
-        model_request_parameters: ModelRequestParameters,
-    ) -> ModelResponse:
-        transformed = await _inject_preamble(messages, self._conversation_key)
-        return await self.wrapped.request(
-            transformed, model_settings, model_request_parameters
-        )
-
-    @asynccontextmanager
-    async def request_stream(
-        self,
-        messages: list[ModelMessage],
-        model_settings: ModelSettings | None,
-        model_request_parameters: ModelRequestParameters,
-        run_context: RunContext[Any] | None = None,
-    ) -> AsyncGenerator[StreamedResponse]:
-        transformed = await _inject_preamble(messages, self._conversation_key)
-        async with self.wrapped.request_stream(
-            transformed, model_settings, model_request_parameters, run_context
-        ) as response:
-            yield response
-
-
-async def _inject_preamble(
-    messages: list[ModelMessage], conversation_key: str
-) -> list[ModelMessage]:
-    preamble = await _get_preamble(conversation_key)
-    transformed = [message for message in messages if not _is_operator_request(message)]
-    transformed.insert(
-        0,
-        ModelRequest(
-            parts=[UserPromptPart(content=preamble)],
-            metadata={_MARKER_KEY: _MARKER_VALUE},
-        ),
-    )
-    return transformed
-
-
-async def _transform_model_messages(
-    _agent_name: str | None, messages: list[ModelMessage]
-) -> None:
-    messages[:] = await _inject_preamble(messages, _conversation_key())
-
-
-def _is_operator_request(message: ModelMessage) -> bool:
-    return (
-        isinstance(message, ModelRequest)
-        and message.metadata is not None
-        and message.metadata.get(_MARKER_KEY) == _MARKER_VALUE
-    )
-
-
-async def _get_preamble(conversation_key: str) -> str:
-    task = _render_tasks.get(conversation_key)
-    if task is None:
-        task = asyncio.create_task(_render_preamble(conversation_key))
-        _render_tasks[conversation_key] = task
-    return await asyncio.shield(task)
-
-
-async def _render_preamble(conversation_key: str) -> str:
-    process: asyncio.subprocess.Process | None = None
-    try:
-        process = await asyncio.create_subprocess_exec(
-            "operator-helper",
-            "preamble",
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-        stdout, stderr = await asyncio.wait_for(
-            process.communicate(), timeout=_RENDER_TIMEOUT_SECONDS
-        )
-        content = _remove_process_newline(stdout.decode(errors="replace"))
-        if process.returncode == 0 and content:
-            return content
-        detail = _remove_process_newline(stderr.decode(errors="replace"))
-        reason = detail or f"operator-helper exited with status {process.returncode}"
-    except asyncio.CancelledError:
-        if process is not None:
-            await _stop_process(process)
-        raise
-    except TimeoutError:
-        if process is not None:
-            await _stop_process(process)
-        reason = "operator-helper preamble timed out"
-    except OSError as error:
-        if process is not None:
-            await _stop_process(process)
-        reason = str(error)
-
-    emit_warning(
-        "Operator Memory could not render for this conversation. "
-        "Run `operator-helper install code-puppy` to repair the integration."
-    )
-    return (
-        "<operator-diagnostic>\n"
-        "Operator Memory could not render its preamble. Continue without Operator Memory, "
-        "help the user repair `operator-helper`, then ask them to start a new conversation.\n"
-        f"Failure: {reason}\n"
-        "</operator-diagnostic>"
-    )
-
-
-async def _stop_process(process: asyncio.subprocess.Process) -> None:
-    with suppress(ProcessLookupError):
-        process.kill()
-    await process.wait()
-
-
-def _remove_process_newline(value: str) -> str:
-    if value.endswith("\r\n"):
-        return value[:-2]
-    if value.endswith("\n"):
-        return value[:-1]
-    return value
-
-
-def _conversation_key() -> str:
-    return get_conversation_root_id() or get_current_session_name()
-
-
-def _installed_code_puppy_version() -> str | None:
-    try:
-        return importlib.metadata.version("code-puppy")
-    except Exception:
-        return None
-
-
-def _supports_model_message_transform(version: str | None) -> bool:
-    if version is None:
-        return False
-    release = version.partition("+")[0].partition("-")[0]
-    try:
-        parts = tuple(int(part) for part in release.split("."))
-    except ValueError:
-        return False
-    return parts >= _MODEL_MESSAGE_TRANSFORM_VERSION
-
-
-def _register_preamble_injection(version: str | None) -> None:
-    if _supports_model_message_transform(version):
-        register_callback("transform_model_messages", _transform_model_messages)
-    else:
-        register_callback("agent_run_context", _agent_run_context)
-
-
-@asynccontextmanager
-async def _agent_run_context(
-    _agent: Any, pydantic_agent: Any, _group_id: str, _mcp_servers: Any
-) -> AsyncGenerator[None]:
-    model = pydantic_agent.model
-    if model is None:
-        yield
-        return
-    if _is_dbos_agent(pydantic_agent):
-        _warn_dbos_incompatible()
-        yield
-        return
-    with pydantic_agent.override(model=OperatorModel(model, _conversation_key())):
-        yield
-
-
-def _is_dbos_agent(pydantic_agent: Any) -> bool:
-    # DBOSAgent installs its own captured DBOSModel through a nested
-    # override inside run(), which supersedes any override applied here.
-    # Duck-type: avoid importing the optional durable_exec module.
-    return hasattr(pydantic_agent, "_dbos_overrides")
-
-
-_DBOS_WARNED = False
-
-
-def _warn_dbos_incompatible() -> None:
-    global _DBOS_WARNED
-    if _DBOS_WARNED:
-        return
-    _DBOS_WARNED = True
-    emit_warning(
-        "Operator Memory preamble injection is disabled: DBOS durable execution "
-        "supersedes the model override it relies on. Disable DBOS to restore "
-        "Operator Memory: /set enable_dbos false, then restart Code Puppy."
-    )
-
-
-async def _session_end() -> None:
-    tasks = tuple(_render_tasks.values())
-    _render_tasks.clear()
-    for task in tasks:
-        task.cancel()
-    await asyncio.gather(*tasks, return_exceptions=True)
-
-
-def _custom_command(_command: str, name: str) -> CustomCommandResult | None:
-    definition = _COMMANDS.get(name)
-    if definition is None:
-        return None
-
-    description, operation, instructions = definition
-    return CustomCommandResult(
-        f"# {description}\n\n"
-        "1. Run `operator-helper version`. If an update is available, run "
-        "`operator-helper upgrade` before continuing.\n"
-        f"2. Run `operator-helper {operation}`. {instructions}\n\n"
-        "## Recovery\n\n"
-        "- If Helper cannot start, install or repair the npm package "
-        "`@aerovato/operator-helper` globally and retry the failed command.\n"
-        "- If the version check or upgrade fails, diagnose the error and retry.\n"
-        f"- If `operator-helper {operation}` reports a failure, use its output to "
-        "resolve it and rerun it as needed.\n"
-        "- If you cannot resolve a problem, report the blocker.\n\n"
-        "Use Helper output as working context. Do not reproduce it wholesale or "
-        "reimplement Helper logic."
-    )
-
-
-def _custom_command_help() -> list[tuple[str, str]]:
-    return [(name, definition[0]) for name, definition in _COMMANDS.items()]
-
-
-_UPDATE_NOTE = "Operator Updated · Restart Code Puppy to apply"
-_update_note_pending = False
-
-
-def _launch_update() -> None:
-    global _update_launched
-    if _update_launched:
-        return
-    _update_launched = True
-    try:
-        process = subprocess.Popen(
-            ("operator-helper", "install", "code-puppy"),
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.DEVNULL,
-            text=True,
-            creationflags=(
-                subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.DETACHED_PROCESS
-                if os.name == "nt"
-                else 0
-            ),
-            start_new_session=os.name != "nt",
-        )
-    except OSError:
-        return
-    threading.Thread(target=_monitor_update, args=(process,), daemon=True).start()
-
-
-def _monitor_update(process: subprocess.Popen[str]) -> None:
-    global _update_note_pending
-    try:
-        output = process.communicate()[0] or ""
-    except Exception:
-        return
-    if process.returncode == 0 and "plugin updated" in output:
-        _update_note_pending = True
-        _paint_status_indicator(_UPDATE_NOTE)
-        _emit_update_notice()
-
-
-def _emit_update_notice() -> None:
-    try:
-        from rich.text import Text
-
-        from code_puppy.messaging import emit_warning
-
-        notice = Text()
-        notice.append("Operator Updated · ", style="bold magenta")
-        notice.append("Restart Code Puppy to apply", style="magenta")
-        emit_warning(notice)
-    except Exception:
-        pass
-
-
-_STARTUP_INDICATOR = "Operator Ready"
-_STATUS_INDICATOR = "   Operator Ready"
-_active_runs = 0
-
-
-def _paint_status_indicator(text: str) -> None:
-    try:
-        from code_puppy.messaging.bottom_bar import get_bottom_bar
-
-        get_bottom_bar().set_status_suffix(text)
-    except Exception:
-        pass
-
-
-async def _show_status_indicator() -> None:
-    global _update_note_pending
-    if _update_note_pending:
-        _update_note_pending = False
-        return
-    _paint_status_indicator(_STARTUP_INDICATOR)
-
-
-async def _agent_run_start(*_args: Any) -> None:
-    global _active_runs
-    _active_runs += 1
-    _paint_status_indicator(_STATUS_INDICATOR)
-
-
-async def _agent_run_end(*_args: Any) -> None:
-    global _active_runs
-    _active_runs = max(0, _active_runs - 1)
-    if _active_runs == 0:
-        _paint_status_indicator("")
-
-
-_register_preamble_injection(_installed_code_puppy_version())
-register_callback("session_end", _session_end)
-if CustomCommandResult is not None:
-    register_callback("custom_command", _custom_command)
-    register_callback("custom_command_help", _custom_command_help)
-else:
-    emit_warning(
-        "Operator commands are disabled: this Code Puppy version is too old to "
-        "process command output as user input. Preamble injection still works. "
-        "Upgrade Code Puppy to enable the /operator:* commands."
-    )
-register_callback("startup", _show_status_indicator)
-register_callback("agent_run_start", _agent_run_start)
-register_callback("agent_run_end", _agent_run_end)
-_launch_update()