@vellumai/assistant 0.8.7-dev.202606052232.2ddc989 → 0.8.8

package/src/config/bundled-skills/app-builder/tools/app-list.ts

@@ -1,62 +0,0 @@
-import * as appStore from "../../../../memory/app-store.js";
-import type {
-  ToolContext,
-  ToolExecutionResult,
-} from "../../../../tools/types.js";
-
-interface AppListEntry {
-  app_id: string;
-  name: string;
-  description?: string;
-  updated_at: number;
-  created_at: number;
-}
-
-function toEntry(app: appStore.AppDefinition): AppListEntry {
-  return {
-    app_id: app.id,
-    name: app.name,
-    ...(app.description ? { description: app.description } : {}),
-    updated_at: app.updatedAt,
-    created_at: app.createdAt,
-  };
-}
-
-export async function run(
-  input: Record<string, unknown>,
-  _context: ToolContext,
-): Promise<ToolExecutionResult> {
-  const apps = appStore.listApps();
-  const entries = apps.map(toEntry);
-
-  const query =
-    typeof input.query === "string" ? input.query.trim().toLowerCase() : "";
-
-  if (!query) {
-    return {
-      content: JSON.stringify({ count: entries.length, apps: entries }),
-      isError: false,
-    };
-  }
-
-  // Resolve the app the user mentioned by name. Prefer an exact (case-insensitive)
-  // name match, then fall back to substring matches in either direction so
-  // "habit tracker" resolves "Habit Tracker" and "my budget" resolves "Budget".
-  const exact = entries.filter((e) => e.name.toLowerCase() === query);
-  const matches =
-    exact.length > 0
-      ? exact
-      : entries.filter((e) => {
-          const name = e.name.toLowerCase();
-          return name.includes(query) || query.includes(name);
-        });
-
-  return {
-    content: JSON.stringify({
-      query: input.query,
-      match_count: matches.length,
-      matches,
-    }),
-    isError: false,
-  };
-}

package/src/daemon/conversation-registry.ts

