@miphamai/cli 0.85.1 → 0.85.2

package/src/tools/exec/task.ts

@@ -1,4 +1,5 @@
 import type { ToolDefinition } from '../../shared/index.ts'
+import type { BackgroundAgentRegistry, BackgroundTask } from '../../agent/background-registry'
 import { hasSupportedEvidenceSince } from '../../core/working-memory'
 
 export interface Task {
@@ -14,9 +15,7 @@ export interface Task {
   createdAt: string
   /** 完成证据：completed 时是否有 supported 决策接地（软门，unverified 只标记不阻断）。 */
   completionEvidence?: 'supported' | 'unverified'
-  /** Background task output content (set when a background agent completes). */
-  output?: string
-  /** Background task error message (set when a background agent fails). */
+  /** Set by the `stop` action on a running task ("Task stopped by user."). */
   outputError?: string
 }
 
@@ -36,6 +35,66 @@ function formatTask(t: Task): string {
   return `[${t.status}] #${t.id}: ${t.subject}${owner}${blocks}${blocked}${meta}`
 }
 
+/**
+ * Render a **background agent** the way the `output` action renders a session task.
+ *
+ * Background agents are not in the local `tasks` map: BackgroundAgentRegistry mints
+ * their ids in a separate space (`bg-<n>-<base36>`) and keeps results on the registry
+ * itself. The Agent tool hands those ids to the model with an explicit
+ * `Use Task output taskId="bg-…"` line, so this action has to answer for them —
+ * without this path the advertised call can only return `Task #bg-… not found`.
+ */
+function formatBackgroundOutput(bg: BackgroundTask): {
+  success: boolean
+  content: string
+  error?: string
+} {
+  const head = `Background task ${bg.id}`
+  const meta = `Status: ${bg.status}\nAgent type: ${bg.agentType}\nTask: ${bg.description}`
+
+  if (bg.status === 'running') {
+    return {
+      success: true,
+      content: `${head} is still running — output not yet available.\n${meta}\n\nUse Task output again once it completes.`,
+    }
+  }
+
+  if (bg.status === 'failed') {
+    return {
+      success: false,
+      content: '',
+      error: `${head} failed: ${bg.error ?? '(no error recorded)'}`,
+    }
+  }
+
+  return {
+    success: true,
+    content: `── ${head} Output ──\n${meta}\n\n${(bg.result ?? '(no output recorded)').slice(0, 5000)}`,
+  }
+}
+
+/** Stop a running background agent through the registry that owns it. */
+function stopBackgroundTask(
+  bg: BackgroundTask,
+  registry: BackgroundAgentRegistry,
+): { success: boolean; content: string; error?: string } {
+  if (bg.status !== 'running') {
+    return {
+      success: true,
+      content: `Background task ${bg.id} is already ${bg.status}. Nothing to stop.`,
+    }
+  }
+  // `stop()` also returns false when the task is no longer running (it completed
+  // between the lookup above and this call), so the message must not claim why.
+  const aborted = registry.stop(bg.id)
+  return {
+    success: true,
+    content: aborted
+      ? `Background task ${bg.id} stopped.\nTask: ${bg.description}`
+      : `Background task ${bg.id} was not stopped — it is no longer running.`,
+  }
+}
+
 /** Check if a task is blocked — has unresolved dependencies. */
 function isBlocked(task: Task): boolean {
   if (task.blockedBy.length === 0) return false
@@ -238,11 +297,6 @@ export const taskTool: ToolDefinition = {
         }
       }
       if (task.metadata) lines.push(`Metadata: ${JSON.stringify(task.metadata)}`)
-      if (task.output) {
-        lines.push('')
-        lines.push('── Output ──')
-        lines.push(task.output.slice(0, 2000))
-      }
       if (task.outputError) {
         lines.push('')
         lines.push(`── Error ──`)
@@ -320,7 +374,14 @@ export const taskTool: ToolDefinition = {
     if (action === 'output') {
       const taskId = params.taskId as string
       const task = tasks.get(taskId)
-      if (!task) return { success: false, content: '', error: `Task #${taskId} not found` }
+      if (!task) {
+        // Not a session task — it may be a background agent id (`bg-…`), which is
+        // the id space this action is advertised for. The registry is wired onto
+        // the tool context by the engine (`engine.ts` defaultToolContext).
+        const bg = _ctx.backgroundAgentRegistry?.get(taskId)
+        if (bg) return formatBackgroundOutput(bg)
+        return { success: false, content: '', error: `Task #${taskId} not found` }
+      }
 
       if (task.status === 'pending') {
         return {
@@ -336,13 +397,6 @@ export const taskTool: ToolDefinition = {
         }
       }
 
-      if (task.status === 'completed' && task.output) {
-        return {
-          success: true,
-          content: `── Task #${taskId} Output ──\nStatus: completed\nSubject: ${task.subject}\n\n${task.output.slice(0, 5000)}`,
-        }
-      }
-
       if (task.status === 'failed' && task.outputError) {
         return {
           success: false,
@@ -361,7 +415,15 @@ export const taskTool: ToolDefinition = {
     if (action === 'stop') {
       const taskId = params.taskId as string
       const task = tasks.get(taskId)
-      if (!task) return { success: false, content: '', error: `Task #${taskId} not found` }
+      if (!task) {
+        // Background agent id (`bg-…`) — the other id space. The local branch
+        // below only marks a status; an actual running agent is aborted through
+        // the registry that owns it.
+        const registry = _ctx.backgroundAgentRegistry
+        const bg = registry?.get(taskId)
+        if (registry && bg) return stopBackgroundTask(bg, registry)
+        return { success: false, content: '', error: `Task #${taskId} not found` }
+      }
 
       if (task.status === 'completed' || task.status === 'deleted') {
         return {
@@ -376,22 +438,12 @@ export const taskTool: ToolDefinition = {
         return { success: true, content: `Task #${taskId} cancelled (was pending).` }
       }
 
-      // For in_progress tasks: mark as failed — actual process termination is handled
-      // by BackgroundAgentRegistry.stop() when wired via the engine context
+      // For in_progress session tasks: mark as failed. There is no process behind
+      // one — a *background agent* is aborted by stopBackgroundTask() above, which
+      // the registry owns.
       task.status = 'failed'
       task.outputError = 'Task stopped by user.'
 
-      // If BackgroundAgentRegistry is available in context, try to abort
-      if (_ctx.registry) {
-        // Signal to any background registry that this task should stop
-        // The background registry will be injected via the engine context
-        const bgRegistry = (_ctx as unknown as Record<string, unknown>).backgroundAgentRegistry as
-          { stop(id: string): boolean } | undefined
-        if (bgRegistry) {
-          bgRegistry.stop(taskId)
-        }
-      }
-
       return { success: true, content: `Task #${taskId} stopped.` }
     }
 

package/src/tools/scheduling/cron.ts

@@ -1,11 +1,5 @@
-import {
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-  unlinkSync,
-  readdirSync,
-  existsSync,
-} from 'node:fs'
+import { mkdirSync, readFileSync, unlinkSync, readdirSync, existsSync } from 'node:fs'
+import { atomicWriteFileSync } from '../../shared/atomic-write'
 import { join } from 'node:path'
 import { createHash } from 'node:crypto'
 import type { ToolDefinition } from '../../shared/index.ts'
@@ -78,7 +72,7 @@ export function readAllJobs(): CronJob[] {
 /** Persist a job (create or update) to its JSON file. */
 export function writeJob(job: CronJob): void {
   ensureCronDir()
-  writeFileSync(jobPath(job.id), JSON.stringify(job, null, 2), 'utf-8')
+  atomicWriteFileSync(jobPath(job.id), JSON.stringify(job, null, 2), { mode: 0o644 })
 }
 
 /** Delete a job's file. Returns false when the job did not exist. */

package/src/ui/app.tsx

@@ -3,6 +3,7 @@ import { Box, Text, useInput } from 'ink'
 import TextInput from 'ink-text-input'
 import { execSync } from 'node:child_process'
 import { ErrorBoundary } from './error-boundary'
+import { useCtrlCConfirm } from './ctrl-c-confirm'
 import { formatThinking } from './thinking'
 import type { QueryEngine } from '../core/engine'
 import type { RemoteEngine } from '../daemon/remote-engine'
@@ -1136,22 +1137,55 @@ export function App({
     [engine, mkCtx, runTurn],
   )
 
-  useInput((_input, key) => {
-    // Escape: close apiKeyPrompt → close picker → abort loading (does NOT exit app)
-    if (key.escape) {
-      if (apiKeyPrompt) {
-        setApiKeyPrompt(null)
-        setApiKeyInput('')
-        return
-      }
-      if (pickerOpen) {
-        setPickerOpen(false)
+  /**
+   * 关掉「最上面那一层」—— 密钥提示框 / 选择器 / 正在跑的回合。关掉了返回 true。
+   *
+   * Esc 与 Ctrl+C 共用这一份：在用户心里这两个键是同一件事（「停」），分成两套
+   * 判断迟早会漂移。没有可关的东西 ⇒ false，由调用方决定下一步。
+   */
+  const dismissTopmost = (): boolean => {
+    if (apiKeyPrompt) {
+      setApiKeyPrompt(null)
+      setApiKeyInput('')
+      return true
+    }
+    if (pickerOpen) {
+      setPickerOpen(false)
+      return true
+    }
+    if (isLoading && abortRef.current) {
+      abortRef.current.abort()
+      return true
+    }
+    return false
+  }
+
+  // Ctrl+C 的「再按一次才退」，语义与计时器见 ui/ctrl-c-confirm.ts
+  const ctrlC = useCtrlCConfirm()
+
+  useInput((input, key) => {
+    // Ctrl+C：先关最上面那一层；没得关时**不退出**，只提示「再按一次」。
+    //
+    // 从前这里没有这个分支，而 Ink 自己的 Ctrl+C 处理（`exitOnCtrlC`，默认
+    // true）在按键**到达任何 handler 之前**就把进程退了 —— 于是对话框里一次
+    // 误按就把整个会话带走。`render()` 三处均已传 `exitOnCtrlC: false`，
+    // 否则这个分支永远不会被调用（见 src/index.tsx 的注释）。
+    if (key.ctrl && input === 'c') {
+      if (dismissTopmost()) {
+        // 这一按被「关掉最上面一层」消费掉了 —— 用户想的是「停」，不是「退」，
+        // 所以待确认窗口要一并撤掉，免得下一次误按直接退出。
+        ctrlC.reset()
         return
       }
-      if (isLoading && abortRef.current) {
-        abortRef.current.abort()
-        return
+      if (ctrlC.isArmed()) {
+        process.exit(0)
       }
+      ctrlC.arm()
+      return
+    }
+    // Escape: close apiKeyPrompt → close picker → abort loading (does NOT exit app)
+    if (key.escape) {
+      if (dismissTopmost()) return
       // Otherwise let InputBar handle Escape (clear draft)
       return
     }
@@ -1372,6 +1406,7 @@ export function App({
                   {' · '}
                   {t('ui.status.left_for_agents')}
                 </Text>
+                {ctrlC.armed && <Text color="yellow"> {t('ui.status.ctrl_c_again')}</Text>}
               </Box>
             </Box>
 

package/src/ui/commands.ts

@@ -2504,7 +2504,8 @@ const marketplaceCmd: CommandHandler = async (_ctx, args) => {
     isValidMarketplaceRef,
     MARKETPLACES_PATH,
   } = await import('../skills/marketplace')
-  const { readFileSync, writeFileSync, existsSync, mkdirSync } = await import('node:fs')
+  const { readFileSync, existsSync, mkdirSync } = await import('node:fs')
+  const { atomicWriteFileSync } = await import('../shared/atomic-write')
   const { dirname } = await import('node:path')
 
   const readSources = () =>
@@ -2537,7 +2538,9 @@ const marketplaceCmd: CommandHandler = async (_ctx, args) => {
     const changed = 'added' in result ? result.added : result.removed
     try {
       mkdirSync(dirname(MARKETPLACES_PATH), { recursive: true })
-      writeFileSync(MARKETPLACES_PATH, JSON.stringify(result.sources, null, 2), 'utf-8')
+      atomicWriteFileSync(MARKETPLACES_PATH, JSON.stringify(result.sources, null, 2), {
+        mode: 0o644,
+      })
     } catch (err) {
       return { content: `❌ Failed to save marketplaces: ${String(err)}` }
     }

package/src/ui/ctrl-c-confirm.ts

@@ -0,0 +1,63 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+/**
+ * Ctrl+C 的「再按一次才退出」窗口。
+ *
+ * 为什么需要它：Ink 默认的 Ctrl+C 语义是**立刻退出**，而 TUI 里 Ctrl+C 的合
+ * 理语义是「停下手上这件事」—— 对话框开着、回合跑着的时候，误按一次不该把
+ * 整个会话带走。所以 `render()` 处一律传 `exitOnCtrlC: false`（见
+ * `src/index.tsx`），退出的决定权收回到这里：第一次按只「上膛」，窗口内再按
+ * 一次才真退。
+ *
+ * 两个入口（主界面 `ui/app.tsx`、看板 `agent-view/dashboard.tsx`）共用这一份，
+ * 而不是各写一遍 —— 同一条语义有两份实现，迟早会长成两个东西。
+ *
+ * 注意 `isArmed()` 与 `armed` 是**两条路**，不是冗余：
+ * - 判据要走 `isArmed()`（ref）—— 在同一个按键回调里 `arm()` 之后 state 还没
+ *   重渲染，用 state 读的话第二次按键看到的仍是 false，就永远退不出去；
+ * - `armed`（state）只给渲染用（页脚那句提示）。
+ */
+export interface CtrlCConfirm {
+  /** 渲染用：当前是否处于「待确认」窗口内。 */
+  armed: boolean
+  /** 判据用：同步读数，同一次按键回调里 `arm()` 之后立刻为 true。 */
+  isArmed: () => boolean
+  /** 上膛：进入待确认窗口，`windowMs` 后自动撤。 */
+  arm: () => void
+  /** 撤膛：关掉窗口并清掉计时器（例如这次按键被别的事情消费掉了）。 */
+  reset: () => void
+}
+
+export function useCtrlCConfirm(windowMs = 2000): CtrlCConfirm {
+  const armedRef = useRef(false)
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+  const [armed, setArmed] = useState(false)
+
+  const clear = useCallback(() => {
+    if (timerRef.current) clearTimeout(timerRef.current)
+    timerRef.current = null
+  }, [])
+
+  const reset = useCallback(() => {
+    clear()
+    armedRef.current = false
+    setArmed(false)
+  }, [clear])
+
+  const arm = useCallback(() => {
+    clear()
+    armedRef.current = true
+    setArmed(true)
+    timerRef.current = setTimeout(() => {
+      armedRef.current = false
+      setArmed(false)
+    }, windowMs)
+  }, [clear, windowMs])
+
+  // 卸载时撤掉计时器 —— 否则它到点后会往已经卸掉的组件里 setState。
+  useEffect(() => clear, [clear])
+
+  const isArmed = useCallback(() => armedRef.current, [])
+
+  return { armed, isArmed, arm, reset }
+}

package/src/workflow/journal.ts

@@ -1,12 +1,7 @@
-import {
-  mkdirSync,
-  writeFileSync,
-  readFileSync,
-  existsSync,
-  appendFileSync,
-  readdirSync,
-} from 'node:fs'
+import { mkdirSync, existsSync, readdirSync } from 'node:fs'
 import { join } from 'node:path'
+import { atomicWriteFileSync } from '../shared/atomic-write'
+import { appendRegularFileSync, readRegularFileSync } from '../shared/regular-file'
 import { miphamHome } from '../core/paths.ts'
 
 const WORKFLOW_DIR = miphamHome('workflows')
@@ -33,15 +28,23 @@ export function createJournal(runId: string, script: string): string {
   const dir = join(WORKFLOW_DIR, runId)
   mkdirSync(dir, { recursive: true })
 
-  writeFileSync(join(dir, 'script.js'), script, 'utf-8')
-  writeFileSync(join(dir, 'journal.jsonl'), '', 'utf-8')
-  writeFileSync(join(dir, 'state.json'), JSON.stringify({ seq: 0, phases: [] }), 'utf-8')
+  // 三份都走助手：新建 run 目录里本来没有旧内容可丢，但**路径上可能被放了个 FIFO**
+  // （`writeFileSync` 会打开它写 ⇒ 干等到有读者为止）。`atomicWriteFileSync` 的 rename
+  // 与 `appendRegularFileSync` 的类型闸都不打开目标，于是在这里也一并关掉。
+  atomicWriteFileSync(join(dir, 'script.js'), script, { mode: 0o644 })
+  if (!appendRegularFileSync(join(dir, 'journal.jsonl'), '')) {
+    throw new Error(`workflow journal for run "${runId}" is not appendable`)
+  }
+  atomicWriteFileSync(join(dir, 'state.json'), JSON.stringify({ seq: 0, phases: [] }))
 
   return dir
 }
 
 /**
  * Append an agent call to the journal. Returns the new sequence number.
+ *
+ * 先 append journal（权威记录）、后写 state（它的影子）—— 顺序有意义：中途被打断时
+ * 唯一的后果是影子落后，而不是记录丢失。
  */
 export function appendJournal(runId: string, entry: Omit<JournalEntry, 'seq'>): number {
   const dir = join(WORKFLOW_DIR, runId)
@@ -50,32 +53,84 @@ export function appendJournal(runId: string, entry: Omit<JournalEntry, 'seq'>):
   const seq = state.seq + 1
   const fullEntry: JournalEntry = { seq, ...entry }
 
-  appendFileSync(join(dir, 'journal.jsonl'), JSON.stringify(fullEntry) + '\n', 'utf-8')
+  // 权威记录写不进去 = 这个 run 没法记账（含路径上是个 FIFO）：**不做影子**、当场说清，
+  // 好过把 state 推进到一个 journal 里不存在的 seq 上。
+  if (!appendRegularFileSync(join(dir, 'journal.jsonl'), JSON.stringify(fullEntry) + '\n')) {
+    throw new Error(`workflow journal for run "${runId}" is not appendable`)
+  }
 
   state.seq = seq
-  writeFileSync(join(dir, 'state.json'), JSON.stringify(state), 'utf-8')
+  atomicWriteFileSync(join(dir, 'state.json'), JSON.stringify(state))
 
   return seq
 }
 
 /**
  * Load all journal entries for a run. Returns empty array if run not found.
+ *
+ * **逐行**解析：`appendFileSync` 被打断会在尾部留下半截行，而从前一个半截行让整份
+ * 读取抛 `SyntaxError`（`/workflow` 那条链上没有兜它）。坏行丢掉、其余全留 —— 一份
+ * 日志里少一行，好过整份读不出来。
  */
 export function loadJournal(runId: string): JournalEntry[] {
-  const journalPath = join(WORKFLOW_DIR, runId, 'journal.jsonl')
-  if (!existsSync(journalPath)) return []
-
-  const raw = readFileSync(journalPath, 'utf-8')
-  return raw
-    .split('\n')
-    .filter((line) => line.trim())
-    .map((line) => JSON.parse(line) as JournalEntry)
+  const raw = readRegularFileSync(join(WORKFLOW_DIR, runId, 'journal.jsonl'))
+  if (raw === null) return []
+
+  const entries: JournalEntry[] = []
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue
+    try {
+      const parsed: unknown = JSON.parse(line)
+      if (isJournalEntry(parsed)) entries.push(parsed)
+    } catch {
+      // 半截行（append 被打断）/坏行 —— 只丢这一行
+    }
+  }
+  return entries
 }
 
+function isJournalEntry(e: unknown): e is JournalEntry {
+  if (!e || typeof e !== 'object' || Array.isArray(e)) return false
+  const ev = e as Record<string, unknown>
+  return (
+    typeof ev.seq === 'number' && (ev.type === 'agent' || ev.type === 'phase' || ev.type === 'log')
+  )
+}
+
+/**
+ * 读 state.json。
+ *
+ * 从前这里是**裸**的 `JSON.parse(readFileSync(...))`：state.json 是非原子写的，半截写
+ * 会让 `appendJournal` 当场抛 `SyntaxError`，整个 run 停摆 —— 而 state 只是**派生**信息。
+ * 所以坏掉/缺字段时把 `seq` 从 journal 尾行**重新推出来**，而不是归零：归零会让后续
+ * append 复用已经在用的序号，而那正是这份文件存在的意义。
+ */
 function readState(runId: string): JournalState {
-  const statePath = join(WORKFLOW_DIR, runId, 'state.json')
-  if (!existsSync(statePath)) return { seq: 0, phases: [] }
-  return JSON.parse(readFileSync(statePath, 'utf-8'))
+  const raw = readRegularFileSync(join(WORKFLOW_DIR, runId, 'state.json'))
+  if (raw !== null) {
+    try {
+      const parsed: unknown = JSON.parse(raw)
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        const { seq, phases } = parsed as { seq?: unknown; phases?: unknown }
+        if (typeof seq === 'number' && Number.isFinite(seq)) {
+          return {
+            seq,
+            phases: Array.isArray(phases)
+              ? phases.filter((p): p is string => typeof p === 'string')
+              : [],
+          }
+        }
+      }
+    } catch {
+      // 半截写/坏形状 —— 落到下面按 journal 推。
+    }
+  }
+  return { seq: lastJournalSeq(runId), phases: [] }
+}
+
+/** journal 尾行的 seq —— 权威记录在 journal.jsonl，state.json 只是它的影子。 */
+function lastJournalSeq(runId: string): number {
+  return loadJournal(runId).reduce((max, e) => (e.seq > max ? e.seq : max), 0)
 }
 
 /**
@@ -83,8 +138,7 @@ function readState(runId: string): JournalState {
  */
 export function loadScript(runId: string): string {
   const scriptPath = join(WORKFLOW_DIR, runId, 'script.js')
-  if (!existsSync(scriptPath)) return ''
-  return readFileSync(scriptPath, 'utf-8')
+  return readRegularFileSync(scriptPath) ?? ''
 }
 
 /**