@xelauvas/xela-cli 0.3.1 → 0.4.0

package/src/_shims/register.js

@@ -6,7 +6,9 @@ register('./loader.js', import.meta.url);
 // Provide a global `require` for CJS-style requires in ESM context
 // (Bun supports this but Node ESM doesn't)
 import { dirname, resolve, extname } from 'node:path';
-import { existsSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, readFileSync, statSync, mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { createHash } from 'node:crypto';
 import { transformSync } from 'esbuild';
 import { fileURLToPath } from 'node:url';
 import Module from 'node:module';
@@ -92,9 +94,20 @@ Module._resolveFilename = function(request, parent, isMain, options) {
       }
     }
     // Last resort: return CJS stub for missing modules
-    // (DCE'd feature-gated code)
+    // (DCE'd feature-gated code). One tiny file per specifier so the stub can
+    // report which module was missing (XELA_LOADER_DEBUG=1).
     const CJS_STUB_PATH = resolve(dirname(fileURLToPath(import.meta.url)), 'cjs_stub.cjs');
-    return CJS_STUB_PATH;
+    try {
+      const dir = resolve(tmpdir(), 'xela-cjs-stubs');
+      mkdirSync(dir, { recursive: true });
+      const file = resolve(dir, createHash('sha1').update(request).digest('hex').slice(0, 16) + '.cjs');
+      if (!existsSync(file)) {
+        writeFileSync(file, `module.exports = require(${JSON.stringify(CJS_STUB_PATH)}).__makeStub(${JSON.stringify(request)});\n`);
+      }
+      return file;
+    } catch {
+      return CJS_STUB_PATH;
+    }
   }
 };
 

package/src/assistant/gate.ts

@@ -0,0 +1,15 @@
+import { isEnvTruthy } from '../utils/envUtils.js'
+
+/**
+ * Entitlement gate for assistant (KAIROS) mode. Upstream this asks a remote
+ * feature service; a local build has nobody to ask, so it is on unless
+ * explicitly disabled.
+ */
+export async function isKairosEnabled(): Promise<boolean> {
+  if (isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_ASSISTANT)) return false
+  return true
+}
+
+export function isKairosEnabledSync(): boolean {
+  return !isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_ASSISTANT)
+}

package/src/assistant/index.ts