@@ -1,159 +0,0 @@
-/**
- * In-memory registry of active {@link Conversation} instances, keyed by
- * conversation ID, plus the read/write accessors over it.
- *
- * This is a leaf module: it imports `Conversation` as a type only, so any
- * layer — including the memory-retrieval plugin's injectors, which only know a
- * conversation id — can look up the live conversation and read its state
- * without pulling in the daemon-core creation graph (providers, system-prompt
- * assembly, the `Conversation` class value) that `getOrCreateConversation` in
- * `conversation-store` depends on. Keeping the registry free of those value
- * imports is what lets the injector chain consume it without forming an import
- * cycle (`injectors → store → conversation → agent-loop → runtime-assembly →
- * injector-chain → injectors`).
- *
- * `conversation-store` owns the creation/reuse lifecycle and writes top-level
- * conversations into this map via {@link setConversation}.
- */
-
-import type { Conversation } from "./conversation.js";
-
-const conversations = new Map<string, Conversation>();
-
-// ── Read helpers ───────────────────────────────────────────────────
-
-export function findConversation(
-  conversationId: string | undefined,
-): Conversation | undefined {
-  if (!conversationId) return undefined;
-  return conversations.get(conversationId);
-}
-
-export function findConversationBySurfaceId(
-  surfaceId: string,
-): Conversation | undefined {
-  // Fast path: exact surfaceId match in surfaceState
-  for (const c of conversations.values()) {
-    if (c.surfaceState.has(surfaceId)) return c;
-  }
-
-  // Fallback: standalone app surfaces use "app-open-{appId}" IDs that
-  // were never part of any conversation.  Extract the appId and find
-  // a conversation whose surfaceState has a surface for that app.
-  const appOpenPrefix = "app-open-";
-  if (surfaceId.startsWith(appOpenPrefix)) {
-    const appId = surfaceId.slice(appOpenPrefix.length);
-    for (const c of conversations.values()) {
-      for (const [, state] of c.surfaceState.entries()) {
-        const data = state.data as unknown as Record<string, unknown>;
-        if (data?.appId === appId) {
-          // Register this surfaceId so subsequent lookups are O(1)
-          c.surfaceState.set(surfaceId, state);
-          return c;
-        }
-      }
-    }
-  }
-
-  return undefined;
-}
-
-export function conversationCount(): number {
-  return conversations.size;
-}
-
-/** Iterate over all active conversations. */
-export function allConversations(): IterableIterator<Conversation> {
-  return conversations.values();
-}
-
-/** Iterate over all [id, conversation] entries. */
-export function conversationEntries(): IterableIterator<
-  [string, Conversation]
-> {
-  return conversations.entries();
-}
-
-/** Iterate over all active conversation IDs. */
-export function conversationIds(): IterableIterator<string> {
-  return conversations.keys();
-}
-
-// ── Write helpers ──────────────────────────────────────────────────
-
-export function setConversation(
-  conversationId: string,
-  conversation: Conversation,
-): void {
-  conversations.set(conversationId, conversation);
-}
-
-export function deleteConversation(conversationId: string): boolean {
-  return conversations.delete(conversationId);
-}
-
-export function clearConversations(): void {
-  conversations.clear();
-}
-
-// ── Underlying Map (for the evictor, which takes a mutable ref) ───
-
-/**
- * Expose the raw Map for the {@link ConversationEvictor}, which needs
- * a mutable reference to delete entries during sweeps. No other code
- * should use this — prefer the named helpers above.
- */
-export function getConversationMap(): Map<string, Conversation> {
-  return conversations;
-}
-
-// ── Subagent live-conversation index ───────────────────────────────
-//
-// Subagents run their own agent loop — and therefore the injector chain — but
-// are owned by the `SubagentManager` rather than the daemon's eviction-managed
-// store, so they are deliberately absent from `conversations` above. This
-// point-lookup index lets the per-conversation injectors (workspace context,
-// disk-pressure warning) resolve a subagent's live `Conversation` by id and
-// read state off it. It is intentionally excluded from the iteration accessors
-// and the evictor map so subagent lifecycle stays solely with the manager.
-
-const subagentConversations = new Map<string, Conversation>();
-
-/** Register a subagent's live conversation for point lookups. */
-export function setSubagentConversation(
-  conversationId: string,
-  conversation: Conversation,
-): void {
-  subagentConversations.set(conversationId, conversation);
-}
-
-/**
- * Remove a subagent's conversation from the index. Guards against clobbering a
- * newer registration for the same id by only deleting when the stored entry
- * still points at this instance.
- */
-export function removeSubagentConversation(
-  conversationId: string,
-  conversation: Conversation,
-): void {
-  if (subagentConversations.get(conversationId) === conversation) {
-    subagentConversations.delete(conversationId);
-  }
-}
-
-/**
- * Resolve a live `Conversation` by id, including subagent conversations.
- * Top-level conversations are checked first, then subagents. Used by the
- * per-conversation injectors, which run for subagent turns too; other callers
- * should use {@link findConversation}, which is scoped to the eviction-managed
- * top-level conversations.
- */
-export function findConversationOrSubagent(
-  conversationId: string | undefined,
-): Conversation | undefined {
-  if (!conversationId) return undefined;
-  return (
-    conversations.get(conversationId) ??
-    subagentConversations.get(conversationId)
-  );
-}

package/src/daemon/overflow-reduction-loop.ts

