@mycadet/assistant 0.12.9 → 0.12.10

package/src/persistence/lifecycle-events-store.ts

@@ -1,110 +0,0 @@
-import { recordTelemetryEvent } from "../telemetry/telemetry-events-outbox.js";
-import type {
-  LifecycleTelemetryEvent,
-  TelemetryEventBase,
-} from "../telemetry/types.js";
-import { APP_VERSION } from "../version.js";
-
-export interface LifecycleEvent {
-  id: string;
-  eventName: string;
-  createdAt: number;
-}
-
-/**
- * Optional typed attributes a lifecycle event carries alongside its name.
- *
- * Every one is nullable and optional on the wire, so a caller with nothing to
- * say omits it and a cloud that predates the field ignores it. They exist
- * so grouping dimensions (risk, access preset, surface) are columns rather
- * than substrings of `event_name`, which the server caps at 64 chars.
- */
-export interface LifecycleEventAttributes {
-  /**
-   * Tool the event is about. The stable join key between a permission prompt
-   * and its decision: `event_name` embeds a truncated tool name, this does not.
-   */
-  toolName?: string;
-  /** Classified risk of the invocation ("low" | "medium" | "high"). */
-  riskLevel?: string;
-  /** Auto-approve threshold (access preset) in effect for the invocation. */
-  riskThreshold?: string;
-  /** Channel the event's turn runs on ("cadet", "slack", "telegram", ...). */
-  surface?: string;
-  /**
-   * Parent conversation. Rides the same `share_analytics` gate as the
-   * conversation ids on `turn` / `llm_usage` / `tool_executed`, and scopes the
-   * pending outbox row so deleting the conversation deletes the row with it.
-   */
-  conversationId?: string;
-}
-
-/** Lifecycle wire payload minus the fields `recordTelemetryEvent` stamps. */
-type LifecycleFields = Omit<LifecycleTelemetryEvent, keyof TelemetryEventBase>;
-
-/**
- * Assemble the lifecycle wire fields, omitting attributes the caller left
- * unset so a plain `app_open` payload stays exactly as small as it was.
- *
- * An empty attribute is omitted rather than sent: the wire schema requires at
- * least one character, and a single failing field makes the server drop the
- * whole event silently.
- */
-function buildLifecycleFields(
-  eventName: string,
-  attributes: LifecycleEventAttributes,
-): LifecycleFields {
-  const fields: LifecycleFields = { event_name: eventName };
-  if (attributes.toolName) {
-    fields.tool_name = attributes.toolName;
-  }
-  if (attributes.riskLevel) {
-    fields.risk_level = attributes.riskLevel;
-  }
-  if (attributes.riskThreshold) {
-    fields.risk_threshold = attributes.riskThreshold;
-  }
-  if (attributes.surface) {
-    fields.surface = attributes.surface;
-  }
-  if (attributes.conversationId) {
-    fields.conversation_id = attributes.conversationId;
-  }
-  return fields;
-}
-
-/**
- * Wire shape of one lifecycle event, for callers that insert outbox rows via
- * raw SQL (conversation-crud's clearAll audit path). Mirrors the shape
- * `recordTelemetryEvent` stamps — the shared `LifecycleTelemetryEvent` type
- * keeps them in sync.
- */
-export function buildLifecycleTelemetryEvent(
-  id: string,
-  eventName: string,
-  createdAt: number,
-): LifecycleTelemetryEvent {
-  return {
-    type: "lifecycle",
-    daemon_event_id: id,
-    event_name: eventName,
-    recorded_at: createdAt,
-    assistant_version: APP_VERSION,
-  };
-}
-
-/**
- * Record a lifecycle event (e.g. app_open, hatch) into the `telemetry_events`
- * outbox. Consent gating and degraded-mode `null` are `recordTelemetryEvent`'s.
- */
-export function recordLifecycleEvent(
-  eventName: string,
-  attributes: LifecycleEventAttributes = {},
-): LifecycleEvent | null {
-  const recorded = recordTelemetryEvent(
-    "lifecycle",
-    buildLifecycleFields(eventName, attributes),
-    { conversationId: attributes.conversationId ?? null },
-  );
-  return recorded ? { ...recorded, eventName } : null;
-}

package/src/plugins/defaults/memory/__tests__/activation-session-store.test.ts

