@vellumai/assistant 0.7.1 → 0.7.3

package/src/runtime/routes/conversation-routes.ts

@@ -39,12 +39,15 @@ import {
   resolveSlash,
 } from "../../daemon/conversation-slash.js";
 import { getOrCreateConversation as getOrCreateConversationInstance } from "../../daemon/conversation-store.js";
+import { canonicalizeTimeZone } from "../../daemon/date-context.js";
 import {
   getCannedFirstGreeting,
   isWakeUpGreeting,
 } from "../../daemon/first-greeting.js";
 import { renderHistoryContent } from "../../daemon/handlers/shared.js";
+import { HostAppControlProxy } from "../../daemon/host-app-control-proxy.js";
 import { HostCuProxy } from "../../daemon/host-cu-proxy.js";
+import { preactivateHostProxySkills } from "../../daemon/host-proxy-preactivation.js";
 import type { ServerMessage } from "../../daemon/message-protocol.js";
 import type {
   HostProxyTransportMetadata,
@@ -84,6 +87,8 @@ import {
   getOrCreateConversation,
 } from "../../memory/conversation-key-store.js";
 import { searchConversations } from "../../memory/conversation-queries.js";
+import { normalizeOnboardingContext } from "../../prompts/normalize-onboarding.js";
+import { writeOnboardingSection } from "../../prompts/persona-resolver.js";
 import { getConfiguredProvider } from "../../providers/provider-send-message.js";
 import type { Provider } from "../../providers/types.js";
 import { checkIngressForSecrets } from "../../security/secret-ingress.js";
@@ -997,7 +1002,7 @@ function mergeConsecutiveAssistantMessages(messages: MessageRow[]): {
 /**
  * Persist the pre-chat onboarding payload to disk.
  *
- * Runs only on the very first message of a fresh conversation. Three
+ * Runs only on the very first message of a fresh conversation. Four
  * artifacts are produced:
  *
  *   1. `data/onboarding-context.json` — sidecar read by the
@@ -1005,12 +1010,15 @@ function mergeConsecutiveAssistantMessages(messages: MessageRow[]): {
  *      the pure-recomputation write cycle (every turn boundary rebuilds
  *      facts from markdown; the sidecar is the durable source for the
  *      tool/task/tone chips).
- *   2. `IDENTITY.md` / `USER.md` — persona seed files, only written
- *      when missing so we never clobber existing content. These feed
- *      the system prompt and the relationship-state writer's
- *      `parseIdentity` / `parseUserName` helpers after a daemon
- *      restart when the in-memory onboarding context is gone.
- *   3. `data/relationship-state.json` — kicked off fire-and-forget so
+ *   2. `IDENTITY.md` — assistant persona seed file, only written when
+ *      missing so we never clobber existing content. Feeds the system
+ *      prompt and the relationship-state writer's `parseIdentity`
+ *      helper after a daemon restart when the in-memory onboarding
+ *      context is gone.
+ *   3. Onboarding section in the guardian persona file — written via
+ *      `writeOnboardingSection`, which handles the user's preferred
+ *      name (with fallback to root `USER.md`).
+ *   4. `data/relationship-state.json` — kicked off fire-and-forget so
  *      the Home page can populate immediately on first visit instead
  *      of waiting for the first agent-turn boundary.
  *
@@ -1055,25 +1063,11 @@ export function persistOnboardingArtifacts(onboarding: {
     }
   }
 
-  const userName = onboarding.userName?.trim();
-  if (userName) {
-    const userPath = getWorkspacePromptPath("USER.md");
-    try {
-      if (existsSync(userPath)) {
-        const content = readFileSync(userPath, "utf-8");
-        const updated = content.replace(
-          /^- (?:\*\*)?Name:(?:\*\*)?\s*.*$/m,
-          () => `- **Name:** ${userName}`,
-        );
-        if (updated !== content) {
-          writeFileSync(userPath, updated, "utf-8");
-        }
-      } else {
-        writeFileSync(userPath, `# User\n\n- **Name:** ${userName}\n`, "utf-8");
-      }
-    } catch (err) {
-      log.warn({ err, userPath }, "Failed to seed USER.md from onboarding");
-    }
+  try {
+    const normalized = normalizeOnboardingContext(onboarding);
+    writeOnboardingSection(normalized);
+  } catch (err) {
+    log.warn({ err }, "Failed to write onboarding section to persona file");
   }
 
   void writeRelationshipState().catch((err) => {
@@ -1102,6 +1096,7 @@ export async function handleSendMessage(
     bypassSecretCheck?: boolean;
     hostHomeDir?: string;
     hostUsername?: string;
+    clientTimezone?: unknown;
     clientId?: string;
     clientMessageId?: string;
     inferenceProfile?: string | null;
@@ -1181,6 +1176,10 @@ export async function handleSendMessage(
       )}`,
     );
   }
+  const clientTimezone =
+    typeof body.clientTimezone === "string"
+      ? (canonicalizeTimeZone(body.clientTimezone) ?? undefined)
+      : undefined;
 
   // When conversationKey is omitted, derive a stable default from
   // sourceChannel + sourceInterface so that repeated calls from the same
@@ -1300,10 +1299,12 @@ export async function handleSendMessage(
         interfaceId: sourceInterface,
         hostHomeDir: body.hostHomeDir,
         hostUsername: body.hostUsername,
+        ...(clientTimezone ? { clientTimezone } : {}),
       } satisfies HostProxyTransportMetadata)
     : ({
         channelId: sourceChannel,
         interfaceId: sourceInterface,
+        ...(clientTimezone ? { clientTimezone } : {}),
       } satisfies NonHostProxyTransportMetadata);
 
   const conversation = await smDeps.getOrCreateConversation(
@@ -1320,10 +1321,9 @@ export async function handleSendMessage(
 
   // Store pre-chat onboarding context on the conversation when this is the
   // very first message (no prior messages loaded). Artifact persistence
-  // (IDENTITY.md, USER.md, sidecar) is deferred: on the canned greeting
-  // path it runs inside the setTimeout right before warmPromptCache() so
-  // the warmed system prompt includes the identity; on the normal LLM
-  // path it runs immediately before inference starts.
+  // (IDENTITY.md, USER.md, sidecar) runs before either the canned greeting
+  // broadcast or normal LLM inference so client-side identity reads observe
+  // the selected assistant name.
   const isFirstOnboarding =
     !!body.onboarding && conversation.messages.length === 0;
   if (isFirstOnboarding) {
@@ -1395,15 +1395,30 @@ export async function handleSendMessage(
     if (!conversation.isProcessing() || !conversation.hostCuProxy) {
       conversation.setHostCuProxy(new HostCuProxy());
     }
-    // Only preactivate CU when the conversation is idle — if the conversation is
-    // processing, this message will be queued and preactivation is deferred
-    // to dequeue time in drainQueueImpl to avoid mutating in-flight turn state.
-    if (!conversation.isProcessing()) {
-      conversation.addPreactivatedSkillId("computer-use");
-    }
   } else if (!conversation.isProcessing()) {
     conversation.setHostCuProxy(undefined);
   }
+  // App-control mirrors CU's per-conversation lifecycle: the proxy owns a
+  // singleton lock plus per-session loop tracking. Instantiation is
+  // unconditional when the client supports the capability — feature-flag
+  // gating lives in the skill-projection layer (which reads the
+  // `feature-flag: app-control` declaration in SKILL.md frontmatter), so
+  // an attached proxy is harmless when the flag resolves to off.
+  if (supportsHostProxy(sourceInterface, "host_app_control")) {
+    if (!conversation.isProcessing() || !conversation.hostAppControlProxy) {
+      conversation.setHostAppControlProxy(
+        new HostAppControlProxy(mapping.conversationId),
+      );
+    }
+  } else if (!conversation.isProcessing()) {
+    conversation.setHostAppControlProxy(undefined);
+  }
+  // Only preactivate when the conversation is idle — if it's processing,
+  // this message will be queued and preactivation is deferred to dequeue
+  // time in drainQueueImpl to avoid mutating in-flight turn state.
+  if (!conversation.isProcessing()) {
+    preactivateHostProxySkills(conversation, sourceInterface);
+  }
   // Wire sendToClient to the SSE hub so all subsystems can reach the HTTP client.
   // hasNoClient must remain `!isInteractive` so downstream tool gating
   // (`isToolActiveForContext` for HOST_TOOL_NAMES, `createToolExecutor`'s
@@ -1473,6 +1488,10 @@ export async function handleSendMessage(
         conversationId,
       };
 
+      if (isFirstOnboarding) {
+        persistOnboardingArtifacts(body.onboarding!);
+      }
+
       setTimeout(() => {
         broadcastMessage({
           type: "user_message_echo",
@@ -1493,9 +1512,6 @@ export async function handleSendMessage(
           "canned-greeting queue drain",
         );
 
-        if (isFirstOnboarding) {
-          persistOnboardingArtifacts(body.onboarding!);
-        }
         conversation.warmPromptCache();
       }, 0);
 
@@ -1974,6 +1990,13 @@ async function generateLlmSuggestion(
   // prefill-safe model. Keep `stop_sequences: ["</reply>"]` as an
   // early-termination hint; the parser below handles both tagged and
   // untagged responses so untagged "casual answer" replies still work.
+  //
+  // Force `thinking: disabled` + `effort: none` so the call works on any
+  // user profile — including thinking-enabled profiles (Opus 4.x at
+  // `effort: high|xhigh`, etc.) where Anthropic 400s on `temperature` ≠ 1
+  // when thinking is enabled or in adaptive mode. A 60-token reply chip
+  // doesn't benefit from extended thinking anyway, and burning thinking
+  // tokens here would be wasteful.
   const response = await provider.sendMessage(
     [{ role: "user", content: [{ type: "text", text: userPrompt }] }],
     [], // no tools
@@ -1984,6 +2007,8 @@ async function generateLlmSuggestion(
         max_tokens: 60,
         stop_sequences: ["</reply>"],
         temperature: 0.7,
+        thinking: { type: "disabled" },
+        effort: "none",
       },
     },
   );
@@ -2257,6 +2282,7 @@ export const ROUTES: RouteDefinition[] = [
         .optional(),
       conversationType: z.string().optional(),
       slashCommand: z.string().optional(),
+      clientTimezone: z.string().optional(),
       inferenceProfile: z.string().nullable().optional(),
       riskThreshold: z.enum(VALID_RISK_THRESHOLDS).optional(),
     }),

package/src/runtime/routes/debug-bash-routes.ts

@@ -0,0 +1,163 @@
+/**
+ * IPC route for executing shell commands through the assistant process.
+ *
+ * The CLI sends the command over the IPC socket and receives a single
+ * response containing stdout, stderr, and the exit code.
+ *
+ * **Security**: Gated behind VELLUM_DEBUG=1. When debug mode is off (the
+ * default), the handler returns an error immediately so the CLI surfaces a
+ * clear rejection instead of hanging. The assistant must be restarted with
+ * VELLUM_DEBUG=1 for this route to execute commands.
+ */
+
+import { spawn } from "node:child_process";
+
+import { z } from "zod";
+
+import { getIsContainerized } from "../../config/env-registry.js";
+import { getWorkspaceDir } from "../../util/platform.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+
+function isDebugMode(): boolean {
+  return (
+    process.env.VELLUM_DEBUG === "1" || process.env.VELLUM_DEBUG === "true"
+  );
+}
+
+interface DebugBashResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number | null;
+  timedOut: boolean;
+  error?: string;
+}
+
+function handleDebugBash({ body }: RouteHandlerArgs): Promise<DebugBashResult> {
+  if (getIsContainerized()) {
+    return Promise.resolve({
+      stdout: "",
+      stderr: "",
+      exitCode: null,
+      timedOut: false,
+      error: "debug bash is not available in containerized environments",
+    });
+  }
+
+  if (!isDebugMode()) {
+    return Promise.resolve({
+      stdout: "",
+      stderr: "",
+      exitCode: null,
+      timedOut: false,
+      error:
+        "Bash debug execution is disabled. The running assistant process must have been started with VELLUM_DEBUG=1 (setting it on the CLI command alone is not enough). Restart the assistant with: vellum sleep && VELLUM_DEBUG=1 vellum wake",
+    });
+  }
+
+  const { command, timeoutMs } = body as {
+    command?: string;
+    timeoutMs?: number;
+  };
+
+  if (!command || typeof command !== "string") {
+    return Promise.resolve({
+      stdout: "",
+      stderr: "",
+      exitCode: null,
+      timedOut: false,
+      error: "command is required",
+    });
+  }
+
+  const effectiveTimeout =
+    typeof timeoutMs === "number" && timeoutMs > 0
+      ? timeoutMs
+      : DEFAULT_TIMEOUT_MS;
+
+  return new Promise<DebugBashResult>((resolve) => {
+    const stdoutChunks: Buffer[] = [];
+    const stderrChunks: Buffer[] = [];
+    let timedOut = false;
+    let settled = false;
+
+    const finish = (result: DebugBashResult) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+
+    const child = spawn("bash", ["-c", command], {
+      cwd: getWorkspaceDir(),
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true,
+    });
+
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        process.kill(-child.pid!, "SIGKILL");
+      } catch {
+        // Process group may have already exited.
+      }
+    }, effectiveTimeout);
+
+    child.stdout.on("data", (data: Buffer) => {
+      stdoutChunks.push(data);
+    });
+
+    child.stderr.on("data", (data: Buffer) => {
+      stderrChunks.push(data);
+    });
+
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      finish({
+        stdout: Buffer.concat(stdoutChunks).toString(),
+        stderr: Buffer.concat(stderrChunks).toString(),
+        exitCode: code,
+        timedOut,
+      });
+    });
+
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      finish({
+        stdout: "",
+        stderr: "",
+        exitCode: null,
+        timedOut: false,
+        error: err.message,
+      });
+    });
+  });
+}
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "debug_bash",
+    endpoint: "debug/bash",
+    method: "POST",
+    requireGuardian: false,
+    summary: "Execute a shell command in the assistant process",
+    description:
+      "Developer debugging tool. Requires the assistant to be running with VELLUM_DEBUG=1.",
+    tags: ["debug"],
+    requestBody: z.object({
+      command: z.string().describe("Shell command to execute via bash -c"),
+      timeoutMs: z
+        .number()
+        .optional()
+        .describe("Execution timeout in milliseconds (default: 30000)"),
+    }),
+    responseBody: z.object({
+      stdout: z.string(),
+      stderr: z.string(),
+      exitCode: z.number().nullable(),
+      timedOut: z.boolean(),
+      error: z.string().optional(),
+    }),
+    handler: handleDebugBash,
+  },
+];