@@ -1,230 +0,0 @@
-import type { ContextWindowConfig } from "../config/schemas/inference.js";
-import type {
-  ContextWindowCompactOptions,
-  ContextWindowResult,
-} from "../context/window-manager.js";
-import type { Message } from "../providers/types.js";
-import {
-  createInitialReducerState,
-  reduceContextOverflow,
-  type ReducerState,
-} from "./context-overflow-reducer.js";
-import type { InjectionMode } from "./conversation-runtime-assembly.js";
-
-/**
- * Input to the overflow-reduction loop. Captures everything the reducer
- * tier loop needs, including the message history, reducer configuration,
- * and side-effect callbacks that bridge the loop back to the orchestrator's
- * mutable per-turn state (context-window manager, activity emitter, runtime
- * injection reassembly, memory reinjection).
- *
- * The callbacks are supplied by the orchestrator because the reducer loop
- * needs to coordinate with state that lives on the `AgentLoopConversationContext`
- * (message mutation, compaction event emission, circuit breaker tracking,
- * injection block reassembly). Keeping them as explicit callbacks keeps the
- * loop free of any dependency on the agent-loop context object.
- */
-export interface OverflowReduceArgs {
-  /** Bare persisted message history (the reducer applies results to a copy
-   *  of this array). */
-  readonly messages: Message[];
-  /** Current run-time message array with runtime injections applied. */
-  readonly runMessages: Message[];
-  /** System prompt used for post-step token estimation. */
-  readonly systemPrompt: string;
-  /** Provider name used for token estimation (calibration provider key). */
-  readonly providerName: string;
-  /** Context window config (drives compaction behavior). */
-  readonly contextWindow: ContextWindowConfig;
-  /** Token budget the reducer must get below (preflight budget). */
-  readonly preflightBudget: number;
-  /** Tool-token overhead included in every estimation call. */
-  readonly toolTokenBudget?: number;
-  /** Maximum reducer iterations before the loop exits unconditionally. */
-  readonly maxAttempts: number;
-  /** Abort signal threaded through compaction calls. */
-  readonly abortSignal?: AbortSignal;
-  /**
-   * Compaction callback — the loop never owns the ContextWindowManager
-   * instance. The orchestrator supplies this closure so the loop can
-   * delegate the forced-compaction tier without crossing the infra
-   * boundary on its own.
-   */
-  readonly compactFn: (
-    messages: Message[],
-    signal: AbortSignal | undefined,
-    options: unknown,
-  ) => Promise<ContextWindowResult>;
-  /**
-   * Invoked before each reducer iteration to emit the `context_compacting`
-   * activity state. The orchestrator owns activity emission because the
-   * signal is trust/channel aware.
-   */
-  readonly emitActivityState: () => void;
-  /**
-   * Invoked after each reducer step that produced a successful compaction.
-   * Handles circuit-breaker tracking, event emission, and context mutation.
-   */
-  readonly onCompactionResult: (
-    result: ContextWindowResult,
-    compactedBasis?: Message[],
-  ) => void | Promise<void>;
-  /**
-   * Invoked after each step to rebuild `runMessages` from the step's
-   * reduced history with the requested injection mode. The orchestrator
-   * owns this helper so the full per-turn injection options object doesn't
-   * leak into the loop. The current reduced messages array is passed
-   * explicitly so the orchestrator doesn't need to read mutable shared
-   * state. Returns the new `runMessages`.
-   *
-   * Two distinct "did compact" signals are passed so the orchestrator can
-   * apply the correct per-iteration vs sticky gating:
-   * - `stepCompacted` — whether THIS iteration's reducer step produced a
-   *   fresh compaction. Gates PKB / NOW re-injection: compaction strips the
-   *   existing blocks, so only iterations that just compacted need the
-   *   content re-threaded. Iterations that only truncated tool results or
-   *   downgraded injections must NOT force a re-injection or the token
-   *   count grows each round.
-   * - `accumulatedCompacted` — whether ANY iteration in this invocation has
-   *   compacted. Gates `slackChronologicalMessages` suppression: once
-   *   compaction has run, the captured Slack transcript snapshot would
-   *   overwrite the compacted history, so it must stay suppressed for every
-   *   subsequent iteration even if that iteration didn't re-compact.
-   */
-  readonly reinjectForMode: (
-    messages: Message[],
-    mode: InjectionMode,
-    stepCompacted: boolean,
-    accumulatedCompacted: boolean,
-  ) => Promise<Message[]>;
-  /**
-   * Invoked after each step to post-estimate the rebuilt `runMessages`.
-   * Pulled out so the orchestrator controls how estimation is performed
-   * (and which fields feed it) without the loop reimplementing it.
-   */
-  readonly estimatePostInjection: (runMessages: Message[]) => number;
-}
-
-/** Output of the overflow-reduction loop. */
-export interface OverflowReduceResult {
-  /** Final reduced `ctx.messages` value. */
-  readonly messages: Message[];
-  /** Final `runMessages` with re-applied runtime injections. */
-  readonly runMessages: Message[];
-  /** Final injection mode (may be `"minimal"` if the downgrade tier fired). */
-  readonly injectionMode: InjectionMode;
-  /** Accumulated reducer state at exit. */
-  readonly reducerState: ReducerState;
-  /** True if any step successfully compacted history. */
-  readonly reducerCompacted: boolean;
-  /** How many iterations of the tier loop executed. */
-  readonly attempts: number;
-}
-
-/**
- * Run the context-overflow reducer tier loop — forced compaction, tool-result
- * truncation, media stubbing, injection downgrade — plus the post-step
- * re-injection / re-estimation convergence check.
- *
- * The forced-compaction tier is delegated through `args.compactFn`; the other
- * tiers mutate the message array directly. After each step the orchestrator
- * rebuilds `runMessages` via `args.reinjectForMode` and the loop re-estimates
- * the post-injection token count, exiting once it fits the preflight budget,
- * the reducer is exhausted, or `maxAttempts` is reached.
- */
-export async function runOverflowReductionLoop(
-  args: OverflowReduceArgs,
-): Promise<OverflowReduceResult> {
-  let messages = args.messages;
-  let runMessages = args.runMessages;
-  let injectionMode: "full" | "minimal" = "full";
-  let reducerState: ReducerState = createInitialReducerState();
-  let reducerCompacted = false;
-  let attempts = 0;
-
-  while (attempts < args.maxAttempts && !reducerState.exhausted) {
-    // Abort check at the top of every iteration. When the caller aborts
-    // externally, this check lets us bail out BETWEEN iterations rather
-    // than letting another round of compaction / re-injection mutate
-    // `ctx.messages` after the turn has already failed. Individual
-    // `reduceContextOverflow` calls also honor the signal, but without this
-    // gate a fresh iteration could still start after the signal fires,
-    // since the previous one returned normally before the abort propagated.
-    args.abortSignal?.throwIfAborted();
-
-    attempts++;
-    args.emitActivityState();
-
-    const basisMessages = messages;
-    const step = await reduceContextOverflow(
-      basisMessages,
-      {
-        providerName: args.providerName,
-        systemPrompt: args.systemPrompt,
-        contextWindow: args.contextWindow,
-        targetTokens: args.preflightBudget,
-        toolTokenBudget: args.toolTokenBudget,
-      },
-      reducerState,
-      (msgs, signal, opts: ContextWindowCompactOptions) =>
-        args.compactFn(msgs, signal, opts),
-      args.abortSignal,
-    );
-
-    reducerState = step.state;
-    messages = step.messages;
-    injectionMode = step.state.injectionMode;
-
-    // Per-iteration compaction flag: whether THIS step just produced a
-    // fresh compaction. PKB / NOW re-injection is gated on this — see the
-    // reinjectForMode JSDoc for why the two signals differ.
-    const stepCompacted = step.compactionResult?.compacted === true;
-
-    // Let the orchestrator apply compaction side effects (circuit-breaker
-    // tracking, event emission, ctx mutation) before we re-inject.
-    if (step.compactionResult) {
-      await args.onCompactionResult(step.compactionResult, basisMessages);
-      if (stepCompacted) {
-        reducerCompacted = true;
-      }
-    }
-
-    // Second abort gate — if the side effects or the step itself took us
-    // past the deadline, don't rebuild runMessages or iterate again.
-    args.abortSignal?.throwIfAborted();
-
-    // Rebuild runMessages via the orchestrator-supplied helper (which
-    // re-runs `applyRuntimeInjections` with potentially downgraded mode
-    // and freshly re-hydrated PKB/NOW blocks after compaction). We pass
-    // the current reduced `messages` explicitly so the orchestrator never
-    // has to read from mutable shared state to rebuild runMessages — a
-    // tier that doesn't trigger compaction (tool-result truncation, media
-    // stubbing) won't update `ctx.messages` on its own.
-    //
-    // `stepCompacted` and `reducerCompacted` are both passed so the
-    // orchestrator can gate PKB / NOW re-injection per-iteration while
-    // keeping `slackChronologicalMessages` suppressed once any iteration
-    // has compacted.
-    runMessages = await args.reinjectForMode(
-      messages,
-      injectionMode,
-      stepCompacted,
-      reducerCompacted,
-    );
-
-    // Re-estimate with injections included — `step.estimatedTokens` was
-    // computed on bare history and doesn't account for tokens added by
-    // runtime injections.
-    const postInjectionTokens = args.estimatePostInjection(runMessages);
-    if (postInjectionTokens <= args.preflightBudget) break;
-  }
-
-  return {
-    messages,
-    runMessages,
-    injectionMode,
-    reducerState,
-    reducerCompacted,
-    attempts,
-  };
-}