@@ -1,76 +0,0 @@
-import { Database } from "bun:sqlite";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { drizzle } from "drizzle-orm/bun-sqlite";
-
-import { getMemorySqlite } from "../../../../persistence/db-connection.js";
-import { initializeDb } from "../../../../persistence/db-init.js";
-import {
-  clearStoredDb,
-  setStoredDb,
-} from "../../../../persistence/db-singleton.js";
-import * as schema from "../../../../persistence/schema/index.js";
-import {
-  isActivationSession,
-  markActivationSession,
-} from "../activation-session-store.js";
-
-await initializeDb();
-
-describe("activation-session-store", () => {
-  beforeEach(() => {
-    getMemorySqlite()!.exec("DELETE FROM activation_sessions");
-  });
-
-  test("marks a conversation and reports it as an activation session", () => {
-    markActivationSession("c1");
-    expect(isActivationSession("c1")).toBe(true);
-  });
-
-  test("unmarked conversations are not activation sessions", () => {
-    expect(isActivationSession("nope")).toBe(false);
-  });
-
-  test("marking the same conversation twice is idempotent", () => {
-    markActivationSession("c1");
-    markActivationSession("c1");
-    expect(isActivationSession("c1")).toBe(true);
-    const { n } = getMemorySqlite()!
-      .query("SELECT COUNT(*) AS n FROM activation_sessions")
-      .get() as { n: number };
-    expect(n).toBe(1);
-  });
-
-  test("rows land in the memory database, not main", () => {
-    markActivationSession("c-placement");
-    const inMemory = getMemorySqlite()!
-      .query(
-        "SELECT conversation_id FROM activation_sessions WHERE conversation_id = 'c-placement'",
-      )
-      .get() as { conversation_id: string } | null;
-    expect(inMemory?.conversation_id).toBe("c-placement");
-  });
-});
-
-describe("activation-session-store — degraded memory database", () => {
-  // Install a memory DB WITHOUT the activation_sessions table: the store's
-  // catch paths must swallow the failure (write no-ops, read reports false)
-  // rather than throw into the turn.
-  let brokenSqlite: Database;
-
-  beforeEach(() => {
-    brokenSqlite = new Database(":memory:");
-    setStoredDb("memory", drizzle(brokenSqlite, { schema }), () =>
-      brokenSqlite.close(),
-    );
-  });
-
-  afterEach(() => {
-    clearStoredDb("memory");
-  });
-
-  test("mark is a no-op and read reports false", () => {
-    expect(() => markActivationSession("c1")).not.toThrow();
-    expect(isActivationSession("c1")).toBe(false);
-  });
-});

package/src/plugins/defaults/memory/activation-session-store.ts

@@ -1,50 +0,0 @@
-import { getLogger } from "./logging.js";
-import { memorySqliteOrNull } from "./memory-db.js";
-
-const log = getLogger("activation-session-store");
-
-/**
- * Mark a conversation as an activation-rail session. Idempotent (the row's
- * primary key is the conversation id) and best-effort: an unavailable memory
- * database or a write failure is logged and swallowed so it never blocks the
- * turn that triggered it.
- */
-export function markActivationSession(conversationId: string): void {
-  try {
-    const raw = memorySqliteOrNull("markActivationSession");
-    if (!raw) {
-      return;
-    }
-    raw
-      .query(
-        /*sql*/ `INSERT OR IGNORE INTO activation_sessions (conversation_id, created_at) VALUES (?, ?)`,
-      )
-      .run(conversationId, Date.now());
-  } catch (err) {
-    log.warn({ err, conversationId }, "Failed to mark activation session");
-  }
-}
-
-/**
- * Whether the given conversation was started on the activation rail.
- * Best-effort: an unavailable memory database or a read failure is logged and
- * treated as "not an activation session".
- */
-export function isActivationSession(conversationId: string): boolean {
-  try {
-    const raw = memorySqliteOrNull("isActivationSession");
-    if (!raw) {
-      return false;
-    }
-    return (
-      raw
-        .query(
-          /*sql*/ `SELECT 1 FROM activation_sessions WHERE conversation_id = ?`,
-        )
-        .get(conversationId) != null
-    );
-  } catch (err) {
-    log.warn({ err, conversationId }, "Failed to read activation session");
-    return false;
-  }
-}

package/src/plugins/defaults/memory/src/__tests__/memory-v3-gate-stats.test.ts

