agent-mockingbird 0.0.1

package/apps/server/src/backend/runtime/errors.ts

@@ -0,0 +1,61 @@
+export class RuntimeSessionNotFoundError extends Error {
+  constructor(sessionId: string) {
+    super(`Session not found: ${sessionId}`);
+    this.name = "RuntimeSessionNotFoundError";
+  }
+}
+
+export class RuntimeSessionBusyError extends Error {
+  constructor(sessionId: string) {
+    super(`Session is already processing: ${sessionId}`);
+    this.name = "RuntimeSessionBusyError";
+  }
+}
+
+export class RuntimeSessionQueuedError extends Error {
+  constructor(
+    public sessionId: string,
+    public depth: number,
+  ) {
+    super(`Session is busy; message queued (${depth} pending): ${sessionId}`);
+    this.name = "RuntimeSessionQueuedError";
+  }
+}
+
+export class RuntimeContinuationDetachedError extends Error {
+  constructor(
+    public sessionId: string,
+    public childRunCount: number,
+  ) {
+    super(`Session is still running via ${childRunCount} child run(s): ${sessionId}`);
+    this.name = "RuntimeContinuationDetachedError";
+  }
+}
+
+export class RuntimeProviderQuotaError extends Error {
+  constructor(message = "Provider quota exceeded. Add credits or switch provider/model.") {
+    super(message);
+    this.name = "RuntimeProviderQuotaError";
+  }
+}
+
+export class RuntimeProviderAuthError extends Error {
+  constructor(message = "Provider authentication failed. Check API key or provider credentials.") {
+    super(message);
+    this.name = "RuntimeProviderAuthError";
+  }
+}
+
+export class RuntimeProviderRateLimitError extends Error {
+  constructor(message = "Provider rate limited this request. Please retry in a moment.") {
+    super(message);
+    this.name = "RuntimeProviderRateLimitError";
+  }
+}
+
+export class RuntimeTurnTimeoutError extends Error {
+  constructor(sessionId: string, timeoutMs: number) {
+    super(`Session response timed out after ${timeoutMs}ms: ${sessionId}`);
+    this.name = "RuntimeTurnTimeoutError";
+  }
+}

package/apps/server/src/backend/runtime/index.ts

@@ -0,0 +1,72 @@
+import { OpencodeRuntime } from "./opencodeRuntime";
+import { getConfigSnapshot } from "../config/service";
+import type { RuntimeEngine } from "../contracts/runtime";
+import { readConfiguredMcpServersFromWorkspaceConfig } from "../mcp/service";
+import { getOpencodeConnectionInfo } from "../opencode/client";
+import { listManagedSkillCatalog } from "../skills/service";
+
+let runtimeInstance: RuntimeEngine | null = null;
+
+interface RuntimeStartupInfo {
+  opencode: {
+    baseUrl: string;
+    providerId: string;
+    modelId: string;
+    fallbackModels: Array<string>;
+    smallModel: string;
+    timeoutMs: number;
+    promptTimeoutMs: number;
+    directoryConfigured: boolean;
+    authConfigured: boolean;
+  };
+}
+
+export function createRuntime(): RuntimeEngine {
+  const config = getConfigSnapshot().config;
+  const runtime = new OpencodeRuntime({
+    defaultProviderId: config.runtime.opencode.providerId,
+    defaultModelId: config.runtime.opencode.modelId,
+    fallbackModelRefs: config.runtime.opencode.fallbackModels,
+    getRuntimeConfig: () => getConfigSnapshot().config.runtime.opencode,
+    getEnabledSkills: () => listManagedSkillCatalog(getConfigSnapshot().config.runtime.opencode.directory).enabled,
+    getEnabledMcps: () =>
+      readConfiguredMcpServersFromWorkspaceConfig(getConfigSnapshot().config)
+        .filter(server => server.enabled)
+        .map(server => server.id),
+    getConfiguredMcpServers: () => readConfiguredMcpServersFromWorkspaceConfig(getConfigSnapshot().config),
+  });
+  runtimeInstance = runtime;
+  return runtime;
+}
+
+export function getRuntime(): RuntimeEngine | null {
+  return runtimeInstance;
+}
+
+export function getRuntimeStartupInfo(): RuntimeStartupInfo {
+  const config = getConfigSnapshot().config;
+  const connection = getOpencodeConnectionInfo({
+    baseUrl: config.runtime.opencode.baseUrl,
+    timeoutMs: config.runtime.opencode.timeoutMs,
+    directory: config.runtime.opencode.directory,
+  });
+  return {
+    opencode: {
+      baseUrl: connection.baseUrl,
+      providerId: config.runtime.opencode.providerId,
+      modelId: config.runtime.opencode.modelId,
+      fallbackModels: config.runtime.opencode.fallbackModels,
+      smallModel: config.runtime.opencode.smallModel,
+      timeoutMs: connection.timeoutMs,
+      promptTimeoutMs: config.runtime.opencode.promptTimeoutMs,
+      directoryConfigured: connection.directoryConfigured,
+      authConfigured: connection.authConfigured,
+    },
+  };
+}
+
+export {
+  RuntimeSessionBusyError,
+  RuntimeSessionNotFoundError,
+  RuntimeTurnTimeoutError,
+} from "./errors";