package/src/memory/migrations/272-acp-session-history-cwd.ts

@@ -1,36 +0,0 @@
-import type { DrizzleDb } from "../db-connection.js";
-import { getSqliteFrom } from "../db-connection.js";
-import { withCrashRecovery } from "./validate-migration-state.js";
-
-const CHECKPOINT_KEY = "migration_acp_session_history_cwd_v1";
-
-const TABLE = "acp_session_history";
-const COLUMN = "cwd";
-
-/**
- * Add a nullable `cwd TEXT` column to `acp_session_history`.
- *
- * Records the working directory the ACP agent process was spawned with so
- * that a persisted session can later be resumed (`session/load` /
- * `session/resume` both require the original cwd to reconstruct params).
- *
- * `NULL` for rows persisted before this migration ran — legacy sessions
- * simply are not resumable.
- *
- * Idempotent — the PRAGMA guard makes re-running a no-op once the column
- * exists.
- */
-export function migrateAcpSessionHistoryCwd(database: DrizzleDb): void {
-  withCrashRecovery(database, CHECKPOINT_KEY, () => {
-    const raw = getSqliteFrom(database);
-
-    const columns = raw.query(`PRAGMA table_info(${TABLE})`).all() as Array<{
-      name: string;
-    }>;
-    const columnNames = new Set(columns.map((c) => c.name));
-
-    if (!columnNames.has(COLUMN)) {
-      raw.exec(`ALTER TABLE ${TABLE} ADD COLUMN ${COLUMN} TEXT`);
-    }
-  });
-}

