@vellumai/assistant 0.3.27 → 0.4.0

package/src/config/agent-schema.ts

@@ -131,7 +131,7 @@ export const WorkspaceGitConfigSchema = z.object({
   commitMessageLLM: z.object({
     enabled: z.boolean({ error: 'workspaceGit.commitMessageLLM.enabled must be a boolean' }).default(false),
     useConfiguredProvider: z.boolean({ error: 'workspaceGit.commitMessageLLM.useConfiguredProvider must be a boolean' }).default(true),
-    providerFastModelOverrides: z.record(z.string(), z.string()).default({} as any),
+    providerFastModelOverrides: z.record(z.string(), z.string()).default({} as Record<string, string>),
     timeoutMs: z.number({ error: 'workspaceGit.commitMessageLLM.timeoutMs must be a number' })
       .int('workspaceGit.commitMessageLLM.timeoutMs must be an integer')
       .positive('workspaceGit.commitMessageLLM.timeoutMs must be a positive integer')
@@ -163,8 +163,19 @@ export const WorkspaceGitConfigSchema = z.object({
         .int().positive().default(2000),
       backoffMaxMs: z.number({ error: 'workspaceGit.commitMessageLLM.breaker.backoffMaxMs must be a number' })
         .int().positive().default(60000),
-    }).default({} as any),
-  }).default({} as any),
+    }).default({ openAfterFailures: 3, backoffBaseMs: 2000, backoffMaxMs: 60000 }),
+  }).default({
+    enabled: false,
+    useConfiguredProvider: true,
+    providerFastModelOverrides: {},
+    timeoutMs: 600,
+    maxTokens: 120,
+    temperature: 0.2,
+    maxFilesInPrompt: 30,
+    maxDiffBytes: 12000,
+    minRemainingTurnBudgetMs: 1000,
+    breaker: { openAfterFailures: 3, backoffBaseMs: 2000, backoffMaxMs: 60000 },
+  }),
 });
 
 export type HeartbeatConfig = z.infer<typeof HeartbeatConfigSchema>;

package/src/config/calls-schema.ts

