@vellumai/assistant 0.8.9-staging.3 → 0.8.9-staging.4

package/src/cli/commands/memory-v3.ts

@@ -1,47 +1,38 @@
 /**
  * `assistant memory v3` CLI subgroup.
  *
- * Operator-facing tree-gardening + core-editing subcommands for the v3 memory
- * subsystem (leaf-tree activation model). The daemon owns the live tree, so the
- * mutating verbs route through `cliIpcCall` to handlers that run inside the
- * assistant process (where the in-memory lanes can be invalidated after a
- * write). The read-only `health` report and the `set-core` cost preview also
- * route through the daemon so it stays the single source of truth for the live
- * workspace tree.
+ * Operator-facing live-lane maintenance subcommands for the v3 memory subsystem
+ * (section-lane retrieval model). The daemon owns the live shadow lanes, so the
+ * verbs route through `cliIpcCall` to handlers that run inside the assistant
+ * process (where the in-memory lanes can be invalidated/rebuilt after a write).
  *
  * Subcommands:
  *
- *   - `health` — print the structural health report (read-only).
- *   - `reconcile` — v1 convergence pass: rewrites any dangling page/core ref to
- *     the current on-disk tree and prunes stale core entries. It does NOT yet
- *     detect renames/moves/splits — that requires a captured prior leaf
- *     snapshot (a follow-up), so `renames` is always empty in v1.
- *   - `set-core` — add/remove always-on core leaves. Validates that every added
- *     leaf exists, previews the resulting always-on page count, and writes only
- *     on `--yes`.
  *   - `rebuild-index` — invalidate the v3 lanes so the next turn rebuilds.
- *
- * Deferred to follow-ups: thin `add-leaf` / `rename-leaf` / `delete-leaf`
- * wrappers (edit the leaf file[s] then reconcile).
+ *   - `backfill-sections` — one-time: embed every page's sections (including
+ *     synthetic skill/CLI rows) into the dense store, then advance the maintain
+ *     checkpoint. For the transition before A/B/cutover, since the collection
+ *     starts empty and the incremental maintain pass only re-embeds deltas.
  */
 
 import type { Command } from "commander";
 
 import { cliIpcCall } from "../../ipc/cli-client.js";
 import type {
-  MemoryV3HealthResult,
+  MemoryV3BackfillSectionsResult,
   MemoryV3RebuildIndexResult,
-  MemoryV3ReconcileResult,
-  MemoryV3SetCoreResult,
 } from "../../runtime/routes/memory-v3-routes.js";
 import { registerCommand } from "../lib/register-command.js";
 import { log } from "../logger.js";
 
