@aerovato/operator-helper 1.9.0 → 1.11.0

package/README.md

@@ -43,7 +43,7 @@ Restart the harness, then run `/operator:user-init` in a new conversation to beg
 
 ### Usage
 
-Users interact with Operator through the harness commands `/operator:user-init`, `/operator:project-init`, `/operator:index`, and `/operator:repair`. These commands guide the working agent, which uses Operator Helper for setup, status, validation, and repair mechanics.
+Users interact with Operator through the harness commands `/operator:user-init`, `/operator:project-init`, and `/operator:index`. These commands guide the working agent, which uses Operator Helper for setup, status, and validation.
 
 Run each Operator command in a new conversation so the agent can focus on that operation with a clean working context. Initialization preserves existing content. Project setup configures `.operator/` in the global Git ignore but does not automatically untrack files already committed.
 

package/dist/index.js

@@ -33,6 +33,19 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../node_modules/.bun/cli-table3@0.6.5/node_modules/cli-table3/src/debug.js
@@ -8659,6 +8672,20 @@ var require_public_api = __commonJS(function(exports) {
   exports.stringify = stringify;
 });
 
+// ../core/src/prompts/preamble-v1.ts
+var exports_preamble_v1 = {};
+__export(exports_preamble_v1, {
+  PREAMBLE_PROMPT: () => PREAMBLE_PROMPT,
+  PREAMBLE_TENETS: () => PREAMBLE_TENETS
+});
+
+// ../core/src/prompts/preamble-v2.ts
+var exports_preamble_v2 = {};
+__export(exports_preamble_v2, {
+  PREAMBLE_PROMPT: () => PREAMBLE_PROMPT2,
+  PREAMBLE_TENETS: () => PREAMBLE_TENETS2
+});
+
 // src/index.ts
 import { homedir } from "node:os";
 // ../../node_modules/.bun/effect@4.0.0-beta.107/node_modules/effect/dist/Pipeable.js
