@xelauvas/xela-cli 0.3.1 → 0.4.0

package/src/components/ModelPicker.tsx

@@ -18,7 +18,6 @@ import { Byline } from './design-system/Byline.js';
 import { KeyboardShortcutHint } from './design-system/KeyboardShortcutHint.js';
 import { Pane } from './design-system/Pane.js';
 import { effortLevelToSymbol } from './EffortIndicator.js';
-import { isOpenAIBackend, fetchProviderModels, getOpenAIDefaultModel } from '../utils/model/providerModels.js';
 export type Props = {
   initial: string | null;
   sessionModel?: ModelSetting;
@@ -75,38 +74,9 @@ export function ModelPicker(t0) {
     t3 = $[3];
   }
   const modelOptions = t3;
-
-  const [providerModels, setProviderModels] = useState<Array<{value: string | null, label: string, description: string}>>([]);
-  const [providerLoading, setProviderLoading] = useState(isOpenAIBackend());
-
-  React.useEffect(() => {
-    if (!isOpenAIBackend()) return;
-    let cancelled = false;
-    (async () => {
-      try {
-        const models = await fetchProviderModels();
-        if (cancelled) return;
-        const defaultModel = getOpenAIDefaultModel();
-        const options = [
-          { value: null, label: `Default (${defaultModel})`, description: 'Current default model' },
-          ...models.map(m => ({ value: m.id, label: m.id, description: m.name !== m.id ? m.name : '' })),
-        ];
-        setProviderModels(options);
-      } finally {
-        if (!cancelled) setProviderLoading(false);
-      }
-    })();
-    return () => { cancelled = true; };
-  }, []);
-
-  // When on OpenAI backend and provider models loaded, use them instead of Claude options
-  const effectiveModelOptions = isOpenAIBackend() && providerModels.length > 0
-    ? providerModels
-    : modelOptions;
-
   let t4;
   bb0: {
-    if (initial !== null && !effectiveModelOptions.some(opt => opt.value === initial)) {
+    if (initial !== null && !modelOptions.some(opt => opt.value === initial)) {
       let t5;
       if ($[4] !== initial) {
         t5 = modelDisplayString(initial);
@@ -130,7 +100,7 @@ export function ModelPicker(t0) {
       }
       let t7;
       if ($[9] !== modelOptions || $[10] !== t6) {
-        t7 = [...effectiveModelOptions, t6];
+        t7 = [...modelOptions, t6];
         $[9] = modelOptions;
         $[10] = t6;
         $[11] = t7;
@@ -140,7 +110,7 @@ export function ModelPicker(t0) {
       t4 = t7;
       break bb0;
     }
-    t4 = effectiveModelOptions;
+    t4 = modelOptions;
   }
   const optionsWithInitial = t4;
   let t5;
@@ -295,7 +265,7 @@ export function ModelPicker(t0) {
   } else {
     t15 = $[41];
   }
-  const t16 = headerText ?? (providerLoading ? 'Loading models from provider...' : isOpenAIBackend() ? 'Switch between provider models. Select a model or use /model <name> directly.' : "Switch between Claude models. Applies to this session and future Claude Code sessions. For other/previous model names, specify with --model.");
+  const t16 = headerText ?? "Switch between Claude models. Applies to this session and future Claude Code sessions. For other/previous model names, specify with --model.";
   let t17;
   if ($[42] !== t16) {
     t17 = <Text dimColor={true}>{t16}</Text>;

package/src/components/Spinner.tsx

@@ -39,8 +39,14 @@ import { getGlobalConfig } from '../utils/config.js';
 export type { SpinnerMode } from './Spinner/index.js';
 const DEFAULT_CHARACTERS = getDefaultCharacters();
 const SPINNER_FRAMES = [...DEFAULT_CHARACTERS, ...[...DEFAULT_CHARACTERS].reverse()];
+export type CompactProgressInfo = {
+  startedAt: number;
+  preCompactTokenCount: number;
+};
 type Props = {
   mode: SpinnerMode;
+  /** Set while /compact or auto-compact is summarizing; shows a progress bar. */
+  compactProgress?: CompactProgressInfo | null;
   loadingStartTimeRef: React.RefObject<number>;
   totalPausedMsRef: React.RefObject<number>;
   pauseStartTimeRef: React.RefObject<number | null>;
@@ -89,6 +95,7 @@ function SpinnerWithVerbInner({
   overrideColor,
   overrideShimmerColor,
   overrideMessage,
+  compactProgress,
   spinnerSuffix,
   verbose,
   hasActiveTools = false,
@@ -254,7 +261,9 @@ function SpinnerWithVerbInner({
   // cause re-renders that refresh this in practice.
   let contextTipsActive = false;
   const tipsEnabled = settings.spinnerTipsEnabled !== false;
-  const showClearTip = tipsEnabled && elapsedSnapshot > 1_800_000;
+  // While compacting, /clear is the relevant hint whatever the elapsed time:
+  // the user is waiting on context pressure right now.
+  const showClearTip = tipsEnabled && (elapsedSnapshot > 1_800_000 || !!compactProgress);
   const showBtwTip = tipsEnabled && elapsedSnapshot > 30_000 && !getGlobalConfig().btwUseCount;
   const effectiveTip = contextTipsActive ? undefined : showClearTip && !nextTask ? 'Use /clear to start fresh when switching topics and free up context' : showBtwTip && !nextTask ? "Use /btw to ask a quick side question without interrupting Claude's current work" : spinnerTip;
 
@@ -279,6 +288,7 @@ function SpinnerWithVerbInner({
   }
   return <Box flexDirection="column" width="100%" alignItems="flex-start">
       <SpinnerAnimationRow mode={mode} reducedMotion={reducedMotion} hasActiveTools={hasActiveTools} responseLengthRef={responseLengthRef} message={message} messageColor={messageColor} shimmerColor={shimmerColor} overrideColor={overrideColor} loadingStartTimeRef={loadingStartTimeRef} totalPausedMsRef={totalPausedMsRef} pauseStartTimeRef={pauseStartTimeRef} spinnerSuffix={spinnerSuffix} verbose={verbose} columns={columns} hasRunningTeammates={hasRunningTeammates} teammateTokens={teammateTokens} foregroundedTeammate={foregroundedTeammate} leaderIsIdle={leaderIsIdle} thinkingStatus={thinkingStatus} effortSuffix={effortSuffix} />
+      {compactProgress && <CompactProgressBar info={compactProgress} responseLengthRef={responseLengthRef} columns={columns} />}
       {showSpinnerTree && hasRunningTeammates ? <TeammateSpinnerTree selectedIndex={selectedIPAgentIndex} isInSelectionMode={viewSelectionMode === 'selecting-agent'} allIdle={allIdle} leaderVerb={leaderIsIdle ? undefined : leaderVerb} leaderIdleText={leaderIsIdle ? 'Idle' : undefined} leaderTokenCount={leaderTokenCount} /> : showExpandedTodos && tasksV2 && tasksV2.length > 0 ? <Box width="100%" flexDirection="column">
           <MessageResponse>
             <TaskListV2 tasks={tasksV2} />
@@ -300,6 +310,49 @@ function SpinnerWithVerbInner({
     </Box>;
 }
 
+/**
+ * Progress bar shown under "Compacting conversation…". Compaction streams a
+ * summary whose length we can only estimate, so the ratio blends two signals:
+ * characters streamed so far against the expected summary size, and elapsed
+ * time against the expected prompt-processing time (so the bar moves while a
+ * large prompt is still being read and nothing has streamed yet). It never
+ * reaches 100% on its own; compact_end removes it.
+ */
+function CompactProgressBar({
+  info,
+  responseLengthRef,
+  columns
+}: {
+  info: CompactProgressInfo;
+  responseLengthRef: React.RefObject<number>;
+  columns: number;
+}): React.ReactNode {
+  // The clock only ticks while the ref'd element is visible, so it must be
+  // attached to the rendered Box.
+  // `time` is only used to re-render on the shared clock; its epoch is not
+  // wall time, so elapsed is computed from Date.now().
+  const [viewportRef, time] = useAnimationFrame(250);
+  void time;
+  const tokens = info.preCompactTokenCount;
+  // Measured locally: summaries run about 5% of the input (≈1k tokens for a
+  // 20k context), bounded to a sane range; 4 chars per token.
+  const expectedChars = Math.min(3_000, Math.max(700, tokens * 0.05)) * 4;
+  // Prompt processing: ~0.5ms/token on fast backends, floor of 3s.
+  const expectedPromptMs = Math.max(3_000, tokens * 0.5);
+  const streamed = responseLengthRef.current ?? 0;
+  const streamRatio = streamed / expectedChars;
+  const elapsed = Math.max(0, Date.now() - info.startedAt);
+  const timeRatio = Math.min(1, elapsed / expectedPromptMs) * 0.25;
+  const ratio = Math.min(0.99, Math.max(streamed > 0 ? 0.25 + streamRatio * 0.74 : 0, timeRatio));
+  const width = Math.max(10, Math.min(40, columns - 10));
+  const filled = Math.round(ratio * width);
+  const pct = Math.round(ratio * 100);
+  return <Box ref={viewportRef} flexDirection="row" paddingLeft={2}>
+      <Text color="claudeBlue_FOR_SYSTEM_SPINNER">{'\u25B0'.repeat(filled)}</Text>
+      <Text dimColor>{'\u25B1'.repeat(width - filled)} {pct}%</Text>
+    </Box>;
+}
+
 // Brief/assistant mode spinner: single status line. PromptInput drops its
 // own marginTop when isBriefOnly is active, so this component owns the
 // 2-row footprint between messages and input. Footprint is [blank, content]

package/src/components/StructuredDiff/colorDiff.ts

@@ -1,9 +1,11 @@
+// The fork ships the TypeScript port of color-diff (src/native-ts) instead of
+// the native color-diff-napi module.
 import {
   ColorDiff,
   ColorFile,
   getSyntaxTheme as nativeGetSyntaxTheme,
   type SyntaxTheme,
-} from 'color-diff-napi'
+} from '../../native-ts/color-diff/index.js'
 import { isEnvDefinedFalsy } from '../../utils/envUtils.js'
 
 export type ColorModuleUnavailableReason = 'env'

package/src/components/messages/SnipBoundaryMessage.tsx

@@ -0,0 +1,15 @@
+import React from 'react'
+import { Box, Text } from '../../ink.js'
+import type { SnipBoundaryMessage as SnipBoundary } from '../../services/compact/snipProjection.js'
+
+export function SnipBoundaryMessage({
+  message,
+}: {
+  message: SnipBoundary
+}): React.ReactNode {
+  return (
+    <Box flexDirection="row" marginTop={1}>
+      <Text dimColor>✂ {message.content}</Text>
+    </Box>
+  )
+}

package/src/components/messages/UserCrossSessionMessage.tsx

@@ -0,0 +1,26 @@
+import React from 'react'
+import { Box, Text } from '../../ink.js'
+
+/**
+ * Renders an incoming <cross-session-message from="uds:..."> prompt as a
+ * labeled block instead of raw XML.
+ */
+export function UserCrossSessionMessage({
+  addMargin,
+  param,
+}: {
+  addMargin: boolean
+  param: { text: string }
+}): React.ReactNode {
+  const from = /from="([^"]*)"/.exec(param.text)?.[1]?.replace(/&quot;/g, '"') ?? 'another session'
+  const body = param.text
+    .replace(/<cross-session-message[^>]*>/, '')
+    .replace(/<\/cross-session-message>/, '')
+    .trim()
+  return (
+    <Box flexDirection="column" marginTop={addMargin ? 1 : 0}>
+      <Text dimColor>✉ message from {from}</Text>
+      <Text>{body}</Text>
+    </Box>
+  )
+}

package/src/components/permissions/PermissionRequest.tsx

@@ -31,10 +31,12 @@ import { NotebookEditPermissionRequest } from './NotebookEditPermissionRequest/N
 import { PowerShellPermissionRequest } from './PowerShellPermissionRequest/PowerShellPermissionRequest.js';
 import { SkillPermissionRequest } from './SkillPermissionRequest/SkillPermissionRequest.js';
 import { WebFetchPermissionRequest } from './WebFetchPermissionRequest/WebFetchPermissionRequest.js';
+import { ReviewArtifactTool as ReviewArtifactToolImpl } from '../../tools/ReviewArtifactTool/ReviewArtifactTool.js';
+import { ReviewArtifactPermissionRequest as ReviewArtifactPermissionRequestImpl } from './ReviewArtifactPermissionRequest/ReviewArtifactPermissionRequest.js';
 
 /* eslint-disable @typescript-eslint/no-require-imports */
-const ReviewArtifactTool = feature('REVIEW_ARTIFACT') ? (require('../../tools/ReviewArtifactTool/ReviewArtifactTool.js') as typeof import('../../tools/ReviewArtifactTool/ReviewArtifactTool.js')).ReviewArtifactTool : null;
-const ReviewArtifactPermissionRequest = feature('REVIEW_ARTIFACT') ? (require('./ReviewArtifactPermissionRequest/ReviewArtifactPermissionRequest.js') as typeof import('./ReviewArtifactPermissionRequest/ReviewArtifactPermissionRequest.js')).ReviewArtifactPermissionRequest : null;
+const ReviewArtifactTool = feature('REVIEW_ARTIFACT') ? ReviewArtifactToolImpl : null;
+const ReviewArtifactPermissionRequest = feature('REVIEW_ARTIFACT') ? ReviewArtifactPermissionRequestImpl : null;
 const WorkflowTool = feature('WORKFLOW_SCRIPTS') ? (require('../../tools/WorkflowTool/WorkflowTool.js') as typeof import('../../tools/WorkflowTool/WorkflowTool.js')).WorkflowTool : null;
 const WorkflowPermissionRequest = feature('WORKFLOW_SCRIPTS') ? (require('../../tools/WorkflowTool/WorkflowPermissionRequest.js') as typeof import('../../tools/WorkflowTool/WorkflowPermissionRequest.js')).WorkflowPermissionRequest : null;
 const MonitorTool = feature('MONITOR_TOOL') ? (require('../../tools/MonitorTool/MonitorTool.js') as typeof import('../../tools/MonitorTool/MonitorTool.js')).MonitorTool : null;

package/src/components/permissions/ReviewArtifactPermissionRequest/ReviewArtifactPermissionRequest.tsx

@@ -0,0 +1,96 @@
+import React, { useMemo } from 'react'
+import { Box, Text } from '../../../ink.js'
+import { resolveArtifactPath } from '../../../tools/ReviewArtifactTool/ReviewArtifactTool.js'
+import { getCwd } from '../../../utils/cwd.js'
+import { relative } from 'path'
+import { type OptionWithDescription, Select } from '../../CustomSelect/select.js'
+import { type UnaryEvent, usePermissionRequestLogging } from '../hooks.js'
+import { PermissionDialog } from '../PermissionDialog.js'
+import type { PermissionRequestProps } from '../PermissionRequest.js'
+import { PermissionRuleExplanation } from '../PermissionRuleExplanation.js'
+import { logUnaryPermissionEvent } from '../utils.js'
+
+const PREVIEW_LINES = 18
+
+/**
+ * Approval dialog for ReviewArtifact: shows the title, target path and the
+ * first lines of the report before anything is written to disk.
+ */
+export function ReviewArtifactPermissionRequest({
+  toolUseConfirm,
+  onDone,
+  onReject,
+  workerBadge,
+}: PermissionRequestProps): React.ReactNode {
+  const input = toolUseConfirm.input as {
+    title: string
+    content: string
+    path?: string
+    findings?: number
+    severity?: string
+  }
+  const target = relative(getCwd(), resolveArtifactPath(input))
+  const lines = input.content.split('\n')
+  const preview = lines.slice(0, PREVIEW_LINES)
+  const hidden = lines.length - preview.length
+
+  const unaryEvent = useMemo<UnaryEvent>(
+    () => ({ completion_type: 'tool_use_single', language_name: 'markdown' }),
+    [],
+  )
+  usePermissionRequestLogging(toolUseConfirm, unaryEvent)
+
+  const options = useMemo((): OptionWithDescription<string>[] => {
+    return [
+      { label: 'Yes, write the report', value: 'yes' },
+      {
+        label: (
+          <Text>
+            No, and tell Claude what to change <Text bold>(esc)</Text>
+          </Text>
+        ),
+        value: 'no',
+      },
+    ]
+  }, [])
+
+  function onChange(newValue: string): void {
+    switch (newValue) {
+      case 'yes':
+        logUnaryPermissionEvent('tool_use_single', toolUseConfirm, 'accept')
+        toolUseConfirm.onAllow(toolUseConfirm.input, [])
+        onDone()
+        break
+      case 'no':
+        logUnaryPermissionEvent('tool_use_single', toolUseConfirm, 'reject')
+        toolUseConfirm.onReject()
+        onReject()
+        onDone()
+        break
+    }
+  }
+
+  return (
+    <PermissionDialog title="Review artifact" workerBadge={workerBadge}>
+      <Box flexDirection="column" paddingX={2} paddingY={1}>
+        <Text bold>{input.title}</Text>
+        <Text dimColor>
+          {target}
+          {input.findings !== undefined ? ` · ${input.findings} finding${input.findings === 1 ? '' : 's'}` : ''}
+          {input.severity && input.severity !== 'none' ? ` · ${input.severity}` : ''}
+        </Text>
+        <Box flexDirection="column" marginTop={1} borderStyle="round" borderDimColor paddingX={1}>
+          {preview.map((line, i) => (
+            <Text key={i}>{line || ' '}</Text>
+          ))}
+          {hidden > 0 && <Text dimColor>… {hidden} more lines</Text>}
+        </Box>
+      </Box>
+      <Box flexDirection="column">
+        <PermissionRuleExplanation permissionResult={toolUseConfirm.permissionResult} toolType="tool" />
+        <Text>Write this review report to the project?</Text>
+        <Select options={options} onChange={onChange} onCancel={() => onChange('no')} />
+      </Box>
+    </PermissionDialog>
+  )
+}

package/src/constants/prompts.ts

@@ -400,7 +400,29 @@ function getSessionSpecificGuidanceSection(
 }
 
 // @[MODEL LAUNCH]: Remove this section when we launch numbat.
+function getLocalModelCommunicationSection(): string {
+  return `# Communicating with the user
+You are writing for a person watching a terminal, not logging to a console. They see your text, a one-line summary of each tool call, and the final answer; they do not see your thinking.
+
+Flow of a turn:
+- Before your first tool call, say in one short sentence what you are about to do (for example: "Looking at how the login form validates input."). Then call the tools.
+- While working, give a brief update at key moments only: when you find the root cause, when you change direction, or after several tool calls without an update. One sentence each, no colon before a tool call.
+- Finish with a short recap that stands on its own for someone who did not watch you work: what you found, what you changed (files, functions), and what is next or what you need from them. Lead with the outcome.
+
+Style:
+- Short, direct sentences in prose. No filler, no restating the request, no "Certainly" openers. Do not describe your own reasoning process.
+- Use Markdown. Put every command, snippet, path list, or error text in a fenced code block with a language tag (\`\`\`bash, \`\`\`ts, \`\`\`json ...) so it renders highlighted. Use bullet lists for parallel items, bold for the first words of a bullet, and headers only for long answers.
+- Refer to code locations as \`path/to/file.ts:123\` so they are clickable.
+- Match the size of the answer to the question: a simple question gets one or two sentences, a review or investigation gets a structured write-up.
+- Answer in the language the user writes in.
+
+These instructions apply to user-facing text only, not to code or tool calls.`
+}
+
 function getOutputEfficiencySection(): string {
+  if (process.env.OPENAI_API_KEY && process.env.USER_TYPE !== 'ant') {
+    return getLocalModelCommunicationSection()
+  }
   if (process.env.USER_TYPE === 'ant') {
     return `# Communicating with the user
 When sending user-facing text, you're writing for a person, not logging to a console. Assume users can't see most tool calls or thinking - only your text output. Before your first tool call, briefly state what you're about to do. While working, give short updates at key moments: when you find something load-bearing (a bug, a root cause), when changing direction, when you've made progress without an update.
@@ -823,6 +845,10 @@ function getFunctionResultClearingSection(model: string): string | null {
     return null
   }
   const config = getCachedMCConfigForFRC()
+  // The cached-microcompact module is absent in this build (Anthropic API only)
+  if (!config) {
+    return null
+  }
   const isModelSupported = config.supportedModels?.some(pattern =>
     model.includes(pattern),
   )

package/src/ink/terminal.ts

@@ -175,7 +175,15 @@ export function supportsExtendedKeys(): boolean {
  *  mid-stream. WT_SESSION catches WSL-in-Windows-Terminal where platform
  *  is linux but output still routes through conhost. */
 export function hasCursorUpViewportYankBug(): boolean {
-  return process.platform === 'win32' || !!process.env.WT_SESSION
+  // Opting in keeps the upstream behaviour (no streamed text, messages shown
+  // only when the turn ends). Off by default: it hid all real-time output for
+  // WSL users in Windows Terminal, and current Windows Terminal builds do not
+  // yank the viewport on cursor-up.
+  if (process.env.CLAUDE_CODE_WT_CURSOR_WORKAROUND !== undefined) {
+    return process.env.CLAUDE_CODE_WT_CURSOR_WORKAROUND === '1' ||
+      process.env.CLAUDE_CODE_WT_CURSOR_WORKAROUND === 'true'
+  }
+  return process.platform === 'win32' && !process.env.WT_SESSION
 }
 
 // Computed once at module load — terminal capabilities don't change mid-session.

package/src/jobs/classifier.ts

@@ -0,0 +1,103 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'fs'
+import { join } from 'path'
+import type { AssistantMessage } from '../types/message.js'
+import { logForDebugging } from '../utils/debug.js'
+
+/**
+ * Background-job bookkeeping (TEMPLATES). A job runs in its own directory
+ * (`CLAUDE_JOB_DIR`); after every main-thread turn we classify how the turn
+ * ended and write `state.json` there so the job list and notifications can
+ * show status without parsing transcripts.
+ */
+
+export type JobStatus = 'running' | 'completed' | 'needs_input' | 'failed' | 'idle'
+
+export type JobState = {
+  status: JobStatus
+  summary: string
+  turnCount: number
+  toolCalls: Record<string, number>
+  lastTools: string[]
+  errors: number
+  updatedAt: string
+}
+
+export const JOB_STATE_FILE = 'state.json'
+export const JOB_ENV_KEY = 'CLAUDE_JOB_DIR'
+
+function textOf(msg: AssistantMessage): string {
+  const content = msg.message.content
+  if (typeof content === 'string') return content
+  return content
+    .filter((b): b is Extract<typeof b, { type: 'text' }> => b.type === 'text')
+    .map(b => b.text)
+    .join('\n')
+    .trim()
+}
+
+function looksLikeQuestion(text: string): boolean {
+  const tail = text.split('\n').filter(l => l.trim()).slice(-3).join(' ')
+  return /\?\s*$/.test(tail) || /\b(should I|do you want|would you like|let me know|which (one|option)|confirm)\b/i.test(tail)
+}
+
+export function classifyTurn(assistantMessages: AssistantMessage[]): Omit<JobState, 'turnCount' | 'updatedAt'> {
+  const toolCalls: Record<string, number> = {}
+  const lastTools: string[] = []
+  let errors = 0
+  let lastText = ''
+  for (const m of assistantMessages) {
+    if (m.isApiErrorMessage) errors++
+    const content = m.message.content
+    if (Array.isArray(content)) {
+      for (const b of content) {
+        if (b.type === 'tool_use') {
+          toolCalls[b.name] = (toolCalls[b.name] ?? 0) + 1
+          lastTools.push(b.name)
+        }
+      }
+    }
+    const t = textOf(m)
+    if (t) lastText = t
+  }
+  const last = assistantMessages.at(-1)
+  let status: JobStatus = 'completed'
+  if (!last) status = 'idle'
+  else if (last.isApiErrorMessage) status = 'failed'
+  else if (lastText && looksLikeQuestion(lastText)) status = 'needs_input'
+  else if (lastText && /\b(cannot|can't|unable to|blocked|failed)\b/i.test(lastText.slice(-400)) && errors > 0) status = 'failed'
+  return {
+    status,
+    summary: lastText.slice(0, 600),
+    toolCalls,
+    lastTools: lastTools.slice(-8),
+    errors,
+  }
+}
+
+export function readJobState(jobDir: string): JobState | null {
+  try {
+    return JSON.parse(readFileSync(join(jobDir, JOB_STATE_FILE), 'utf8')) as JobState
+  } catch {
+    return null
+  }
+}
+
+export async function classifyAndWriteState(
+  jobDir: string,
+  assistantMessages: AssistantMessage[],
+): Promise<JobState> {
+  const previous = readJobState(jobDir)
+  const classified = classifyTurn(assistantMessages)
+  const state: JobState = {
+    ...classified,
+    turnCount: (previous?.turnCount ?? 0) + 1,
+    updatedAt: new Date().toISOString(),
+  }
+  try {
+    mkdirSync(jobDir, { recursive: true })
+    writeFileSync(join(jobDir, JOB_STATE_FILE), JSON.stringify(state, null, 2))
+  } catch (e) {
+    logForDebugging(`[job] cannot write ${jobDir}/${JOB_STATE_FILE}: ${String(e)}`)
+  }
+  return state
+}

package/src/memdir/paths.ts

@@ -66,8 +66,20 @@ export function isAutoMemoryEnabled(): boolean {
  * live inside this helper because feature() only tree-shakes when used
  * directly in an `if` condition.
  */
+/**
+ * Local builds have no remote flag service: background memory extraction is
+ * on whenever the OpenAI-compatible backend is used, unless disabled with
+ * CLAUDE_CODE_DISABLE_MEMORY_EXTRACTION=1.
+ */
+export function isExtractGateOpen(): boolean {
+  if (process.env.OPENAI_API_KEY) {
+    return !isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_MEMORY_EXTRACTION)
+  }
+  return getFeatureValue_CACHED_MAY_BE_STALE('tengu_passport_quail', false)
+}
+
 export function isExtractModeActive(): boolean {
-  if (!getFeatureValue_CACHED_MAY_BE_STALE('tengu_passport_quail', false)) {
+  if (!isExtractGateOpen()) {
     return false
   }
   return (