@miphamai/cli 0.24.16 → 0.26.0

package/skills/standard/triage.SKILL.md

@@ -0,0 +1,155 @@
+---
+name: triage
+description: Structured task decomposition and tracking across sessions. Use for breaking complex plans into trackable tickets with dependency graphs, checking task status, or continuing work from a previous session.
+version: 1.0.0
+user-invocable: true
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+---
+
+# Triage — Cross-Session Task Tracking
+
+Turn plans into trackable tickets with dependency management. Inspired by Matt Pocock's `triage` + `to-tickets` + `wayfinder` skills, consolidated into one Mipham Code skill.
+
+## When to Use
+
+- Breaking a large plan into actionable tickets
+- Tracking work across multiple sessions
+- User asks: "what's next?", "where did I leave off?", "what's the status?"
+- Complex tasks with dependencies between them
+
+---
+
+## The Ticket Format
+
+Tickets live in `.mipham/tickets/` as individual Markdown files:
+
+```markdown
+---
+id: T-001
+title: Add user authentication
+status: in-progress
+priority: P0
+depends_on: []
+blocks: [T-003]
+created: 2026-08-10
+tags:
+  - auth
+  - backend
+---
+
+## Description
+
+Add JWT-based authentication with refresh token rotation.
+
+## Acceptance Criteria
+
+- [ ] Login endpoint returns access + refresh tokens
+- [ ] Refresh endpoint rotates tokens
+- [ ] Invalid tokens return 401
+- [ ] Rate limiting on login attempts
+
+## Notes
+
+- OAuth not in scope for T-001 (punted to T-005)
+```
+
+### Status Values
+
+| Status        | Meaning                                    |
+| ------------- | ------------------------------------------ |
+| `backlog`     | Not yet planned for any session            |
+| `planned`     | Scoped and ready to work                   |
+| `in-progress` | Currently being worked on                  |
+| `review`      | Implementation done, awaiting verification |
+| `done`        | Verified and merged                        |
+| `blocked`     | Cannot proceed due to dependency           |
+| `wontfix`     | Decided not to do                          |
+
+---
+
+## The Triage Workflow
+
+### Phase 1: Decompose (Plan → Tickets)
+
+Given a plan or feature request:
+
+1. **Identify the smallest independently-valuable units of work**
+   - Each ticket should deliver value on its own
+   - If a ticket requires 3+ files touched, it's probably too big
+   - If a ticket can be done in < 15 minutes, it's probably too small
+
+2. **Map dependencies**
+   - What must be done first? (hard dependency)
+   - What would be easier after something else? (soft dependency)
+   - What blocks other work? (reverse dependency)
+
+3. **Assign priorities**
+   - **P0**: Blocks other work, must do first
+   - **P1**: High value, should do soon
+   - **P2**: Nice to have, can defer
+   - **P3**: Optional, do if time permits
+
+4. **Write acceptance criteria**
+   - Specific, testable, unambiguous
+   - "Login works" is bad. "POST /auth/login with valid credentials returns 200 + JWT" is good.
+
+### Phase 2: Status Check
+
+When the user asks "what's next?" or "what's the status?":
+
+1. Read `.mipham/tickets/` directory
+2. Report:
+   - Currently in-progress tickets
+   - Blocked tickets (and what's blocking them)
+   - Next unblocked P0/P1 tickets ready to work
+   - Recently completed tickets (for context)
+
+### Phase 3: Session Handoff
+
+When starting a new session, check for continuity:
+
+1. Read the previous session's context from the session store
+2. Check ticket statuses — any that were `in-progress` last session?
+3. Present: "Last session you were working on T-004 (Add rate limiting). Continue from there, or start on T-007 (API docs) which is next in the P1 queue?"
+
+### Phase 4: Ticket Lifecycle
+
+When working on a ticket:
+
+- Mark it `in-progress` when you start
+- Mark it `review` when implementation is done
+- Mark it `done` after verification (tests pass, typecheck clean)
+- If you discover new dependencies, add them to `blocks`/`depends_on`
+
+---
+
+## Dependency Graph
+
+For tickets with complex dependencies, generate a visual summary:
+
+```
+T-001 (Auth) ──blocks──→ T-003 (Dashboard)
+    │                        │
+    └──blocks──→ T-002 (API) ─┘
+                     │
+                     └──soft-dep──→ T-004 (Rate Limiting)
+
+Ready to work: T-001 (no dependencies)
+Blocked: T-002 (waiting on T-001), T-003 (waiting on T-001, T-002)
+```
+
+---
+
+## Integration With Mipham Code
+
+- **Session Store**: Ticket status persists across sessions via `.mipham/tickets/`
+- **Memory System**: Active tickets are loaded as project memory for context
+- **grill-with-docs**: The output of a grill session feeds directly into ticket decomposition
+- **Background Agents**: Long-running work on a ticket can be spawned as a background agent
+- **Critical Thinking Layer**: When decomposing, ask "what's the smallest thing that delivers value?" — don't over-decompose

package/src/agent/message-bus.ts

@@ -56,15 +56,20 @@ export class AgentMessageBus {
   /**
    * Get all unread messages addressed to the given agent.
    * Does NOT mark them as read — use markRead() for that.
+   * P2-3: Auto-prunes messages older than 1 hour before polling.
    */
   poll(agentId: string): AgentMessage[] {
+    // Auto-prune stale messages to prevent accumulation and stuck states
+    this.prune(60 * 60 * 1000) // 1 hour TTL
     return this.messages.filter((m) => m.to === agentId && !m.read)
   }
 
   /**
    * Get all messages addressed to the given agent (read + unread).
+   * P2-3: Auto-prunes stale messages before listing.
    */
   list(agentId: string): AgentMessage[] {
+    this.prune(60 * 60 * 1000) // 1 hour TTL
     return this.messages.filter((m) => m.to === agentId)
   }
 

package/src/agent/sub-agent.ts

@@ -198,6 +198,22 @@ export class SubAgent {
     const agentType = options.type || 'general'
     const agentDef = options.agentDef
 
+    // ── P0-3: Create isolated PermissionSystem for this sub-agent ──
+    // The agent definition's permissionMode is clamped against parent's org
+    // restrictions (maxAllowedMode, forbiddenModes). When permissionMode is
+    // 'inherit' or not set, the parent's mode is used but still clamped.
+    let subPermission = this.permission // default: use parent's
+    if (this.permission) {
+      const agentPermMode =
+        agentDef?.permissionMode && agentDef.permissionMode !== 'inherit'
+          ? agentDef.permissionMode
+          : 'inherit'
+      subPermission = this.permission.createSubAgentPermission(agentPermMode)
+      // P0-5: Enable sub-agent safety mode — auto mode returns 'ask' for
+      // Bash/Write/Edit so hooks remain the safety gate in background agents.
+      subPermission.setSubAgentMode(true)
+    }
+
     // Resolve execution directory: worktree isolation or process cwd
     const execCwd = options.worktreePath || process.cwd()
 
@@ -212,6 +228,25 @@ export class SubAgent {
         }
         // Otherwise, proceed with a warning — don't block agent execution
       }
+
+      // P0-4: Auto-disallow Git tool for worktree-isolated sub-agents
+      // to prevent destructive operations on the main checkout.
+      // Agent definitions can explicitly re-enable Git if needed.
+      if (!agentDef?.tools) {
+        // No explicit allowlist — add Git to disallowedTools
+        const existingDisallowed = agentDef?.disallowedTools
+          ? agentDef.disallowedTools
+              .split(',')
+              .map((s) => s.trim())
+              .filter(Boolean)
+          : []
+        if (!existingDisallowed.includes('Git')) {
+          existingDisallowed.push('Git')
+        }
+        if (agentDef) {
+          agentDef.disallowedTools = existingDisallowed.join(',')
+        }
+      }
     }
 
     // Resolve system prompt: agentDef > options.systemPrompt > builtin type
@@ -352,11 +387,36 @@ export class SubAgent {
             continue
           }
 
+          // ── P0-5: Run PreToolUse hooks (before permission check) ──
+          let effectiveInput = tu.input
+          if (this.hookEngine) {
+            const preResult = await this.hookEngine.executePreToolUse(
+              tu.name,
+              tu.input,
+              'sub-agent',
+            )
+            if (!preResult.allowed) {
+              const denialMsg = preResult.reason
+                ? `Tool "${tu.name}" blocked by PreToolUse hook: ${preResult.reason}`
+                : `Tool "${tu.name}" blocked by PreToolUse hook.`
+              currentMessages.push({
+                role: 'user' as const,
+                content: denialMsg,
+              })
+              continue
+            }
+            // Apply modified input from hooks
+            if (preResult.modifiedInput) {
+              effectiveInput = { ...tu.input, ...preResult.modifiedInput }
+            }
+          }
+
           // Security: check permission before executing.
           // Sub-agents run without user interaction — tools requiring approval are rejected.
           // When permission system is absent (undefined), allow all tools (backward compat
           // for tests and headless usage). When present, always enforce approval checks.
-          if (this.permission?.needsApproval(tool, tu.input)) {
+          // P0-3: Uses isolated subPermission (clamped by org restrictions) instead of parent's.
+          if (subPermission?.needsApproval(tool, effectiveInput)) {
             currentMessages.push({
               role: 'user' as const,
               content:
@@ -367,16 +427,40 @@ export class SubAgent {
           }
 
           try {
-            const result = await tool.execute(tu.input, {
+            const result = await tool.execute(effectiveInput, {
               cwd: execCwd,
               sessionId: 'sub-agent',
               provider: '',
               model: finalModel,
             })
 
+            // ── P0-5: Run PostToolUse hooks ──
+            let displayResult = result
+            if (this.hookEngine) {
+              const postResult = await this.hookEngine.executePostToolUse(
+                tu.name,
+                effectiveInput,
+                result,
+                'sub-agent',
+              )
+              if (postResult.updatedOutput) {
+                displayResult = { ...result, content: postResult.updatedOutput }
+              }
+              if (postResult.additionalContext) {
+                displayResult = {
+                  ...displayResult,
+                  content: displayResult.content
+                    ? displayResult.content + '\n' + postResult.additionalContext
+                    : postResult.additionalContext,
+                }
+              }
+            }
+
             currentMessages.push({
               role: 'assistant' as const,
-              content: [{ type: 'tool_use' as const, id: tu.id, name: tu.name, input: tu.input }],
+              content: [
+                { type: 'tool_use' as const, id: tu.id, name: tu.name, input: effectiveInput },
+              ],
             })
             currentMessages.push({
               role: 'user' as const,
@@ -384,11 +468,22 @@ export class SubAgent {
                 {
                   type: 'tool_result' as const,
                   tool_use_id: tu.id,
-                  content: result.success ? result.content : result.error || result.content,
+                  content: displayResult.success
+                    ? displayResult.content
+                    : displayResult.error || displayResult.content,
                 },
               ],
             })
           } catch (err) {
+            // ── P0-5: Run PostToolUseFailure hooks ──
+            if (this.hookEngine) {
+              this.hookEngine
+                .executePostToolUseFailure(tu.name, effectiveInput, String(err), 'sub-agent')
+                .catch(() => {
+                  // Hook failures never block execution
+                })
+            }
+
             currentMessages.push({
               role: 'user' as const,
               content: `Tool "${tu.name}" execution error: ${String(err)}`,

package/src/agent/types.ts

@@ -8,7 +8,8 @@ export interface AgentFrontmatter {
   tools?: string // comma-separated allowlist
   disallowedTools?: string
   model?: string // 'sonnet' | 'opus' | 'haiku' | 'inherit' | full model ID
-  permissionMode?: 'default' | 'acceptEdits' | 'auto' | 'bypass' | 'plan'
+  permissionMode?:
+    'default' | 'acceptEdits' | 'auto' | 'bypass' | 'plan' | 'bypassPermissions' | 'dontAsk'
   maxTurns?: number
   skills?: string
   background?: boolean

package/src/core/engine.ts

@@ -112,6 +112,16 @@ export class QueryEngine {
       if (messages.length > 0) {
         const bus = getMessageBus()
         for (const msg of messages) {
+          // P2-1: Trigger Notification hook for cross-session messages
+          if (this.hookEngine) {
+            this.hookEngine
+              .executeNotification(
+                `Cross-session message from ${msg.from}: ${msg.summary}`,
+                this.sessionId,
+              )
+              .catch(() => {})
+          }
+
           if (policy === 'ask') {
             // Mark as awaiting approval — the model should verify with the user before acting
             bus.post(
@@ -836,17 +846,31 @@ export class QueryEngine {
   private async executeTool(name: string, params: Record<string, unknown>): Promise<ToolResult> {
     const tool = this.tools.get(name)
     if (!tool) {
-      return { success: false, content: '', error: `Unknown tool: ${name}` }
+      // P2-4: Provide a more helpful error for unavailable tools
+      const isMcpTool = name.startsWith('mcp__')
+      const hint = isMcpTool
+        ? `\nMCP tool "${name}" is no longer available. The MCP server may have been removed or disconnected. Use tool-search to discover available tools.`
+        : `\nTool "${name}" is not registered. Available tools may have changed — check the tool list.`
+      return { success: false, content: '', error: `Unknown tool: ${name}${hint}` }
     }
 
     // Security: check permission before executing
     if (this.permission.needsApproval(tool, params)) {
+      // P1-4: Increment consecutive block counter; if limit exceeded,
+      // tell the model to move on instead of retrying.
+      const limitExceeded = this.permission.incrementBlockCounter()
+      const baseError = t('errors.tool_not_allowed', { name })
+      const moveOnHint = limitExceeded
+        ? '\n(Consecutive block limit reached. Please try a different approach or ask the user for guidance.)'
+        : ''
       return {
         success: false,
         content: '',
-        error: t('errors.tool_not_allowed', { name }),
+        error: baseError + moveOnHint,
       }
     }
+    // P1-4: Tool allowed — reset block counter
+    this.permission.resetBlockCounter()
 
     // Run PreToolUse hooks
     let effectiveParams = params
@@ -902,7 +926,21 @@ export class QueryEngine {
 
       // Run PostToolUse hooks
       if (this.hookEngine) {
-        await this.hookEngine.executePostToolUse(name, effectiveParams, result, this.sessionId)
+        const postResult = await this.hookEngine.executePostToolUse(
+          name,
+          effectiveParams,
+          result,
+          this.sessionId,
+        )
+        // P1-2: Consume hook result — apply updatedOutput and additionalContext
+        if (postResult.updatedOutput) {
+          result.content = postResult.updatedOutput
+        }
+        if (postResult.additionalContext) {
+          result.content = result.content
+            ? result.content + '\n' + postResult.additionalContext
+            : postResult.additionalContext
+        }
       }
 
       // CRSI: Track rule effectiveness after tool execution
@@ -920,6 +958,15 @@ export class QueryEngine {
 
       return result
     } catch (err) {
+      // P1-3: Trigger PostToolUseFailure hook on tool execution errors
+      if (this.hookEngine) {
+        this.hookEngine
+          .executePostToolUseFailure(name, effectiveParams, String(err), this.sessionId)
+          .catch(() => {
+            // Hook failures never block error handling
+          })
+      }
+
       // Sanitize error: strip stack traces and internal paths to prevent
       // information disclosure to the LLM conversation context.
       const message =

package/src/core/instructions.ts

@@ -47,7 +47,7 @@ export class InstructionsLoader {
     this.tryLoad(join(home, '.mipham', 'USER.md'), 'user')
   }
 
-  buildSystemPrompt(): string {
+  buildSystemPrompt(permissionMode?: string): string {
     const parts: string[] = []
 
     for (const inst of this.instructions) {
@@ -61,11 +61,56 @@ export class InstructionsLoader {
       parts.push(`<!-- ${levelLabel[inst.level] || inst.level} (${inst.path}) -->\n${inst.content}`)
     }
 
+    // P2-2: Inject current permission mode so the model knows its constraints
+    if (permissionMode) {
+      parts.push(this.buildPermissionContext(permissionMode))
+    }
+
     // Append skills reminder after all instructions
     if (this.skillsReminder) {
       parts.push(this.skillsReminder)
     }
 
+    // Inject critical thinking self-check layer (for analysis/comparison tasks)
+    parts.push(`## Critical Thinking Self-Check
+
+Before delivering any analysis, comparison, evaluation, or "X vs Y"
+report, run this checklist internally:
+
+### 1. Evidence Standard
+- Every factual claim MUST cite a specific source (file path, URL, line number)
+- If you cannot cite a source, label the claim as [推断] (inference) or [待验证] (unverified)
+- Numbers (counts, percentages, download stats) require cross-validation from a second source
+
+### 2. Equivalence Verification
+- When you claim "A is equivalent to B" or "X has been merged from Y",
+  compare their ACTUAL implementation, not just their names or descriptions
+- If you haven't read both implementations, say "appears similar at the
+  description level; implementation equivalence not verified"
+
+### 3. Counter-Example Search
+- For each major conclusion, find at least 1 counter-example or edge case
+- If you cannot find one, state that explicitly: "No counter-example found
+  within the examined scope"
+- When comparing two systems, ask: "What does X do that Y CANNOT do?"
+  (and vice versa) — don't just list overlaps
+
+### 4. Confidence Calibration
+- Label each conclusion with confidence: [高] [中] [低]
+- [高] = verified from source code or primary documentation
+- [中] = inferred from description but not implementation-verified
+- [低] = speculative, based on naming convention or surface similarity
+
+### 5. Depth Check
+- If your analysis is based ONLY on file names and description fields,
+  you are doing surface analysis — state this limitation upfront
+- To reach depth: read at least one implementation file per comparison target
+- Ask: "What would a domain expert notice that I'm missing?"
+
+These checks are not optional for analysis tasks. Apply them before
+presenting conclusions, and surface any [低] confidence findings
+explicitly rather than burying them.`)
+
     // Inject workflow auto-generation guidance
     parts.push(`## Workflow Auto-Generation
 
@@ -102,6 +147,30 @@ Script format: export const meta = { name, description, phases: [...] }
     this.skillsReminder = reminder
   }
 
+  /**
+   * P2-2: Build a permission-mode context block for the system prompt.
+   * Tells the model its current permission level and what to expect.
+   */
+  private buildPermissionContext(mode: string): string {
+    const modeDescriptions: Record<string, string> = {
+      default:
+        'You are in **default** mode. Tools marked as requiring approval will be blocked. Use Read/Grep/Glob for exploration.',
+      acceptEdits:
+        'You are in **acceptEdits** mode. File reads and edits are allowed; Bash requires approval.',
+      plan: 'You are in **plan** mode. Only Read/Grep/Glob are allowed — no file modifications or command execution.',
+      auto: 'You are in **auto** mode. Most tools run without approval. If a tool is blocked by security policy or hooks, try a different approach instead of retrying.',
+      dontAsk:
+        'You are in **dontAsk** mode. All tools blocked unless explicitly allowlisted. Check your allow rules before acting.',
+      bypassPermissions:
+        'You are in **bypassPermissions** mode. All tools are allowed. Use this power responsibly.',
+    }
+
+    const description = modeDescriptions[mode]
+    if (!description) return ''
+
+    return `## Permission Context\n\n${description}\n\nWhen a tool is denied, do NOT retry with the same tool and similar parameters. Move on to a different approach or ask the user for guidance.`
+  }
+
   list(): InstructionFile[] {
     return [...this.instructions]
   }

package/src/core/permission.ts

@@ -29,6 +29,13 @@ export class PermissionSystem {
   // ── Org-level restrictions (P0 security) ──
   private restrictions: PermissionRestrictions | undefined = undefined
 
+  // ── P0-5: Sub-agent mode (auto mode hardening for background tasks) ──
+  private isSubAgent = false
+
+  // ── P1-4: Consecutive block counter (prevents infinite retry loops) ──
+  private consecutiveBlockCount = 0
+  private static readonly MAX_CONSECUTIVE_BLOCKS = 3
+
   /** Invalidate the permission cache (called on any rule/mode change). */
   private invalidateCache(): void {
     this.checkCache.clear()
@@ -77,6 +84,85 @@ export class PermissionSystem {
     return this.restrictions
   }
 
+  /**
+   * P0-5 (v2.1.222 alignment): Enable sub-agent safety mode.
+   * When true, auto mode returns 'ask' for Bash/Write/Edit tools instead of
+   * 'bypass', ensuring PreToolUse hooks remain the safety gate in background agents.
+   */
+  setSubAgentMode(enabled: boolean): void {
+    this.isSubAgent = enabled
+    this.invalidateCache()
+  }
+
+  /**
+   * P1-4 (v2.1.225 alignment): Increment the consecutive block counter
+   * when a tool is denied. Safety-filter refusals should NOT count.
+   * Returns true if the consecutive block limit has been exceeded.
+   */
+  incrementBlockCounter(): boolean {
+    this.consecutiveBlockCount++
+    return this.consecutiveBlockCount >= PermissionSystem.MAX_CONSECUTIVE_BLOCKS
+  }
+
+  /** Reset the block counter when a tool is successfully executed. */
+  resetBlockCounter(): void {
+    this.consecutiveBlockCount = 0
+  }
+
+  /** Get the current consecutive block count. */
+  getBlockCount(): number {
+    return this.consecutiveBlockCount
+  }
+
+  /**
+   * P0-3 (v2.1.223 alignment): Create a permission context for a sub-agent.
+   *
+   * The sub-agent's requested permissionMode is clamped against the parent's
+   * org restrictions (maxAllowedMode, forbiddenModes). Deny rules from the
+   * parent are propagated so org safety policies always apply.
+   *
+   * Returns a new PermissionSystem instance — NOT shared with the parent.
+   */
+  createSubAgentPermission(agentPermissionMode: string): PermissionSystem {
+    const resolvedMode = this.resolveAgentMode(agentPermissionMode)
+    const subPerm = new PermissionSystem(resolvedMode)
+
+    // Propagate org restrictions to sub-agent
+    if (this.restrictions) {
+      subPerm.setRestrictions(this.restrictions)
+    }
+
+    // Propagate deny rules (org safety policies must always apply)
+    for (const denyEntry of this.denyRules) {
+      subPerm.deny(denyEntry.pattern)
+    }
+
+    return subPerm
+  }
+
+  /**
+   * Resolve an agent's permissionMode string to a clamped PermissionMode.
+   * 'inherit' means "use the parent's current mode".
+   * 'bypass' is treated as an alias for 'bypassPermissions'.
+   */
+  private resolveAgentMode(agentMode: string): PermissionMode {
+    // Normalize aliases
+    const normalized = agentMode === 'bypass' ? 'bypassPermissions' : agentMode
+
+    const modeMap: Record<string, PermissionMode> = {
+      bypassPermissions: 'bypassPermissions',
+      dontAsk: 'dontAsk',
+      auto: 'auto',
+      plan: 'plan',
+      acceptEdits: 'acceptEdits',
+      default: 'default',
+      inherit: this.mode,
+    }
+
+    const desired: PermissionMode = modeMap[normalized] || 'default'
+    return clampMode(desired, this.restrictions)
+  }
+
   // ── Rule management ──
 
   allow(rule: string): void {
@@ -267,6 +353,12 @@ export class PermissionSystem {
         if (tool.name === 'SendMessage') {
           return 'mode-baseline'
         }
+        // P0-5: In sub-agent context, enforce 'ask' for destructive tools
+        // so hooks remain the sole safety gate. Without hooks, these tools
+        // would otherwise run completely un-gated in auto mode.
+        if (this.isSubAgent && ['Bash', 'Write', 'Edit'].includes(tool.name)) {
+          return 'ask'
+        }
         return 'bypass'
 
       case 'dontAsk':

package/src/index.tsx

@@ -238,12 +238,12 @@ export async function runApp(options: RunOptions): Promise<void> {
       for (const msg of saved.messages) {
         context.addMessage(msg)
       }
-      context.setSystemPrompt(instructions.buildSystemPrompt())
+      context.setSystemPrompt(instructions.buildSystemPrompt(config.permission as string))
     }
   }
 
   if (context.getMessageCount() === 0) {
-    const basePrompt = instructions.buildSystemPrompt()
+    const basePrompt = instructions.buildSystemPrompt(config.permission as string)
     const memoryReminder = loadSessionMemories(basePrompt)
 
     // Inject previous session summary for AI continuity
@@ -430,12 +430,19 @@ export async function runApp(options: RunOptions): Promise<void> {
   const crossSessionConfig = loadCrossSessionConfig(process.cwd())
   engine.setCrossSessionConfig(crossSessionConfig)
 
+  // P2-1: Trigger SessionStart hooks after full initialization
+  hookEngine.executeSessionStart(sessionName).catch(() => {
+    // Hook failures never block session startup
+  })
+
   // Auto-save session on exit
   let saved = false
   const saveAndExit = () => {
     saved = true
     clearInterval(heartbeatInterval)
     unregisterSession(sessionName)
+    // P2-1: Trigger SessionEnd hooks before cleanup (best-effort)
+    hookEngine.executeSessionEnd(sessionName).catch(() => {})
     artifactServer.stop()
     if (context.getMessageCount() > 0) {
       SessionStore.save(sessionName, context.getMessages(), {