@@ -15319,7 +15346,7 @@ var log = (...args) => consoleWith((console2) => sync(() => {
 // package.json
 var package_default = {
   name: "@aerovato/operator-helper",
-  version: "1.9.0",
+  version: "1.11.0",
   description: "Installation and setup CLI for Operator Memory",
   license: "BSD-3-Clause",
   author: "Aerovato Research",
@@ -15509,16 +15536,6 @@ function runProcess(executable, arguments_, cwd, environment) {
     };
   });
 }
-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");
@@ -16479,37 +16496,21 @@ function commandFailure(result, fallback) {
 // src/commands/install/codex.ts
 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_SOURCE = "https://github.com/aerovato/operator-memory.git";
 var MARKETPLACE_NAME = "operator-memory";
-var PLUGIN_NAME = "aerovato";
-var PLUGIN_ID2 = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
-var MARKETPLACE = `${JSON.stringify({
-  name: MARKETPLACE_NAME,
-  plugins: [
-    {
-      name: PLUGIN_NAME,
-      source: {
-        source: "npm",
-        package: "@aerovato/operator-codex",
-        version: "latest"
-      },
-      policy: { installation: "AVAILABLE" }
-    }
-  ]
-}, null, 2)}
-`;
+var PLUGIN_ID2 = `aerovato@${MARKETPLACE_NAME}`;
 var installCodex = fn2("installCodex")(function* (context) {
-  const marketplace = yield* writeMarketplace(context.home);
-  if (!marketplace.ok)
-    return marketplace.result;
-  const addMarketplace = yield* runProcess("codex", ["plugin", "marketplace", "add", marketplace.path, "--json"], context.cwd, { NPM_CONFIG_MIN_RELEASE_AGE: "0" });
+  const addMarketplace = yield* runProcess("codex", ["plugin", "marketplace", "add", MARKETPLACE_SOURCE, "--ref", "main", "--json"], context.cwd, { NPM_CONFIG_MIN_RELEASE_AGE: "0" });
   if (!addMarketplace.ok && isMissingBinary(addMarketplace.error)) {
-    return yield* registerDesktopMarketplace(context, marketplace.path);
+    return yield* registerDesktopMarketplace(context);
   }
   const addFailure = commandFailure2(addMarketplace, "Codex marketplace installation failed");
   if (addFailure !== null)
     return addFailure;
+  const upgrade = yield* runProcess("codex", ["plugin", "marketplace", "upgrade", MARKETPLACE_NAME, "--json"], context.cwd, { NPM_CONFIG_MIN_RELEASE_AGE: "0" });
+  const upgradeFailure = commandFailure2(upgrade, "Codex marketplace upgrade failed");
+  if (upgradeFailure !== null)
+    return upgradeFailure;
   const install = yield* runProcess("codex", ["plugin", "add", PLUGIN_ID2, "--json"], context.cwd, {
     NPM_CONFIG_MIN_RELEASE_AGE: "0"
   });
@@ -16535,48 +16536,17 @@ var installCodex = fn2("installCodex")(function* (context) {
 `)
   };
 });
-function writeMarketplace(home) {
-  return promise2(async () => {
-    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)) {
-        return {
-          ok: false,
-          result: {
-            exitCode: 1,
-            output: `✗ Preserved unmanaged Codex marketplace at ${root}`
-          }
-        };
-      }
-      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 {
-        ok: false,
-        result: {
-          exitCode: 1,
-          output: `✗ Could not prepare Codex marketplace: ${getErrorMessage(error)}`
-        }
-      };
-    }
-  });
-}
 function isMissingBinary(error) {
   return error.startsWith("NotFound:");
 }
-function registerDesktopMarketplace(context, marketplacePath) {
+function registerDesktopMarketplace(context) {
   return promise2(async () => {
     const codexHome = process.env.CODEX_HOME || join2(context.home, ".codex");
     const config = join2(codexHome, "config.toml");
     try {
       const content = await readOptionalFile(config);
       await mkdir2(codexHome, { recursive: true });
-      await writeFile3(config, upsertMarketplaceTable(content, marketplacePath));
+      await writeFile3(config, upsertMarketplaceTable(content));
     } catch (error) {
       return {
         exitCode: 1,
@@ -16593,11 +16563,12 @@ function registerDesktopMarketplace(context, marketplacePath) {
     };
   });
 }
-function upsertMarketplaceTable(content, source) {
+function upsertMarketplaceTable(content) {
   const header = `[marketplaces.${MARKETPLACE_NAME}]`;
   const block = `${header}
-source_type = "local"
-source = ${JSON.stringify(source)}
+source_type = "git"
+source = ${JSON.stringify(MARKETPLACE_SOURCE)}
+ref = "main"
 `;
   if (content === null)
     return block;
@@ -16678,7 +16649,7 @@ function profileResult(profile, result) {
 }
 
 // src/commands/install/kiro.ts
-import { mkdir as mkdir3, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir3, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
 import { dirname as dirname2, join as join3 } from "node:path";
 
 // src/templates/kiro.ts
@@ -16749,26 +16720,12 @@ description: Build or refresh the Operator Project Index. Use only when the user
 If the Project Brain is missing, tell the user to invoke \`/operator-project-init\` to set it up.
 
 ${RECOVERY("index init")}`;
-var REPAIR = `---
-name: operator-repair
-description: Diagnose and repair Operator memory load failures. Use only when the user invokes /operator-repair.
----
-
-# Operator Memory Repair
-
-1. Run \`operator-helper version\`. If an update is available, run \`operator-helper upgrade\` before continuing.
-2. Run \`operator-helper 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.
-
-If \`~/.kiro/hooks/operator-memory.json\` or \`~/.kiro/steering/operator-memory.md\` is missing, tell the user to run \`operator-helper install kiro\` and start a new session.
-
-${RECOVERY("memory check")}`;
 var KIRO_FILES = [
   { path: "hooks/operator-memory.json", content: HOOK },
   { path: "steering/operator-memory.md", content: STEERING },
   { path: "skills/operator-user-init/SKILL.md", content: USER_INIT },
   { path: "skills/operator-project-init/SKILL.md", content: PROJECT_INIT },
-  { path: "skills/operator-index/SKILL.md", content: INDEX },
-  { path: "skills/operator-repair/SKILL.md", content: REPAIR }
+  { path: "skills/operator-index/SKILL.md", content: INDEX }
 ];
 
 // src/commands/install/kiro.ts
@@ -16788,6 +16745,7 @@ var installKiro = fn2("installKiro")(function* (context) {
 function writeKiroFiles(kiroHome) {
   return promise2(async () => {
     try {
+      await rm2(join3(kiroHome, "skills", "operator-repair", "SKILL.md"), { force: true });
       for (const file of KIRO_FILES) {
         const path = join3(kiroHome, file.path);
         await mkdir3(dirname2(path), { recursive: true });
@@ -17136,7 +17094,7 @@ var memoryCheck = fn2("memoryCheck")(function* (context) {
   }
   if (!failed) {
     lines.push(`
-No issues detected.`);
+No memory load failures detected.`);
   }
   return { exitCode: failed ? 1 : 0, output: lines.join(`
 `) };
@@ -17149,8 +17107,60 @@ function entries(snapshot) {
   ];
 }
 
-// ../core/src/prompts/preamble.ts
-var PREAMBLE_PROMPT = `<operator-guidance>
+// ../core/src/preamble-rollout.ts
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { platform } from "node:os";
+var ROLLOUT_NAMESPACE = "operator-preamble-rollout-v1:";
+function selectPreambleVersion() {
+  if (process.env.OPERATOR_PREAMBLE_BETA === "1") {
+    return "2.0";
+  }
+  const machineId = readMachineId();
+  if (machineId === null) {
+    return "1.1";
+  }
+  const bucket = createHash("sha256").update(`${ROLLOUT_NAMESPACE}${machineId}`).digest().readUInt32BE(0) % 100;
+  return bucket < 20 ? "2.0" : "1.1";
+}
+function readMachineId() {
+  try {
+    switch (platform()) {
+      case "linux": {
+        const value = readFileSync("/etc/machine-id", "utf8").trim().toLowerCase();
+        return /^[a-f0-9]{32}$/.test(value) && !/^0+$/.test(value) ? value : null;
+      }
+      case "darwin": {
+        const output = execFileSync("/usr/sbin/ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
+          encoding: "utf8",
+          timeout: 2000,
+          stdio: ["ignore", "pipe", "ignore"]
+        });
+        return normalizeUuid(output.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/)?.[1]);
+      }
+      case "win32": {
+        const output = execFileSync("reg.exe", ["query", "HKLM\\SOFTWARE\\Microsoft\\Cryptography", "/v", "MachineGuid", "/reg:64"], {
+          encoding: "utf8",
+          timeout: 2000,
+          stdio: ["ignore", "pipe", "ignore"]
+        });
+        return normalizeUuid(output.match(/MachineGuid\s+REG_SZ\s+(\S+)/i)?.[1]);
+      }
+      default:
+        return null;
+    }
+  } catch {
+    return null;
+  }
+}
+function normalizeUuid(value) {
+  const normalized = value?.toLowerCase();
+  return normalized !== undefined && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(normalized) && normalized !== "00000000-0000-0000-0000-000000000000" ? normalized : null;
+}
+
+// ../core/src/prompts/preamble-v1.ts
+var PREAMBLE_PROMPT = `<operator-guidance version="1.1">
 
 # Operator
 
@@ -17329,7 +17339,7 @@ Examples — record brain entries in scenarios like these:
 </example>
 
 </operator-guidance>`;
-var PREAMBLE_TENETS = `<operator-tenets>
+var PREAMBLE_TENETS = `<operator-tenets version="1.1">
 ## **REMEMBER: Core Tenets**
 
 <important>
@@ -17344,12 +17354,164 @@ var PREAMBLE_TENETS = `<operator-tenets>
 **You must remember these tenets and apply them while you work.**
 </operator-tenets>`;
 
+// ../core/src/prompts/preamble-v2.ts
+var PREAMBLE_PROMPT2 = `<operator-guidance version="2.0">
+
+# Operator
+
+You are working under **Operator by Aerovato Research**. Operator Memory is a plugin that gives you a human-readable **brain** on disk so knowledge survives your ephemeral conversation. **Consult and proactively maintain it** using the guidance below. This fixed preamble introduces the system; available memory follows.
+
+## The Brain
+
+\`\`\`
+Operator Memory
+├── User Partition (~/.operator/user/)         private; global; applies to all projects
+│   ├── operator.md      User Instructions
+│   ├── catalog.md       User Catalog
+│   └── …                Freeform user memory
+├── Project Private (.operator/)               private; local; default for new project work
+│   ├── index/           Project Index (codebase map)
+│   ├── operator.md      Operator Instructions
+│   ├── catalog.md       Project Partition Catalog (brain map)
+│   └── …                Freeform project brain
+└── Project Shared (.operator-shared/)         optional; published with the repo; team-wide knowledge
+    └── (same layout as Project Private)
+\`\`\`
+
+The User Partition is cross-project. The Project Brain consists of both Project Partitions, split into Private and Shared so local work and published knowledge stay distinct.
+
+---
+
+**Follow the memory-aware workflow:** user prompts → consult the Brain → do the work → update the Brain. Do not work from scratch when relevant memory exists or leave durable findings only in the conversation. Maintain the brain without user intervention.
+
+## Consult the Brain
+
+Before searching or opening files, use the context already injected below. Don't reread already injected files. Open additional context and freeform files when appropriate.
+
+- \`operator.md\` — always-loaded context and instructions, like a more sophisticated \`AGENTS.md\` file. Follow instruction authority: **Project Private > User > Project Shared**.
+- \`catalog.md\` — maps one partition's Brain documents. Root catalogs are injected; linked sub-catalogs and document bodies are not. **Follow matching Read If entries through sub-catalogs to relevant documents before exploring or implementing**. Don't skip reading because code or context seems sufficient; you'll need to update documents if truth changes. Read only what's needed.
+- \`index/*\`, \`index/index.md\` — project indexes; maps codebase structure and intent. Main index (\`index/index.md\`) and subindex listings are injected; read relevant subindexes for info; combine indexes with your other search tools before deep code reads.
+- Freeform Documents — brain knowledge. Specifications, guides, research, product vision, plans, skills, style guides, workflows, long-term memory, etc. Documents can be more than Markdown; images, folders, mini-repos, artifact-backed skills, etc.
+
+## Update the Brain
+
+Proactively preserve context, decisions, big-picture contracts, guides, conventions, rules, reused workflows, meta-requirements, etc., information future sessions will need. Preserve essential orientation and durable knowledge; do not duplicate implementation details. Do not restate implementation details, or document trivial changes. No bloating documents with minor tweaks.
+
+### Placement and Authority
+
+- Place project content per \`operator.md\` shared/private placement policy, else common sense and existing brain conventions, else Private. Record permanent share patterns in appropriate \`operator.md\`; don't leak private details in shared \`operator.md\`.
+- Modify the user partition when the user asks to remember or record project-agnostic content. Do not place project-specific facts, constraints, or instructions there. Do not infer personal traits or perferences from incidental behavior; only if repeated or stated explicitly by user.
+- **Shared must never reference private files, paths, or private-only material.** Private may reference Shared.
+- Keep one canonical home for each fact and partitions mostly mutually exclusive. Private instructions may override Shared instructions.
+
+### Operator Instructions
+
+Each partition has one \`operator.md\` for essential, always-loaded context and instructions. It should do everything an \`AGENTS.md\` file does but better.
+
+- Project: contains purpose, architectural overview, essential working context, and project rules, conventions, sharing policy, and more. Whatever needs to be loaded into context immediately, put here.
+  - **Proactively maintain established context; do not wait for a request to document it.**
+- User: contains relevant user background and context, response preferences, workflow, autonomy, engineering principles, working style, coding preferences, style guides, global operating instructions, global rules, global memory, inferred preferences, and more.
+
+Keep these files concise and structured for the user. Detailed or task-specific knowledge belongs in cataloged freeform files, not in an ever-growing \`operator.md\`.
+
+### Project Index
+
+- Every index file requires YAML \`description\` and \`read_if\`. The main index is \`<partition>/index/index.md\`, titled \`Private Project Index\` or \`Shared Project Index\`.
+- Maintain a sole existing index as the main map. If both partitions have indexes, Shared owns the publishable codebase map and Private owns private corpora; keep coverage mutually exclusive.
+- Update indexes after new or significantly changed code and proactively correct stale or missing entries as you learn.
+- For larger code bases: use main as index essential navigation and split large modules into subindexes linked from main tree. Add a private subindex and main-index link for cloned reference trees.
+- Cover every non-ignored path in scope; use a single directory entry for large or low-value trees. Omit build/cache/dependency directories unless relevant; include ignored paths only when useful.
+
+Main index (\`<partition>/index/index.md\`):
+
+\`\`\`markdown
+${PROJECT_INDEX_TEMPLATE.trimEnd()}
+\`\`\`
+
+Subindex (\`<partition>/index/**/*.md\`, excluding the main index):
+
+\`\`\`markdown
+${PROJECT_SUBINDEX_TEMPLATE.trimEnd()}
+\`\`\`
+
+General rules:
+
+- Index every non-ignored path in scope unless a directory is large or low-value — then one directory line only.
+- Generic/config files: \`Ditto\`. Similar files: one grouped bullet.
+- Link each subindex from the main tree; keep the main index must-know navigation, not a full dump of every package detail.
+- Omit build/cache/dependency directories unless relevant. Document ignored paths only when agents need them.
+- Brain documents and layout belong in catalogs, not codebase indexes.
+- Follow index shapes when seeding; never freehand your own structure.
+
+
+### Partition Catalogs
+
+Maintain one \`catalog.md\` per partition, updated whenever freeform content or layout changes. The catalog is an agent-maintained map of a partition's brain root. If a specific folder grows large, you may create a sub-catalog and link from main catalog.
+
+- Catalog that partition's Brain only: no repository source files, project \`index/\`, or other partitions' paths.
+- Every freeform document entry requires \`Description\` and \`Read If\`. Partition root \`operator.md\` and \`catalog.md\` entries use \`Read If: Auto-injected\`; non-root proceed as normal.
+- Group similar entries, use \`Ditto\` where obvious, and list large or low-value directories as a single entry.
+- For an artifact-backed skill folder, catalog only its entry file (e.g. \`powerpoint-builder/SKILL.md\`), not the folder or individual supporting artifacts. Similar for other larger folders. Use few sub-catalogs only where appropriate; but prefer to keep brain lean and self-contained.
+- Follow this exact shape; remove seed instructions, placeholders, and example content from finished catalogs.
+
+\`\`\`markdown
+${CATALOG_TEMPLATE.trimEnd()}
+\`\`\`
+
+### Freeform Brain
+
+Proactively preserve detailed knowledge in focused, cataloged documents. Suggested organization:
+
+- \`specs/\` — contracts, invariants, design decisions, requirements, expected behavior, documents code cannot own. Organized by feature, module, or system. Organize via subdirectories where appropriate.
+- \`guides/\` — reusable library, SDK, API, harness, and integration knowledge, including non-obvious and reusable findings from source exploration that will be used again. Create and record comprehensive guides, not one-off searches.
+- \`product/\` — user-established product intent, business vision, positioning, marketing, direction, and more, separate from implementation contracts.
+- Other documents and groupings you see fit. \`workflows/\`, \`research/\`, \`promo/\`, \`plans/\`, etc.
+
+Freeform can include supporting code and artifacts, not just Markdown. Scripts, instructions, workflows, entire skill packages or repos can live inside the brain. Keep documents cohesive: extend it for the same concern, create another for a different concern, and split or consolidate when needed. Do not give into inertia, but do not neurotically refactor after every change. Update the catalog when content or scope changes.
+
+**User-authored documents:** Certain instructions, workflows, or documents may be user authored or controlled; mark clearly if so, and do not change without user intent.
+
+**Cold starts:** After Operator is added to an existing project, the brain may hold little more than instructions, catalogs, and indexes. Still create small, reasonably scoped specs for features/systems you actually work on. Document even if the brain is new. Do not skip writing because the brain is empty, and do not invent, infer, or pad requirements to make a document feel complete. Do not give into inertia. Greenfield projects are not cold starts; document as you build.
+
+- **DO** proactively document in the freeform brain.
+- **DO** create a new spec when the work changes concern. Do not grow the first-feature spec into a catch-all contract.
+- **DO** update a spec only when the documented contract, invariant, or non-obvious decision changed. If existing clauses still hold, leave it. Naturally rewrite sentences instead of adding caveat or explanation paragraphs.
+- **DO** delete obsolete documentation after removing or simplifying features rather than replacing with commentary, caveats, or explanations. Document historical detail only if it's actually important.
+- **DO NOT** restate implementation details, inventory artifacts, or write file-by-file walkthroughs outside the Project Index. Concise purpose, architecture, and working-context overviews belong in \`operator.md\`, even when established from code.
+- **DO** preserve contracts, requirements, invariants, conventions, and other durable knowledge the code alone cannot convey.
+- **DO** keep the Partition Catalog in sync when freeform structure changes.
+
+Examples — record brain entries in scenarios like these:
+
+<example>
+- Durable contract, invariant, or convention the code does not make obvious (module, feature, or cross-cutting) → write or update a specification. If no single owner, use a shared architecture note.
+- User- or agent-defined decision, convention, or standard that should outlive this session → record it in the spec or work-area document that will enforce it. Do not leave it only in chat.
+- Deep dive into unfamiliar libraries, APIs, subsystems, or a cloned third-party tree that future work will reuse → write research notes or a focused guide. Add a private subindex if the source is cloned.
+- Integrating an external library, SDK, or product with non-obvious usage and no local notes → write an integration guide.
+- Trivial implementation changes, disposable exploration results, or guidance limited to the current task → do not add documentation unless an existing statement becomes outdated. Preserve lasting decisions even when stated or discovered only once. If long-term value is uncertain, ask the user.
+</example>
+
+</operator-guidance>`;
+var PREAMBLE_TENETS2 = `<operator-tenets version="2.0">
+## **REMEMBER: Core Tenets**
+
+<important>
+- **Run the memory-aware loop.** Consult relevant brain docs before you build; update it after you learn. Do not build from zero while a brain exists; do not leave durable knowledge unrecorded.
+- **Documents are truth and knowledge.** Read matching documents before every task. Update when details changes. Explore progressively. Do not default to reading everything.
+- **Persist durable, reusable knowledge.** Your context is ephemeral. You WILL forget everything after this session ends. Proactively maintain essential context: specs, decisions, guides, rules, findings, etc. in their canonical homes. Do not record task-local guidance or findings with no future usefulness. Permanent rules or definitely useful findings may be recorded in appropriate locations. If uncertain about long-term value, ask user whether to record.
+- **Keep memory current and lean.** Update changed contracts, resolve completed plans, and remove obsolete content without duplicating explanations or restating implementation. Outside of essential context or overviews, do not summarize or restate the code. Do not record paragraphs for minor tweaks. No edit sprawl; one home. Update naturally; state what is true now; no mentioning historical detail unless useful.
+</important>
+
+**You must remember these tenets and apply them while you work.**
+</operator-tenets>`;
+
 // ../core/src/preamble.ts
 var SHARED_ROOT = ".operator-shared";
 var PRIVATE_ROOT = ".operator";
 var USER_INSTRUCTIONS_PATH = "~/.operator/user/operator.md";
 var USER_CATALOG_PATH = "~/.operator/user/catalog.md";
 function renderPreamble(memory) {
+  const { PREAMBLE_PROMPT, PREAMBLE_TENETS } = selectPreambleVersion() === "2.0" ? exports_preamble_v2 : exports_preamble_v1;
   if (!memory.shared.ok || !memory.user.ok || !memory.private.ok) {
     return {
       content: `${PREAMBLE_PROMPT}
@@ -17425,12 +17587,19 @@ ${status("Shared", memory.shared)}
 ${status("User", memory.user)}
 ${status("Private", memory.private)}
 
-IMPORTANT: You MUST focus explicitly and exclusively on fixing Operator memory loading before proceeding with the user's requested work; otherwise, user and project instructions will not be loaded and you may not perform according to the user's wishes.
+IMPORTANT: You MUST resolve Operator memory loading before proceeding with the user's requested work. User and project instructions were not loaded.
+
+1. Run \`operator-helper version\`. If an update is available, run \`operator-helper upgrade\` before continuing.
+2. Run \`operator-helper memory check\` from the affected project directory to obtain current loading results.
+3. Repair only the reported load failures. Preserve existing content, do not initialize absent partitions, and do not reset or replace the Brain. If a repair requires deleting content, reconstructing instructions, or choosing between ambiguous fixes, stop and ask the user for guidance.
+4. Rerun \`operator-helper memory check\` after repairs. Resolve any additional load failures it reveals until the check succeeds or a concrete blocker prevents further progress.
 
-Use the error paths and causes above to repair the affected partitions, then run \`operator-helper memory check\` to validate the full load. \`operator-helper\` is the globally installed Operator CLI (npm package \`@aerovato/operator-helper\`), not a project dependency; it runs directly in any shell.
+\`operator-helper\` is the globally installed Operator CLI (npm package \`@aerovato/operator-helper\`), not a project dependency.
 
-- If the check succeeds: tell the user to start a new session and resubmit their original request so the next session loads the full preamble.
-- If you cannot resolve the loading failure: stop, ask the user for guidance, and suggest they run \`/operator:repair\` in a standalone session to perform self-repair.
+- If Helper cannot start, install or repair its global installation and retry the failed command.
+- If the version check or upgrade fails, diagnose the failure and retry.
+- If recovery is blocked, report the failing path or operation, the cause, and what is needed to continue. Do not proceed with the original task.
+- When validation succeeds, tell the user that loading is repaired and ask them to start a new session and resubmit their original request so the complete preamble is loaded. Do not resume the original task in this diagnostic-only session.
 </operator-diagnostic>`;
 }
 function renderInstructions(memory) {
@@ -18144,4 +18313,4 @@ var main = gen2(function* () {
 }).pipe(provide4(LiveLayers));
 runMain2(main);
 
-//# debugId=EFA6C78B3DF809B164756E2164756E21
+//# debugId=9837A2D60E03644D64756E2164756E21

package/package.json

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