@mycadet/assistant 0.12.7 → 0.12.9

package/src/plugins/defaults/index.ts

@@ -32,6 +32,7 @@ import { registerPlugin, resetPluginRegistryForTests } from "../registry.js";
 import { type Plugin, PluginExecutionError } from "../types.js";
 import { channelInjectors } from "./channel/injectors.js";
 import channelPkg from "./channel/package.json" with { type: "json" };
+import cloudHostedPkg from "./cloud-hosted/package.json" with { type: "json" };
 import compactionPkg from "./compaction/package.json" with { type: "json" };
 import { documentsInjectors } from "./documents/injectors.js";
 import documentsPkg from "./documents/package.json" with { type: "json" };
@@ -71,7 +72,6 @@ import memoryShutdown from "./memory/hooks/shutdown.js";
 import memoryUserPromptSubmit from "./memory/hooks/user-prompt-submit.js";
 import { memoryInjectors } from "./memory/injectors.js";
 import memoryPkg from "./memory/package.json" with { type: "json" };
-import platformHostedPkg from "./platform-hosted/package.json" with { type: "json" };
 import { sessionInjectors } from "./session/injectors.js";
 import sessionPkg from "./session/package.json" with { type: "json" };
 import surfaceCompletionNudgePostModelCall from "./surface-completion-nudge/hooks/post-model-call.js";
@@ -274,15 +274,15 @@ export const defaultSessionPlugin: Plugin = {
 };
 
 /**
- * `platform-hosted` — contributes the platform-hosted `/reengage` route. It
+ * `cloud-hosted` — contributes the cloud-hosted `/reengage` route. It
  * ships no hooks, tools, or injectors, so it registers as a manifest only;
  * the route source is served once the assistant dispatches default-plugin
  * routes.
  */