package/src/runtime/routes/disk-pressure-routes.ts

@@ -0,0 +1,121 @@
+import { z } from "zod";
+
+import {
+  acknowledgeDiskPressureLock,
+  DISK_PRESSURE_OVERRIDE_CONFIRMATION,
+  getDiskPressureStatus,
+  overrideDiskPressureLock,
+} from "../../daemon/disk-pressure-guard.js";
+import { RouteError } from "./errors.js";
+import type { RouteDefinition } from "./types.js";
+
+const DiskPressureStatusSchema = z.object({
+  enabled: z.boolean(),
+  state: z.enum(["disabled", "ok", "critical", "unknown"]),
+  locked: z.boolean(),
+  acknowledged: z.boolean(),
+  overrideActive: z.boolean(),
+  effectivelyLocked: z.boolean(),
+  lockId: z.string().nullable(),
+  usagePercent: z.number().nullable(),
+  thresholdPercent: z.number(),
+  path: z.string().nullable(),
+  lastCheckedAt: z.string().nullable(),
+  blockedCapabilities: z.array(
+    z.enum(["agent-turns", "background-work", "remote-ingress"]),
+  ),
+  error: z.string().nullable(),
+});
+
+const DiskPressureActionResponseSchema = z.object({
+  status: DiskPressureStatusSchema,
+});
+
+const OverrideRequestSchema = z.object({
+  confirmation: z.string(),
+});
+
+function statusResponse() {
+  return { status: getDiskPressureStatus() };
+}
+
+function transitionErrorCode(
+  reason: "not_locked" | "already_acknowledged" | "already_overridden",
+): string {
+  if (reason === "not_locked") return "NOT_LOCKED";
+  if (reason === "already_acknowledged") return "ALREADY_ACKNOWLEDGED";
+  return "ALREADY_OVERRIDDEN";
+}
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "getDiskPressureStatus",
+    endpoint: "disk-pressure/status",
+    method: "GET",
+    policyKey: "disk-pressure/status",
+    requirePolicyEnforcement: true,
+    summary: "Get disk pressure status",
+    description:
+      "Return the current disk pressure status snapshot. When safe storage limits are disabled, returns a disabled status.",
+    tags: ["disk-pressure"],
+    responseBody: DiskPressureActionResponseSchema,
+    handler: () => statusResponse(),
+  },
+  {
+    operationId: "acknowledgeDiskPressure",
+    endpoint: "disk-pressure/acknowledge",
+    method: "POST",
+    policyKey: "disk-pressure/acknowledge",
+    requirePolicyEnforcement: true,
+    summary: "Acknowledge disk pressure",
+    description:
+      "Acknowledge the current disk pressure lock and enter cleanup mode without overriding assistant protections.",
+    tags: ["disk-pressure"],
+    responseBody: DiskPressureActionResponseSchema,
+    additionalResponses: {
+      "409": { description: "No active lock or lock already acknowledged." },
+    },
+    handler: () => {
+      const result = acknowledgeDiskPressureLock();
+      if (result.ok) return { status: result.status };
+      if (result.reason === "invalid_confirmation") {
+        throw new RouteError(result.message, "INVALID_CONFIRMATION", 400);
+      }
+      throw new RouteError(
+        result.message,
+        transitionErrorCode(result.reason),
+        409,
+      );
+    },
+  },
+  {
+    operationId: "overrideDiskPressure",
+    endpoint: "disk-pressure/override",
+    method: "POST",
+    policyKey: "disk-pressure/override",
+    requirePolicyEnforcement: true,
+    summary: "Override disk pressure",
+    description: `Override the current disk pressure lock only after confirming "${DISK_PRESSURE_OVERRIDE_CONFIRMATION}".`,
+    tags: ["disk-pressure"],
+    requestBody: OverrideRequestSchema,
+    responseBody: DiskPressureActionResponseSchema,
+    additionalResponses: {
+      "400": { description: "Confirmation phrase is invalid." },
+      "409": { description: "No active lock or lock already overridden." },
+    },
+    handler: ({ body }) => {
+      const parsed = OverrideRequestSchema.safeParse(body);
+      const confirmation = parsed.success ? parsed.data.confirmation : "";
+      const result = overrideDiskPressureLock(confirmation);
+      if (result.ok) return { status: result.status };
+      if (result.reason === "invalid_confirmation") {
+        throw new RouteError(result.message, "INVALID_CONFIRMATION", 400);
+      }
+      throw new RouteError(
+        result.message,
+        transitionErrorCode(result.reason),
+        409,
+      );
+    },
+  },
+];

