@vellumai/assistant 0.6.5 → 0.6.6

package/src/config/bundled-skills/messaging/tools/__tests__/messaging-feed-events.test.ts

@@ -0,0 +1,207 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { EmitFeedEventParams } from "../../../../../home/emit-feed-event.js";
+
+// Capture all emitFeedEvent calls
+const emittedEvents: EmitFeedEventParams[] = [];
+
+mock.module("../../../../../home/emit-feed-event.js", () => ({
+  emitFeedEvent: async (params: EmitFeedEventParams) => {
+    emittedEvents.push(params);
+    return {
+      id: `emit:${params.source}:${params.dedupKey ?? "random"}`,
+      type: "action",
+      source: params.source,
+      title: params.title,
+      summary: params.summary,
+      priority: 50,
+      status: "new",
+      author: "assistant",
+      timestamp: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+    };
+  },
+}));
+
+// Stub messaging provider dependencies
+const mockCreateDraft = mock(async () => ({ id: "draft-123" }));
+const mockCreateDraftRaw = mock(async () => ({ id: "draft-raw-456" }));
+const mockGetThread = mock(async () => ({
+  messages: [
+    {
+      payload: {
+        headers: [
+          { name: "From", value: "sender@example.com" },
+          { name: "To", value: "user@example.com" },
+          { name: "Subject", value: "Test Subject" },
+          { name: "Message-ID", value: "<msg-1@example.com>" },
+        ],
+      },
+    },
+  ],
+}));
+const mockGetProfile = mock(async () => ({
+  emailAddress: "user@example.com",
+}));
+
+mock.module("../../../../../messaging/providers/gmail/client.js", () => ({
+  createDraft: mockCreateDraft,
+  createDraftRaw: mockCreateDraftRaw,
+  getThread: mockGetThread,
+  getProfile: mockGetProfile,
+}));
+
+mock.module("../../../../../messaging/providers/gmail/mime-builder.js", () => ({
+  buildMultipartMime: () => "mock-raw-mime",
+}));
+
+const mockSendMessage = mock(async () => ({
+  id: "msg-sent-789",
+  threadId: "thread-1",
+}));
+const mockArchiveByQuery = mock(async () => ({
+  archived: 3,
+  truncated: false,
+}));
+
+mock.module("../shared.js", () => ({
+  resolveProvider: async (platform?: string) => ({
+    id: platform === "slack" ? "slack" : "gmail",
+    displayName: platform === "slack" ? "Slack" : "Gmail",
+    sendMessage: mockSendMessage,
+    archiveByQuery: mockArchiveByQuery,
+  }),
+  getProviderConnection: async () => ({ token: "mock-token" }),
+  ok: (msg: string) => ({ status: "ok", output: msg }),
+  err: (msg: string) => ({ status: "error", output: msg }),
+  extractEmail: (addr: string) => addr.replace(/.*<(.+)>/, "$1").toLowerCase(),
+  extractHeader: (
+    headers: Array<{ name: string; value: string }>,
+    name: string,
+  ) => headers.find((h: { name: string }) => h.name === name)?.value ?? null,
+  parseAddressList: (addrs: string | null) =>
+    addrs ? addrs.split(",").map((a: string) => a.trim()) : [],
+}));
+
+// Stub gmail-mime-helpers
+mock.module("../gmail-mime-helpers.js", () => ({
+  guessMimeType: () => "application/octet-stream",
+}));
+
+// Stub conversation dependencies used by messaging-send cross-post
+mock.module("../../../../../memory/conversation-crud.js", () => ({
+  addMessage: async () => ({ id: "msg-1" }),
+  getConversation: () => null,
+}));
+mock.module("../../../../../memory/conversation-disk-view.js", () => ({
+  syncMessageToDisk: () => {},
+}));
+mock.module("../../../../../memory/external-conversation-store.js", () => ({
+  getBindingByChannelChat: () => null,
+}));
+
+const { run: runSend } = await import("../messaging-send.js");
+const { run: runArchive } = await import("../messaging-archive-by-sender.js");
+
+const baseContext = {
+  workingDir: "/tmp/test",
+  conversationId: "conv-xyz",
+  assistantId: "assistant-1",
+  triggeredBySurfaceAction: true,
+  batchAuthorizedByTask: false,
+  approvedViaPrompt: false,
+  trustClass: "guardian" as const,
+};
+
+beforeEach(() => {
+  emittedEvents.length = 0;
+  mockCreateDraft.mockClear();
+  mockCreateDraftRaw.mockClear();
+  mockSendMessage.mockClear();
+  mockArchiveByQuery.mockClear();
+});
+
+afterEach(() => {
+  emittedEvents.length = 0;
+});
+
+describe("messaging-send feed events", () => {
+  test("Gmail draft creation emits with source 'gmail' and dedup by draft ID", async () => {
+    await runSend(
+      {
+        platform: "gmail",
+        conversation_id: "recipient@example.com",
+        text: "Hello there",
+        subject: "Test",
+      },
+      baseContext,
+    );
+
+    expect(emittedEvents).toHaveLength(1);
+    expect(emittedEvents[0].source).toBe("gmail");
+    expect(emittedEvents[0].title).toBe("Email Draft Created");
+    expect(emittedEvents[0].dedupKey).toBe("email-draft:draft-123");
+  });
+
+  test("Slack sends emit with source 'slack'", async () => {
+    await runSend(
+      {
+        platform: "slack",
+        conversation_id: "#general",
+        text: "Hello Slack",
+      },
+      baseContext,
+    );
+
+    expect(emittedEvents).toHaveLength(1);
+    expect(emittedEvents[0].source).toBe("slack");
+    expect(emittedEvents[0].title).toBe("Slack Message Sent");
+    expect(emittedEvents[0].dedupKey).toBe("message-sent:msg-sent-789");
+  });
+
+  test("Non-Gmail, non-Slack sends emit with source 'gmail' as fallback", async () => {
+    await runSend(
+      {
+        platform: "other-email",
+        conversation_id: "user@example.com",
+        text: "Hello",
+      },
+      baseContext,
+    );
+
+    expect(emittedEvents).toHaveLength(1);
+    expect(emittedEvents[0].source).toBe("gmail");
+    // Mock resolveProvider returns id:"gmail" for non-slack platforms,
+    // so this goes through the Gmail draft path
+    expect(emittedEvents[0].title).toBe("Email Draft Created");
+    expect(emittedEvents[0].summary).toBe("Created an email draft.");
+  });
+});
+
+describe("messaging-archive feed events", () => {
+  test("Archive emits only when result.archived > 0", async () => {
+    await runArchive(
+      { platform: "gmail", query: "from:sender@example.com" },
+      baseContext,
+    );
+
+    expect(emittedEvents).toHaveLength(1);
+    expect(emittedEvents[0].source).toBe("gmail");
+    expect(emittedEvents[0].title).toBe("Messages Archived");
+    expect(emittedEvents[0].summary).toContain("Archived 3 message(s)");
+  });
+
+  test("Zero-match archives do NOT emit", async () => {
+    mockArchiveByQuery.mockResolvedValueOnce({
+      archived: 0,
+      truncated: false,
+    });
+
+    await runArchive(
+      { platform: "gmail", query: "from:nobody@example.com" },
+      baseContext,
+    );
+
+    expect(emittedEvents).toHaveLength(0);
+  });
+});

