@miphamai/cli 0.85.2 → 0.85.3

package/bin/mipham.ts

@@ -437,6 +437,19 @@ async function runAttachCLI(): Promise<boolean> {
   const args = process.argv.slice(2)
   if (args[0] !== 'attach') return false
 
+  // `--permission <mode>` is the same flag here as on the interactive path, because it
+  // is the same gate — it just lives on the other side of the socket. The request goes
+  // out as `set_mode` when the TUI starts, and the daemon's answer is what the footer
+  // shows: it clamps, so `--permission bypassPermissions` under an org cap comes back
+  // narrower. Checked before the daemon is contacted: a misspelled mode is wrong whether
+  // or not a daemon happens to be running.
+  const { parsePermissionFlag, firstPositional } = await import('../src/shared/arg-validation')
+  const permissionFlag = parsePermissionFlag(args)
+  if (permissionFlag.kind === 'error') {
+    console.error(permissionFlag.message)
+    process.exit(1)
+  }
+
   const { getPort, getDaemonStatus } = await import('../src/daemon/index')
   const { join } = await import('node:path')
   const { readFileSync, existsSync } = await import('node:fs')
@@ -479,7 +492,10 @@ async function runAttachCLI(): Promise<boolean> {
   }
 
   const latestFlag = args.includes('--latest')
-  const sessionIdArg = args[1] && !args[1].startsWith('-') ? args[1] : undefined
+  // Skip flags **and the values of value-taking flags**: with `--permission plan <id>`
+  // the old `args[1]` read `--permission` (starts with `-`, so no id) and silently fell
+  // through to the session list — the flag would have looked accepted and done nothing.
+  const sessionIdArg = firstPositional(args.slice(1)) ?? undefined
 
   let targetSession: SessionInfo | null = null
 
@@ -534,6 +550,7 @@ async function runAttachCLI(): Promise<boolean> {
   const { runApp } = await import('../src/index')
   await runApp({
     version,
+    permission: permissionFlag.kind === 'ok' ? permissionFlag.mode : undefined,
     remoteSession: {
       sessionId: targetSession.id,
       port,
@@ -1198,6 +1215,10 @@ async function main() {
     process.argv.includes('-h') ||
     process.argv.slice(2).some((a) => a === 'help')
   ) {
+    // The mode list is **derived**, never typed out here — a help screen with its own copy
+    // is how it comes to advertise a mode the flag then refuses (see `arg-validation`:
+    // the list in the error message and the list in the help are the same array).
+    const { ALL_MODES } = await import('../src/core/permission-config')
     console.log(`Mipham Code — AI-powered coding terminal
 
 Usage:
@@ -1226,6 +1247,8 @@ Flags:
   --dump-config              Print the assembled profile tree
   --safe-mode                Skip custom agents, skills, hooks, plugins
   --resume <name>            Open a saved session (see /resume for names)
+  --permission <mode>        Start in this mode: ${ALL_MODES.join('|')}
+                             (also accepted by 'mipham attach'; the daemon may clamp it)
   --version, -v, -V          Print version
 
 Docs: https://mipham.ai/code
@@ -1348,9 +1371,26 @@ npm:  https://www.npmjs.com/package/@miphamai/cli`)
     }
   }
 
+  // Parse --permission <mode>: the session's starting mode. `runApp` has accepted
+  // `options.permission` all along — the system prompt and the engine both read the live
+  // permission system it is applied to — but **nothing ever passed it**, so the only ways
+  // to pick a mode were `config.yml`, Shift+Tab after startup, or the daemon's env var.
+  // Same shape as `--resume` above; same remedy, and the value is refused rather than
+  // silently replaced (see `parsePermissionFlag`).
+  const { parsePermissionFlag } = await import('../src/shared/arg-validation')
+  const permissionFlag = parsePermissionFlag(process.argv.slice(2))
+  if (permissionFlag.kind === 'error') {
+    console.error(permissionFlag.message)
+    process.exit(1)
+  }
+
   try {
     const { runApp } = await import('../src/index')
-    await runApp({ version: APP_VERSION, resume: resumeName })
+    await runApp({
+      version: APP_VERSION,
+      resume: resumeName,
+      permission: permissionFlag.kind === 'ok' ? permissionFlag.mode : undefined,
+    })
   } catch (err: unknown) {
     const msg = err instanceof Error ? err.message : String(err)
     if (msg.includes('react-devtools-core')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.85.2",
+  "version": "0.85.3",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/skills/standard/mipham-code-setup.SKILL.md

@@ -360,13 +360,20 @@ Press **Shift+Tab** to change the mode live; it cycles
 `bypassPermissions` is a legal mode but is deliberately **not** on the wheel —
 it is reached by naming it in config, where the user has said what they mean.
 
-To persist a mode for a project, in `.mipham/config.yml`:
+To persist a mode, name it in `~/.mipham/config.yml`:
 
 ```yaml
 permission: default
 ```
 
-Any mode name from the table above is accepted, including `bypassPermissions`.
+Or in `~/.mipham/settings.json` as `permissions.defaultMode` (the key Claude Code
+users already have). Any mode name from the table above is accepted in either,
+including `bypassPermissions`.
+
+A **project-level** `.mipham/config.yml` cannot set a mode — that file arrives with
+the code, so whoever wrote the repository would be choosing the approval gate. A
+mode found there is ignored and reported; the fix is to move the line to the user
+level, or to pass `--permission <mode>` for one invocation.
 
 Or via slash command:
 

package/src/agent/sub-agent.ts

@@ -7,6 +7,7 @@ import { getBackgroundAgentRegistry } from './background-registry'
 import { formatInboundMessage, getMessageBus } from './message-bus'
 import type { HookEngine } from '../core/hooks'
 import { PermissionSystem } from '../core/permission'
+import { buildPermissionBlock } from '../core/instructions'
 import { AgentExperience } from './agent-experience'
 import { PatternAnalyzer } from './pattern-analyzer.js'
 import { getWorkspaceTrust } from '../core/workspace-trust'
@@ -148,7 +149,10 @@ export class SubAgent {
 
     // ── Synchronous execution path ──
     try {
-      const result = await this.runExecution(prompt, options)
+      // A caller that spawned the registry task itself owns the only abort
+      // controller for it; without passing it down the run ignores every check
+      // inside `runExecution` and cannot be stopped from the dashboard.
+      const result = await this.runExecution(prompt, options, options.signal)
       if (this.hookEngine) {
         await this.hookEngine.executeSubagentStop(agentType, description, 'sub-agent', true, result)
       }
@@ -385,7 +389,24 @@ export class SubAgent {
     let hitMaxTurns = false
 
     let currentMessages = messages
-    let currentSystemPrompt = systemPrompt
+    // ── 子代理报**它自己的档**，不是父档 ──
+    // `gate` 是每个工具调用真正过的那个闸门（上面构造的那个，缺省是 `default`）；
+    // 闸门的模式取自 `createSubAgentPermission` 的**解析结果** —— 定义写了
+    // `permissionMode` 的就是它自己那一档，写 `inherit` 的才是父档 —— 这里只读结果、
+    // 不重算，免得同一个事实有第二份推导。读 `getMode()` 而不是定义里那个字符串：
+    // 组织级上限（`maxAllowedMode`/`forbiddenModes`）会静默把模式钳走，报请求档就是
+    // 报得比实际宽 —— 与系统提示那边（`index.tsx` 的接线行）同一个理由。
+    //
+    // 它烘在**这一处**而不是走 `ContextManager.setPermissionContextSource`：子代理的请求
+    // 读的是下面这个局部变量（`systemPrompt: currentSystemPrompt`），**从不读上下文**的
+    // 系统提示 —— 挂在上下文上会是一处装饰（有接线、请求里一个字都到不了），正是本仓库
+    // 反复收的那种账。同样因为后续回合把提示清成 `''`（`currentSystemPrompt = ''`，
+    // 首轮才带系统提示），
+    // 权限段随**唯一**带提示的那一轮走，而不是每轮派生。
+    const permissionBlock = buildPermissionBlock(gate.getMode())
+    let currentSystemPrompt = permissionBlock
+      ? `${systemPrompt}\n\n---\n\n${permissionBlock}`
+      : systemPrompt
     let totalTokens = 0
 
     // Context for the sub-agent's own tool calls. Built once per run: the caller's

package/src/agent/types.ts

@@ -55,6 +55,16 @@ export interface SubAgentOptions {
   worktreePath?: string
   /** Seed the sub-agent with a parent conversation prefix (e.g., fork inheritance). */
   inheritContext?: { messages: Message[] }
+  /**
+   * Abort signal for a caller-owned execution.
+   *
+   * The `runInBackground` path mints its own controller inside `SubAgent`, so it
+   * needs nothing here. A caller that spawned the task in the registry itself
+   * (`/bg`, `/fork`) holds the only handle that can stop it — and if it does not
+   * hand that signal down, the signal is decoration: the registry's `stop()`
+   * aborts a controller nobody reads, and the agent runs to completion.
+   */
+  signal?: AbortSignal
   /**
    * Who authored the prompt. `'script'` marks text computed by a workflow
    * script — which is not the user speaking, even though it arrives as the

package/src/agent-view/agent-view-manager.ts

@@ -34,6 +34,16 @@ export interface AgentSession {
   branch?: string
   /** Created PR URL (if requested) */
   prUrl?: string
+  /**
+   * Id of the `BackgroundAgentRegistry` task actually doing the work, when this
+   * session was spawned by `/bg` or `/fork`.
+   *
+   * The two id spaces are minted separately (`agent-…` here, `bg-…` there), so
+   * without this the dashboard holds a row it cannot act on: its own `kill()`
+   * only flips the row's status and leaves the real task running with no handle
+   * left in the UI. This field is that handle.
+   */
+  taskId?: string
   /** Working directory the session was spawned from (used for directory grouping). */
   directory: string
 }
@@ -60,6 +70,35 @@ export class AgentViewManager {
   private sessions: Map<string, AgentSession> = new Map()
   private sessionOrder: string[] = []
   private idCounter = 0
+  private listeners: Set<() => void> = new Set()
+
+  /**
+   * Subscribe to any mutation of the session set. Returns an unsubscribe fn.
+   *
+   * The dashboard renders from this object, but the changes originate elsewhere
+   * (`/bg` and `/fork` mutate it from their executors, which resolve long after
+   * the keystroke that spawned them). Without a subscription the view is a
+   * snapshot painted once at mount: `setVersion` had exactly one caller
+   * (Ctrl+X), so a row that finished while the panel was open stayed `working`
+   * on screen forever.
+   */
+  onChange(listener: () => void): () => void {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  /** One listener throwing must not stop the others, nor the mutation itself. */
+  private notify(): void {
+    for (const listener of this.listeners) {
+      try {
+        listener()
+      } catch {
+        // A broken view must never break the state transition that triggered it.
+      }
+    }
+  }
 
   /**
    * Create a new background agent session.
@@ -82,6 +121,7 @@ export class AgentViewManager {
 
     this.sessions.set(id, session)
     this.sessionOrder.push(id)
+    this.notify()
 
     return session
   }
@@ -171,6 +211,7 @@ export class AgentViewManager {
       session.startedAt = new Date()
     }
 
+    this.notify()
     return session
   }
 
@@ -189,6 +230,7 @@ export class AgentViewManager {
 
     session.status = 'failed'
     session.completedAt = new Date()
+    this.notify()
     return true
   }
 
@@ -208,6 +250,7 @@ export class AgentViewManager {
       session.completedAt = new Date()
     }
 
+    this.notify()
     return true
   }
 
@@ -219,6 +262,7 @@ export class AgentViewManager {
     if (!session) return false
 
     session.messages.push(message)
+    this.notify()
     return true
   }
 
@@ -247,6 +291,7 @@ export class AgentViewManager {
     const session = this.sessions.get(id)
     if (!session) return false
     session.title = newTitle
+    this.notify()
     return true
   }
 
@@ -257,6 +302,7 @@ export class AgentViewManager {
     if (!this.sessions.has(id)) return false
     this.sessions.delete(id)
     this.sessionOrder = this.sessionOrder.filter((oid) => oid !== id)
+    this.notify()
     return true
   }
 

package/src/agent-view/dashboard.tsx

@@ -8,12 +8,14 @@
  *   mipham agents          (from CLI)
  *   /agents                (from slash command within a running session)
  */
-import React, { useState, useCallback, useMemo } from 'react'
+import React, { useState, useCallback, useEffect, useMemo } from 'react'
 import { Box, Text, useInput } from 'ink'
+import TextInput from 'ink-text-input'
 import { AgentViewManager, type AgentSession, type SessionStatus } from './agent-view-manager'
 import { SessionRow } from './session-row'
 import { SessionPeek } from './session-peek'
 import { useCtrlCConfirm } from '../ui/ctrl-c-confirm'
+import { getBackgroundAgentRegistry } from '../agent/background-registry'
 
 interface DashboardProps {
   manager: AgentViewManager
@@ -33,8 +35,10 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
   const [peekingSessionId, setPeekingSessionId] = useState<string | null>(null)
   const [groupBy, setGroupBy] = useState<'status' | 'directory'>('status')
   const [feedback, setFeedback] = useState<string | null>(null)
-  // Bump to force flatList recompute after a session is removed (list membership change).
+  // Bump to force flatList recompute after the session set changes.
   const [version, setVersion] = useState(0)
+  // Non-null while the rename box is open; holds the row being renamed + the draft.
+  const [renaming, setRenaming] = useState<{ id: string; draft: string } | null>(null)
 
   // Ctrl+C 的「再按一次才退」，与主界面同源（见 ui/ctrl-c-confirm.ts）
   const ctrlC = useCtrlCConfirm()
@@ -45,6 +49,12 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
     setTimeout(() => setFeedback(null), 1800)
   }, [])
 
+  // The mutations that matter happen outside this component: `/bg` and `/fork`
+  // resolve their executors long after the keystroke that spawned them, so a
+  // run that finishes while this panel is open used to leave the row — and the
+  // header counts — frozen at whatever they were when the panel mounted.
+  useEffect(() => manager.onChange(() => setVersion((v) => v + 1)), [manager])
+
   // Build a flat list of sessions in group order, with group headers
   const flatList = useMemo(() => {
     const result: Array<
@@ -115,7 +125,37 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
     [manager, onAttach],
   )
 
+  // Commit the open rename box. Empty title cancels — a session with no name is
+  // indistinguishable in the list, so the box refuses rather than writing ''.
+  const handleRenameSubmit = useCallback(
+    (value: string) => {
+      const id = renaming?.id
+      setRenaming(null)
+      if (!id) return
+      const title = value.trim()
+      if (!title) {
+        showFeedback('Rename cancelled — title cannot be empty')
+        return
+      }
+      manager.rename(id, title)
+      showFeedback(`Renamed to ${title}`)
+    },
+    [manager, renaming, showFeedback],
+  )
+
   useInput((input, key) => {
+    // While the rename box is open it owns the keyboard: the list keys below
+    // must not fire on the same keystroke that is being typed into the title
+    // (Ink delivers every key to every mounted useInput).
+    if (renaming) {
+      if (key.escape || (key.ctrl && input === 'c')) {
+        setRenaming(null)
+        ctrlC.reset()
+        showFeedback('Rename cancelled')
+      }
+      return
+    }
+
     // Ctrl+C 不再一下就退出（Ink 的 `exitOnCtrlC` 已在 render 处关掉，见
     // src/index.tsx）：第一次只提示，再按一次才走。面板里 Esc 已经是退出键，
     // 所以这里只补「误按一次不带走整个面板」。
@@ -150,7 +190,7 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
       return
     }
 
-    // Ctrl+R — rename selected session
+    // Ctrl+R — open the rename box on the selected session
     if (key.ctrl && input === 'r') {
       if (sessionsOnly.length === 0) {
         showFeedback('No sessions to rename')
@@ -158,13 +198,13 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
       }
       const current = sessionsOnly[selectedIndex]
       if (!current) return
-      const newTitle = `session-${Date.now().toString(36)}`
-      manager.rename(current.session.id, newTitle)
-      showFeedback(`Renamed to ${newTitle}`)
+      // Seeded with the current title: renaming is usually an edit, and a box
+      // that opens blank silently invites the user to retype a whole task name.
+      setRenaming({ id: current.session.id, draft: current.session.title })
       return
     }
 
-    // Ctrl+X — permanently remove the selected session
+    // Ctrl+X — stop the selected session's work (if any) and drop its row
     if (key.ctrl && input === 'x') {
       if (sessionsOnly.length === 0) {
         showFeedback('No sessions to remove')
@@ -172,11 +212,20 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
       }
       const current = sessionsOnly[selectedIndex]
       if (!current) return
-      manager.remove(current.session.id)
+      const session = current.session
+      // Discarding a row whose work is still running would throw away the only
+      // handle to it — the manager's own `kill()` flips a status label and
+      // stops nothing, and the running sub-agent checks the registry's abort
+      // signal. So: stop the task, then remove the row.
+      const stopped = session.taskId ? getBackgroundAgentRegistry().stop(session.taskId) : false
+      manager.remove(session.id)
       setPeekingSessionId(null)
       setSelectedIndex((prev) => Math.max(0, Math.min(prev, sessionsOnly.length - 2)))
-      setVersion((v) => v + 1)
-      showFeedback(`Removed ${current.session.title || current.session.id}`)
+      showFeedback(
+        stopped
+          ? `Stopped + removed ${session.title || session.id}`
+          : `Removed ${session.title || session.id}`,
+      )
       return
     }
 
@@ -220,11 +269,7 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
       }
       const current = sessionsOnly[selectedIndex]
       if (!current) return
-      if (peekingSessionId) {
-        handleAttach(current.session.id)
-      } else {
-        handleAttach(current.session.id)
-      }
+      handleAttach(current.session.id)
       return
     }
   })
@@ -233,7 +278,9 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
   const peekData = useMemo(() => {
     if (!peekingSessionId) return null
     return manager.peek(peekingSessionId) ?? null
-  }, [manager, peekingSessionId])
+    // `version` is a dependency so an open peek keeps up with a session that
+    // reports new messages while the viewer sits on it.
+  }, [manager, peekingSessionId, version])
 
   const totalSessions = sessionsOnly.length
   const counts = manager.countByStatus()
@@ -323,6 +370,27 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
         <SessionPeek session={peekData.session} recentMessages={peekData.recentMessages} />
       )}
 
+      {/* Rename box — opens on Ctrl+R, owns the keyboard until Enter/Esc */}
+      {renaming && (
+        <Box
+          flexDirection="column"
+          marginTop={1}
+          borderStyle="single"
+          borderColor="cyan"
+          padding={1}
+        >
+          <Text dimColor>Rename session — Enter to save · Esc to cancel</Text>
+          <Box>
+            <Text color="cyan">{'> '}</Text>
+            <TextInput
+              value={renaming.draft}
+              onChange={(draft) => setRenaming((cur) => (cur ? { ...cur, draft } : cur))}
+              onSubmit={handleRenameSubmit}
+            />
+          </Box>
+        </Box>
+      )}
+
       {/* Feedback toast — flashes briefly on action */}
       {feedback && (
         <Box marginTop={1}>

package/src/agent-view/session-view.tsx

@@ -0,0 +1,128 @@
+/**
+ * AgentSessionView — where Enter ("attach") in the Agent View dashboard lands.
+ *
+ * Read-only on purpose. The session's work runs inside its own `SubAgent` with
+ * its own context; this CLI has no channel back into that loop, so a view that
+ * accepted input would be collecting keystrokes it could not deliver. What this
+ * shows is the real thing instead: the transcript the session actually
+ * accumulated, kept current through the manager's change notifications.
+ *
+ * Esc returns to the dashboard.
+ */
+import React, { useCallback, useEffect, useMemo, useState } from 'react'
+import { Box, Text, useInput } from 'ink'
+import { AgentViewManager, type SessionStatus } from './agent-view-manager'
+import { ChatPanel } from '../ui/chat'
+
+interface AgentSessionViewProps {
+  manager: AgentViewManager
+  sessionId: string
+  onDetach: () => void
+}
+
+const STATUS_COLORS: Record<SessionStatus, string> = {
+  'needs-input': 'yellow',
+  working: 'cyan',
+  completed: 'green',
+  failed: 'red',
+}
+
+const STATUS_LABELS: Record<SessionStatus, string> = {
+  'needs-input': 'needs input',
+  working: 'working',
+  completed: 'completed',
+  failed: 'failed',
+}
+
+export function AgentSessionView({ manager, sessionId, onDetach }: AgentSessionViewProps) {
+  const [version, setVersion] = useState(0)
+
+  // The session keeps running while we look at it — follow it rather than
+  // photographing it once at mount.
+  useEffect(() => manager.onChange(() => setVersion((v) => v + 1)), [manager])
+
+  const session = useMemo(
+    () => manager.get(sessionId),
+    // `version` is a dependency so the transcript keeps up with a session that
+    // reports new messages while the viewer sits on it.
+    [manager, sessionId, version],
+  )
+
+  useInput((_input, key) => {
+    if (key.escape) onDetach()
+  })
+
+  // Esc while the agent view is open is the app's "go back" — but the app-level
+  // handler lives in `app.tsx` and only knows its own layers, so this component
+  // answers for itself.
+  const status = session ? STATUS_LABELS[session.status] : 'gone'
+  const statusColor = session ? STATUS_COLORS[session.status] : 'red'
+
+  const transcript = session?.messages ?? []
+  const emptyState = useCallback(
+    () => (
+      <Box paddingLeft={2}>
+        <Text dimColor>(no messages yet)</Text>
+      </Box>
+    ),
+    [],
+  )
+
+  if (!session) {
+    return (
+      <Box flexDirection="column" padding={1} height="100%">
+        <Text bold color="red">
+          Session {sessionId} no longer exists.
+        </Text>
+        <Box marginTop={1}>
+          <Text dimColor>Esc back to Agent View</Text>
+        </Box>
+      </Box>
+    )
+  }
+
+  return (
+    <Box flexDirection="column" padding={1} height="100%">
+      {/* Header */}
+      <Box flexDirection="column" marginBottom={1}>
+        <Box>
+          <Text bold color="cyan">
+            Attached
+          </Text>
+          <Text dimColor> — {session.id}</Text>
+        </Box>
+        <Box>
+          <Text>{session.title}</Text>
+          <Text dimColor>
+            {' '}
+            · {session.provider}/{session.model} · <Text color={statusColor}>{status}</Text>
+          </Text>
+        </Box>
+        {session.branch && (
+          <Box>
+            <Text dimColor>
+              branch {session.branch} · worktree {session.worktree}
+            </Text>
+          </Box>
+        )}
+        <Box>
+          <Text dimColor>
+            {transcript.length} message(s) · read-only transcript · Esc back to Agent View
+          </Text>
+        </Box>
+      </Box>
+
+      {/* Divider */}
+      <Box marginBottom={1}>
+        <Text dimColor>{'─'.repeat(70)}</Text>
+      </Box>
+
+      {/* Transcript */}
+      {transcript.length === 0 ? (
+        emptyState()
+      ) : (
+        <ChatPanel messages={transcript} focusMode={false} />
+      )}
+    </Box>
+  )
+}

package/src/commands/project.ts

@@ -240,8 +240,10 @@ Messages:   ${msgs.length} in context
 Tools:      ${ctx.engine.getTools().size} available
 
 Shift+Tab cycles: ${renderCycleLine()} (this session only).
-To persist a mode, set \`permission:\` in .mipham/config.yml — every mode below is
-accepted there.
+To persist a mode, name it in ~/.mipham/config.yml (\`permission:\`) or in
+~/.mipham/settings.json (\`permissions.defaultMode\`) — every mode below is accepted
+in either. A **project-level** file cannot set a mode: it arrives with the code, so
+whoever wrote the repository would be choosing the approval gate.
 
 Modes (least → most permissive):
 ${renderModeTable()}
@@ -476,7 +478,7 @@ const setupCmd: CommandHandler = async (ctx, args) => {
   ${skills.length} loaded (${standardSkills} standard + ${miphamSkills} mipham)
 
   Permissions
-  Mode: ${ctx.config.permission}  ·  Tools: ${ctx.engine.getTools().size}
+  Mode: ${ctx.engine.getPermission().getMode()}  ·  Tools: ${ctx.engine.getTools().size}
 
 
   ── Setup Steps ──