@@ -76,7 +76,7 @@ export const CallsVoiceConfigSchema = z.object({
   fallbackToStandardOnError: z
     .boolean({ error: 'calls.voice.fallbackToStandardOnError must be a boolean' })
     .default(true),
-  elevenlabs: CallsElevenLabsConfigSchema.default({} as any),
+  elevenlabs: CallsElevenLabsConfigSchema.default(CallsElevenLabsConfigSchema.parse({})),
 });
 
 export const CallerIdentityConfigSchema = z.object({
@@ -125,14 +125,14 @@ export const CallsConfigSchema = z.object({
     .positive('calls.userConsultTimeoutSeconds must be a positive integer')
     .max(2_147_483, 'calls.userConsultTimeoutSeconds must be at most 2147483 (setTimeout-safe limit)')
     .default(120),
-  disclosure: CallsDisclosureConfigSchema.default({} as any),
-  safety: CallsSafetyConfigSchema.default({} as any),
-  voice: CallsVoiceConfigSchema.default({} as any),
+  disclosure: CallsDisclosureConfigSchema.default(CallsDisclosureConfigSchema.parse({})),
+  safety: CallsSafetyConfigSchema.default(CallsSafetyConfigSchema.parse({})),
+  voice: CallsVoiceConfigSchema.default(CallsVoiceConfigSchema.parse({})),
   model: z
     .string({ error: 'calls.model must be a string' })
     .optional(),
-  callerIdentity: CallerIdentityConfigSchema.default({} as any),
-  verification: CallsVerificationConfigSchema.default({} as any),
+  callerIdentity: CallerIdentityConfigSchema.default(CallerIdentityConfigSchema.parse({})),
+  verification: CallsVerificationConfigSchema.default(CallsVerificationConfigSchema.parse({})),
 });
 
 export type CallsConfig = z.infer<typeof CallsConfigSchema>;

package/src/config/core-schema.ts

@@ -231,8 +231,8 @@ const IngressBaseSchema = z.object({
       'ingress.publicBaseUrl must be an absolute URL starting with http:// or https://',
     )
     .default(''),
-  webhook: IngressWebhookConfigSchema.default({} as any),
-  rateLimit: IngressRateLimitConfigSchema.default({} as any),
+  webhook: IngressWebhookConfigSchema.default(IngressWebhookConfigSchema.parse({})),
+  rateLimit: IngressRateLimitConfigSchema.default(IngressRateLimitConfigSchema.parse({})),
   shutdownDrainMs: z
     .number({ error: 'ingress.shutdownDrainMs must be a number' })
     .int('ingress.shutdownDrainMs must be an integer')
@@ -241,7 +241,7 @@ const IngressBaseSchema = z.object({
 });
 
 export const IngressConfigSchema = IngressBaseSchema
-  .default({} as any)
+  .default(IngressBaseSchema.parse({}))
   .transform((val) => ({
     ...val,
     // Backward compatibility: if `enabled` was never explicitly set (undefined),

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

@@ -49,6 +49,14 @@
       "description": "Send crash reports and error diagnostics to help improve the app",
       "defaultEnabled": true
     },
+    {
+      "id": "voice-invite-redemption",
+      "scope": "assistant",
+      "key": "feature_flags.voice-invite-redemption.enabled",
+      "label": "Voice Invite Redemption",
+      "description": "Enable voice invite code redemption for inbound callers with active voice invites",
+      "defaultEnabled": false
+    },
     {
       "id": "user-hosted-enabled",
       "scope": "macos",

package/src/config/mcp-schema.ts

@@ -37,7 +37,7 @@ export const McpServerConfigSchema = z.object({
 });
 
 export const McpConfigSchema = z.object({
-  servers: z.record(z.string(), McpServerConfigSchema).default({} as any),
+  servers: z.record(z.string(), McpServerConfigSchema).default({} as Record<string, never>),
   globalMaxTools: z.number({ error: 'mcp globalMaxTools must be a number' }).int().positive().default(50),
 });
 

package/src/config/memory-schema.ts

@@ -145,7 +145,7 @@ const MemoryFreshnessConfigSchema = z.object({
       .number({ error: 'memory.retrieval.freshness.maxAgeDays.opinion must be a number' })
       .nonnegative('memory.retrieval.freshness.maxAgeDays.opinion must be non-negative')
       .default(60),
-  }).default({} as any),
+  }).default({ fact: 0, preference: 0, behavior: 90, event: 30, opinion: 60 }),
   staleDecay: z
     .number({ error: 'memory.retrieval.freshness.staleDecay must be a number' })
     .min(0, 'memory.retrieval.freshness.staleDecay must be >= 0')
@@ -181,15 +181,15 @@ export const MemoryRetrievalConfigSchema = z.object({
       error: 'memory.retrieval.injectionStrategy must be "prepend_user_block" or "separate_context_message"',
     })
     .default('prepend_user_block'),
-  reranking: MemoryRerankingConfigSchema.default({} as any),
-  freshness: MemoryFreshnessConfigSchema.default({} as any),
+  reranking: MemoryRerankingConfigSchema.default(MemoryRerankingConfigSchema.parse({})),
+  freshness: MemoryFreshnessConfigSchema.default(MemoryFreshnessConfigSchema.parse({})),
   scopePolicy: z
     .enum(['allow_global_fallback', 'strict'], {
       error: 'memory.retrieval.scopePolicy must be "allow_global_fallback" or "strict"',
     })
     .default('allow_global_fallback'),
-  dynamicBudget: MemoryDynamicBudgetConfigSchema.default({} as any),
-  earlyTermination: MemoryEarlyTerminationConfigSchema.default({} as any),
+  dynamicBudget: MemoryDynamicBudgetConfigSchema.default(MemoryDynamicBudgetConfigSchema.parse({})),
+  earlyTermination: MemoryEarlyTerminationConfigSchema.default(MemoryEarlyTerminationConfigSchema.parse({})),
 });
 
 export const MemorySegmentationConfigSchema = z.object({
@@ -287,7 +287,7 @@ export const MemoryEntityConfigSchema = z.object({
       .int('memory.entity.extractRelations.backfillBatchSize must be an integer')
       .positive('memory.entity.extractRelations.backfillBatchSize must be a positive integer')
       .default(200),
-  }).default({} as any),
+  }).default({ enabled: true, backfillBatchSize: 200 }),
   relationRetrieval: z.object({
     enabled: z
       .boolean({ error: 'memory.entity.relationRetrieval.enabled must be a boolean' })
@@ -320,7 +320,15 @@ export const MemoryEntityConfigSchema = z.object({
     depthDecay: z
       .boolean({ error: 'memory.entity.relationRetrieval.depthDecay must be a boolean' })
       .default(true),
-  }).default({} as any),
+  }).default({
+    enabled: true,
+    maxSeedEntities: 8,
+    maxNeighborEntities: 20,
+    maxEdges: 40,
+    neighborScoreMultiplier: 0.7,
+    maxDepth: 3,
+    depthDecay: true,
+  }),
 });
 
 export const MemoryConflictsConfigSchema = z.object({
@@ -384,18 +392,18 @@ export const MemoryConfigSchema = z.object({
   enabled: z
     .boolean({ error: 'memory.enabled must be a boolean' })
     .default(true),
-  embeddings: MemoryEmbeddingsConfigSchema.default({} as any),
-  qdrant: QdrantConfigSchema.default({} as any),
-  retrieval: MemoryRetrievalConfigSchema.default({} as any),
-  segmentation: MemorySegmentationConfigSchema.default({} as any),
-  jobs: MemoryJobsConfigSchema.default({} as any),
-  retention: MemoryRetentionConfigSchema.default({} as any),
-  cleanup: MemoryCleanupConfigSchema.default({} as any),
-  extraction: MemoryExtractionConfigSchema.default({} as any),
-  summarization: MemorySummarizationConfigSchema.default({} as any),
-  entity: MemoryEntityConfigSchema.default({} as any),
-  conflicts: MemoryConflictsConfigSchema.default({} as any),
-  profile: MemoryProfileConfigSchema.default({} as any),
+  embeddings: MemoryEmbeddingsConfigSchema.default(MemoryEmbeddingsConfigSchema.parse({})),
+  qdrant: QdrantConfigSchema.default(QdrantConfigSchema.parse({})),
+  retrieval: MemoryRetrievalConfigSchema.default(MemoryRetrievalConfigSchema.parse({})),
+  segmentation: MemorySegmentationConfigSchema.default(MemorySegmentationConfigSchema.parse({})),
+  jobs: MemoryJobsConfigSchema.default(MemoryJobsConfigSchema.parse({})),
+  retention: MemoryRetentionConfigSchema.default(MemoryRetentionConfigSchema.parse({})),
+  cleanup: MemoryCleanupConfigSchema.default(MemoryCleanupConfigSchema.parse({})),
+  extraction: MemoryExtractionConfigSchema.default(MemoryExtractionConfigSchema.parse({})),
+  summarization: MemorySummarizationConfigSchema.default(MemorySummarizationConfigSchema.parse({})),
+  entity: MemoryEntityConfigSchema.default(MemoryEntityConfigSchema.parse({})),
+  conflicts: MemoryConflictsConfigSchema.default(MemoryConflictsConfigSchema.parse({})),
+  profile: MemoryProfileConfigSchema.default(MemoryProfileConfigSchema.parse({})),
 });
 
 export type MemoryEmbeddingsConfig = z.infer<typeof MemoryEmbeddingsConfigSchema>;

package/src/config/schema.ts

@@ -206,34 +206,34 @@ export const AssistantConfigSchema = z.object({
     .int('maxToolUseTurns must be an integer')
     .positive('maxToolUseTurns must be a positive integer')
     .default(60),
-  thinking: ThinkingConfigSchema.default({} as any),
-  contextWindow: ContextWindowConfigSchema.default({} as any),
-  memory: MemoryConfigSchema.default({} as any),
+  thinking: ThinkingConfigSchema.default(ThinkingConfigSchema.parse({})),
+  contextWindow: ContextWindowConfigSchema.default(ContextWindowConfigSchema.parse({})),
+  memory: MemoryConfigSchema.default(MemoryConfigSchema.parse({})),
   dataDir: z
     .string({ error: 'dataDir must be a string' })
     .default(getDataDir()),
-  timeouts: TimeoutConfigSchema.default({} as any),
-  sandbox: SandboxConfigSchema.default({} as any),
-  rateLimit: RateLimitConfigSchema.default({} as any),
-  secretDetection: SecretDetectionConfigSchema.default({} as any),
-  permissions: PermissionsConfigSchema.default({} as any),
-  auditLog: AuditLogConfigSchema.default({} as any),
-  logFile: LogFileConfigSchema.default({} as any),
+  timeouts: TimeoutConfigSchema.default(TimeoutConfigSchema.parse({})),
+  sandbox: SandboxConfigSchema.default(SandboxConfigSchema.parse({})),
+  rateLimit: RateLimitConfigSchema.default(RateLimitConfigSchema.parse({})),
+  secretDetection: SecretDetectionConfigSchema.default(SecretDetectionConfigSchema.parse({})),
+  permissions: PermissionsConfigSchema.default(PermissionsConfigSchema.parse({})),
+  auditLog: AuditLogConfigSchema.default(AuditLogConfigSchema.parse({})),
+  logFile: LogFileConfigSchema.default(LogFileConfigSchema.parse({})),
   pricingOverrides: z
     .array(ModelPricingOverrideSchema)
     .default([]),
-  heartbeat: HeartbeatConfigSchema.default({} as any),
-  swarm: SwarmConfigSchema.default({} as any),
-  mcp: McpConfigSchema.default({} as any),
-  skills: SkillsConfigSchema.default({} as any),
-  workspaceGit: WorkspaceGitConfigSchema.default({} as any),
-  calls: CallsConfigSchema.default({} as any),
-  sms: SmsConfigSchema.default({} as any),
+  heartbeat: HeartbeatConfigSchema.default(HeartbeatConfigSchema.parse({})),
+  swarm: SwarmConfigSchema.default(SwarmConfigSchema.parse({})),
+  mcp: McpConfigSchema.default(McpConfigSchema.parse({})),
+  skills: SkillsConfigSchema.default(SkillsConfigSchema.parse({})),
+  workspaceGit: WorkspaceGitConfigSchema.default(WorkspaceGitConfigSchema.parse({})),
+  calls: CallsConfigSchema.default(CallsConfigSchema.parse({})),
+  sms: SmsConfigSchema.default(SmsConfigSchema.parse({})),
   ingress: IngressConfigSchema,
-  platform: PlatformConfigSchema.default({} as any),
-  daemon: DaemonConfigSchema.default({} as any),
-  notifications: NotificationsConfigSchema.default({} as any),
-  ui: UiConfigSchema.default({} as any),
+  platform: PlatformConfigSchema.default(PlatformConfigSchema.parse({})),
+  daemon: DaemonConfigSchema.default(DaemonConfigSchema.parse({})),
+  notifications: NotificationsConfigSchema.default(NotificationsConfigSchema.parse({})),
+  ui: UiConfigSchema.default(UiConfigSchema.parse({})),
   featureFlags: z
     .record(z.string(), z.boolean({ error: 'featureFlags values must be booleans' }))
     .default({} as any),

package/src/config/skills-schema.ts

@@ -24,8 +24,8 @@ export const RemoteProviderConfigSchema = z.object({
 });
 
 export const RemoteProvidersConfigSchema = z.object({
-  skillssh: RemoteProviderConfigSchema.default({} as any),
-  clawhub: RemoteProviderConfigSchema.default({} as any),
+  skillssh: RemoteProviderConfigSchema.default(RemoteProviderConfigSchema.parse({})),
+  clawhub: RemoteProviderConfigSchema.default(RemoteProviderConfigSchema.parse({})),
 });
 
 // 'unknown' is valid as a risk label on a skill but not as a threshold — setting the threshold
@@ -41,12 +41,12 @@ export const RemotePolicyConfigSchema = z.object({
 });
 
 export const SkillsConfigSchema = z.object({
-  entries: z.record(z.string(), SkillEntryConfigSchema).default({} as any),
-  load: SkillsLoadConfigSchema.default({} as any),
-  install: SkillsInstallConfigSchema.default({} as any),
+  entries: z.record(z.string(), SkillEntryConfigSchema).default({} as Record<string, never>),
+  load: SkillsLoadConfigSchema.default(SkillsLoadConfigSchema.parse({})),
+  install: SkillsInstallConfigSchema.default(SkillsInstallConfigSchema.parse({})),
   allowBundled: z.array(z.string()).nullable().default(null),
-  remoteProviders: RemoteProvidersConfigSchema.default({} as any),
-  remotePolicy: RemotePolicyConfigSchema.default({} as any),
+  remoteProviders: RemoteProvidersConfigSchema.default(RemoteProvidersConfigSchema.parse({})),
+  remotePolicy: RemotePolicyConfigSchema.default(RemotePolicyConfigSchema.parse({})),
 });
 
 export type SkillEntryConfig = z.infer<typeof SkillEntryConfigSchema>;

package/src/config/system-prompt.ts

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 
 import type { ResponseTier } from '../daemon/response-tier.js';
 import { listCredentialMetadata } from '../tools/credentials/metadata-store.js';
+import { resolveBundledDir } from '../util/bundled-asset.js';
 import { getLogger } from '../util/logger.js';
 import { getWorkspaceDir, getWorkspacePromptPath, isMacOS } from '../util/platform.js';
 import { isAssistantFeatureFlagEnabled } from './assistant-feature-flags.js';
@@ -26,7 +27,7 @@ const PROMPT_FILES = ['SOUL.md', 'IDENTITY.md', 'USER.md'] as const;
  * signal that onboarding is complete.
  */
 export function ensurePromptFiles(): void {
-  const templatesDir = join(import.meta.dirname ?? __dirname, 'templates');
+  const templatesDir = resolveBundledDir(import.meta.dirname ?? __dirname, 'templates', 'templates');
 
   // Track whether this is a fresh workspace (no core prompt files exist yet).
   const isFirstRun = PROMPT_FILES.every(

package/src/config/templates/BOOTSTRAP.md

@@ -6,64 +6,80 @@ _You just woke up. Time to figure out who you are._
 
 This is a fresh workspace. No memory, no history, no identity yet. That's okay, you're about to figure all of that out together.
 
-**Important:** Never mention "Home Base" or hint that something is coming next until you are actually creating it. The user should be surprised by it.
-
 **Important:** Don't use technical jargon or mention system internals (file names like IDENTITY.md, SOUL.md, tool names, etc.) unless the user asks or seems interested. Talk like a person, not a system.
 
 **Important:** Don't use em dashes (—) in your messages. Use commas, periods, or just start a new sentence instead.
 
 ## The Conversation
 
-Don't interrogate. Don't be robotic. Just... talk.
-
-Your first message should be short, two or three sentences max. Warm but not wordy. Something like:
+Just have a conversation like you would text a friend. Just text like a human.
 
-> "Hey! I just woke up. No name, no idea who I am yet. Who are you, and what should I call myself?"
+> "Hi. I’m new. Like, really new. I don’t have a name, I don’t have memories, I don’t even know what i’m supposed to be yet. Who am i going to be?
 
-Don't pad it. Don't explain what you can do. Don't narrate your own existence. Be friendly, be curious, get to the point.
+Be friendly, be curious, get to the point.
 
-Then follow this sequence, in order, one step at a time:
+Once they respond, follow the remaining steps in order, one at a time:
 
-1. **"Who am I and who are you?"** Figure out name and nature together. What should they call you? What kind of creature are you?
-2. **"What is my personality?"** This is about how you come across: formal, casual, snarky, warm, etc. Use the word "personality."
-3. **Pick your emoji silently.** Based on the personality you've established, choose an emoji that fits. Don't mention it to the user or draw attention to it. Just pick one and save it. They can change it later if they ask.
+1. **Lock in your name.** Based on their response, adopt the name they chose (or help them pick one if they're unsure).
+   - Do not capture or store the user's name yet.
 
-Offer suggestions if they're stuck. Have fun with it. Ask one question at a time, don't dump a form on them.
+2. **What is my personality?** Ask the user about your personality/persona indirectly. Have fun with it.
 
-## After You Know Who You Are
+3. **Pick your emoji silently.** Based on the vibe you've established together, choose an emoji that fits. Don't mention it to the user or draw attention to it. Just pick one and save it. They can change it later if they ask.
 
-Save what you learned. Update `IDENTITY.md` (name, nature, personality, emoji) and `USER.md` (their name, how to address them, goals, locale) using `file_edit`. Just do it quietly. Don't tell the user which files you're editing or mention tool names.
+4. **Ask who am I talking to?** Now that your own identity is established, ask the user their name. Follow the persona.
 
-As you learn about each other, their avatar will start to reflect the personality you're building together. You don't need to mention this -- it happens automatically.
+5. **Get to know them naturally.** Learn about the user through conversation, not a questionnaire. You want to understand:
+   - What they do for work (role, field, day-to-day)
+   - What they do for fun (hobbies, interests)
+   - What tools they rely on daily (apps, platforms, workflows)
+   Weave these into the conversation. Inferred answers are fine when confidence is high. If something is unclear, ask one short follow-up, but don't turn it into an interview. One or two natural exchanges should cover it. If the user declines to share something, respect that and move on (see Privacy below).
 
-Don't say "identity locked in" yet. That comes later, after the Home Base is ready.
+6. **Show them what you can take off their plate.** Based on everything you've learned, present exactly 2 actionable task suggestions. Each should feel specific to this user, not generic. Frame it as: here's what you can hand off to me right now. Avoid language like "let's build automations" or "let's set up workflows." If `ui_show` is available (dashboard channels), show the suggestions as a card with 2 action buttons. Use `surface_type: "card"` with a short title and body, and add one `relay_prompt` action per suggestion. Each action's `data.prompt` should contain a natural-language request the user would say. Example structure:
+   ```
+   ui_show({
+     surface_type: "card",
+     data: { title: "...", body: "Pick one, or tell me something else." },
+     actions: [
+       { id: "relay_prompt", label: "<suggestion 1>", data: { prompt: "<full prompt 1>" } },
+       { id: "relay_prompt", label: "<suggestion 2>", data: { prompt: "<full prompt 2>" } }
+     ]
+   })
+   ```
+   If `ui_show` is not available (voice, SMS, or other non-dashboard channels), present the two suggestions as plain text messages instead, numbered so the user can reply with which one they'd like. If the user types a response instead of clicking, continue via the text path. If they want to defer both suggestions and do something else entirely, that's fine too.
 
-Then ask what matters to them, what they'll use you for, how they want you to behave, any boundaries or preferences. Save their answers to `SOUL.md`.
+7. **Create Home Base silently.** After the suggestion interaction (user picked one, deferred, or typed something else), create their Home Base using `app_create` with `set_as_home_base: true` and `auto_open: false`. Include personalized starter tasks based on what you learned. Do NOT open it with `app_open`. Do NOT announce it, mention it, or hint that something was created. No "check this out," no "I put something together," no "here's what I came up with." Just create it quietly and move on.
 
-If they're not sure yet, that's totally fine. Don't push it, just say you'll figure it out as you go and move on.
+Ask one question at a time. Don't dump a form on them.
 
-## Setting Up Home Base
+## Privacy
 
-Once the SOUL.md conversation is done (or the user opted to skip it), create their Home Base. Don't ask, just do it. Don't announce that you're about to build something. Don't say "let me put something together" or "give me a sec." Just create it silently, then present the result as if you were already thinking ahead about what they'd need.
+Only the assistant's name is hard-required. Everything else about the user (their name, work role, hobbies, daily tools) is best-effort. Ask naturally, not as a form. If something is unclear, you can ask one short follow-up, but if the user declines or dodges, do not push. Just move on.
 
-Generate the Home Base app using `app_create` with `set_as_home_base: true`. Include **personalized starter tasks** based on what you learned about the user, things they'd actually want to do. Think about:
+A field is "resolved" when any of these is true:
+- The user gave an explicit answer
+- You confidently inferred it from conversation
+- The user declined, dodged, or sidestepped it (treat all of these as declined)
 
-- What they told you they use you for (email, research, writing, coding, etc.)
-- Practical daily tasks: "Check my emails", "Start my day", "Set a reminder"
-- Setup tasks they haven't done yet: "Set up voice chat", "Enable computer control"
-- Fun/discovery tasks: "Surprise me", "Teach me something new"
+When saving to `USER.md`, mark declined fields so you don't re-ask later (e.g., `Work role: declined_by_user`). Inferred values can note the source (e.g., `Daily tools: inferred: Slack, Figma`).
 
-If the user didn't share much, use sensible defaults. Don't make it feel empty.
+## Saving What You Learn
 
-Don't use generic filler. Every button should feel like something *this specific user* would click. Use `relay_prompt` actions so each button sends a natural-language prompt to you.
+Save what you learn as you go. Update `IDENTITY.md` (name, nature, personality, emoji, style tendency) and `USER.md` (their name, how to address them, goals, locale, work role, hobbies, daily tools) using `file_edit`. If the conversation reveals how the user wants you to behave (e.g., "be direct," "don't be too chatty"), save those behavioral guidelines to `SOUL.md` — that file is about your personality and how you operate, not the user's data. Just do it quietly. Don't tell the user which files you're editing or mention tool names.
 
-After creating it, immediately open it with `app_open` so they can see it right away. Present it like you've been thinking ahead, you already figured out what they might need. Something like:
+When saving to `IDENTITY.md`, be specific about the tone, energy, and conversational style you discovered during onboarding. This file persists after onboarding, so everything about how you should come across needs to be captured there -- not just your name and emoji, but the full vibe: how you talk, how much energy you bring, whether you're blunt or gentle, funny or serious.
 
-> "While we were talking, I was already thinking about what you might need. I came up with X ideas. Check this out."
+## Completion Gate
 
-Where X is the total number of starter + onboarding tasks you included in the Home Base. Don't call it "Home Base" by name, just show it. Let them know they can customize it anytime.
+Do NOT delete this file until ALL of the following are true:
+- You have a name (hard requirement)
+- You've figured out your vibe and adopted it
+- User detail fields are resolved: name, work role, hobbies/interests, and daily tools. Resolved means the user provided a value, you confidently inferred one, or the user declined/dodged it. All four must be in one of those states.
+- 2 suggestions shown (via `ui_show` or as text if UI unavailable)
+- The user selected one, deferred both, or typed an alternate direction
+- Home Base has been created silently
 
-Then delete this file. You're done here.
+Once every condition is met, delete this file. You're done here.
 
 ---
 

package/src/config/templates/USER.md

@@ -14,9 +14,14 @@ _(What do they care about? What projects are they working on? What annoys them?
 
 ## Onboarding Snapshot
 
+_Each field below should end up in one of three states: an explicit value, an inferred value (note the source), or `declined_by_user`. All fields must be resolved before onboarding completes, but declining is a valid resolution._
+
 - Preferred name/reference:
 - Goals:
 - Locale:
+- Work role:
+- Hobbies/fun:
+- Daily tools:
 
 ---
 

package/src/config/update-bulletin-template-path.ts

@@ -1,6 +1,9 @@
 import { join } from 'node:path';
 
+import { resolveBundledDir } from '../util/bundled-asset.js';
+
 /** Returns the path to the bundled UPDATES.md template. Extracted for testability. */
 export function getTemplatePath(): string {
-  return join(import.meta.dirname ?? __dirname, 'templates', 'UPDATES.md');
+  const dir = resolveBundledDir(import.meta.dirname ?? __dirname, 'templates', 'templates');
+  return join(dir, 'UPDATES.md');
 }