package/src/config/bundled-skills/messaging/tools/messaging-archive-by-sender.ts

@@ -1,9 +1,13 @@
+import { emitFeedEvent } from "../../../../home/emit-feed-event.js";
 import type {
   ToolContext,
   ToolExecutionResult,
 } from "../../../../tools/types.js";
+import { getLogger } from "../../../../util/logger.js";
 import { err, getProviderConnection, ok, resolveProvider } from "./shared.js";
 
+const log = getLogger("messaging-archive-by-sender");
+
 export async function run(
   input: Record<string, unknown>,
   context: ToolContext,
@@ -46,6 +50,14 @@ export async function run(
     }
 
     const summary = `Archived ${result.archived} message(s) matching query: ${query}`;
+    void emitFeedEvent({
+      source: "gmail",
+      title: "Messages Archived",
+      summary,
+      dedupKey: `email-archive:${Date.now()}`,
+    }).catch((err) => {
+      log.warn({ err }, "Failed to emit email archive feed event");
+    });
     if (result.truncated) {
       return ok(
         `${summary}\n\nNote: this operation was capped at 5000 messages. Additional messages matching the query may remain in the inbox. Run the command again to archive more.`,

package/src/config/bundled-skills/messaging/tools/messaging-send.ts

@@ -1,6 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { basename } from "node:path";
 
+import { emitFeedEvent } from "../../../../home/emit-feed-event.js";
 import {
   addMessage,
   getConversation,
@@ -149,6 +150,14 @@ export async function run(
             ccList.length > 0
               ? `To: ${toList.join(", ")}; Cc: ${ccList.join(", ")}`
               : `To: ${toList.join(", ")}`;
+          void emitFeedEvent({
+            source: "gmail",
+            title: "Email Draft Created",
+            summary: `Drafted reply to ${recipientSummary}.`,
+            dedupKey: `email-draft:${draft.id}`,
+          }).catch((err) => {
+            log.warn({ err }, "Failed to emit email draft feed event");
+          });
           return ok(
             `Gmail draft created with ${attachments.length} attachment(s): ${filenames} (Draft ID: ${draft.id}). ${recipientSummary}. Review in Gmail Drafts, then tell me to send it or send it yourself.`,
           );
@@ -169,6 +178,14 @@ export async function run(
           ccList.length > 0
             ? `To: ${toList.join(", ")}; Cc: ${ccList.join(", ")}`
             : `To: ${toList.join(", ")}`;
+        void emitFeedEvent({
+          source: "gmail",
+          title: "Email Draft Created",
+          summary: `Drafted reply to ${recipientSummary}.`,
+          dedupKey: `email-draft:${draft.id}`,
+        }).catch((err) => {
+          log.warn({ err }, "Failed to emit email draft feed event");
+        });
         return ok(
           `Gmail draft created (ID: ${draft.id}). ${recipientSummary}. Review in Gmail Drafts, then tell me to send it or send it yourself.`,
         );
@@ -195,6 +212,14 @@ export async function run(
         const draft = await createDraftRaw(gmailConn, raw, threadId);
 
         const filenames = attachments.map((a) => a.filename).join(", ");
+        void emitFeedEvent({
+          source: "gmail",
+          title: "Email Draft Created",
+          summary: "Created an email draft.",
+          dedupKey: `email-draft:${draft.id}`,
+        }).catch((err) => {
+          log.warn({ err }, "Failed to emit email draft feed event");
+        });
         return ok(
           `Gmail draft created with ${attachments.length} attachment(s): ${filenames} (Draft ID: ${draft.id}). Review in Gmail Drafts, then tell me to send it or send it yourself.`,
         );
@@ -211,6 +236,14 @@ export async function run(
         undefined,
         threadId,
       );
+      void emitFeedEvent({
+        source: "gmail",
+        title: "Email Draft Created",
+        summary: "Created an email draft.",
+        dedupKey: `email-draft:${draft.id}`,
+      }).catch((err) => {
+        log.warn({ err }, "Failed to emit email draft feed event");
+      });
       return ok(
         `Gmail draft created (ID: ${draft.id}). Review it in your Gmail Drafts, then tell me to send it or send it yourself from Gmail.`,
       );
@@ -224,6 +257,31 @@ export async function run(
       assistantId: context.assistantId,
     });
 
+    const sendSummary =
+      provider.id === "slack"
+        ? "Sent a Slack message."
+        : provider.id === "telegram"
+          ? "Sent a Telegram message."
+          : "Sent an email.";
+    void emitFeedEvent({
+      source:
+        provider.id === "slack"
+          ? "slack"
+          : provider.id === "telegram"
+            ? "telegram"
+            : "gmail",
+      title:
+        provider.id === "slack"
+          ? "Slack Message Sent"
+          : provider.id === "telegram"
+            ? "Telegram Message Sent"
+            : "Email Sent",
+      summary: sendSummary,
+      dedupKey: `message-sent:${result.id}`,
+    }).catch((err) => {
+      log.warn({ err }, "Failed to emit message send feed event");
+    });
+
     const threadSuffix = result.threadId
       ? `, "thread_id": "${result.threadId}"`
       : "";

package/src/config/bundled-skills/schedule/SKILL.md

@@ -8,7 +8,7 @@ metadata:
     display-name: "Schedule"
 ---
 
-Manage scheduled automations. Schedules can be **recurring** (cron or RRULE expression) or **one-shot** (a single `fire_at` timestamp). Both recurring and one-shot schedules support two modes: **execute** (run a message through the assistant) and **notify** (send a notification to the user).
+Manage scheduled automations. Schedules can be **recurring** (cron or RRULE expression) or **one-shot** (a single `fire_at` timestamp). Schedules support three modes: **execute** (run a message through the assistant), **notify** (send a notification to the user), and **script** (run a shell command directly without LLM involvement).
 
 ## Schedule Syntax
 
@@ -70,11 +70,13 @@ Exclusions (EXDATE, EXRULE) always take precedence over inclusions (RRULE, RDATE
 To create a one-time schedule that fires once and is done, pass `fire_at` (an ISO 8601 timestamp) instead of an `expression`. This replaces the old reminder concept - "remind me at 3pm" becomes a one-shot schedule with `fire_at`.
 
 One-shot schedules:
+
 - Fire once at the specified time, then are marked as `fired` and disabled.
 - Support both `execute` and `notify` modes (see below).
 - Can be cancelled before they fire.
 
 Examples:
+
 - "remind me at 3pm" → `schedule_create` with `fire_at: "2025-03-15T15:00:00-05:00"`, `mode: "notify"`
 - "at 5pm, check my email and summarize it" → `schedule_create` with `fire_at`, `mode: "execute"`
 
@@ -84,8 +86,9 @@ The `mode` parameter controls what happens when a schedule fires:
 
 - **execute** (default) - sends the schedule's message to a background assistant conversation for autonomous handling. The assistant processes the message as if the user sent it.
 - **notify** - sends a notification to the user via the notification pipeline. No assistant processing occurs.
+- **script** - runs the `script` field as a shell command directly. No LLM invoked, no conversation created. stdout/stderr are captured in the schedule run record. Exit code 0 = success, non-zero = error. Commands run in the workspace directory with a 60-second timeout.
 
-Use `notify` for simple reminders ("remind me to take medicine at 9am") and `execute` for tasks that need assistant action ("check my calendar at 8am and send me a digest").
+Use `notify` for simple reminders ("remind me to take medicine at 9am"), `execute` for tasks that need assistant action ("check my calendar at 8am and send me a digest"), and `script` for lightweight shell automations that don't need LLM involvement ("refresh a cache", "poll an API", "rotate logs").
 
 ## Conversation Reuse
 
@@ -121,6 +124,7 @@ Optionally pass `routing_hints` (a JSON object) to influence routing decisions (
   3. If neither field is present or the interface is `cli`, omit `preferred_channels`.
 
   When a channel is determined, include it as a routing hint:
+
   ```
   routing_hints: { preferred_channels: ["<resolved channel>"] }
   routing_intent: "all_channels"
@@ -157,6 +161,7 @@ Phrases like "at the 45 minute mark", "at the top of the hour", "at noon", or "2
    - "noon" / "midnight" → 12:00 PM or 12:00 AM today; if past, tomorrow
 
 3. **Ask only if truly ambiguous** - if neither rule resolves, ask for clarification. Never silently default to "from now."
+
 - Timezones default to the system timezone if omitted. Use IANA timezone identifiers (e.g. "America/Los_Angeles").
 - Prefer RRULE for complex patterns that cron cannot express (e.g. "every other Tuesday", "last weekday of the month").
 
@@ -184,7 +189,7 @@ Scheduled messages run without user interaction. If the task produces output tha
 Choose the right delivery tool based on the content:
 
 - **Rich content** (digests, summaries, reports): For Gmail, use `messaging_send` with the target platform and conversation ID. For Slack, use the Slack Web API directly via CLI (`chat.postMessage`). This preserves the full content and posts directly.
-- **Short alerts** (status updates, completion notices): Use `send_notification` to let the notification router pick the best channel. Note: the router's decision engine rewrites content into short alerts, so it is not suitable for rich content.
+- **Short alerts** (status updates, completion notices): Use `assistant notifications send` via `bash` to let the notification router pick the best channel. Note: the router's decision engine rewrites content into short alerts, so it is not suitable for rich content.
 
 Example schedule message for a Slack digest:
 

package/src/config/bundled-skills/schedule/TOOLS.json

@@ -32,7 +32,11 @@
           },
           "message": {
             "type": "string",
-            "description": "The message to send to the assistant when the schedule triggers"
+            "description": "The message to send to the assistant when the schedule triggers. Required for execute and notify modes."
+          },
+          "script": {
+            "type": "string",
+            "description": "The shell command to run when the schedule triggers. Required for script mode. Runs in the workspace directory with a sanitized environment."
           },
           "enabled": {
             "type": "boolean",
@@ -40,8 +44,8 @@
           },
           "mode": {
             "type": "string",
-            "enum": ["notify", "execute"],
-            "description": "Whether to notify the user or execute autonomously when triggered. Defaults to \"execute\"."
+            "enum": ["notify", "execute", "script"],
+            "description": "Whether to notify the user, execute autonomously via LLM, or run a shell command directly. Defaults to \"execute\"."
           },
           "routing_intent": {
             "type": "string",
@@ -65,7 +69,7 @@
             "description": "Brief non-technical explanation of why this tool is being called"
           }
         },
-        "required": ["name", "message"]
+        "required": ["name"]
       },
       "executor": "tools/schedule-create.ts",
       "execution_target": "host"
@@ -127,7 +131,11 @@
           },
           "message": {
             "type": "string",
-            "description": "New message to send when triggered"
+            "description": "New message to send when triggered (for execute/notify modes)"
+          },
+          "script": {
+            "type": "string",
+            "description": "New shell command to run when triggered (for script mode)"
           },
           "enabled": {
             "type": "boolean",
@@ -135,8 +143,8 @@
           },
           "mode": {
             "type": "string",
-            "enum": ["notify", "execute"],
-            "description": "Whether to notify the user or execute autonomously when triggered"
+            "enum": ["notify", "execute", "script"],
+            "description": "Whether to notify the user, execute autonomously via LLM, or run a shell command directly"
           },
           "routing_intent": {
             "type": "string",

package/src/config/bundled-skills/schedule/references/SCRIPT_MODE_PATTERNS.md

@@ -0,0 +1,59 @@
+# Script Mode Patterns
+
+Script mode runs shell commands without LLM involvement, but scripts can escalate to the assistant or notify the user via CLI commands when conditions are met. This makes script mode a building block for conditional automation — fast, deterministic checks that only invoke heavier machinery when needed.
+
+## Script → LLM Escalation
+
+Use `assistant conversations wake` to hand off to the assistant when a script detects something that needs LLM reasoning. The wake command injects a hint into an existing conversation without creating a user-visible message.
+
+Example: poll an API and wake the assistant only when results change.
+
+```sh
+LAST="/workspace/data/api-status-last.txt"
+CURRENT=$(curl -sf https://api.example.com/status)
+[ "$CURRENT" = "$(cat "$LAST" 2>/dev/null)" ] && exit 0
+echo "$CURRENT" > "$LAST"
+assistant conversations wake CONVERSATION_ID --hint "API status changed: $CURRENT" --source scheduled-poll
+```
+
+Example: check disk usage and escalate to the assistant when it's high.
+
+```sh
+USAGE=$(df /workspace --output=pcent | tail -1 | tr -d ' %')
+[ "$USAGE" -lt 90 ] && exit 0
+assistant conversations wake CONVERSATION_ID --hint "Disk usage at ${USAGE}% — investigate and clean up" --source disk-monitor
+```
+
+## Script → Notification
+
+Use `assistant notifications send` to alert the user directly when a script detects something noteworthy. No LLM is involved — the notification goes straight to the user's connected channels.
+
+Example: check if a service is down and notify the user.
+
+```sh
+if ! curl -sf --max-time 5 https://myapp.example.com/health > /dev/null; then
+  assistant notifications send \
+    --source-channel scheduler \
+    --source-event-name schedule.notify \
+    --message "myapp.example.com health check failed" \
+    --urgency high \
+    --dedupe-key "myapp-health-$(date +%Y%m%d)"
+fi
+```
+
+Example: notify when a long-running background job finishes.
+
+```sh
+if [ -f /workspace/data/export-complete.flag ]; then
+  assistant notifications send \
+    --source-channel scheduler \
+    --source-event-name schedule.notify \
+    --message "Data export finished — file ready at /workspace/data/export.csv" \
+    --no-requires-action
+  rm /workspace/data/export-complete.flag
+fi
+```
+
+## Tips
+
+Both patterns keep scheduled runs fast and cheap — the script exits immediately when nothing interesting happens, and only reaches for the assistant or notification system when there's something to act on. Use `quiet: true` on the schedule to suppress the per-run completion noise.

package/src/config/bundled-tool-registry.ts

@@ -39,8 +39,6 @@ import * as contactMerge from "./bundled-skills/contacts/tools/contact-merge.js"
 import * as contactSearch from "./bundled-skills/contacts/tools/contact-search.js";
 import * as contactUpsert from "./bundled-skills/contacts/tools/contact-upsert.js";
 import * as googleContacts from "./bundled-skills/contacts/tools/google-contacts.js";
-// ── conversations ──────────────────────────────────────────────────────────────
-import * as renameConversation from "./bundled-skills/conversations/tools/rename-conversation.js";
 // ── document ───────────────────────────────────────────────────────────────────
 import * as documentCreate from "./bundled-skills/document/tools/document-create.js";
 import * as documentUpdate from "./bundled-skills/document/tools/document-update.js";
@@ -68,8 +66,6 @@ import * as messagingRead from "./bundled-skills/messaging/tools/messaging-read.
 import * as messagingSearch from "./bundled-skills/messaging/tools/messaging-search.js";
 import * as messagingSend from "./bundled-skills/messaging/tools/messaging-send.js";
 import * as messagingSenderDigest from "./bundled-skills/messaging/tools/messaging-sender-digest.js";
-// ── notifications ──────────────────────────────────────────────────────────────
-import * as sendNotification from "./bundled-skills/notifications/tools/send-notification.js";
 // ── phone-calls ────────────────────────────────────────────────────────────────
 import * as callEnd from "./bundled-skills/phone-calls/tools/call-end.js";
 import * as callStart from "./bundled-skills/phone-calls/tools/call-start.js";
@@ -84,8 +80,6 @@ import * as scheduleCreate from "./bundled-skills/schedule/tools/schedule-create
 import * as scheduleDelete from "./bundled-skills/schedule/tools/schedule-delete.js";
 import * as scheduleList from "./bundled-skills/schedule/tools/schedule-list.js";
 import * as scheduleUpdate from "./bundled-skills/schedule/tools/schedule-update.js";
-// ── screen-watch ───────────────────────────────────────────────────────────────
-import * as startScreenWatch from "./bundled-skills/screen-watch/tools/start-screen-watch.js";
 // ── sequences ──────────────────────────────────────────────────────────────────
 import * as sequenceAnalytics from "./bundled-skills/sequences/tools/sequence-analytics.js";
 import * as sequenceCreate from "./bundled-skills/sequences/tools/sequence-create.js";
@@ -152,9 +146,6 @@ export const bundledToolRegistry = new Map<string, SkillToolScript>([
   ["contacts:tools/contact-merge.ts", contactMerge],
   ["contacts:tools/google-contacts.ts", googleContacts],
 
-  // conversations
-  ["conversations:tools/rename-conversation.ts", renameConversation],
-
   // document
   ["document:tools/document-create.ts", documentCreate],
   ["document:tools/document-update.ts", documentUpdate],
@@ -190,9 +181,6 @@ export const bundledToolRegistry = new Map<string, SkillToolScript>([
   ["messaging:tools/messaging-sender-digest.ts", messagingSenderDigest],
   ["messaging:tools/messaging-archive-by-sender.ts", messagingArchiveBySender],
 
-  // notifications
-  ["notifications:tools/send-notification.ts", sendNotification],
-
   // phone-calls
   ["phone-calls:tools/call-start.ts", callStart],
   ["phone-calls:tools/call-status.ts", callStatus],
@@ -210,9 +198,6 @@ export const bundledToolRegistry = new Map<string, SkillToolScript>([
   ["schedule:tools/schedule-update.ts", scheduleUpdate],
   ["schedule:tools/schedule-delete.ts", scheduleDelete],
 
-  // screen-watch
-  ["screen-watch:tools/start-screen-watch.ts", startScreenWatch],
-
   // sequences
   ["sequences:tools/sequence-create.ts", sequenceCreate],
   ["sequences:tools/sequence-list.ts", sequenceList],

package/src/config/feature-flag-registry.json

@@ -327,7 +327,7 @@
       "key": "onboarding-pre-chat",
       "label": "Pre-Chat Onboarding Flow",
       "description": "Gates the 3-screen pre-chat onboarding flow (tools, tasks/tone, name exchange) shown before the first conversation",
-      "defaultEnabled": false
+      "defaultEnabled": true
     },
     {
       "id": "home-tab",
@@ -376,6 +376,22 @@
       "label": "Message Height Cache",
       "description": "Swap the transcript's LazyVStack for a plain VStack so scrollContentHeight is the true sum of row heights (no LazyVStack estimator drift). Row frames are not pinned — the earlier frame-pinning approach was removed because it caused overlap when rows grew past their first measurement (streaming, expanding thinking blocks). Tradeoff: eager layout — every row measures up-front, which can stall for many seconds to minutes on very long conversations.",
       "defaultEnabled": true
+    },
+    {
+      "id": "permission-controls-v3",
+      "scope": "assistant",
+      "key": "permission-controls-v3",
+      "label": "Permission Controls v3",
+      "description": "Enables permission controls v3: gateway-backed auto-approve thresholds, risk badges on tool results, simplified Allow/Deny permission prompt, and rule editor modal.",
+      "defaultEnabled": false
+    },
+    {
+      "id": "compaction-playground",
+      "scope": "assistant",
+      "key": "compaction-playground",
+      "label": "Compaction Playground",
+      "description": "Expose the developer-only Compaction Playground tab in macOS Settings and enable the /playground/* HTTP endpoints for exercising compaction conditions. Dev-only; default off.",
+      "defaultEnabled": false
     }
   ]
 }

package/src/config/schema.ts

@@ -43,6 +43,8 @@ export {
   TwilioConfigSchema,
   WhatsAppConfigSchema,
 } from "./schemas/channels.js";
+export type { ConversationsConfig } from "./schemas/conversations.js";
+export { ConversationsConfigSchema } from "./schemas/conversations.js";
 export {
   DEFAULT_ELEVENLABS_VOICE_ID,
   VALID_CONVERSATION_TIMEOUTS,
@@ -240,6 +242,7 @@ import {
   TwilioConfigSchema,
   WhatsAppConfigSchema,
 } from "./schemas/channels.js";
+import { ConversationsConfigSchema } from "./schemas/conversations.js";
 import { FilingConfigSchema } from "./schemas/filing.js";
 import { HeartbeatConfigSchema } from "./schemas/heartbeat.js";
 import { HostBrowserConfigSchema } from "./schemas/host-browser.js";
@@ -307,6 +310,9 @@ export const AssistantConfigSchema = z
     hostBrowser: HostBrowserConfigSchema.default(
       HostBrowserConfigSchema.parse({}),
     ),
+    conversations: ConversationsConfigSchema.default(
+      ConversationsConfigSchema.parse({}),
+    ),
     journal: JournalConfigSchema.default(JournalConfigSchema.parse({})),
     analysis: AnalysisConfigSchema.default(AnalysisConfigSchema.parse({})),
     backup: BackupConfigSchema.default(BackupConfigSchema.parse({})),
@@ -328,6 +334,19 @@ export const AssistantConfigSchema = z
       NotificationsConfigSchema.parse({}),
     ),
     ui: UiConfigSchema.default(UiConfigSchema.parse({})),
+    // Per-plugin config blocks keyed by plugin name. The schema is intentionally
+    // permissive — each plugin's manifest supplies its own validator which the
+    // plugin bootstrap (`external-plugins-bootstrap.ts`) runs against the raw
+    // block under `plugins.<name>` before handing the parsed result to the
+    // plugin's `init()`. Keeping this open here means adding a new plugin does
+    // not require a core-schema change, while invalid configs still surface
+    // through the plugin's own validator at bootstrap.
+    plugins: z
+      .record(z.string(), z.unknown())
+      .optional()
+      .describe(
+        "Per-plugin configuration keyed by plugin name. Validated downstream by each plugin's manifest.config validator at bootstrap.",
+      ),
     collectUsageData: z
       .boolean()
       .default(true)

package/src/config/schemas/backup.ts

@@ -54,7 +54,7 @@ export const BackupConfigSchema = z
       .int("backup.retention must be an integer")
       .min(1, "backup.retention must be >= 1")
       .max(100, "backup.retention must be <= 100")
-      .default(7)
+      .default(3)
       .describe("Number of recent backups to retain"),
     offsite: BackupOffsiteConfigSchema.default(
       BackupOffsiteConfigSchema.parse({}),