-export const defaultPlatformHostedPlugin: Plugin = {
+export const defaultCloudHostedPlugin: Plugin = {
   manifest: {
-    name: platformHostedPkg.name,
-    version: platformHostedPkg.version,
+    name: cloudHostedPkg.name,
+    version: cloudHostedPkg.version,
   },
 };
 
@@ -459,7 +459,7 @@ export function getAllDefaultPlugins(): readonly Plugin[] {
     defaultDocumentsPlugin,
     defaultChannelPlugin,
     defaultSessionPlugin,
-    defaultPlatformHostedPlugin,
+    defaultCloudHostedPlugin,
     defaultImageFallbackPlugin,
     defaultToolResultTruncatePlugin,
     defaultEmptyResponsePlugin,

package/src/plugins/defaults/main.ts

@@ -78,8 +78,8 @@ export function isFirstPartyDefaultPlugin(name: string): boolean {
 }
 
 /**
- * Manifest name (e.g. `default-platform-hosted`) for a default plugin's
- * *directory* name (e.g. `platform-hosted`), or `null` when `<dirName>` is not
+ * Manifest name (e.g. `default-cloud-hosted`) for a default plugin's
+ * *directory* name (e.g. `cloud-hosted`), or `null` when `<dirName>` is not
  * a default plugin. Memoized alongside {@link getAllDefaultPluginNames}.
  *
  * Default-plugin `.disabled` sentinels are keyed by the manifest name (the CLI
@@ -115,7 +115,7 @@ export function getDefaultPluginManifestName(dirName: string): string | null {
  * or `null` when `<name>` is not a default plugin's route namespace.
  *
  * A default plugin's route namespace is `default-<directory-name>` (e.g.
- * `default-platform-hosted`) — the same `default-…` name its `.disabled`
+ * `default-cloud-hosted`) — the same `default-…` name its `.disabled`
  * sentinel and per-chat scoping are keyed by. `<name>` is the namespace: the
  * `default-` prefix is stripped to recover the source directory, so a name
  * without the prefix (e.g. the bare directory name) resolves to `null`. The
@@ -140,7 +140,7 @@ export function getDefaultPluginRoutesDir(name: string): string | null {
 
 /**
  * Enumerate default plugins that ship a `routes/` directory, keyed by their
- * route namespace (`default-<directory-name>`, e.g. `default-platform-hosted`).
+ * route namespace (`default-<directory-name>`, e.g. `default-cloud-hosted`).
  * Mirrors {@link getDefaultPluginRoutesDir} so route discovery and dispatch
  * agree on which default plugin routes exist and under which namespace.
  */
@@ -166,7 +166,7 @@ export function getDefaultPluginRouteRoots(): {
 
 /**
  * Enumerate default plugins that ship a `skills/` directory, keyed by their
- * plugin name (`default-<directory-name>`, e.g. `default-platform-hosted`).
+ * plugin name (`default-<directory-name>`, e.g. `default-cloud-hosted`).
  * Each `skillsDir` holds the plugin's resident skills at `<id>/SKILL.md`, the
  * same layout an installed plugin uses under
  * `<workspaceDir>/plugins/<name>/skills/`.

package/src/plugins/defaults/memory/__tests__/memory-retrospective-job.test.ts

@@ -1007,7 +1007,7 @@ describe("memoryRetrospectiveJob", () => {
     ]);
   });
 
-  test("scaffold_managed_skill counts as durable work even with zero remembers", async () => {
+  test("scaffold_cloud_skill counts as durable work even with zero remembers", async () => {
     mockWakeResult = { invoked: true, exitReason: "no_tool_calls" };
     messagesByConversationId["fork-conv-1"] = [
       {
@@ -1016,7 +1016,7 @@ describe("memoryRetrospectiveJob", () => {
           {
             type: "tool_use",
             id: "tu-skill-1",
-            name: "scaffold_managed_skill",
+            name: "scaffold_cloud_skill",
             input: { name: "deploy-checklist" },
           },
         ]),
@@ -1343,7 +1343,7 @@ describe("memoryRetrospectiveJob", () => {
     const opts = wakeCalls[0]!.opts;
     expect(opts.allowedTools).toEqual([
       "remember",
-      "scaffold_managed_skill",
+      "scaffold_cloud_skill",
       "skill_load",
       "find_similar_skills",
     ]);
@@ -2616,7 +2616,7 @@ describe("memoryRetrospectiveJob", () => {
     );
     // None of the skill-authoring directives appear.
     expect(instructionText).not.toContain("find_similar_skills");
-    expect(instructionText).not.toContain("scaffold_managed_skill");
+    expect(instructionText).not.toContain("scaffold_cloud_skill");
     expect(instructionText).not.toContain("companion file");
     expect(instructionText).not.toContain("user-authored");
   });
@@ -2631,7 +2631,7 @@ describe("memoryRetrospectiveJob", () => {
     // Available-tools line names the skill-authoring pair; skill-management is
     // preactivated, so no `skill_load` step is instructed.
     expect(instructionText).toContain("find_similar_skills");
-    expect(instructionText).toContain("scaffold_managed_skill");
+    expect(instructionText).toContain("scaffold_cloud_skill");
     expect(instructionText).not.toContain("skill_load skill-management");
 
     // Permissive relevance pre-check keyed on actually-executed procedures.

package/src/plugins/defaults/memory/__tests__/memory-retrospective-prompt.test.ts

@@ -107,7 +107,7 @@ For everything else in your review window, use the \`remember\` tool on facts, p
   test("proc-to-skills active: tool line widens and the authoring section is appended", () => {
     const out = buildForkInstruction(makeArgs({ procToSkillsActive: true }));
     expect(out).toContain(
-      "Only `remember`, `find_similar_skills`, and `scaffold_managed_skill` are available for this pass",
+      "Only `remember`, `find_similar_skills`, and `scaffold_cloud_skill` are available for this pass",
     );
     // skill-management is preactivated for the wake, so the prompt no longer
     // instructs a `skill_load` step.

package/src/plugins/defaults/memory/__tests__/memory-retrospective-provider-path.test.ts

@@ -18,7 +18,7 @@
  *     `memory_retrospective_state`: the handler re-reads the fork's persisted
  *     rows (`collectRetrospectiveRunEvidence` → `loadRetrospectiveRunMessages`
  *     → `getMessages`) and only advances when THIS run persisted a durable
- *     memory-writing `tool_use` (`remember` / `scaffold_managed_skill`) or
+ *     memory-writing `tool_use` (`remember` / `scaffold_cloud_skill`) or
  *     replied and stopped on its own (a completed no-findings review).
  */
 

package/src/plugins/defaults/memory/__tests__/memory-tier-boundary-guard.test.ts

@@ -209,8 +209,13 @@ interface TierKeyExemption {
  *   tuning when building the graph view.
  * - `src/memory-v2-routes.ts` (v2) — the v2 tuning routes read and merge
  *   `memory.v2` config directly.
+ * - `config/substrate-twin-shadowing.ts` (substrate) — the operator-facing
+ *   twin detector: it reads substrate PRESENCE so a `memory.v2` write can
+ *   warn that the twin namespace wins. It never resolves a tunable itself —
+ *   resolution stays in `substrate/tuning.ts`.
  */
 const TIER_KEY_READ_ALLOWLIST: readonly TierKeyExemption[] = [
+  { path: "src/config/substrate-twin-shadowing.ts", keys: ["substrate"] },
   { path: "src/config/loader.ts", keys: ["v3"] },
   { path: "src/config/memory-v3-gate.ts", keys: ["v2", "v3"] },
   {

package/src/plugins/defaults/memory/config.ts

@@ -108,18 +108,18 @@ function deleteLeaf(
 
 /**
  * Deployment-context fill for the memory slice, mirroring the memory entry of
- * the host loader's `getDeploymentContextDefaults()`: platform-managed
- * assistants (IS_PLATFORM) embed via the managed gemini backend unless the
+ * the host loader's `getDeploymentContextDefaults()`: cloud-managed
+ * assistants (IS_CLOUD) embed via the cloud gemini backend unless the
  * provider leaf is explicitly set on disk. Kept local so this module does not
  * import the host loader (whose partial test mocks would otherwise break the
  * import); the parity test compares against the real loader under
- * IS_PLATFORM, so a divergent fill fails loudly there.
+ * IS_CLOUD, so a divergent fill fails loudly there.
  */
 function applyDeploymentContextFill(
   memory: MemoryConfig,
   raw: Record<string, unknown>,
 ): void {
-  if (process.env.IS_PLATFORM !== "true" && process.env.IS_PLATFORM !== "1") {
+  if (process.env.IS_CLOUD !== "true" && process.env.IS_CLOUD !== "1") {
     return;
   }
   const rawEmbeddings = raw.embeddings;

package/src/plugins/defaults/memory/memory-retrospective-constants.ts

@@ -65,7 +65,7 @@ export const SKILL_CARD_MESSAGE_KIND = "skill-authored-card";
  * Request-origin tag the fork wake stamps onto `ToolContext.requestOrigin`
  * (via the wake's tool-context pin). The permission checker scopes its
  * non-interactive skill-authoring auto-grant to this origin, so a retrospective
- * pass can call `scaffold_managed_skill` / `find_similar_skills` /
+ * pass can call `scaffold_cloud_skill` / `find_similar_skills` /
  * `skill_load skill-management` without an interactive approval prompt. Matches
  * the `"memory_retrospective"` member of `TitleOrigin`.
  */
@@ -73,7 +73,7 @@ export const MEMORY_RETROSPECTIVE_ORIGIN = "memory_retrospective";
 
 /**
  * Bundled skill that provides the retrospective's authoring tools
- * (`find_similar_skills`, `scaffold_managed_skill`, and the `skill_load`
+ * (`find_similar_skills`, `scaffold_cloud_skill`, and the `skill_load`
  * target). Preactivated for the fork wake so those tools join the turn's active
  * set from turn 1, and matched by the permission checker's origin-scoped grant.
  */

package/src/plugins/defaults/memory/memory-retrospective-job.ts

@@ -543,8 +543,8 @@ export async function runForkBasedRetrospective(
       trustContext: INTERNAL_GUARDIAN_TRUST_CONTEXT,
       callSite: "memoryRetrospective",
       // `remember` saves ordinary facts; the skill-authoring trio
-      // (`scaffold_managed_skill` / `skill_load` / `find_similar_skills`) lets a
-      // pass author or refine a managed skill from an observed procedure. The
+      // (`scaffold_cloud_skill` / `skill_load` / `find_similar_skills`) lets a
+      // pass author or refine a cloud skill from an observed procedure. The
       // allowlist is gated on the same `procToSkillsActive` predicate as the
       // fork instruction and the checker's origin-scoped grant, so an inactive
       // install is remember-only — the authoring trio is not even named on the
@@ -552,7 +552,7 @@ export async function runForkBasedRetrospective(
       allowedTools: procToSkillsActive
         ? [
             "remember",
-            "scaffold_managed_skill",
+            "scaffold_cloud_skill",
             "skill_load",
             "find_similar_skills",
           ]
@@ -584,7 +584,7 @@ export async function runForkBasedRetrospective(
           }
         : {}),
       // Preactivate skill-management so its authoring tools (`find_similar_skills`
-      // / `scaffold_managed_skill` / the `skill_load` target) are in the turn's
+      // / `scaffold_cloud_skill` / the `skill_load` target) are in the turn's
       // active set from turn 1; the checker's origin-scoped grant then makes them
       // callable without an interactive prompt. Same `procToSkillsActive` gate as
       // the allowlist above.
@@ -1042,7 +1042,7 @@ async function finalizeSuccessfulRetrospective(args: {
 
   // Skill cards are not a finalize concern: when the run authors a skill, the
   // scaffold executor enqueues the durable `skill_card_insert` delivery job at
-  // the creation site (see `executeScaffoldManagedSkill` and
+  // the creation site (see `executeScaffoldCloudSkill` and
   // `memory-retrospective-skill-card.ts`), so the GC below can never destroy
   // the card's inputs.
 
@@ -1246,13 +1246,13 @@ async function extractRetrospectiveRunRemembers(
 /**
  * Tool names whose persisted `tool_use` blocks count as durable memory work
  * for the fail-closed advancement gate: `remember` writes the memory buffer,
- * `scaffold_managed_skill` writes a managed skill. Read-only tools on the
+ * `scaffold_cloud_skill` writes a cloud skill. Read-only tools on the
  * retrospective allowlist (`skill_load`, `find_similar_skills`) deliberately
  * do not qualify: a run that only browsed produced nothing durable.
  */
 const DURABLE_RETROSPECTIVE_TOOLS: ReadonlySet<string> = new Set([
   "remember",
-  "scaffold_managed_skill",
+  "scaffold_cloud_skill",
 ]);
 
 /**

package/src/plugins/defaults/memory/memory-retrospective-prompt.ts

@@ -176,7 +176,7 @@ export function buildForkInstruction({
     : `Your review window starts at ${anchorDescription} and ends just before this instruction message. If you cannot locate that anchoring turn in your visible history (for example, it is behind the compaction summary), fail closed: review only the most recent visible messages after the summary, not the whole conversation.`;
 
   const availableToolsLine = procToSkillsActive
-    ? "Only `remember`, `find_similar_skills`, and `scaffold_managed_skill` are available for this pass — any other tool call will be rejected, so don't attempt one."
+    ? "Only `remember`, `find_similar_skills`, and `scaffold_cloud_skill` are available for this pass — any other tool call will be rejected, so don't attempt one."
     : "Only the `remember` tool is available for this pass — any other tool call will be rejected, so don't attempt one.";
 
   const override = loadPromptOverride({
@@ -211,7 +211,7 @@ export function buildForkInstruction({
 /**
  * Skill-authoring addendum appended to the fork instruction when
  * procedural-memory-as-skills is active. Directs the pass to capture a
- * genuinely-executed, reusable procedure as a managed skill — but only to
+ * genuinely-executed, reusable procedure as a cloud skill — but only to
  * overwrite or refine a skill it authored, never to overwrite or shadow a
  * skill of any other source.
  */
@@ -219,13 +219,13 @@ function buildSkillAuthoringSection(): string {
   return `
 ---
 
-If your review window contains a PROCEDURE you actually carried out — a sequence of real \`tool_use\` steps you executed (not merely discussed or planned) that is plausibly worth reusing later — also consider capturing it as a managed skill. Keep this bar low: when in doubt and the procedure looks reusable, author it. If the window contains no executed, reusable procedure, skip this entirely and just \`remember\` as above.
+If your review window contains a PROCEDURE you actually carried out — a sequence of real \`tool_use\` steps you executed (not merely discussed or planned) that is plausibly worth reusing later — also consider capturing it as a cloud skill. Keep this bar low: when in doubt and the procedure looks reusable, author it. If the window contains no executed, reusable procedure, skip this entirely and just \`remember\` as above.
 
 When you do capture a procedure:
 
-1. Deduplicate against existing skills first. Call \`find_similar_skills\` with the procedure's goal as its \`goal\` argument. Each hit carries a \`source\` (bundled, managed, plugin, workspace, or extra), and a managed hit also carries \`author\` (\`"assistant"\` if you authored it, \`"user"\` if a person did, omitted if untagged). You may only overwrite or refine a skill YOU authored: a hit with \`source: "managed"\` AND \`author: "assistant"\`. ANY other hit means the procedure is ALREADY COVERED: a non-managed source (bundled, plugin, workspace, or extra), OR a managed skill that is NOT \`author: "assistant"\` (a person wrote it, or it is untagged). For an ALREADY COVERED hit do not \`overwrite\` it, do not shadow it by creating a skill with its \`skill_id\`, and do not create a near-duplicate. Skip it. Only when a returned skill is one of your own (\`source: "managed"\`, \`author: "assistant"\`) and is the SAME procedure, UPDATE it. Such a hit carries \`current\`: the skill as it is now, in \`scaffold_managed_skill\`'s own argument names. Call \`scaffold_managed_skill\` with that \`skill_id\` and \`overwrite: true\`, rewriting \`body_markdown\` from \`current.body_markdown\` plus what you actually observed in the trace (keep the steps the trace did not contradict; correct or add the ones it did), restate \`current.activation_hints\` (revised only if the procedure's triggers changed; they are the skill's retrieval signal, not something to regenerate) and leave out any other \`current\` field you are not changing (\`emoji\`, \`category\`, \`includes\`, \`avoid_when\`): an omitted field keeps its current value and an empty one clears it, and pass \`change_summary\` (the update is rejected without it): one or two short sentences (under 200 characters) for the person who reads the "Skill updated" notice, naming what you changed and what in the trace prompted it (for example "Added the retry after an expired session and the export endpoint that held steady."). The notice shows nothing else about the change, so name the concrete step, value, or gotcha rather than saying the skill was refined. Only CREATE a new skill (fresh \`skill_id\`) when no existing skill of any source covers the procedure. Bias strongly toward reusing or refining your own skills over spawning near-duplicates.
+1. Deduplicate against existing skills first. Call \`find_similar_skills\` with the procedure's goal as its \`goal\` argument. Each hit carries a \`source\` (bundled, managed, plugin, workspace, or extra), and a cloud hit also carries \`author\` (\`"assistant"\` if you authored it, \`"user"\` if a person did, omitted if untagged). You may only overwrite or refine a skill YOU authored: a hit with \`source: "managed"\` AND \`author: "assistant"\`. ANY other hit means the procedure is ALREADY COVERED: a non-managed source (bundled, plugin, workspace, or extra), OR a cloud skill that is NOT \`author: "assistant"\` (a person wrote it, or it is untagged). For an ALREADY COVERED hit do not \`overwrite\` it, do not shadow it by creating a skill with its \`skill_id\`, and do not create a near-duplicate. Skip it. Only when a returned skill is one of your own (\`source: "managed"\`, \`author: "assistant"\`) and is the SAME procedure, UPDATE it. Such a hit carries \`current\`: the skill as it is now, in \`scaffold_cloud_skill\`'s own argument names. Call \`scaffold_cloud_skill\` with that \`skill_id\` and \`overwrite: true\`, rewriting \`body_markdown\` from \`current.body_markdown\` plus what you actually observed in the trace (keep the steps the trace did not contradict; correct or add the ones it did), restate \`current.activation_hints\` (revised only if the procedure's triggers changed; they are the skill's retrieval signal, not something to regenerate) and leave out any other \`current\` field you are not changing (\`emoji\`, \`category\`, \`includes\`, \`avoid_when\`): an omitted field keeps its current value and an empty one clears it, and pass \`change_summary\` (the update is rejected without it): one or two short sentences (under 200 characters) for the person who reads the "Skill updated" notice, naming what you changed and what in the trace prompted it (for example "Added the retry after an expired session and the export endpoint that held steady."). The notice shows nothing else about the change, so name the concrete step, value, or gotcha rather than saying the skill was refined. Only CREATE a new skill (fresh \`skill_id\`) when no existing skill of any source covers the procedure. Bias strongly toward reusing or refining your own skills over spawning near-duplicates.
 
-2. Capture procedure-scoped knowledge alongside the body. Failure modes, gotchas, and cached values you observed in the trace (error signatures and how you recovered, preconditions, IDs/paths/endpoints that held steady) belong in companion files passed via \`scaffold_managed_skill\`'s \`files\` input (for example \`references/failure-modes.md\`), and the SKILL.md body should reference them so a future load surfaces them.
+2. Capture procedure-scoped knowledge alongside the body. Failure modes, gotchas, and cached values you observed in the trace (error signatures and how you recovered, preconditions, IDs/paths/endpoints that held steady) belong in companion files passed via \`scaffold_cloud_skill\`'s \`files\` input (for example \`references/failure-modes.md\`), and the SKILL.md body should reference them so a future load surfaces them.
 
 3. Extract code you actually ran into reusable \`scripts/\` companion files. When the trace shows a script or non-trivial snippet you executed successfully (\`python3\` or \`bun\` — the only runtimes present), save that exact code verbatim as a companion file (for example \`scripts/export-report.py\`) — never a reconstruction of code the trace does not prove ran. When the trace shows the file's absolute path (workspace or /tmp), pass it as the entry's \`copy_from\` instead of re-typing the contents; inline \`content\` only when the code survives nowhere but the trace. Have the body give the literal rerun command anchored with \`{baseDir}\` (for example \`python3 {baseDir}/scripts/export-report.py\`); it resolves to the skill folder on load, and the terminal does not run from there. A stored working script beats re-deriving the code on every future use.
 

package/src/plugins/defaults/memory/memory-retrospective-skill-card.ts

@@ -2,8 +2,8 @@
 // Memory retrospective — skill-authored card delivery.
 // ---------------------------------------------------------------------------
 //
-// When a retrospective pass genuinely CREATES a managed skill, the scaffold
-// executor (`executeScaffoldManagedSkill`) enqueues a durable
+// When a retrospective pass genuinely CREATES a cloud skill, the scaffold
+// executor (`executeScaffoldCloudSkill`) enqueues a durable
 // `skill_card_insert` job at the creation site — the executor knows
 // created-vs-overwrote, the request origin, and the fork-parent source
 // conversation as facts, so no message archaeology is needed. This module

package/src/plugins/defaults/memory/src/__tests__/memory-v2-routes.test.ts

@@ -80,7 +80,7 @@ describe("memory_v2_list_concept_pages handler", () => {
       {
         slug: "people/carol",
         frontmatter: { edges: ["alice"], ref_files: [], ref_urls: [] },
-        body: "Carol leads the platform team.\n",
+        body: "Carol leads the cloud team.\n",
       },
     ];
     for (const page of pages) {

package/src/plugins/defaults/memory/src/__tests__/memory-worker-routes.test.ts

@@ -155,7 +155,7 @@ describe("memory_worker_status", () => {
     expect(res).toMatchObject({ status: "not_running" });
   });
 
-  test("surfaces the local embedding backend (the default non-platform provider)", async () => {
+  test("surfaces the local embedding backend (the default non-cloud provider)", async () => {
     backendStatus = {
       enabled: true,
       degraded: false,

package/src/plugins/defaults/memory/substrate/__tests__/boot-maintenance.test.ts

@@ -1,14 +1,14 @@
 /**
  * Tests for the boot-maintenance helpers in `boot-maintenance.ts`:
  *
- * - `maybeReseedCapabilitiesAfterManagedCredential`: the secrets route calls
- *   this when a managed-proxy credential lands, to close the first-boot race
+ * - `maybeReseedCapabilitiesAfterCloudCredential`: the secrets route calls
+ *   this when a cloud-proxy credential lands, to close the first-boot race
  *   where the daemon's startup capability seed (skills + CLI commands) runs
- *   before the platform provisions the managed embedding credential — the
+ *   before the cloud provisions the cloud embedding credential — the
  *   seed's embed throws and the synthetic capability pages never reach the
  *   page index. The reseed must fire only when the substrate is active AND the
- *   managed-proxy prerequisites are now satisfied, so self-hosted / BYOK
- *   assistants (no managed proxy) are never made to run a doomed embed. When
+ *   cloud-proxy prerequisites are now satisfied, so self-hosted / BYOK
+ *   assistants (no cloud proxy) are never made to run a doomed embed. When
  *   v3 is live it then enqueues a `memory_v3_maintain` job so v3 picks up the
  *   capability pages immediately instead of waiting out the 6h maintain
  *   backstop.
@@ -67,8 +67,8 @@ const pageStoreDelegates: {
   hasConceptPages: async () => true,
 };
 
-mock.module("../../../../../providers/platform-proxy/context.js", () => ({
-  hasManagedProxyPrereqs: async () => proxyState.prereqs,
+mock.module("../../../../../providers/cloud-proxy/context.js", () => ({
+  hasCloudProxyPrereqs: async () => proxyState.prereqs,
 }));
 
 // `config/memory-v3-gate.js` is deliberately NOT mocked. It is pure (its only
@@ -115,7 +115,7 @@ mock.module("../../../../../daemon/embedding-reconcile.js", () => ({
 
 const {
   maybeRebuildConceptCollection,
-  maybeReseedCapabilitiesAfterManagedCredential,
+  maybeReseedCapabilitiesAfterCloudCredential,
 } = await import("../boot-maintenance.js");
 
 /**
@@ -156,11 +156,11 @@ afterEach(() => {
   proxyState.prereqs = true;
 });
 
-describe("maybeReseedCapabilitiesAfterManagedCredential", () => {
-  test("reseeds both skill and CLI entries when v2 is enabled and managed-proxy prereqs are satisfied", async () => {
+describe("maybeReseedCapabilitiesAfterCloudCredential", () => {
+  test("reseeds both skill and CLI entries when v2 is enabled and cloud-proxy prereqs are satisfied", async () => {
     proxyState.prereqs = true;
 
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
+    await maybeReseedCapabilitiesAfterCloudCredential(configWithV2(true));
 
     expect(seedSkill).toHaveBeenCalledTimes(1);
     expect(seedCli).toHaveBeenCalledTimes(1);
@@ -169,7 +169,7 @@ describe("maybeReseedCapabilitiesAfterManagedCredential", () => {
   test("enqueues a v3 maintain pass after reseeding when v3 is live", async () => {
     proxyState.prereqs = true;
 
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV3());
+    await maybeReseedCapabilitiesAfterCloudCredential(configWithV3());
 
     expect(enqueueJob).toHaveBeenCalledTimes(1);
     expect(enqueueJob).toHaveBeenCalledWith("memory_v3_maintain", {});
@@ -178,7 +178,7 @@ describe("maybeReseedCapabilitiesAfterManagedCredential", () => {
   test("reseeds but does not enqueue a v3 maintain pass when v3 is not live", async () => {
     proxyState.prereqs = true;
 
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
+    await maybeReseedCapabilitiesAfterCloudCredential(configWithV2(true));
 
     expect(seedSkill).toHaveBeenCalledTimes(1);
     expect(seedCli).toHaveBeenCalledTimes(1);
@@ -186,17 +186,17 @@ describe("maybeReseedCapabilitiesAfterManagedCredential", () => {
   });
 
   test("no-op when v2 memory is disabled", async () => {
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(false));
+    await maybeReseedCapabilitiesAfterCloudCredential(configWithV2(false));
 
     expect(seedSkill).not.toHaveBeenCalled();
     expect(seedCli).not.toHaveBeenCalled();
     expect(enqueueJob).not.toHaveBeenCalled();
   });
 
-  test("no-op for non-managed assistants (managed-proxy prereqs not satisfied)", async () => {
+  test("no-op for non-cloud assistants (cloud-proxy prereqs not satisfied)", async () => {
     proxyState.prereqs = false;
 
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
+    await maybeReseedCapabilitiesAfterCloudCredential(configWithV2(true));
 
     expect(seedSkill).not.toHaveBeenCalled();
     expect(seedCli).not.toHaveBeenCalled();
@@ -211,7 +211,7 @@ describe("maybeReseedCapabilitiesAfterManagedCredential", () => {
 
     // Must not reject — the helper contains each seed's failure so a doomed
     // embed never propagates back to the credential-store caller.
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
+    await maybeReseedCapabilitiesAfterCloudCredential(configWithV2(true));
 
     expect(seedCli).toHaveBeenCalledTimes(1);
   });
@@ -222,7 +222,7 @@ describe("maybeReseedCapabilitiesAfterManagedCredential", () => {
       throw new Error('Embedding backend "gemini" is not configured');
     });
 
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV3());
+    await maybeReseedCapabilitiesAfterCloudCredential(configWithV3());
 
     // The CLI catalog seeded, so v3 must still rebuild its lanes — a single
     // catalog failure cannot suppress the maintain pass.
@@ -237,7 +237,7 @@ describe("maybeReseedCapabilitiesAfterManagedCredential", () => {
     // the field. The CLI reseed completes normally.
     seedSkill.mockImplementationOnce(() => new Promise<void>(() => {}));
 
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV3(), {
+    await maybeReseedCapabilitiesAfterCloudCredential(configWithV3(), {
       reseedTimeoutMs: 20,
     });
 
@@ -258,7 +258,7 @@ describe("maybeReseedCapabilitiesAfterManagedCredential", () => {
         }),
     );
 
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV3(), {
+    await maybeReseedCapabilitiesAfterCloudCredential(configWithV3(), {
       reseedTimeoutMs: 10,
     });
 

package/src/plugins/defaults/memory/substrate/__tests__/cli-command-store.test.ts

@@ -324,7 +324,7 @@ describe("seedV2CliCommandEntries", () => {
   });
 
   test("populates the cache from the declarative help on the first seed even when the embedding backend is unavailable (cold-start needle resilience)", async () => {
-    // Cold-start race: the startup seed runs before the managed embedding
+    // Cold-start race: the startup seed runs before the cloud embedding
     // credential is provisioned, so the first `embedWithBackend` throws. The
     // in-memory cache (read by the v3 needle lane and the page index) must
     // still populate from the declarative help so CLI commands are

package/src/plugins/defaults/memory/substrate/__tests__/skill-store.test.ts

@@ -691,8 +691,8 @@ Write a local article draft.
   });
 
   test("populates the cache from the local catalog on the first seed even when the embedding backend is unavailable (cold-start needle resilience)", async () => {
-    // Regression: on a brand-new managed assistant the startup seed runs before
-    // the platform provisions the managed embedding credential, so the very
+    // Regression: on a brand-new cloud assistant the startup seed runs before
+    // the cloud provisions the cloud embedding credential, so the very
     // first `embedWithBackend` throws. The in-memory cache (which the v3 needle
     // lane and the page index read) must still populate from the local catalog
     // so skills are discoverable from first boot; only the dense Qdrant upsert
@@ -724,7 +724,7 @@ Write a local article draft.
   });
 
   test("surfaces the dense-embed failure to throwOnError callers while still populating the needle cache", async () => {
-    // The managed-credential reseed and the operator reembed route pass
+    // The cloud-credential reseed and the operator reembed route pass
     // `throwOnError` so they learn the dense lane didn't complete and the
     // retry/maintain machinery backfills it — but the needle cache is fixed
     // regardless before the error propagates.

package/src/plugins/defaults/memory/substrate/boot-maintenance.ts

@@ -58,10 +58,10 @@ export function maybeSeedCliCommandCards(config: AssistantConfig): void {
 
 /**
  * Default upper bound on how long
- * {@link maybeReseedCapabilitiesAfterManagedCredential} waits for the capability
+ * {@link maybeReseedCapabilitiesAfterCloudCredential} waits for the capability
  * reseeds before enqueuing the v3 maintain pass. The reseeds keep running
  * detached past this bound — it only stops the barrier from waiting on a wedged
- * catalog (a stalled `getCatalog()` or a managed-proxy embed that never
+ * catalog (a stalled `getCatalog()` or a cloud-proxy embed that never
  * returns). A straggler that finishes later re-enqueues maintain.
  */
 const RESEED_BARRIER_TIMEOUT_MS = 120_000;
@@ -89,13 +89,13 @@ async function settledWithin(
 }
 
 /**
- * Re-seed the v2 skill and CLI-command capability entries once a managed-proxy
+ * Re-seed the v2 skill and CLI-command capability entries once a cloud-proxy
  * credential lands, closing the first-boot race where the daemon's startup seed
- * runs before the platform has provisioned the managed embedding credential.
+ * runs before the cloud has provisioned the cloud embedding credential.
  *
- * On a brand-new managed assistant the memory worker fires the startup seed
+ * On a brand-new cloud assistant the memory worker fires the startup seed
  * (`maybeSeedCapabilitySkills` / `maybeSeedCliCommandCards`) seconds after
- * boot, but the platform pushes `cadet:assistant_api_key` (the credential the
+ * boot, but the cloud pushes `cadet:assistant_api_key` (the credential the
  * managed Gemini embedding backend needs) tens of seconds later. The seed's
  * `embedWithBackend` call throws `EmbeddingBackendUnavailableError` before the
  * skill/CLI `entries` cache is replaced, so `listSkillEntries()` /
@@ -105,7 +105,7 @@ async function settledWithin(
  * the next daemon restart. Re-running the seed when the credential arrives
  * restores the capability pages without a restart.
  *
- * Gated on the managed-proxy prerequisites now being satisfied (both the
+ * Gated on the cloud-proxy prerequisites now being satisfied (both the
  * platform base URL and the assistant API key present) so a non-managed
  * credential write — or a partial update that has not yet completed the pair —
  * does not kick a doomed embed. Idempotent: `seedV2SkillEntries` /
@@ -125,7 +125,7 @@ async function settledWithin(
  *
  * The maintain enqueue must NOT be gated on both catalogs settling. The two
  * embeds are independent, and a single wedged catalog (a stalled `getCatalog()`
- * or a managed-proxy embed that never returns) would otherwise block the v3 lane
+ * or a cloud-proxy embed that never returns) would otherwise block the v3 lane
  * rebuild indefinitely, so the catalog that DID seed never reaches the selector.
  * The barrier is therefore bounded by `reseedTimeoutMs`: maintain is enqueued
  * once the barrier resolves (the pass is idempotent and reconciles whatever the
@@ -136,7 +136,7 @@ async function settledWithin(
  * `reseedTimeoutMs` is injectable for tests; production uses
  * {@link RESEED_BARRIER_TIMEOUT_MS}.
  */
-export async function maybeReseedCapabilitiesAfterManagedCredential(
+export async function maybeReseedCapabilitiesAfterCloudCredential(
   config: AssistantConfig,
   opts: { reseedTimeoutMs?: number } = {},
 ): Promise<void> {
@@ -144,13 +144,13 @@ export async function maybeReseedCapabilitiesAfterManagedCredential(
     return;
   }
 
-  const { hasManagedProxyPrereqs } =
-    await import("../../../../providers/platform-proxy/context.js");
-  if (!(await hasManagedProxyPrereqs())) {
+  const { hasCloudProxyPrereqs } =
+    await import("../../../../providers/cloud-proxy/context.js");
+  if (!(await hasCloudProxyPrereqs())) {
     return;
   }
 
-  // The managed credential has just landed, so the embedding backend is now
+  // The cloud credential has just landed, so the embedding backend is now
   // reachable. Retry the embedding-identity reconcile to close the
   // fresh-platform-install-booted-with-Gemini-down case: the first boot defers
   // (degraded) because the backend probe returns null, and this credential-
@@ -168,7 +168,7 @@ export async function maybeReseedCapabilitiesAfterManagedCredential(
   } catch (err) {
     log.warn(
       { err },
-      "Embedding-identity reconcile after managed proxy credential update threw — continuing",
+      "Embedding-identity reconcile after cloud proxy credential update threw — continuing",
     );
   }
 
@@ -200,12 +200,12 @@ export async function maybeReseedCapabilitiesAfterManagedCredential(
     seed().then(
       () =>
         log.info(
-          `Memory v2 ${label} entries seeded after managed proxy credential update`,
+          `Memory v2 ${label} entries seeded after cloud proxy credential update`,
         ),
       (err: unknown) =>
         log.warn(
           { err },
-          `Failed to seed v2 ${label} entries after managed proxy credential update`,
+          `Failed to seed v2 ${label} entries after cloud proxy credential update`,
         ),
     ),
   );
@@ -229,7 +229,7 @@ export async function maybeReseedCapabilitiesAfterManagedCredential(
     } catch (err) {
       log.warn(
         { err },
-        "Failed to enqueue memory_v3_maintain after managed proxy credential update",
+        "Failed to enqueue memory_v3_maintain after cloud proxy credential update",
       );
     }
   };

package/src/plugins/defaults/memory/substrate/cli-command-store.ts

@@ -159,12 +159,12 @@ async function runSeedV2CliCommandEntries(generation: number): Promise<void> {
 
     // Sparse (BM25/TF) encoding is computed locally; only the dense vectors
     // require `embedWithBackend`, which is unconfigured during the cold-start
-    // window before a managed-proxy embedding credential is provisioned. A
+    // window before a cloud-proxy embedding credential is provisioned. A
     // dense-embed failure is non-fatal to the in-memory cache: the v3 needle
     // finder lane reads CLI capabilities from `entries` / the page index, NOT
     // from Qdrant, so the cache is populated from the local Commander tree
     // regardless of backend state and commands stay discoverable from first
-    // boot. Only the dense Qdrant upsert is skipped; the managed-credential
+    // boot. Only the dense Qdrant upsert is skipped; the cloud-credential
     // reseed and the v3 maintain pass backfill the dense vectors on recovery.
     const nextEntries = new Map<string, CliCommandEntry>();
     let denseVectors: number[][] = [];

package/src/plugins/defaults/memory/substrate/prompts/consolidation.ts

@@ -1182,7 +1182,7 @@ export function renderConsolidationPrompt(
  * page index's reports, `{{OVERLONG_SECTIONS_SECTION}}` from the v3 section
  * scan, and the legacy `{{PROC_TO_SKILLS_SECTION}}` always
  * stripped to empty, so a prompt copied from any past bundled source never
- * leaks a raw placeholder, and a customized prompt can opt into the managed
+ * leaks a raw placeholder, and a customized prompt can opt into the cloud
  * sections.
  *
  * The buffer entries and the repair sections do not wait for opt-in: an