@@ -1,281 +0,0 @@
-/**
- * Tests for `handleMemoryV3GateStats` in `memory-v3-routes.ts`.
- *
- * The handler aggregates gate telemetry from the telemetry DB and buckets it
- * by concept page count. These tests cover:
- *   - empty DB → zero counts, all buckets present, scoredPassRate null
- *   - mixed rows land in the correct buckets by real_concept_page_count
- *   - scored vs unscored runs are counted separately
- *   - rows with no real_concept_page_count go to unknownPageCount
- *   - lookbackDays is clamped to [1, 90]
- *   - malformed JSON rows are skipped
- *   - null/absent DB returns a zero response
- */
-
-import type { Database } from "bun:sqlite";
-import { describe, expect, test } from "bun:test";
-
-import { handleMemoryV3GateStats } from "../memory-v3-routes.js";
-
-// ---------------------------------------------------------------------------
-// Minimal fake SQLite DB that returns pre-set rows
-// ---------------------------------------------------------------------------
-
-type FakeRow = { payload: string };
-
-function makePayload(detail: Record<string, unknown>): string {
-  return JSON.stringify({
-    type: "watchdog",
-    daemon_event_id: "test-id",
-    recorded_at: Date.now(),
-    check_name: "memory_v3_injection_gate",
-    value: 1,
-    detail,
-  });
-}
-
-function fakeDb(rows: FakeRow[]): Database {
-  return {
-    query: (_sql: string) => ({
-      all: (..._args: unknown[]) => rows,
-    }),
-  } as unknown as Database;
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("handleMemoryV3GateStats", () => {
-  test("returns zero counts with all buckets when DB is null", () => {
-    const result = handleMemoryV3GateStats(30, null);
-    expect(result.totalRuns).toBe(0);
-    expect(result.buckets).toHaveLength(4);
-    for (const bucket of result.buckets) {
-      expect(bucket.total).toBe(0);
-      expect(bucket.scored).toBe(0);
-      expect(bucket.passed).toBe(0);
-      expect(bucket.scoredPassRate).toBeNull();
-      expect(bucket.reasons).toEqual({});
-    }
-    expect(result.unknownPageCount).toEqual({
-      total: 0,
-      passed: 0,
-      reasons: {},
-    });
-  });
-
-  test("returns zero counts with all buckets when DB returns no rows", () => {
-    const result = handleMemoryV3GateStats(30, fakeDb([]));
-    expect(result.totalRuns).toBe(0);
-    expect(result.buckets[0]!.pageCountRange).toBe("0–9");
-    expect(result.buckets[3]!.pageCountRange).toBe("200+");
-    for (const b of result.buckets) {
-      expect(b.scoredPassRate).toBeNull();
-    }
-  });
-
-  test("buckets a dense_pass row into 10–49 bucket", () => {
-    const rows = [
-      {
-        payload: makePayload({
-          pass: true,
-          reason: "dense_pass",
-          scored: true,
-          real_concept_page_count: 25,
-        }),
-      },
-    ];
-    const result = handleMemoryV3GateStats(30, fakeDb(rows));
-    expect(result.totalRuns).toBe(1);
-    const bucket = result.buckets.find((b) => b.pageCountRange === "10–49")!;
-    expect(bucket.total).toBe(1);
-    expect(bucket.scored).toBe(1);
-    expect(bucket.passed).toBe(1);
-    expect(bucket.scoredPassRate).toBe(1);
-    expect(bucket.reasons).toEqual({ dense_pass: 1 });
-  });
-
-  test("buckets a fail row into 200+ bucket", () => {
-    const rows = [
-      {
-        payload: makePayload({
-          pass: false,
-          reason: "fail_no_signal",
-          scored: true,
-          real_concept_page_count: 350,
-        }),
-      },
-    ];
-    const result = handleMemoryV3GateStats(30, fakeDb(rows));
-    const bucket = result.buckets.find((b) => b.pageCountRange === "200+")!;
-    expect(bucket.total).toBe(1);
-    expect(bucket.passed).toBe(0);
-    expect(bucket.scoredPassRate).toBe(0);
-    expect(bucket.reasons).toEqual({ fail_no_signal: 1 });
-  });
-
-  test("unscored pass-open rows count in total but not scored", () => {
-    const rows = [
-      {
-        payload: makePayload({
-          pass: true,
-          reason: "dense_unavailable",
-          scored: false,
-          real_concept_page_count: 5,
-        }),
-      },
-    ];
-    const result = handleMemoryV3GateStats(30, fakeDb(rows));
-    const bucket = result.buckets.find((b) => b.pageCountRange === "0–9")!;
-    expect(bucket.total).toBe(1);
-    expect(bucket.scored).toBe(0);
-    expect(bucket.passed).toBe(1);
-    // No scored runs → scoredPassRate is null (unscored pass does not count)
-    expect(bucket.scoredPassRate).toBeNull();
-  });
-
-  test("unscored pass mixed with scored fail does not inflate scoredPassRate", () => {
-    // Regression: before fix, pass-open + scored-fail in same bucket gave 100%
-    const rows = [
-      {
-        payload: makePayload({
-          pass: true,
-          reason: "dense_unavailable",
-          scored: false,
-          real_concept_page_count: 30,
-        }),
-      },
-      {
-        payload: makePayload({
-          pass: false,
-          reason: "fail_no_signal",
-          scored: true,
-          real_concept_page_count: 40,
-        }),
-      },
-    ];
-    const result = handleMemoryV3GateStats(30, fakeDb(rows));
-    const bucket = result.buckets.find((b) => b.pageCountRange === "10–49")!;
-    expect(bucket.total).toBe(2);
-    expect(bucket.scored).toBe(1);
-    expect(bucket.passed).toBe(1); // total passes (scored + unscored)
-    // Only the scored fail counts toward the rate — no scored passes
-    expect(bucket.scoredPassRate).toBe(0);
-  });
-
-  test("rows with no real_concept_page_count go to unknownPageCount", () => {
-    const rows = [
-      {
-        payload: makePayload({
-          pass: false,
-          reason: "fail_no_signal",
-          scored: true,
-        }),
-      },
-    ];
-    const result = handleMemoryV3GateStats(30, fakeDb(rows));
-    expect(result.unknownPageCount.total).toBe(1);
-    expect(result.unknownPageCount.passed).toBe(0);
-    expect(result.unknownPageCount.reasons).toEqual({ fail_no_signal: 1 });
-    for (const b of result.buckets) {
-      expect(b.total).toBe(0);
-    }
-  });
-
-  test("mixed rows across multiple buckets are aggregated correctly", () => {
-    const rows: FakeRow[] = [
-      // 0–9 bucket: 1 unscored pass
-      {
-        payload: makePayload({
-          pass: true,
-          reason: "dense_disabled",
-          scored: false,
-          real_concept_page_count: 3,
-        }),
-      },
-      // 10–49 bucket: 1 pass, 1 fail (both scored)
-      {
-        payload: makePayload({
-          pass: true,
-          reason: "dense_pass",
-          scored: true,
-          real_concept_page_count: 20,
-        }),
-      },
-      {
-        payload: makePayload({
-          pass: false,
-          reason: "fail_no_signal",
-          scored: true,
-          real_concept_page_count: 45,
-        }),
-      },
-      // 50–199 bucket: 2 passes
-      {
-        payload: makePayload({
-          pass: true,
-          reason: "sparse_only_strong",
-          scored: true,
-          real_concept_page_count: 100,
-        }),
-      },
-      {
-        payload: makePayload({
-          pass: true,
-          reason: "dense_pass",
-          scored: true,
-          real_concept_page_count: 150,
-        }),
-      },
-    ];
-
-    const result = handleMemoryV3GateStats(30, fakeDb(rows));
-    expect(result.totalRuns).toBe(5);
-
-    const b09 = result.buckets.find((b) => b.pageCountRange === "0–9")!;
-    expect(b09.total).toBe(1);
-    expect(b09.scored).toBe(0);
-    expect(b09.scoredPassRate).toBeNull();
-
-    const b1049 = result.buckets.find((b) => b.pageCountRange === "10–49")!;
-    expect(b1049.total).toBe(2);
-    expect(b1049.scored).toBe(2);
-    expect(b1049.passed).toBe(1);
-    expect(b1049.scoredPassRate).toBe(0.5);
-    expect(b1049.reasons).toEqual({ dense_pass: 1, fail_no_signal: 1 });
-
-    const b50199 = result.buckets.find((b) => b.pageCountRange === "50–199")!;
-    expect(b50199.scored).toBe(2);
-    expect(b50199.passed).toBe(2);
-    expect(b50199.scoredPassRate).toBe(1);
-  });
-
-  test("lookbackDays is clamped to 1–90", () => {
-    const r1 = handleMemoryV3GateStats(0, fakeDb([]));
-    expect(r1.lookbackDays).toBe(1);
-    const r2 = handleMemoryV3GateStats(999, fakeDb([]));
-    expect(r2.lookbackDays).toBe(90);
-    const r3 = handleMemoryV3GateStats(30, fakeDb([]));
-    expect(r3.lookbackDays).toBe(30);
-  });
-
-  test("malformed JSON payload rows are skipped", () => {
-    const rows: FakeRow[] = [
-      { payload: "not-valid-json" },
-      {
-        payload: makePayload({
-          pass: true,
-          reason: "dense_pass",
-          scored: true,
-          real_concept_page_count: 25,
-        }),
-      },
-    ];
-    const result = handleMemoryV3GateStats(30, fakeDb(rows));
-    // Only the valid row is counted
-    expect(result.totalRuns).toBe(2); // totalRuns counts raw rows before parse
-    const bucket = result.buckets.find((b) => b.pageCountRange === "10–49")!;
-    expect(bucket.total).toBe(1);
-  });
-});

package/src/runtime/routes/auto-profile-routes.ts

@@ -1,83 +0,0 @@
-/**
- * Auto profile routes.
- *
- * POST /v1/auto-profile/preview — which default profile the Auto profile
- * would pick for a draft the user has not sent yet.
- */
-import { z } from "zod";
-
-import { previewAutoProfile } from "../../daemon/auto-profile-router.js";
-import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
-import { BadRequestError } from "./errors.js";
-import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
-
-const MAX_DRAFT_CHARS = 20_000;
-
-const previewRequestSchema = z.object({
-  text: z.string().min(1).max(MAX_DRAFT_CHARS),
-  conversationId: z
-    .string()
-    .describe(
-      "Conversation the draft belongs to, for recent history. Omit for a new chat.",
-    )
-    .optional(),
-});
-
-const previewResponseSchema = z.object({
-  /** The default profile key the draft would run on; null when the Auto
-   *  profile is not available on this install. */
-  profile: z.string().nullable(),
-  outcome: z.enum(["routed", "unavailable", "timeout", "error", "fallback"]),
-  confidence: z.number().optional(),
-});
-
-async function handlePreviewAutoProfile(
-  args: RouteHandlerArgs,
-): Promise<z.infer<typeof previewResponseSchema>> {
-  const parsed = previewRequestSchema.safeParse(args.body ?? {});
-  if (!parsed.success) {
-    throw new BadRequestError(
-      `text must be a non-empty string of at most ${MAX_DRAFT_CHARS} characters`,
-    );
-  }
-  // The composer aborts a preview the moment the draft changes; carrying the
-  // abort through stops the retired Jev call and keeps its late answer out
-  // of the reuse cache.
-  const route = await previewAutoProfile({
-    text: parsed.data.text,
-    ...(parsed.data.conversationId
-      ? { conversationId: parsed.data.conversationId }
-      : {}),
-    ...(args.abortSignal ? { signal: args.abortSignal } : {}),
-  });
-  if (!route) {
-    return { profile: null, outcome: "unavailable" };
-  }
-  return {
-    profile: route.profile,
-    outcome: route.outcome,
-    ...(route.confidence !== undefined ? { confidence: route.confidence } : {}),
-  };
-}
-
-export const ROUTES: RouteDefinition[] = [
-  {
-    operationId: "previewAutoProfile",
-    endpoint: "auto-profile/preview",
-    method: "POST",
-    policy: {
-      requiredScopes: ["chat.write"],
-      allowedPrincipalTypes: ACTOR_PRINCIPALS,
-    },
-    summary: "Preview the Auto profile's pick for a draft",
-    description:
-      "Ask the Auto profile which default profile a draft message would run on, " +
-      "using the conversation's recent history when one is given. The pick is " +
-      "kept briefly so the turn that sends the same text reuses it. Spends one " +
-      "Jev call per request.",
-    tags: ["conversations"],
-    requestBody: previewRequestSchema,
-    responseBody: previewResponseSchema,
-    handler: handlePreviewAutoProfile,
-  },
-];