package/src/plugins/defaults/compaction/compact.ts

@@ -1,59 +0,0 @@
-/**
- * Default compaction implementation.
- *
- * Summarizes conversation history when the context window fills up by
- * delegating to a {@link ContextWindowManager}. The agent loop calls
- * {@link defaultCompact} directly with a {@link CompactionContext}; the request
- * carries the conversational inputs while the manager performs the work.
- *
- * This module is side-effect free: importing it does not register any plugin.
- */
-
-import type {
-  ContextWindowManager,
-  ContextWindowResult,
-} from "../../../context/window-manager.js";
-import type { Message } from "../../../providers/types.js";
-import type { TrustClass } from "../../../runtime/actor-trust-resolver.js";
-
-/**
- * Name under which the default compaction plugin registers. Exposed so call
- * sites can attribute compaction failures to the default plugin.
- */
-export const DEFAULT_COMPACTION_PLUGIN_NAME = "default-compaction";
-
-/**
- * Self-describing compaction request handed to {@link defaultCompact}. Carries
- * the conversational inputs plus the {@link ContextWindowManager} that runs the
- * summary, so the request is the part that can grow toward a model-facing
- * compaction-method shape without coupling callers to the manager's option bag.
- */
-export interface CompactionContext {
-  /** Context window manager that performs the compaction. */
-  manager: ContextWindowManager;
-  /** Message history to consider for compaction. */
-  messages: Message[];
-  /** Abort signal forwarded to the compaction summary call. */
-  signal?: AbortSignal;
-  /** Skip the auto-threshold check (forced/overflow/emergency compaction). */
-  force?: boolean;
-  /** Per-conversation inference-profile override for the summary call. */
-  overrideProfile?: string | null;
-  /** Pre-computed token estimate from a prior `shouldCompact()` call. */
-  precomputedEstimate?: number;
-  /** Legacy keep-boundary hint forwarded to the compactor. */
-  minKeepRecentUserTurns?: number;
-  /** Trust class of the actor whose turn triggered compaction. */
-  actorTrustClass?: TrustClass;
-}
-
-/**
- * Run compaction for the turn: delegates to the request's context window
- * manager and returns the (possibly summarized) message history.
- */
-export async function defaultCompact(
-  context: CompactionContext,
-): Promise<ContextWindowResult> {
-  const { manager, messages, signal, ...options } = context;
-  return manager.maybeCompact(messages, signal, options);
-}

package/src/plugins/defaults/memory-v3-shadow/hooks/post-compact.ts

@@ -1,14 +0,0 @@
-/**
- * No-op `post-compact` scaffolding for the memory-v3-shadow plugin.
- *
- * v3 re-injection after mid-turn compaction is not yet owned by this plugin —
- * the active injector still runs through the static chain. Once the
- * post-compaction hook API stabilizes we will import `memoryV3Injector` from
- * `../injector.js` and re-apply it here. Until then this hook does nothing.
- */
-
-import type { PluginHookFn } from "@vellumai/plugin-api";
-
-const postCompact: PluginHookFn = async () => {};
-
-export default postCompact;

package/src/plugins/defaults/memory-v3-shadow/hooks/user-prompt-submit.ts

@@ -1,19 +0,0 @@
-/**
- * No-op `user-prompt-submit` scaffolding for the memory-v3-shadow plugin.
- *
- * The v3 injector currently runs through the static injector chain
- * (`memory-retrieval/injector-chain.ts`), not through this hook. Once the
- * prompt-submit hook API stabilizes we will import `memoryV3Injector` from
- * `../injector.js` and run it here, so v3 injection is owned by the plugin's
- * own lifecycle rather than the loop-driven chain. Until then this hook
- * intentionally does nothing.
- */
-
-import type {
-  PluginHookFn,
-  UserPromptSubmitContext,
-} from "@vellumai/plugin-api";
-
-const userPromptSubmit: PluginHookFn<UserPromptSubmitContext> = async () => {};
-
-export default userPromptSubmit;