-/** Commander collector for a repeatable option: accumulates each value. */
-function collect(val: string, acc: string[]): string[] {
-  acc.push(val);
-  return acc;
-}
+/**
+ * IPC timeout for `backfill-sections`. The one-time full-corpus section embed
+ * runs every page's chunks through the embedder sequentially, which easily
+ * outlasts `cliIpcCall`'s default 60s — so we give it a generous 30-minute
+ * ceiling rather than report a spurious "Request timed out" while the assistant
+ * keeps working.
+ */
+const BACKFILL_IPC_TIMEOUT_MS = 30 * 60 * 1000;
 
 export function registerMemoryV3Command(program: Command): void {
   // Reuse an existing `memory` parent if some other registrar attached to it
@@ -54,97 +45,80 @@ export function registerMemoryV3Command(program: Command): void {
   registerCommand(memory, {
     name: "v3",
     transport: "ipc",
-    description: "Memory v3 tree-gardening and core-editing (leaf-tree model)",
+    description: "Memory v3 live-lane maintenance (section-lane model)",
     build: (v3) => {
       v3.addHelpText(
         "after",
         `
-The v3 memory subsystem organizes concept pages under a curated leaf tree
-(/workspace/memory/v3/data/) and pins an always-on "core" set of leaves.
-These commands garden that tree safely: each mutating verb snapshots and
-fail-closed validates before committing, and invalidates the live lanes so
-the next turn rebuilds from the reconciled state.
+The v3 memory subsystem retrieves concept pages over section-grain lanes and
+caches them as live shadow lanes inside the assistant. These commands maintain
+that live state safely.
 
 Examples:
-  $ assistant memory v3 health
-  $ assistant memory v3 set-core --add domain-a/topic-x
-  $ assistant memory v3 set-core --remove domain-a/topic-y --yes
-  $ assistant memory v3 reconcile
-  $ assistant memory v3 rebuild-index`,
+  $ assistant memory v3 rebuild-index
+  $ assistant memory v3 backfill-sections`,
       );
 
-      // ── health ────────────────────────────────────────────────────────────
+      // ── rebuild-index ─────────────────────────────────────────────────────
 
-      v3.command("health")
-        .description("Print the v3 structural health report (read-only)")
-        .option("--json", "Emit raw JSON instead of the rendered report")
+      v3.command("rebuild-index")
+        .description("Invalidate the v3 lanes so the next turn rebuilds")
         .addHelpText(
           "after",
           `
-Loads the live leaf tree + core set and reports where the taxonomy has
-drifted from the page graph: unassigned slugs, dangling refs, novel
-clusters, and over/under-sized leaves. Read-only — no writes. Prints
-"all green" when no maintenance is warranted.
+Drops the assistant's cached v3 shadow lanes so the section index is rebuilt
+from the current on-disk state on the next turn. Useful after editing concept
+pages out-of-band.
 
 Examples:
-  $ assistant memory v3 health
-  $ assistant memory v3 health --json | jq '.counts'`,
+  $ assistant memory v3 rebuild-index`,
         )
-        .action(async (opts: { json?: boolean }) => {
-          const result = await cliIpcCall<MemoryV3HealthResult>(
-            "memory_v3_health",
+        .action(async () => {
+          const result = await cliIpcCall<MemoryV3RebuildIndexResult>(
+            "memory_v3_rebuild_index",
             { body: {} },
           );
           if (!result.ok) {
-            log.error(result.error ?? "Failed to compute v3 health");
+            log.error(result.error ?? "Failed to invalidate the v3 lanes");
             process.exitCode = 1;
             return;
           }
-          const payload = result.result!;
-          if (opts.json === true) {
-            log.info(JSON.stringify(payload, null, 2));
-            return;
-          }
-          log.info(
-            payload.rendered === ""
-              ? "memory-v3 health: all green"
-              : payload.rendered,
-          );
+          log.info("v3 lanes invalidated; next turn will rebuild.");
         });
 
-      // ── reconcile ─────────────────────────────────────────────────────────
+      // ── backfill-sections ─────────────────────────────────────────────────
 
-      v3.command("reconcile")
+      v3.command("backfill-sections")
         .description(
-          "v1 convergence/prune pass over page/core refs (no rename detection yet)",
+          "One-time: embed every page's sections into the dense store (incl skills/CLI)",
         )
         .option("--json", "Emit raw JSON instead of a formatted summary")
         .addHelpText(
           "after",
           `
-Runs a convergence pass over the leaf tree: rewrites any page leaves:
-frontmatter or core.json entry that dangles to a path the current on-disk
-tree no longer has, and prunes stale core entries. Fail-closed: snapshots
-before mutating and rolls back if any dangling reference survives
-validation. On success the v3 lanes are invalidated.
+Embeds EVERY concept page's sections — including synthetic skill and CLI
+capability rows — into the section dense store in one pass, then advances
+the maintain checkpoint so the next incremental pass only re-embeds future
+edits. Use this once on an existing install before the section-lane A/B and
+cutover: the dense collection starts empty, and the periodic maintenance
+pass only re-embeds pages edited since its last run (and never the synthetic
+rows), so most of the corpus would otherwise never be embedded.
 
-Limitation: v1 cannot detect renames/moves/splits. The reconciler diffs
-the current tree against itself (there is no captured "before" snapshot),
-so renames always report as empty and a true rename surfaces as a
-delete + add. Full rename/move/split detection requires persisting a prior
-leaf snapshot and is a planned follow-up.
+Idempotent and safe to re-run. Runs inside the assistant so it uses the live
+configuration and advances the checkpoint the assistant reads.
 
 Examples:
-  $ assistant memory v3 reconcile
-  $ assistant memory v3 reconcile --json | jq '.prunedCore'`,
+  $ assistant memory v3 backfill-sections
+  $ assistant memory v3 backfill-sections --json | jq '.sections'`,
         )
         .action(async (opts: { json?: boolean }) => {
-          const result = await cliIpcCall<MemoryV3ReconcileResult>(
-            "memory_v3_reconcile",
+          const result = await cliIpcCall<MemoryV3BackfillSectionsResult>(
+            "memory_v3_backfill_sections",
             { body: {} },
+            { timeoutMs: BACKFILL_IPC_TIMEOUT_MS },
           );
           if (!result.ok) {
-            log.error(result.error ?? "Failed to reconcile the v3 tree");
+            log.error(result.error ?? "Failed to backfill section embeddings");
             process.exitCode = 1;
             return;
           }
@@ -154,127 +128,11 @@ Examples:
             return;
           }
           log.info(
-            `Renamed: ${payload.renames.length === 0 ? "none" : payload.renames.length}`,
-          );
-          for (const r of payload.renames) {
-            log.info(`  - ${r.oldPath} → ${r.newPath}`);
-          }
-          log.info(
-            `Deleted: ${payload.deleted.length === 0 ? "none" : payload.deleted.join(", ")}`,
+            `Embedded ${payload.sections} sections across ${payload.articles} pages` +
+              (payload.failures > 0
+                ? ` (${payload.failures} page(s) failed — see assistant logs).`
+                : "."),
           );
-          log.info(
-            `Pruned core: ${payload.prunedCore.length === 0 ? "none" : payload.prunedCore.join(", ")}`,
-          );
-        });
-
-      // ── set-core ──────────────────────────────────────────────────────────
-
-      v3.command("set-core")
-        .description(
-          "Add/remove always-on core leaves (previews cost; writes on --yes)",
-        )
-        .option(
-          "--add <leaf>",
-          "Leaf path to add to the always-on core set (repeatable)",
-          collect,
-          [] as string[],
-        )
-        .option(
-          "--remove <leaf>",
-          "Leaf path to remove from the always-on core set (repeatable)",
-          collect,
-          [] as string[],
-        )
-        .option("--yes", "Apply the change (otherwise preview only)")
-        .option("--json", "Emit raw JSON instead of a formatted summary")
-        .addHelpText(
-          "after",
-          `
-Edits the always-on core leaf set in core.json. Every --add entry must
-exist in the live tree (unknown leaves are rejected). Without --yes this
-PREVIEWS the resulting core set and the number of unique page slugs it
-would pin always-on, WITHOUT writing. Pass --yes to persist and invalidate
-the lanes.
-
-Examples:
-  $ assistant memory v3 set-core --add domain-a/topic-x        # preview
-  $ assistant memory v3 set-core --add domain-a/topic-x --yes  # apply
-  $ assistant memory v3 set-core --remove domain-b/topic-z --yes`,
-        )
-        .action(
-          async (opts: {
-            add: string[];
-            remove: string[];
-            yes?: boolean;
-            json?: boolean;
-          }) => {
-            if (opts.add.length === 0 && opts.remove.length === 0) {
-              log.error("Pass at least one --add or --remove leaf path.");
-              process.exitCode = 1;
-              return;
-            }
-
-            const result = await cliIpcCall<MemoryV3SetCoreResult>(
-              "memory_v3_set_core",
-              {
-                body: {
-                  add: opts.add,
-                  remove: opts.remove,
-                  write: opts.yes === true,
-                },
-              },
-            );
-            if (!result.ok) {
-              log.error(result.error ?? "Failed to update the v3 core set");
-              process.exitCode = 1;
-              return;
-            }
-            const payload = result.result!;
-            if (opts.json === true) {
-              log.info(JSON.stringify(payload, null, 2));
-              return;
-            }
-            log.info(
-              `Core leaves (${payload.nextCore.length}): ${
-                payload.nextCore.length === 0
-                  ? "none"
-                  : payload.nextCore.join(", ")
-              }`,
-            );
-            log.info(`Always-on page count: ${payload.alwaysOnPageCount}`);
-            if (payload.written) {
-              log.info("Written to core.json; lanes invalidated.");
-            } else {
-              log.info("Preview only — re-run with --yes to apply.");
-            }
-          },
-        );
-
-      // ── rebuild-index ─────────────────────────────────────────────────────
-
-      v3.command("rebuild-index")
-        .description("Invalidate the v3 lanes so the next turn rebuilds")
-        .addHelpText(
-          "after",
-          `
-Drops the daemon's cached v3 shadow lanes so the tree + needle are rebuilt
-from the current on-disk state on the next turn. Useful after editing leaf
-files or assignments out-of-band.
-
-Examples:
-  $ assistant memory v3 rebuild-index`,
-        )
-        .action(async () => {
-          const result = await cliIpcCall<MemoryV3RebuildIndexResult>(
-            "memory_v3_rebuild_index",
-            { body: {} },
-          );
-          if (!result.ok) {
-            log.error(result.error ?? "Failed to invalidate the v3 lanes");
-            process.exitCode = 1;
-            return;
-          }
-          log.info("v3 lanes invalidated; next turn will rebuild.");
         });
     },
   });

package/src/config/call-site-defaults.ts

@@ -25,7 +25,6 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
     profile: "cost-optimized",
     contextWindow: { maxInputTokens: 1000000 },
   },
-  memoryV3RouteL1: { profile: "balanced", temperature: 0 },
   memoryV3SelectL2: { profile: "balanced", temperature: 0 },
   recall: {
     profile: "balanced",

package/src/config/llm-resolver.ts

@@ -78,6 +78,15 @@ export function resolveCallSiteConfig(
 ): z.infer<typeof LLMConfigBase> {
   const layers: Mergeable[] = [llm.default as Mergeable];
 
+  // Effective logit-bias preset, tracked outside the deep-merge so it ties to
+  // the single highest-precedence *profile* that wins resolution rather than
+  // inheriting from a lower one. Profile layers are appended low→high, and each
+  // one fully determines the preset (a profile that omits `logitBias` clears
+  // any value a lower-precedence profile set), so the last profile appended
+  // wins — matching the merge's own precedence and including the implicit
+  // call-site default selected by `effectiveDefault`.
+  const biasRef: LogitBiasRef = { preset: undefined };
+
   const activeFragment = resolveProfileFragment(llm.activeProfile, llm, opts);
   const overrideFragment = resolveProfileFragment(
     opts.overrideProfile,
@@ -89,18 +98,32 @@ export function resolveCallSiteConfig(
     effectiveDefault(callSite, llm, opts.overrideProfile != null);
 
   if (callSite === "mainAgent") {
-    appendCallSiteLayers(layers, callSite, llm, site, opts);
-    appendProfileLayer(layers, activeFragment);
-    appendProfileLayer(layers, overrideFragment);
+    appendCallSiteLayers(layers, callSite, llm, site, opts, biasRef);
+    appendProfileLayer(layers, activeFragment, biasRef);
+    appendProfileLayer(layers, overrideFragment, biasRef);
   } else {
-    appendProfileLayer(layers, activeFragment);
-    appendProfileLayer(layers, overrideFragment);
-    appendCallSiteLayers(layers, callSite, llm, site, opts);
+    appendProfileLayer(layers, activeFragment, biasRef);
+    appendProfileLayer(layers, overrideFragment, biasRef);
+    appendCallSiteLayers(layers, callSite, llm, site, opts, biasRef);
   }
 
-  return finalize(deepMerge(...layers.map(withImpliedProviderForKnownModel)));
+  const resolved = finalize(
+    deepMerge(...layers.map(withImpliedProviderForKnownModel)),
+  );
+  // `logitBias` is profile-scoped: the winning profile is its only source.
+  // Overwrite — or clear — whatever the deep-merge may have copied from a
+  // non-profile layer (`llm.default` or a call-site fragment), so a preset set
+  // outside a profile can't apply to a profile that didn't opt in.
+  if (biasRef.preset !== undefined) {
+    resolved.logitBias = biasRef.preset;
+  } else {
+    delete (resolved as { logitBias?: unknown }).logitBias;
+  }
+  return resolved;
 }
 
+type LogitBiasRef = { preset: ProfileEntry["logitBias"] };
+
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
@@ -261,8 +284,10 @@ function withImpliedProviderForKnownModel(source: Mergeable): Mergeable {
 function appendProfileLayer(
   layers: Mergeable[],
   profile: ProfileEntry | undefined,
+  biasRef: LogitBiasRef,
 ): void {
   if (profile != null) {
+    biasRef.preset = profile.logitBias;
     layers.push(profileConfigFragment(profile));
   }
 }
@@ -273,6 +298,7 @@ function appendCallSiteLayers(
   llm: z.infer<typeof LLMSchema>,
   site: z.infer<typeof LLMSchema>["callSites"][LLMCallSite] | undefined,
   opts: ResolveCallSiteOpts,
+  biasRef: LogitBiasRef,
 ): void {
   if (site != null) {
     if (site.profile != null) {
@@ -286,6 +312,7 @@ function appendCallSiteLayers(
           `LLM call site "${callSite}" references undefined profile "${site.profile}"`,
         );
       }
+      biasRef.preset = profileFragment.logitBias;
       layers.push(profileConfigFragment(profileFragment));
     }
     // Strip the `profile` discriminator before merging — it isn't a
@@ -304,6 +331,11 @@ function profileConfigFragment(profile: ProfileEntry): Mergeable {
     // profile before this point), but strip it defensively so it can never
     // leak into the merged `LLMConfigBase`.
     mix: _mix,
+    // `logitBias` is profile-identity metadata, not inheritable config: a
+    // preset must apply only to the profile that opted in, never bleed from a
+    // lower-precedence (e.g. active) profile into one that merely inherited it.
+    // `RetryProvider` resolves it from the applied profile, not the merge.
+    logitBias: _logitBias,
     ...config
   } = profile;
   return config as Mergeable;

package/src/config/schemas/__tests__/memory-v3.test.ts

@@ -7,19 +7,35 @@ describe("MemoryV3ConfigSchema", () => {
     const parsed = MemoryV3ConfigSchema.parse({});
     expect(parsed).toEqual({
       workingSet: { maxPages: 150, evictWindow: 5 },
-      l2Concurrency: 16,
+      needleK: 100,
+      denseK: 100,
+      edge: { hubDegree: 30, seedCount: 18, perSeed: 6, cap: 45 },
     });
   });
 
-  test("accepts an explicit l2Concurrency override", () => {
-    expect(MemoryV3ConfigSchema.parse({ l2Concurrency: 8 }).l2Concurrency).toBe(
-      8,
-    );
+  test("accepts explicit lane-K overrides", () => {
+    const parsed = MemoryV3ConfigSchema.parse({ needleK: 50, denseK: 75 });
+    expect(parsed.needleK).toBe(50);
+    expect(parsed.denseK).toBe(75);
   });
 
-  test("rejects a non-positive or non-integer l2Concurrency", () => {
-    expect(() => MemoryV3ConfigSchema.parse({ l2Concurrency: 0 })).toThrow();
-    expect(() => MemoryV3ConfigSchema.parse({ l2Concurrency: -4 })).toThrow();
-    expect(() => MemoryV3ConfigSchema.parse({ l2Concurrency: 1.5 })).toThrow();
+  test("accepts a partial edge override, defaulting the rest", () => {
+    const parsed = MemoryV3ConfigSchema.parse({ edge: { hubDegree: 10 } });
+    expect(parsed.edge).toEqual({
+      hubDegree: 10,
+      seedCount: 18,
+      perSeed: 6,
+      cap: 45,
+    });
+  });
+
+  test("rejects non-positive or non-integer lane knobs", () => {
+    expect(() => MemoryV3ConfigSchema.parse({ needleK: 0 })).toThrow();
+    expect(() => MemoryV3ConfigSchema.parse({ denseK: -4 })).toThrow();
+    expect(() => MemoryV3ConfigSchema.parse({ needleK: 1.5 })).toThrow();
+    expect(() =>
+      MemoryV3ConfigSchema.parse({ edge: { perSeed: 0 } }),
+    ).toThrow();
+    expect(() => MemoryV3ConfigSchema.parse({ edge: { cap: -1 } })).toThrow();
   });
 });

package/src/config/schemas/call-site-catalog.ts

@@ -121,13 +121,6 @@ const CATALOG_RECORD: CatalogRecord = {
       "Selects which concept pages to inject for the next agent turn by routing over a cached page index.",
     domain: "memory",
   },
-  memoryV3RouteL1: {
-    id: "memoryV3RouteL1",
-    displayName: "Memory V3 L1 Router",
-    description:
-      "Picks which leaves of the topic tree to open for the next agent turn by routing over a cache-warm static leaf block.",
-    domain: "memory",
-  },
   memoryV3SelectL2: {
     id: "memoryV3SelectL2",
     displayName: "Memory V3 L2 Selector",

package/src/config/schemas/llm.ts

@@ -50,7 +50,6 @@ export const LLMCallSiteEnum = z.enum([
   "memoryV2Migration",
   "memoryV2Sweep",
   "memoryRouter",
-  "memoryV3RouteL1",
   "memoryV3SelectL2",
   "memoryV2Consolidation",
   "memoryRetrospective",
@@ -124,6 +123,17 @@ const VerbosityEnum = z.enum(["low", "medium", "high"]);
 const ModelSchema = z.string().min(1);
 const MaxTokensSchema = z.number().int().positive();
 const TemperatureSchema = z.number().min(0).max(2).nullable();
+// Named, code-resolved logit-bias preset a profile may opt into. The value is a
+// preset *name*, not an inline token→bias map, so the workspace config stays
+// small. This is profile-identity metadata, not inheritable config: the resolver
+// strips it from the deep-merge and re-attaches it from the winning profile (see
+// `profileConfigFragment` / `resolveCallSiteConfig`), and `RetryProvider`
+// resolves it to a `logit_bias` map at request time, forwarded only on the
+// Fireworks (OpenAI-compatible) path. Keep these literals in sync with the
+// presets handled by `resolveLogitBiasPreset` in
+// `providers/inference/logit-bias.ts` (kept separate to avoid a schema →
+// provider import cycle).
+const LogitBiasPresetSchema = z.enum(["suppress-cjk"]);
 
 // ---------------------------------------------------------------------------
 // Thinking & ContextWindow
@@ -316,6 +326,11 @@ export const LLMConfigBase = z.object({
   thinking: ThinkingSchema.default(ThinkingSchema.parse({})),
   contextWindow: ContextWindowSchema.default(ContextWindowSchema.parse({})),
   openrouter: OpenRouterSchema.default(OpenRouterSchema.parse({})),
+  // Not deep-merged like the other fields: `resolveCallSiteConfig` sets this
+  // from the single highest-precedence profile that won resolution (see
+  // `profileConfigFragment`, which strips it from the merge), so a preset
+  // can't bleed from a lower-precedence profile into one that didn't opt in.
+  logitBias: LogitBiasPresetSchema.optional(),
 });
 export type LLMConfigBase = z.infer<typeof LLMConfigBase>;
 
@@ -336,6 +351,7 @@ const LLMConfigFragment = z.object({
   thinking: ThinkingFragmentSchema.optional(),
   contextWindow: ContextWindowDeepPartialSchema.optional(),
   openrouter: OpenRouterDeepPartialSchema.optional(),
+  logitBias: LogitBiasPresetSchema.optional(),
 });
 type LLMConfigFragment = z.infer<typeof LLMConfigFragment>;
 

package/src/config/schemas/memory-v3.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 
 /**
- * Memory v3 (topic-tree routing) working-set configuration.
+ * Memory v3 (section-grain lane retrieval) working-set configuration.
  *
  * The working set is the per-conversation set of concept pages carried
  * forward across turns. Eviction keeps it bounded: pages unseen for longer
@@ -28,20 +28,70 @@ export const MemoryV3WorkingSetSchema = z
   })
   .describe("Memory v3 working-set retention/eviction tuning.");
 
+/**
+ * Edge-lane tuning for the link-graph expansion that folds a turn's lexical and
+ * dense seeds outward to their first-class neighbours.
+ */
+export const MemoryV3EdgeSchema = z
+  .object({
+    hubDegree: z
+      .number({ error: "memory.v3.edge.hubDegree must be a number" })
+      .int("memory.v3.edge.hubDegree must be an integer")
+      .positive("memory.v3.edge.hubDegree must be a positive integer")
+      .default(30)
+      .describe(
+        "In-degree above which an article is treated as a hub and excluded from edge expansion (too generic to be a useful surface).",
+      ),
+    seedCount: z
+      .number({ error: "memory.v3.edge.seedCount must be a number" })
+      .int("memory.v3.edge.seedCount must be an integer")
+      .positive("memory.v3.edge.seedCount must be a positive integer")
+      .default(18)
+      .describe(
+        "Number of top needle+dense seeds (in rank order) expanded by the edge lane.",
+      ),
+    perSeed: z
+      .number({ error: "memory.v3.edge.perSeed must be a number" })
+      .int("memory.v3.edge.perSeed must be an integer")
+      .positive("memory.v3.edge.perSeed must be a positive integer")
+      .default(6)
+      .describe("Maximum neighbours surfaced per expanded seed."),
+    cap: z
+      .number({ error: "memory.v3.edge.cap must be a number" })
+      .int("memory.v3.edge.cap must be an integer")
+      .positive("memory.v3.edge.cap must be a positive integer")
+      .default(45)
+      .describe(
+        "Hard cap on the total number of distinct articles surfaced by the edge lane.",
+      ),
+  })
+  .describe("Memory v3 edge-lane (link-graph expansion) tuning.");
+
 export const MemoryV3ConfigSchema = z
   .object({
     workingSet: MemoryV3WorkingSetSchema.default(
       MemoryV3WorkingSetSchema.parse({}),
     ),
-    l2Concurrency: z
-      .number({ error: "memory.v3.l2Concurrency must be a number" })
-      .int("memory.v3.l2Concurrency must be an integer")
-      .positive("memory.v3.l2Concurrency must be a positive integer")
-      .default(16)
+    needleK: z
+      .number({ error: "memory.v3.needleK must be a number" })
+      .int("memory.v3.needleK must be an integer")
+      .positive("memory.v3.needleK must be a positive integer")
+      .default(100)
+      .describe(
+        "Number of section-grain BM25 needle articles folded into the candidate pool each turn.",
+      ),
+    denseK: z
+      .number({ error: "memory.v3.denseK must be a number" })
+      .int("memory.v3.denseK must be an integer")
+      .positive("memory.v3.denseK must be a positive integer")
+      .default(100)
       .describe(
-        "Bounded fan-out for the per-leaf L2 selection (number of leaf selector calls in flight at once).",
+        "Number of dense-lane articles folded into the candidate pool each turn.",
       ),
+    edge: MemoryV3EdgeSchema.default(MemoryV3EdgeSchema.parse({})),
   })
-  .describe("Memory v3 — topic-tree routing with a carry-forward working set");
+  .describe(
+    "Memory v3 — section-grain lane retrieval with a carry-forward working set",
+  );
 
 export type MemoryV3Config = z.infer<typeof MemoryV3ConfigSchema>;

package/src/config/seed-inference-profiles.ts

@@ -74,6 +74,24 @@ const MANAGED_PROFILE_TEMPLATES: Record<string, ManagedProfileTemplate> = {
     thinking: { enabled: false, streamThinking: false },
     contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
   },
+  // Open-weight economy option: Kimi K2.6 served by Fireworks via managed
+  // platform inference. Carries the `suppress-cjk` logit-bias preset to
+  // discourage the model from spontaneously emitting Chinese in English
+  // output; the preset is profile-scoped and only forwarded on the Fireworks
+  // path (see `providers/inference/logit-bias.ts`).
+  "balanced-economy": {
+    intent: "balanced",
+    provider: "fireworks",
+    connectionName: "fireworks-managed",
+    source: "managed",
+    label: "Balanced Economy",
+    description: "Strong open model (Kimi K2.6) at a lower price point",
+    maxTokens: 16000,
+    effort: "high",
+    thinking: { enabled: true, streamThinking: true },
+    contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
+    logitBias: "suppress-cjk",
+  },
 };
 
 /**