@@ -0,0 +1,89 @@
+import { existsSync, readFileSync } from 'fs'
+import { join } from 'path'
+import { getCwd } from '../utils/cwd.js'
+import { isEnvTruthy } from '../utils/envUtils.js'
+
+/**
+ * Assistant mode: a long-lived session that behaves like a personal
+ * assistant (brief status messages, proactive ticks, an in-process team it
+ * can delegate to). Activated by `--assistant`, CLAUDE_CODE_ASSISTANT=1, or a
+ * project that ships `.claude/agents/assistant.md`.
+ */
+type AssistantState = { forced: boolean; teamInitialized: boolean }
+const state: AssistantState = ((globalThis as unknown as { __xelaAssistant?: AssistantState })
+  .__xelaAssistant ??= { forced: false, teamInitialized: false })
+
+export const ASSISTANT_TEAM_NAME = 'assistant'
+
+export function markAssistantForced(): void {
+  state.forced = true
+}
+
+export function isAssistantForced(): boolean {
+  return state.forced
+}
+
+function assistantDefinitionPath(): string {
+  return join(getCwd(), '.claude', 'agents', 'assistant.md')
+}
+
+export function isAssistantMode(): boolean {
+  if (state.forced) return true
+  if (isEnvTruthy(process.env.CLAUDE_CODE_ASSISTANT)) return true
+  try {
+    return existsSync(assistantDefinitionPath())
+  } catch {
+    return false
+  }
+}
+
+export type AssistantTeamContext = {
+  teamName: string
+  definitionPath: string | null
+}
+
+/**
+ * Pre-seeds the in-process team so `Agent(name: "...")` can spawn teammates
+ * without TeamCreate. The team itself is created lazily by the Agent tool;
+ * here we only record that assistant mode owns it.
+ */
+export async function initializeAssistantTeam(): Promise<AssistantTeamContext> {
+  state.teamInitialized = true
+  const path = assistantDefinitionPath()
+  return { teamName: ASSISTANT_TEAM_NAME, definitionPath: existsSync(path) ? path : null }
+}
+
+/** How assistant mode got turned on, for diagnostics. */
+export function getAssistantActivationPath(): string {
+  if (state.forced) return 'flag'
+  if (isEnvTruthy(process.env.CLAUDE_CODE_ASSISTANT)) return 'env'
+  return existsSync(assistantDefinitionPath()) ? 'agent_file' : 'none'
+}
+
+export function isAssistantTeamInitialized(): boolean {
+  return state.teamInitialized
+}
+
+function readAssistantDefinition(): string | null {
+  try {
+    const path = assistantDefinitionPath()
+    if (!existsSync(path)) return null
+    const raw = readFileSync(path, 'utf8')
+    // Drop YAML frontmatter; the body is the instructions.
+    const m = /^---\n[\s\S]*?\n---\n?/.exec(raw)
+    return (m ? raw.slice(m[0].length) : raw).trim() || null
+  } catch {
+    return null
+  }
+}
+
+export function getAssistantSystemPromptAddendum(): string {
+  const custom = readAssistantDefinition()
+  return [
+    '# Assistant Mode',
+    'You are running as a long-lived personal assistant session. Keep the user informed with short status messages rather than long reports, remember what they ask you to remember, and delegate independent work to teammates with the Agent tool when it helps. Between prompts you may receive <tick> check-ins: do something useful or call Sleep.',
+    custom ? `## Assistant instructions\n\n${custom}` : null,
+  ]
+    .filter(Boolean)
+    .join('\n\n')
+}

package/src/bootstrap/state.ts

@@ -1756,4 +1756,9 @@ export function setPromptId(id: string | null): void {
   STATE.promptId = id
 }
 
-export const isReplBridgeActive = undefined;
+export function isReplBridgeActive(): boolean {
+  return (STATE as { replBridgeActive?: boolean }).replBridgeActive === true
+}
+export function setReplBridgeActive(active: boolean): void {
+  ;(STATE as { replBridgeActive?: boolean }).replBridgeActive = active
+}

package/src/bridge/peerSessions.ts

@@ -0,0 +1,18 @@
+/**
+ * Remote Control ("bridge") peers relay through Anthropic's servers and are
+ * not reachable from a local build. Kept so SendMessage's `bridge:` branch
+ * fails cleanly.
+ */
+export async function postInterClaudeMessage(
+  _sessionId: string,
+  _message: string,
+): Promise<{ ok: boolean; error?: string }> {
+  return {
+    ok: false,
+    error: 'Remote Control is not available in this build; use uds:<socket> for sessions on this machine (see ListPeers)',
+  }
+}
+
+export async function listBridgePeers(): Promise<Array<{ sessionId: string; title?: string }>> {
+  return []
+}

package/src/cli/print.ts