package/src/plugins/defaults/memory-v3-shadow/injector.ts

@@ -1,75 +0,0 @@
-/**
- * The memory-v3 {@link Injector}. Reads both v3 flags:
- *   - `memory-v3-live` on → orchestrate, log, render the working-set selection
- *     into a `<memory>` block, and return it at v2's dynamic-memory placement.
- *   - `memory-v3-shadow` on (live off) → orchestrate + log only, return `null`.
- *   - both off → return `null` (no orchestration).
- *
- * Empty selection and any failure return `null` (no v3 injection). v2
- * suppression keys off BOTH the flag AND this return value, so a `null` here
- * (failure or empty selection) falls back to v2 memory rather than dropping all
- * memory.
- *
- * Orchestration and telemetry live in {@link observeTurn}; this module is the
- * thin injector wrapper that renders the result for live injection.
- */
-
-import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
-import { getConfig } from "../../../config/loader.js";
-import { getLogger } from "../../../util/logger.js";
-import {
-  type InjectionBlock,
-  type Injector,
-  type TurnContext as PluginTurnContext,
-} from "../../types.js";
-import { renderV3PageContent } from "./page-content.js";
-import { renderMemoryBlock } from "./render-injection.js";
-import {
-  MEMORY_V3_LIVE,
-  MEMORY_V3_SHADOW,
-  observeTurn,
-} from "./shadow-plugin.js";
-import { MEMORY_V3_BLOCK_ID } from "./types.js";
-
-const log = getLogger("memory-v3-shadow");
-
-export const memoryV3Injector: Injector = {
-  name: "memory-v3-shadow",
-  // High order so it sorts last; the live `<memory>` block uses the
-  // after-memory-prefix placement so it lands at the memory boundary regardless
-  // of this sort key, which only orders content-producing injectors.
-  order: 1000,
-  async produce(ctx: PluginTurnContext): Promise<InjectionBlock | null> {
-    const config = getConfig();
-    const live = isAssistantFeatureFlagEnabled(MEMORY_V3_LIVE, config);
-    const shadow = isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, config);
-    if (!live && !shadow) return null;
-
-    const result = await observeTurn(ctx.conversationId, ctx.turnIndex);
-    if (!live || !result) return null;
-
-    try {
-      // `renderMemoryBlock` returns "" for an empty selection; inject nothing.
-      const text = await renderMemoryBlock(
-        result.finalInjection,
-        renderV3PageContent,
-      );
-      if (text.length === 0) return null;
-      return {
-        id: MEMORY_V3_BLOCK_ID,
-        text,
-        // Mirror v2's dynamic `<memory>` block placement.
-        placement: "after-memory-prefix",
-      };
-    } catch (err) {
-      log.warn(
-        {
-          err: err instanceof Error ? err.message : String(err),
-          conversationId: ctx.conversationId,
-        },
-        "memory-v3 live render failed (non-fatal) — falling back to v2",
-      );
-      return null;
-    }
-  },
-};

package/src/plugins/defaults/memory-v3-shadow/register.ts

@@ -1,26 +0,0 @@
-/**
- * Default `memory-v3-shadow` plugin.
- *
- * Houses the memory-v3 shadow/live orchestration engine (this directory) and
- * its injector (`./injector.ts`). The injector is still consumed by the static
- * chain in `memory-retrieval/injector-chain.ts`; the `user-prompt-submit` /
- * `post-compact` hooks below are no-op scaffolding for the eventual
- * convergence, when v3 injection moves off the loop-driven chain and into these
- * lifecycle hooks. See each hook file for the convergence note.
- */
-
-import { type Plugin } from "../../types.js";
-import postCompact from "./hooks/post-compact.js";
-import userPromptSubmit from "./hooks/user-prompt-submit.js";
-import pkg from "./package.json" with { type: "json" };
-
-export const memoryV3ShadowPlugin: Plugin = {
-  manifest: {
-    name: pkg.name,
-    version: pkg.version,
-  },
-  hooks: {
-    "user-prompt-submit": userPromptSubmit,
-    "post-compact": postCompact,
-  },
-};