package/src/runtime/routes/document-pdf-renderer.ts

@@ -0,0 +1,169 @@
+/**
+ * Markdown to PDF renderer for document export.
+ *
+ * Converts markdown content to styled HTML via `marked`, then renders
+ * the HTML to a PDF buffer using Playwright headless Chromium.
+ * The HTML template uses print-friendly styling that matches the
+ * document editor typography.
+ */
+
+import { marked } from "marked";
+
+import { importPlaywright } from "../../tools/browser/runtime-check.js";
+
+// ---------------------------------------------------------------------------
+// Print template
+// ---------------------------------------------------------------------------
+
+const FONT_STACK = `"DM Sans", -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif`;
+
+function wrapInPrintTemplate(innerHtml: string): string {
+  return `<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+
+  body {
+    font-family: ${FONT_STACK};
+    font-size: 14px;
+    line-height: 1.7;
+    color: #1a1a1a;
+    background: #ffffff;
+    padding: 0;
+  }
+
+  h1 { font-size: 28px; font-weight: 600; margin-top: 32px; margin-bottom: 12px; }
+  h2 { font-size: 22px; font-weight: 600; margin-top: 28px; margin-bottom: 10px; }
+  h3 { font-size: 18px; font-weight: 600; margin-top: 24px; margin-bottom: 8px; }
+  h4, h5, h6 { font-size: 16px; font-weight: 600; margin-top: 20px; margin-bottom: 8px; }
+
+  p {
+    margin-bottom: 12px;
+  }
+
+  pre {
+    background: #f5f5f5;
+    border-radius: 8px;
+    padding: 12px 16px;
+    overflow-x: auto;
+    margin-bottom: 12px;
+  }
+
+  code {
+    font-family: "DM Mono", "SF Mono", monospace;
+    font-size: 13px;
+    background: #f5f5f5;
+    border-radius: 4px;
+    padding: 2px 5px;
+  }
+
+  pre code {
+    background: none;
+    padding: 0;
+    border-radius: 0;
+  }
+
+  blockquote {
+    border-left: 3px solid #6366f1;
+    padding-left: 16px;
+    margin: 12px 0;
+    color: #555555;
+  }
+
+  table {
+    width: 100%;
+    border-collapse: collapse;
+    margin: 12px 0;
+  }
+
+  th, td {
+    border: 1px solid #e0e0e0;
+    padding: 8px 12px;
+    text-align: left;
+  }
+
+  th {
+    background: #f5f5f5;
+    font-weight: 600;
+  }
+
+  ul, ol {
+    margin: 12px 0;
+    padding-left: 24px;
+  }
+
+  li {
+    margin-bottom: 4px;
+  }
+
+  a {
+    color: #6366f1;
+    text-decoration: none;
+  }
+
+  hr {
+    border: none;
+    border-top: 1px solid #e0e0e0;
+    margin: 24px 0;
+  }
+
+  img {
+    max-width: 100%;
+    height: auto;
+  }
+
+</style>
+</head>
+<body>
+${innerHtml}
+</body>
+</html>`;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Convert a markdown string to a PDF buffer.
+ *
+ * Parses markdown to HTML via `marked`, wraps it in a print-friendly
+ * template, then renders to PDF using Playwright headless Chromium.
+ * The browser is always closed in a `finally` block.
+ */
+export async function renderMarkdownToPDF(
+  title: string,
+  markdown: string,
+): Promise<Buffer> {
+  const innerHtml = marked.parse(markdown, {
+    gfm: true,
+    breaks: true,
+  }) as string;
+  const fullHtml = wrapInPrintTemplate(innerHtml);
+
+  const pw = await importPlaywright();
+  const browser = await pw.chromium.launch({ headless: true });
+  try {
+    const context = await browser.newContext({
+      javaScriptEnabled: false,
+    });
+    const page = await context.newPage();
+    await page.route("**/*", (route) => route.abort());
+    await page.setContent(fullHtml, { waitUntil: "domcontentloaded" });
+    const pdfBuffer = await page.pdf({
+      format: "A4",
+      margin: {
+        top: "0.75in",
+        bottom: "0.75in",
+        left: "0.75in",
+        right: "0.75in",
+      },
+      printBackground: true,
+    });
+    return Buffer.from(pdfBuffer);
+  } finally {
+    await browser.close();
+  }
+}