package/apps/server/src/backend/runtime/memoryPromptDedup.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  analyzeMemoryInjectionResults,
+  buildMemoryContextFingerprint,
+  isMemoryRecallIntentQuery,
+  isWriteIntentMemoryQuery,
+  memoryInjectionResultKey,
+  prepareMemoryInjectionResults,
+} from "./memoryPromptDedup";
+import type { MemorySearchResult } from "../memory/types";
+
+function result(input: {
+  id: string;
+  score: number;
+  path?: string;
+  startLine?: number;
+  endLine?: number;
+  snippet?: string;
+  citation?: string;
+}): MemorySearchResult {
+  return {
+    id: input.id,
+    path: input.path ?? "memory/2026-03-02.md",
+    startLine: input.startLine ?? 1,
+    endLine: input.endLine ?? 3,
+    source: "memory",
+    score: input.score,
+    snippet: input.snippet ?? "snippet",
+    citation: input.citation ?? "memory/2026-03-02.md#L1",
+  };
+}
+
+describe("buildMemoryContextFingerprint", () => {
+  test("ignores score and ordering jitter for same chunk set", () => {
+    const first = buildMemoryContextFingerprint([result({ id: "chunk-b", score: 0.93 }), result({ id: "chunk-a", score: 0.71 })]);
+    const second = buildMemoryContextFingerprint([result({ id: "chunk-a", score: 0.12 }), result({ id: "chunk-b", score: 0.44 })]);
+    expect(first).toBe(second);
+  });
+
+  test("changes when chunk identity set changes", () => {
+    const baseline = buildMemoryContextFingerprint([result({ id: "chunk-a", score: 0.9 }), result({ id: "chunk-b", score: 0.5 })]);
+    const changed = buildMemoryContextFingerprint([result({ id: "chunk-a", score: 0.2 }), result({ id: "chunk-c", score: 0.1 })]);
+    expect(changed).not.toBe(baseline);
+  });
+
+  test("returns stable empty fingerprint", () => {
+    expect(buildMemoryContextFingerprint([])).toBe("[]");
+  });
+});
+
+describe("prepareMemoryInjectionResults", () => {
+  test("drops low-signal boilerplate with no query overlap", () => {
+    const results = prepareMemoryInjectionResults("favorite pokemon", [
+      result({
+        id: "index",
+        score: 0.8,
+        path: "MEMORY.md",
+        snippet: "# Memory Index\nStore durable notes in memory/*.md",
+        citation: "MEMORY.md#L1",
+      }),
+      result({
+        id: "pokemon",
+        score: 0.7,
+        snippet: "User's favorite Pokemon is Vulpix.",
+        citation: "memory/2026-03-02.md#L10",
+      }),
+    ]);
+    expect(results.length).toBe(1);
+    expect(results[0]?.id).toBe("pokemon");
+  });
+
+  test("dedupes structured snippets by memory record id", () => {
+    const sharedSnippetA = [
+      "### [memory:memory_abc123] 2026-03-02T20:41:01.037Z",
+      "```json",
+      '{"id":"memory_abc123"}',
+      "```",
+      "User's favorite Pokemon is Vulpix.",
+    ].join("\n");
+    const sharedSnippetB = `${sharedSnippetA}\n(extra context)`;
+    const results = prepareMemoryInjectionResults("pokemon", [
+      result({ id: "chunk-1", score: 0.9, snippet: sharedSnippetA }),
+      result({ id: "chunk-2", score: 0.7, snippet: sharedSnippetB }),
+    ]);
+    expect(results.length).toBe(1);
+    expect(results[0]?.id).toBe("chunk-1");
+  });
+
+  test("filters structured snippets that are irrelevant to non-recall queries", () => {
+    const structured = [
+      "### [memory:memory_abc123] 2026-03-02T20:41:01.037Z",
+      "```json",
+      '{"id":"memory_abc123"}',
+      "```",
+      "User has a daughter named Lucy Lee in the NICU.",
+    ].join("\n");
+    const results = prepareMemoryInjectionResults("pokemon evolution chart", [
+      result({ id: "chunk-1", score: 0.9, snippet: structured }),
+    ]);
+    expect(results.length).toBe(0);
+  });
+
+  test("keeps structured snippets for explicit recall-intent queries", () => {
+    const structured = [
+      "### [memory:memory_abc123] 2026-03-02T20:41:01.037Z",
+      "```json",
+      '{"id":"memory_abc123"}',
+      "```",
+      "User has a daughter named Lucy Lee in the NICU.",
+    ].join("\n");
+    const analyzed = analyzeMemoryInjectionResults("what do you remember about me?", [
+      result({ id: "chunk-1", score: 0.9, snippet: structured }),
+    ]);
+    expect(analyzed.results.length).toBe(1);
+    expect(analyzed.filteredIrrelevantCount).toBe(0);
+  });
+});
+
+describe("memoryInjectionResultKey", () => {
+  test("uses memory record id when present", () => {
+    const structured = [
+      "### [memory:memory_abc123] 2026-03-02T20:41:01.037Z",
+      "```json",
+      '{"id":"memory_abc123"}',
+      "```",
+      "User has a daughter named Lucy Lee in the NICU.",
+    ].join("\n");
+    expect(memoryInjectionResultKey(result({ id: "chunk-1", score: 0.8, snippet: structured }))).toBe("record:memory_abc123");
+  });
+
+  test("falls back to chunk id for unstructured snippets", () => {
+    expect(memoryInjectionResultKey(result({ id: "chunk-plain", score: 0.8, snippet: "plain snippet" }))).toBe(
+      "chunk:chunk-plain",
+    );
+  });
+});
+
+describe("isWriteIntentMemoryQuery", () => {
+  test("detects write-intent phrases", () => {
+    expect(isWriteIntentMemoryQuery("also remember that I have an android phone")).toBe(true);
+    expect(isWriteIntentMemoryQuery("please note that this is important")).toBe(true);
+    expect(isWriteIntentMemoryQuery("what is my favorite pokemon?")).toBe(false);
+  });
+});
+
+describe("isMemoryRecallIntentQuery", () => {
+  test("detects recall-intent phrases", () => {
+    expect(isMemoryRecallIntentQuery("what do you remember about me?")).toBe(true);
+    expect(isMemoryRecallIntentQuery("remind me what you know from memory")).toBe(true);
+    expect(isMemoryRecallIntentQuery("what is my favorite pokemon?")).toBe(false);
+  });
+});