@@ -2422,6 +2422,11 @@ function runHeadlessStreaming(
         }
       }
     } catch (error) {
+      // XELA_LOADER_DEBUG=1: the result message only carries the error text;
+      // the stack is what locates a stripped-module failure
+      if (process.env.XELA_LOADER_DEBUG && error instanceof Error) {
+        process.stderr.write(`[print] execution error: ${error.stack}\n`)
+      }
       // Emit error result message before shutting down
       // Write directly to structuredIO to ensure immediate delivery
       try {

package/src/commands/assistant/assistant.ts

@@ -0,0 +1,17 @@
+import { getAssistantSystemPromptAddendum, isAssistantForced, isAssistantMode, isAssistantTeamInitialized } from '../../assistant/index.js'
+import type { LocalCommandCall } from '../../types/command.js'
+
+export const call: LocalCommandCall = async args => {
+  if ((args || '').trim() === 'prompt') {
+    return { type: 'text', value: getAssistantSystemPromptAddendum() }
+  }
+  const on = isAssistantMode()
+  const lines = [
+    on
+      ? `Assistant mode is on${isAssistantForced() ? ' (forced by --assistant)' : ''}${isAssistantTeamInitialized() ? ', team ready' : ''}.`
+      : 'Assistant mode is off.',
+    'Enable it with `xela-local --assistant`, `CLAUDE_CODE_ASSISTANT=1`, or a `.claude/agents/assistant.md` file in the project (its body becomes the assistant instructions).',
+    '`/assistant prompt` shows the system-prompt addendum used in this mode.',
+  ]
+  return { type: 'text', value: lines.join('\n') }
+}

package/src/commands/assistant/index.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const assistant = {
+  type: 'local',
+  name: 'assistant',
+  description: 'Show assistant-mode status and how to enable it',
+  supportsNonInteractive: true,
+  load: () => import('./assistant.js'),
+} satisfies Command
+
+export default assistant

package/src/commands/brief.ts

@@ -27,7 +27,9 @@ const briefConfigSchema = lazySchema(() =>
 type BriefConfig = z.infer<ReturnType<typeof briefConfigSchema>>
 
 const DEFAULT_BRIEF_CONFIG: BriefConfig = {
-  enable_slash_command: false,
+  // Local builds have no remote config to turn this on; the command is the
+  // only way for a user to opt into brief mode outside assistant mode.
+  enable_slash_command: true,
 }
 
 // No TTL — this gate controls slash-command *visibility*, not a kill switch.

package/src/commands/buddy/buddy.ts

@@ -0,0 +1,88 @@
+import { companionUserId, getCompanion, roll } from '../../buddy/companion.js'
+import { RARITY_STARS, type StoredCompanion } from '../../buddy/types.js'
+import type { LocalCommandCall } from '../../types/command.js'
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'
+
+const NAMES = [
+  'Pixel', 'Mochi', 'Biscuit', 'Noodle', 'Pebble', 'Waffle', 'Comet', 'Tofu', 'Ziggy', 'Maple',
+  'Bagel', 'Clover', 'Dot', 'Fig', 'Juniper', 'Kiwi', 'Lumen', 'Nimbus', 'Olive', 'Quill',
+]
+
+const PERSONALITIES = [
+  'quietly curious, hums while you compile, delighted by a green test run',
+  'dramatic about typos, loyal to tabs, secretly proud of every commit',
+  'calm and deliberate, counts semicolons for fun, allergic to force-push',
+  'chaotic optimist, cheers for every build, naps during long installs',
+  'dry wit, keeps a mental list of TODOs you forgot, forgives merge conflicts',
+  'tiny perfectionist, loves a tidy diff, sighs at console.log left behind',
+  'warm and encouraging, believes every bug is just a feature that got lost',
+  'nocturnal, sharpest after midnight, suspicious of regexes that work first try',
+]
+
+function hash(s: string): number {
+  let h = 2166136261
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i)
+    h = Math.imul(h, 16777619)
+  }
+  return h >>> 0
+}
+
+function hatch(): StoredCompanion {
+  const seed = hash(companionUserId() + ':soul')
+  return {
+    name: NAMES[seed % NAMES.length]!,
+    personality: PERSONALITIES[(seed >>> 8) % PERSONALITIES.length]!,
+    hatchedAt: Date.now(),
+  }
+}
+
+function describe(): string {
+  const c = getCompanion()
+  if (!c) return 'No companion yet. Run `/buddy` to hatch one.'
+  const muted = getGlobalConfig().companionMuted ? ' (muted)' : ''
+  const stats = Object.entries(c.stats)
+    .map(([k, v]) => `${k} ${v}`)
+    .join(' · ')
+  return [
+    `${c.name}${muted} — ${c.shiny ? 'shiny ' : ''}${c.rarity} ${c.species} ${RARITY_STARS[c.rarity]}`,
+    `Eyes: ${c.eye} · hat: ${c.hat}`,
+    `Personality: ${c.personality}`,
+    `Stats: ${stats}`,
+    `Hatched ${new Date(c.hatchedAt).toLocaleDateString()}. Commands: /buddy rename <name>, /buddy mute, /buddy unmute, /buddy release`,
+  ].join('\n')
+}
+
+export const call: LocalCommandCall = async args => {
+  const [action, ...rest] = (args || '').trim().split(/\s+/).filter(Boolean)
+  const config = getGlobalConfig()
+  switch ((action || '').toLowerCase()) {
+    case 'rename': {
+      const name = rest.join(' ').trim()
+      if (!config.companion) return { type: 'text', value: 'No companion to rename. Run `/buddy` first.' }
+      if (!name) return { type: 'text', value: 'Usage: /buddy rename <name>' }
+      saveGlobalConfig(prev => ({ ...prev, companion: { ...prev.companion!, name: name.slice(0, 24) } }))
+      return { type: 'text', value: `Renamed to ${name.slice(0, 24)}.\n\n${describe()}` }
+    }
+    case 'mute':
+      saveGlobalConfig(prev => ({ ...prev, companionMuted: true }))
+      return { type: 'text', value: 'Companion muted. `/buddy unmute` brings it back.' }
+    case 'unmute':
+      saveGlobalConfig(prev => ({ ...prev, companionMuted: false }))
+      return { type: 'text', value: describe() }
+    case 'release':
+      if (!config.companion) return { type: 'text', value: 'No companion to release.' }
+      saveGlobalConfig(prev => ({ ...prev, companion: undefined, companionMuted: undefined }))
+      return { type: 'text', value: 'Released. Run `/buddy` to hatch a new one (same bones, new soul).' }
+    default: {
+      if (config.companion) return { type: 'text', value: describe() }
+      const soul = hatch()
+      saveGlobalConfig(prev => ({ ...prev, companion: soul, companionMuted: false }))
+      const { bones } = roll(companionUserId())
+      return {
+        type: 'text',
+        value: `An egg cracks… it's a ${bones.shiny ? 'shiny ' : ''}${bones.rarity} ${bones.species} ${RARITY_STARS[bones.rarity]}!\n\n${describe()}`,
+      }
+    }
+  }
+}

package/src/commands/buddy/index.ts

@@ -0,0 +1,12 @@
+import type { Command } from '../../commands.js'
+
+const buddy = {
+  type: 'local',
+  name: 'buddy',
+  description: 'Your terminal companion: hatch it, see it, rename, mute or release it',
+  argumentHint: '[rename <name> | mute | unmute | release]',
+  supportsNonInteractive: true,
+  load: () => import('./buddy.js'),
+} satisfies Command
+
+export default buddy

package/src/commands/model/model.tsx

@@ -14,8 +14,7 @@ import { MODEL_ALIASES } from '../../utils/model/aliases.js';
 import { checkOpus1mAccess, checkSonnet1mAccess } from '../../utils/model/check1mAccess.js';
 import { getDefaultMainLoopModelSetting, isOpus1mMergeEnabled, renderDefaultModelSetting } from '../../utils/model/model.js';
 import { isModelAllowed } from '../../utils/model/modelAllowlist.js';
-import { validateModel } from '../../utils/model/validateModel.js'
-import { isOpenAIBackend, isClaudeModelName } from '../../utils/model/providerModels.js';
+import { validateModel } from '../../utils/model/validateModel.js';
 function ModelPickerWrapper(t0) {
   const $ = _c(17);
   const {
@@ -142,30 +141,13 @@ function SetModelAndClose({
   const model = args === 'default' ? null : args;
   React.useEffect(() => {
     async function handleModelChange(): Promise<void> {
-      if (model && !isOpenAIBackend() && !isModelAllowed(model)) {
+      if (model && !isModelAllowed(model)) {
         onDone(`Model '${model}' is not available. Your organization restricts model selection.`, {
           display: 'system'
         });
         return;
       }
 
-      // Skip validation for default model
-      if (!model) {
-        setModel(null);
-        return;
-      }
-
-      // OpenAI backend: skip all Claude-specific checks, go straight to validation
-      if (isOpenAIBackend()) {
-        const { valid, error: validationError } = await validateModel(model);
-        if (valid) {
-          setModel(model);
-        } else {
-          onDone(validationError || `Model '${model}' not found`, { display: 'system' });
-        }
-        return;
-      }
-
       // @[MODEL LAUNCH]: Update check for 1M access.
       if (model && isOpus1mUnavailable(model)) {
         onDone(`Opus 4.6 with 1M context is not available for your account. Learn more: https://code.claude.com/docs/en/model-config#extended-context-with-1m`, {
@@ -180,6 +162,12 @@ function SetModelAndClose({
         return;
       }
 
+      // Skip validation for default model
+      if (!model) {
+        setModel(null);
+        return;
+      }
+
       // Skip validation for known aliases - they're predefined and should work
       if (isKnownAlias(model)) {
         setModel(model);
@@ -303,9 +291,6 @@ export const call: LocalJSXCommandCall = async (onDone, _context, args) => {
   return <ModelPickerWrapper onDone={onDone} />;
 };
 function renderModelLabel(model: string | null): string {
-  if (isOpenAIBackend() && model && !isClaudeModelName(model)) {
-    return model;
-  }
   const rendered = renderDefaultModelSetting(model ?? getDefaultMainLoopModelSetting());
   return model === null ? `${rendered} (default)` : rendered;
 }

package/src/commands/peers/index.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const peers = {
+  type: 'local',
+  name: 'peers',
+  description: 'List other Xela sessions on this machine that can receive messages',
+  supportsNonInteractive: true,
+  load: () => import('./peers.js'),
+} satisfies Command
+
+export default peers

package/src/commands/peers/peers.ts

@@ -0,0 +1,24 @@
+import type { LocalCommandCall } from '../../types/command.js'
+import { listAllLiveSessions } from '../../utils/udsClient.js'
+import { getUdsMessagingSocketPath } from '../../utils/udsMessaging.js'
+
+export const call: LocalCommandCall = async () => {
+  const sessions = await listAllLiveSessions()
+  const lines: string[] = []
+  const self = getUdsMessagingSocketPath()
+  lines.push(self ? `This session: uds:${self}` : 'This session has no messaging socket (UDS inbox off).')
+  const peers = sessions.filter(s => !s.isSelf)
+  if (peers.length === 0) {
+    lines.push('No other sessions found.')
+  } else {
+    lines.push('Other sessions:')
+    for (const s of peers) {
+      const age = s.startedAt ? `${Math.round((Date.now() - s.startedAt) / 60000)} min` : '?'
+      lines.push(
+        `  pid ${s.pid}  ${s.reachable ? 'reachable' : 'no socket'}  ${s.cwd ?? ''}${s.name ? `  [${s.name}]` : ''}  up ${age}` +
+          (s.messagingSocketPath ? `\n    → SendMessage to: uds:${s.messagingSocketPath}` : ''),
+      )
+    }
+  }
+  return { type: 'text', value: lines.join('\n') }
+}

package/src/commands/proactive/proactive.ts

@@ -0,0 +1,64 @@
+import {
+  activateProactive,
+  deactivateProactive,
+  getProactiveState,
+  getTickPrompt,
+  isProactiveActive,
+  isProactivePaused,
+  pauseProactive,
+  PROACTIVE_TICK_INTERVAL_MS,
+  recordTick,
+  resumeProactive,
+  scheduleNextTick,
+} from '../../proactive/index.js'
+import type { LocalCommandCall } from '../../types/command.js'
+import { enqueue } from '../../utils/messageQueueManager.js'
+
+function status(): string {
+  const s = getProactiveState()
+  if (!s.active) return 'Proactive mode is off. `/proactive on` starts it.'
+  return [
+    `Proactive mode is ${isProactivePaused() ? 'paused' : 'on'} (since ${s.activatedAt ? new Date(s.activatedAt).toLocaleTimeString() : '?'}, ${s.tickCount} ticks, every ${Math.round(PROACTIVE_TICK_INTERVAL_MS / 60_000)} min).`,
+    s.contextBlocked ? 'Ticks are blocked because the context is full; run /compact or /clear.' : null,
+  ]
+    .filter(Boolean)
+    .join('\n')
+}
+
+function kickTick(): void {
+  recordTick()
+  enqueue({ value: getTickPrompt(), mode: 'prompt', priority: 'later' })
+}
+
+export const call: LocalCommandCall = async args => {
+  const action = (args || 'status').trim().toLowerCase()
+  switch (action) {
+    case 'on':
+    case 'start':
+      if (!isProactiveActive()) {
+        // activateProactive schedules the first tick; useProactive (REPL) or
+        // print.ts (headless) delivers it.
+        activateProactive('command')
+        return { type: 'text', value: `Proactive mode on. The model gets a tick prompt shortly, then every ${Math.round(PROACTIVE_TICK_INTERVAL_MS / 60_000)} min or whenever its Sleep ends. \`/proactive off\` stops it.` }
+      }
+      if (isProactivePaused()) resumeProactive()
+      return { type: 'text', value: status() }
+    case 'off':
+    case 'stop':
+      deactivateProactive()
+      return { type: 'text', value: 'Proactive mode off.' }
+    case 'pause':
+      pauseProactive()
+      return { type: 'text', value: status() }
+    case 'resume':
+      resumeProactive()
+      if (isProactiveActive()) scheduleNextTick(0)
+      return { type: 'text', value: status() }
+    case 'tick':
+      if (!isProactiveActive()) activateProactive('command')
+      kickTick()
+      return { type: 'text', value: 'Tick sent.' }
+    default:
+      return { type: 'text', value: status() }
+  }
+}

package/src/commands/proactive.ts

@@ -0,0 +1,12 @@
+import type { Command } from '../commands.js'
+
+const proactive = {
+  type: 'local',
+  name: 'proactive',
+  description: 'Toggle proactive mode: the model keeps working between prompts (on | off | pause | resume | status)',
+  argumentHint: '[on|off|pause|resume|status]',
+  supportsNonInteractive: true,
+  load: () => import('./proactive/proactive.js'),
+} satisfies Command
+
+export default proactive

package/src/commands/workflows/index.ts

@@ -0,0 +1,12 @@
+import type { Command } from '../../commands.js'
+
+const workflows = {
+  type: 'local',
+  name: 'workflows',
+  aliases: ['workflow', 'wf'],
+  description: 'List workflow runs in this session and bundled/saved workflows',
+  supportsNonInteractive: true,
+  load: () => import('./workflows.js'),
+} satisfies Command
+
+export default workflows

package/src/commands/workflows/workflows.ts

@@ -0,0 +1,36 @@
+import { getWorkflowTasks } from '../../tasks/LocalWorkflowTask/LocalWorkflowTask.js'
+import {
+  initBundledWorkflows,
+  listBundledWorkflows,
+} from '../../tools/WorkflowTool/bundled/index.js'
+import type { LocalCommandCall } from '../../types/command.js'
+
+export const call: LocalCommandCall = async (_args, context) => {
+  initBundledWorkflows()
+  const runs = getWorkflowTasks(context.getAppState())
+  const lines: string[] = []
+  if (runs.length === 0) {
+    lines.push('No workflow runs in this session.')
+  } else {
+    lines.push('Workflow runs:')
+    for (const run of runs) {
+      const elapsed = Math.round(((run.endTime ?? Date.now()) - run.startTime) / 1000)
+      const done = run.agents.filter(a => a.status === 'completed').length
+      lines.push(
+        `  ${run.id}  ${run.name}  ${run.status}  ${elapsed}s  agents ${done}/${run.agents.length}` +
+          (run.currentPhase ? `  phase: ${run.currentPhase}` : '') +
+          (run.error ? `  error: ${run.error}` : ''),
+      )
+      for (const a of run.agents) {
+        lines.push(`      - ${a.label} [${a.status}]${a.phase ? ` (${a.phase})` : ''}${a.error ? `: ${a.error}` : ''}`)
+      }
+      lines.push(`      output: ${run.outputFile}`)
+    }
+  }
+  const bundled = listBundledWorkflows()
+  lines.push('')
+  lines.push('Available workflows (run with the slash command below, or the Workflow tool):')
+  for (const wf of bundled) lines.push(`  /${wf.name}  ${wf.description}`)
+  lines.push('  Saved workflows: any .js file in .claude/workflows/ (project) or workflows/ (config dir) becomes a slash command')
+  return { type: 'text', value: lines.join('\n') }
+}

package/src/commands.ts

@@ -83,11 +83,7 @@ const voiceCommand = feature('VOICE_MODE')
 const forceSnip = feature('HISTORY_SNIP')
   ? require('./commands/force-snip.js').default
   : null
-const workflowsCmd = feature('WORKFLOW_SCRIPTS')
-  ? (
-      require('./commands/workflows/index.js') as typeof import('./commands/workflows/index.js')
-    ).default
-  : null
+const workflowsCmd = feature('WORKFLOW_SCRIPTS') ? workflowsCommandImpl : null
 const webCmd = feature('CCR_REMOTE_SETUP')
   ? (
       require('./commands/remote-setup/index.js') as typeof import('./commands/remote-setup/index.js')
@@ -159,6 +155,8 @@ import {
   getDynamicSkills,
 } from './skills/loadSkillsDir.js'
 import { getBundledSkills } from './skills/bundledSkills.js'
+import workflowsCommandImpl from './commands/workflows/index.js'
+import { getWorkflowCommands as getWorkflowCommandsImpl } from './tools/WorkflowTool/createWorkflowCommand.js'
 import { getBuiltinPluginSkillCommands } from './plugins/builtinPlugins.js'
 import {
   getPluginCommands,
@@ -399,9 +397,7 @@ async function getSkills(cwd: string): Promise<{
 
 /* eslint-disable @typescript-eslint/no-require-imports */
 const getWorkflowCommands = feature('WORKFLOW_SCRIPTS')
-  ? (
-      require('./tools/WorkflowTool/createWorkflowCommand.js') as typeof import('./tools/WorkflowTool/createWorkflowCommand.js')
-    ).getWorkflowCommands
+  ? getWorkflowCommandsImpl
   : null
 /* eslint-enable @typescript-eslint/no-require-imports */
 

package/src/components/Messages.tsx

@@ -79,7 +79,7 @@ const LogoHeader = React.memo(function LogoHeader(t0) {
 /* eslint-disable @typescript-eslint/no-require-imports */
 const proactiveModule = feature('PROACTIVE') || feature('KAIROS') ? require('../proactive/index.js') : null;
 const BRIEF_TOOL_NAME: string | null = feature('KAIROS') || feature('KAIROS_BRIEF') ? (require('../tools/BriefTool/prompt.js') as typeof import('../tools/BriefTool/prompt.js')).BRIEF_TOOL_NAME : null;
-const SEND_USER_FILE_TOOL_NAME: string | null = feature('KAIROS') ? (require('../tools/SendUserFileTool/prompt.js') as typeof import('../tools/SendUserFileTool/prompt.js')).SEND_USER_FILE_TOOL_NAME : null;
+const SEND_USER_FILE_TOOL_NAME: string | null = feature('KAIROS') || feature('KAIROS_PUSH_NOTIFICATION') ? (require('../tools/SendUserFileTool/prompt.js') as typeof import('../tools/SendUserFileTool/prompt.js')).SEND_USER_FILE_TOOL_NAME : null;
 
 /* eslint-enable @typescript-eslint/no-require-imports */
 import { VirtualMessageList } from './VirtualMessageList.js';