package/apps/server/src/backend/runtime/memoryPromptDedup.ts

@@ -0,0 +1,76 @@
+import type { MemorySearchResult } from "../memory/types";
+
+const MEMORY_RECORD_MARKER_RE = /###\s+\[memory:([a-zA-Z0-9_-]+)\]/i;
+const TOKEN_RE = /[a-z0-9]{3,}/g;
+const WRITE_INTENT_RE = /\b(?:remember\s+that|note\s+that|save\s+this)\b/i;
+const RECALL_INTENT_RE = /\b(?:what\s+do\s+you\s+remember|remind\s+me|recall|from\s+memory|what\s+do\s+you\s+know\s+about\s+me)\b/i;
+
+function collectTokens(text: string) {
+  const matched = text.toLowerCase().match(TOKEN_RE);
+  return new Set(matched ?? []);
+}
+
+function normalizeSnippetForDedupe(snippet: string) {
+  return snippet.toLowerCase().replace(/\s+/g, " ").trim();
+}
+
+function extractRecordId(snippet: string): string | null {
+  const matched = snippet.match(MEMORY_RECORD_MARKER_RE);
+  const recordId = matched?.[1]?.trim();
+  return recordId || null;
+}
+
+export function isMemoryRecallIntentQuery(query: string): boolean {
+  return RECALL_INTENT_RE.test(query);
+}
+
+export function buildMemoryContextFingerprint(results: MemorySearchResult[]): string {
+  const ids = [...new Set(results.map(result => result.id.trim()).filter(Boolean))].sort((a, b) => a.localeCompare(b));
+  return JSON.stringify(ids);
+}
+
+export function isWriteIntentMemoryQuery(query: string): boolean {
+  return WRITE_INTENT_RE.test(query);
+}
+
+export function memoryInjectionResultKey(result: MemorySearchResult): string {
+  const recordId = extractRecordId(result.snippet);
+  if (recordId) return `record:${recordId}`;
+  return `chunk:${result.id.trim() || normalizeSnippetForDedupe(result.snippet)}`;
+}
+
+export function analyzeMemoryInjectionResults(query: string, results: MemorySearchResult[]): {
+  results: MemorySearchResult[];
+  filteredIrrelevantCount: number;
+  dedupedCount: number;
+} {
+  const queryTokens = collectTokens(query);
+  const recallIntent = isMemoryRecallIntentQuery(query);
+  const deduped = new Map<string, MemorySearchResult>();
+  let filteredIrrelevantCount = 0;
+
+  for (const result of results) {
+    const snippetTokens = collectTokens(`${result.citation}\n${result.snippet}`);
+    const hasOverlap = [...snippetTokens].some(token => queryTokens.has(token));
+    if (!recallIntent && queryTokens.size > 0 && !hasOverlap) {
+      filteredIrrelevantCount += 1;
+      continue;
+    }
+
+    const key = memoryInjectionResultKey(result);
+    if (!deduped.has(key)) {
+      deduped.set(key, result);
+    }
+  }
+
+  const dedupedResults = [...deduped.values()];
+  return {
+    results: dedupedResults,
+    filteredIrrelevantCount,
+    dedupedCount: Math.max(0, results.length - filteredIrrelevantCount - dedupedResults.length),
+  };
+}
+
+export function prepareMemoryInjectionResults(query: string, results: MemorySearchResult[]): MemorySearchResult[] {
+  return analyzeMemoryInjectionResults(query, results).results;
+}