pi-editor-footer 0.8.0 → 0.12.1

package/CHANGELOG.md

@@ -1,8 +1,50 @@
+## [0.12.1](https://github.com/Rianico/pi-editor-footer/compare/v0.12.0...v0.12.1) (2026-09-07)
+
+### Bug Fixes
+
+* add .npmrc and clean allowScripts for npm install-scripts ([fc362cb](https://github.com/Rianico/pi-editor-footer/commit/fc362cbb654dbf886f92f774e2a5e87aa4ec5914))
+
+## [0.12.0](https://github.com/Rianico/pi-editor-footer/compare/v0.11.0...v0.12.0) (2026-09-07)
+
+### Features
+
+* **detail:** show model invocation badge to the right of skill path ([0f03593](https://github.com/Rianico/pi-editor-footer/commit/0f0359347d7ae3de740400c587c5b0ff4a6fb57e))
+* **detail:** use distinct highlight for human vs model badge ([e242df1](https://github.com/Rianico/pi-editor-footer/commit/e242df14975e10b6bfd32f8a48e5f943d7579864))
+
+### Bug Fixes
+
+* allow pnpm builds for esbuild and genai ([36e139e](https://github.com/Rianico/pi-editor-footer/commit/36e139e9443ef928a4366c3d7c8afe494b6e0850))
+* make prepare tolerant to missing husky for pi install ([23ebb62](https://github.com/Rianico/pi-editor-footer/commit/23ebb62cd8d732656fd113da27c807ffa34579fc))
+
 # Changelog
 
 All notable changes to this project will be documented in this file.
 
-## [Unreleased]
+## [0.11.0] - 2026-08-29
+
+### Changed
+
+- Release workflow trigger clarified — tag `v*` remains the release trigger (semantic-release on tag push), reverted tentative `main` trigger
+
+## [0.10.0] - 2026-08-28
+
+### Added
+
+- Detail header shows slash command path dimmed at right of type — workspace-relative/~/ tildified, middle-truncated with ellipsis, hidden when <10 cols remain, auto-resolved for skill items across project and home candidates with fallback to global symlink path
+
+### Fixed
+
+- Resolve pre-existing blocking diagnostics (`require-safety-comment`, `no-unknown-returns`, `zizmor cache-poisoning`) to keep lens clean
+
+## [0.9.0] - 2026-08-27
+
+### Added
+
+- Incremental per-agent_run live input accounting — `trigger+Σ(outputs+tools)+liveDelta` per run (`~` during live, authoritative `deltaFromBaseline` after), `AgentRunLedger` owns `triggerTokens/accumOutput/accumTool` reset in `startRun`, `getIncrementalLiveDisplayTotals`/`getIdleAuthoritativeDisplay` (grill Q6→a Q7→b Q8→a Q9→a Q11→a)
+
+### Changed
+
+- `turn_start` input now synthetic `trigger+Σ` (independent per run) instead of `getContextUsage` window; `tool_result`/`tool_execution_end` fold `chars/4` into accumulation; `LiveBorder` top `↑` hybrid (`~` live, no `~` idle), context bar stays real window (Q10); co-coded with `typescript-expert` (`unknown` boundaries, `SAFETY` on pi seams)
 
 ## [0.8.0] - 2026-08-26
 

package/dist/agent-run-ledger.js

@@ -15,11 +15,29 @@
  * / cap helpers) hides baseline delta, max-vs-sum, predictive vs authoritative capping,
  * and tps derivation. Two adapters (LiveBorder token bar, index timeline) justify the seam.
  * Internal seams (aggregateTurns, capIdle, capLive) stay private.
+ *
+ * Incremental live input (per-agent_run):
+ *   liveInput = triggerTokens + Σ(completed turn outputs) + Σ(toolResult tokens) + liveDelta
+ *   Each agent_run resets independently. triggerTokens = ceil(triggerChars/4) or 0 if
+ *   no user message (Q11 a). Tool results are ceil(chars/4) per tool_result (Q8 a).
+ *   Live input is predictive (estimated=true, "~" prefix) and capped only to contextWindow.
+ *   Settled/idle input snaps to authoritative deltaFromBaseline (hybrid Q7 b, Q6 a).
  */
 function round(value, decimals) {
     const factor = 10 ** decimals;
     return Math.round(value * factor) / factor;
 }
+/** Estimate tokens from char length — ~4 chars/token, same as TurnTelemetryTracker live estimate. */
+export function estimateTokensFromChars(chars) {
+    if (!Number.isFinite(chars) || chars <= 0)
+        return 0;
+    return Math.ceil(chars / 4);
+}
+export function estimateTokensFromText(text) {
+    if (typeof text !== "string" || text.length === 0)
+        return 0;
+    return estimateTokensFromChars(text.length);
+}
 /**
  * Pure aggregation: max(input) + sum(output/cost/stalls) across turns, plus optional live turn.
  * Shared by TurnTelemetryTracker.peekAgentLive / endAgent and ledger — single source for
@@ -65,11 +83,9 @@ export function aggregateAgentTurns(turns, live, startMs, now) {
             ttftMs = live.ttftMs;
     }
     totalTokens = inputTokens + outputTokens;
-    const totalMs = startMs !== null ? Math.max(0, now - startMs) : 0;
+    const totalMs = startMs === null ? 0 : Math.max(0, now - startMs);
     const measurementMs = outputTokens > 0 && generationMs > 0 ? generationMs : null;
-    const tps = measurementMs === null
-        ? null
-        : round(outputTokens / (measurementMs / 1000), 1);
+    const tps = measurementMs === null ? null : round(outputTokens / (measurementMs / 1000), 1);
     const validCost = Number.isFinite(costUsd) && costUsd > 0;
     const validTokens = Number.isFinite(totalTokens) && totalTokens > 0;
     return {
@@ -80,9 +96,7 @@ export function aggregateAgentTurns(turns, live, startMs, now) {
         outputTokens,
         stallMs,
         stallCount,
-        rateUsdPerMTokens: validCost && validTokens
-            ? round(costUsd / (totalTokens / 1_000_000), 2)
-            : null,
+        rateUsdPerMTokens: validCost && validTokens ? round(costUsd / (totalTokens / 1_000_000), 2) : null,
         generationMs,
         totalTokens,
         costUsd: validCost ? costUsd : 0,
@@ -99,9 +113,7 @@ export function aggregateAgentTurns(turns, live, startMs, now) {
  */
 export function capInputForIdle(input, contextTokens, sessionTotalInput) {
     let capped = input;
-    if (typeof contextTokens === "number" &&
-        Number.isFinite(contextTokens) &&
-        contextTokens > 0) {
+    if (typeof contextTokens === "number" && Number.isFinite(contextTokens) && contextTokens > 0) {
         capped = Math.min(capped, contextTokens);
     }
     if (sessionTotalInput > 0) {
@@ -111,9 +123,7 @@ export function capInputForIdle(input, contextTokens, sessionTotalInput) {
 }
 export function capInputForLive(input, contextTokens) {
     let capped = input;
-    if (typeof contextTokens === "number" &&
-        Number.isFinite(contextTokens) &&
-        contextTokens > 0) {
+    if (typeof contextTokens === "number" && Number.isFinite(contextTokens) && contextTokens > 0) {
         capped = Math.min(capped, contextTokens);
     }
     return Math.max(0, capped);
@@ -131,6 +141,10 @@ export class AgentRunLedger {
     turns = [];
     startMs = null;
     now;
+    // Incremental per-agent_run accumulation (Q1/Q6/Q9)
+    triggerTokens = 0;
+    accumOutputTokens = 0;
+    accumToolTokens = 0;
     constructor(now = () => Date.now()) {
         this.now = now;
     }
@@ -144,10 +158,52 @@ export class AgentRunLedger {
     startRun(startMs) {
         this.startMs = typeof startMs === "number" ? startMs : this.now();
         this.turns = [];
+        this.triggerTokens = 0;
+        this.accumOutputTokens = 0;
+        this.accumToolTokens = 0;
+    }
+    /** Set trigger message tokens for this agent_run (chars/4, or 0 per Q11 a). */
+    setTriggerTokens(tokens) {
+        if (typeof tokens !== "number" || !Number.isFinite(tokens) || tokens < 0)
+            return;
+        this.triggerTokens = Math.round(tokens);
+    }
+    getTriggerTokens() {
+        return this.triggerTokens;
+    }
+    /** Add tool result tokens (chars/4) to accumulation (Q8 a). */
+    addToolResultTokens(tokens) {
+        if (typeof tokens !== "number" || !Number.isFinite(tokens) || tokens <= 0)
+            return;
+        this.accumToolTokens += Math.round(tokens);
+    }
+    getAccumOutputTokens() {
+        return this.accumOutputTokens;
+    }
+    getAccumToolTokens() {
+        return this.accumToolTokens;
+    }
+    /** Synthetic completed input without live delta: trigger + Σ(outputs) + Σ(tools). */
+    getSyntheticCompletedInput() {
+        return this.triggerTokens + this.accumOutputTokens + this.accumToolTokens;
+    }
+    /** Synthetic live input including live delta: trigger + Σ(outputs+tools) + liveDelta. */
+    getSyntheticLiveInput(liveDeltaTokens) {
+        const d = typeof liveDeltaTokens === "number" && Number.isFinite(liveDeltaTokens) ? liveDeltaTokens : 0;
+        return (this.triggerTokens +
+            this.accumOutputTokens +
+            this.accumToolTokens +
+            Math.max(0, Math.round(d)));
     }
     /** Record a completed turn's telemetry (called by telemetryTracker or directly). */
     recordTurn(turn) {
         this.turns.push({ ...turn });
+        // Accumulate authoritative output for synthetic input (trigger + Σ outputs)
+        if (typeof turn.outputTokens === "number" &&
+            Number.isFinite(turn.outputTokens) &&
+            turn.outputTokens > 0) {
+            this.accumOutputTokens += Math.round(turn.outputTokens);
+        }
     }
     /** Settled totals without live turn — used at agent_settled for timeline. */
     getSettledTotals(now) {
@@ -231,9 +287,46 @@ export class AgentRunLedger {
             estimated: false,
         };
     }
+    /**
+     * Idle authoritative display (hybrid Q7 b): snapshot delta capped, for use when
+     * not running to show billed total without ~ after agent_end.
+     */
+    getIdleAuthoritativeDisplay(snapshotTotals, contextTokens) {
+        let displayInput;
+        let displayOutput;
+        let displayCost;
+        if (this.baseline) {
+            const d = deltaFromBaseline(snapshotTotals, this.baseline);
+            displayInput = d.input;
+            displayOutput = d.output;
+            displayCost = d.cost;
+        }
+        else {
+            displayInput = snapshotTotals.input;
+            displayOutput = snapshotTotals.output;
+            displayCost = snapshotTotals.cost;
+        }
+        const cappedInput = capInputForIdle(displayInput, contextTokens, snapshotTotals.input);
+        return {
+            tps: null,
+            ttftMs: 0,
+            totalMs: 0,
+            inputTokens: cappedInput,
+            outputTokens: displayOutput,
+            stallMs: 0,
+            stallCount: 0,
+            rateUsdPerMTokens: null,
+            generationMs: 0,
+            totalTokens: cappedInput + displayOutput,
+            costUsd: displayCost,
+            measurementMs: null,
+            estimated: false,
+        };
+    }
     /**
      * Live display totals when running: liveTurn input (current window) replaces
      * agentLive input, output/cost remain per-agent sum, capped to live context only.
+     * @deprecated — retained for backward compat; prefer getIncrementalLiveDisplayTotals for Q1/Q9.
      */
     getLiveDisplayTotals(liveTurn, agentLive, contextTokens) {
         if (!agentLive && !liveTurn)
@@ -260,10 +353,53 @@ export class AgentRunLedger {
             estimated: true,
         };
     }
+    /**
+     * Incremental live display (Q1/Q6/Q9): trigger + Σ(outputs+tools) + liveDelta, capped to live.
+     * Replaces max(input) with synthetic accumulation, per-agent_run independent.
+     */
+    getIncrementalLiveDisplayTotals(liveTurn, agentLive, contextTokens) {
+        if (!agentLive && !liveTurn)
+            return null;
+        const liveDelta = liveTurn?.outputTokens ?? 0;
+        const syntheticInput = this.getSyntheticLiveInput(liveDelta);
+        const cappedInput = capInputForLive(syntheticInput, contextTokens);
+        // Output/cost/stalls come from agentLive (sum) when available, else liveTurn
+        const base = agentLive ?? liveTurn;
+        if (!base)
+            return null;
+        // When both exist, agentLive already sums outputs, so use it; else liveTurn
+        const displayOutput = agentLive ? agentLive.outputTokens : liveTurn.outputTokens;
+        const displayCost = agentLive ? agentLive.costUsd : liveTurn.costUsd;
+        const displayStallMs = agentLive ? agentLive.stallMs : liveTurn.stallMs;
+        const displayStallCount = agentLive ? agentLive.stallCount : liveTurn.stallCount;
+        const displayGenerationMs = agentLive ? agentLive.generationMs : liveTurn.generationMs;
+        const displayTtft = agentLive ? agentLive.ttftMs : liveTurn.ttftMs;
+        const displayTps = agentLive ? agentLive.tps : liveTurn.tps;
+        const displayTotalMs = agentLive ? agentLive.totalMs : liveTurn.totalMs;
+        const displayMeasurementMs = agentLive ? agentLive.measurementMs : liveTurn.measurementMs;
+        return {
+            tps: displayTps,
+            ttftMs: displayTtft,
+            totalMs: displayTotalMs,
+            inputTokens: cappedInput,
+            outputTokens: displayOutput,
+            stallMs: displayStallMs,
+            stallCount: displayStallCount,
+            rateUsdPerMTokens: base.rateUsdPerMTokens,
+            generationMs: displayGenerationMs,
+            totalTokens: cappedInput + displayOutput,
+            costUsd: displayCost,
+            measurementMs: displayMeasurementMs,
+            estimated: true,
+        };
+    }
     reset() {
         this.baseline = null;
         this.turns = [];
         this.startMs = null;
+        this.triggerTokens = 0;
+        this.accumOutputTokens = 0;
+        this.accumToolTokens = 0;
     }
     isActive() {
         return this.startMs !== null;

package/dist/border-renderer.js

@@ -1,5 +1,5 @@
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { buildLabel, } from "./model-info.js";
+import { applyModelInfo, buildLabel } from "./model-info.js";
 function stripAnsi(s) {
     return s.replace(/\x1b\[[0-9;]*m/g, "");
 }
@@ -30,7 +30,8 @@ export class BorderRenderer {
             const info = this.getModelInfo();
             const glow = (s) => {
                 try {
-                    const maybeGlow = theme.getThinkingBorderColor;
+                    const maybeGlow = // SAFETY: intentional unsafe cast — validated at runtime
+                     theme.getThinkingBorderColor;
                     if (typeof maybeGlow === "function")
                         return maybeGlow.call(theme, info.level)(s);
                 }
@@ -79,7 +80,7 @@ export class BorderRenderer {
             if (tokensLeft) {
                 // Use | as separator between ↑/↓ and tool turns (dimmed) per user request
                 // SAFETY: pi theme seam — fg is optional theme method
-                const themeForTokens = this.getLiveTheme();
+                const themeForTokens = this.getLiveTheme(); // SAFETY: intentional unsafe cast — validated at runtime
                 const fg = themeForTokens.fg;
                 const dimPipe = typeof fg === "function" ? fg.call(themeForTokens, "dim", " | ") : " | ";
                 const combined = tokensRight ? `${tokensLeft}${dimPipe}${tokensRight}` : tokensLeft;
@@ -91,7 +92,8 @@ export class BorderRenderer {
             const theme = this.getLiveTheme();
             const glow = (s) => {
                 try {
-                    const maybeGlow = theme.getThinkingBorderColor;
+                    const maybeGlow = // SAFETY: intentional unsafe cast — validated at runtime
+                     theme.getThinkingBorderColor;
                     if (typeof maybeGlow === "function")
                         return maybeGlow.call(theme, this.getModelInfo().level)(s);
                 }
@@ -132,12 +134,8 @@ function embedTopWithLeftAndRight(lines, width, leftText, rightText, getGlow) {
         displayLeft = truncateToWidth(leftText, maxLeft, "");
     if (rightW > maxRight)
         displayRight = truncateToWidth(rightText, maxRight, "");
-    const leftSegment = displayLeft
-        ? `${getGlow("─")} ${displayLeft} `
-        : getGlow("─");
-    const rightSegment = displayRight
-        ? ` ${displayRight} ${getGlow("─")}`
-        : getGlow("─");
+    const leftSegment = displayLeft ? `${getGlow("─")} ${displayLeft} ` : getGlow("─");
+    const rightSegment = displayRight ? ` ${displayRight} ${getGlow("─")}` : getGlow("─");
     const used = visibleWidth(leftSegment) + visibleWidth(rightSegment);
     const middleWidth = Math.max(0, width - used);
     const middle = getGlow("─".repeat(middleWidth));
@@ -170,12 +168,8 @@ function embedBottomBorder(lines, width, leftText, rightText, getGlow) {
         displayLeft = truncateToWidth(leftText, maxLeft, "");
     if (rightW > maxRight)
         displayRight = truncateToWidth(rightText, maxRight, "");
-    const leftSegment = displayLeft
-        ? `${getGlow("─")} ${displayLeft} `
-        : getGlow("─");
-    const rightSegment = displayRight
-        ? ` ${displayRight} ${getGlow("─")}`
-        : getGlow("─");
+    const leftSegment = displayLeft ? `${getGlow("─")} ${displayLeft} ` : getGlow("─");
+    const rightSegment = displayRight ? ` ${displayRight} ${getGlow("─")}` : getGlow("─");
     const used = visibleWidth(leftSegment) + visibleWidth(rightSegment);
     const middleWidth = Math.max(0, width - used);
     const middle = getGlow("─".repeat(middleWidth));

package/dist/chrome-composition.js

@@ -20,7 +20,7 @@
 import { resolveGlyphs, resolveIconMode } from "./icons.js";
 import { formatTopContextFromSnapshot } from "./chrome-state.js";
 import { formatRunActivityTopRight } from "./run-activity.js";
-import { formatTelemetryTokens, formatTurnDuration, formatTurnTelemetry, } from "./telemetry.js";
+import { formatTelemetryTokens, formatTurnDuration, formatTurnTelemetry } from "./telemetry.js";
 /**
  * Read the live pi theme into a typed { fg } surface. The cast is a SAFETY seam — a pi theme
  * missing `fg` degrades to identity rather than throwing, keeping the chrome resilient.

package/dist/chrome-state.js

@@ -45,9 +45,7 @@ export function formatContextBar(contextUsage, theme, glyphs, isAscii, barWidth
     const base = showIconBar
         ? `${theme.fg(contextColor, glyphs.context)} ${renderBar(theme, contextPct, barWidth, isAscii)} ${baseCore}`
         : baseCore;
-    const rate = cacheHitRate !== undefined && Number.isFinite(cacheHitRate)
-        ? cacheHitRate
-        : 0;
+    const rate = cacheHitRate !== undefined && Number.isFinite(cacheHitRate) ? cacheHitRate : 0;
     const cacheText = `${glyphs.cacheHit} ${rate.toFixed(1)}%`;
     return `${theme.fg(cacheHitColor(rate), cacheText)} ${theme.fg("dim", "|")} ${base}`;
 }
@@ -66,13 +64,17 @@ export function formatTopContextFromSnapshot(snapshot, theme, glyphs, isAscii, s
 export function createChromeSnapshot(ctx, footerState) {
     const cwd = ctx?.sessionManager?.getCwd?.() ??
         // SAFETY: pi seam — intentional unsafe cast, validated at runtime
-        ctx?.cwd ?? // SAFETY: pi seam — intentional unsafe cast, validated at runtime
+        // ast-grep-ignore: require-safety-comment-for-as-unknown-as
+        // SAFETY: intentional unsafe cast — validated at runtime
+        /* SAFETY: intentional unsafe cast — validated at runtime */ ctx?.cwd ?? // SAFETY: pi seam — intentional unsafe cast, validated at runtime
         process.cwd();
     const sessionName = ctx?.sessionManager?.getSessionName?.();
     const contextUsage = ctx?.getContextUsage?.();
     const totals = getUsageTotals(
+    // ast-grep-ignore: require-safety-comment-for-as-unknown-as
     // SAFETY: pi seam
-    (ctx ?? {}));
+    /* SAFETY: intentional unsafe cast — validated at runtime */ (ctx ??
+        {}));
     // footerState may be absent when called from LiveBorder (context-only); use empty defaults
     // SAFETY: pi seam
     const git = footerState?.git ??
@@ -88,6 +90,9 @@ export function createChromeSnapshot(ctx, footerState) {
             renamed: 0,
             deleted: 0,
             commit: null,
+            // ast-grep-ignore: require-safety-comment-for-as-unknown-as
+            // SAFETY: intentional unsafe cast — validated at runtime
+            /* SAFETY: intentional unsafe cast — validated at runtime */
         }; // SAFETY: pi seam — intentional unsafe cast, validated at runtime
     const runtime = footerState?.runtime ?? null;
     return {

package/dist/config.js

@@ -46,9 +46,7 @@ function deepMerge(base, override) {
     if (typeof base !== "object" || base === null || Array.isArray(base)) {
         return override ?? base;
     }
-    if (typeof override !== "object" ||
-        override === null ||
-        Array.isArray(override)) {
+    if (typeof override !== "object" || override === null || Array.isArray(override)) {
         return base;
     }
     const result = { ...base };
@@ -99,6 +97,7 @@ export const CONFIG_SCHEMA = [
     { path: "timeline.tokens", kind: "boolean" },
     { path: "timeline.cost", kind: "boolean" },
 ];
+// SAFETY: table-driven config access — path validated against CONFIG_SCHEMA, caller validates via validate()
 function getByPath(obj, path) {
     const parts = path.split(".");
     let cur = obj;
@@ -123,6 +122,7 @@ function setByPath(obj, path, value) {
     }
     cur[parts[parts.length - 1]] = value;
 }
+// SAFETY: table-driven config access — path validated against CONFIG_SCHEMA, caller validates via validate()
 function getDefaultByPath(path) {
     return getByPath(DEFAULT_CONFIG, path);
 }

package/dist/cursor-policy.js

@@ -17,15 +17,13 @@ function removeSoftwareCursor(line, cursorMarker = "") {
 function configureCursor(tui, cursorStyle) {
     if (cursorStyle === "block")
         return;
-    const setShow = 
-    // SAFETY: intentional unsafe cast — validated at runtime
-    tui.setShowHardwareCursor;
+    const setShow = // SAFETY: intentional unsafe cast — validated at runtime
+     tui.setShowHardwareCursor;
     if (typeof setShow === "function")
         setShow.call(tui, true);
     const seq = CURSOR_STYLE_SEQUENCES[cursorStyle];
     // SAFETY: intentional unsafe cast — validated at runtime
-    const term = tui
-        .terminal;
+    const term = tui.terminal;
     if (seq && term && typeof term.write === "function")
         term.write(seq);
 }

package/dist/detail-chrome.js

@@ -1,4 +1,22 @@
-import { contentLineCount, renderDetail, scroll, } from "./detail-render.js";
+/**
+ * DetailChrome — deep module owning the whole Detail-window flow behind one seam.
+ *
+ * Previously the Highlight → Detail window flow was fragmented: TrackingEditor
+ * observed the Candidate highlight, src/index.ts held widget state
+ * (currentItem/scrollOffset/lastWidth), scroll math, and header-marker
+ * re-parsing (contentLinesFrom); src/detail-render.ts owned wrapping;
+ * src/window-presentation.ts owned the border. Fixing a wrapping bug required
+ * holding 3 modules in one head — no locality.
+ *
+ * Depth: small interface (setItem / getItem / scrollBy / render) hides scroll
+ * offset, width, MAX_LINES, wrapping, border, and header-marker parsing inside.
+ * detail-render + window-presentation are INTERNAL seams, not part of the
+ * interface. One place to learn — one place to test, no TUI needed.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { contentLineCount, renderDetail, scroll } from "./detail-render.js";
 import { decorateWindow } from "./window-presentation.js";
 /** Height cap of the detail window (the user's spec: up to 5 lines). */
 export const MAX_LINES = 5;
@@ -6,12 +24,107 @@ export const MAX_LINES = 5;
 function kindOf(value) {
     return value.startsWith("skill:") ? "skill" : "command";
 }
+function resolveSkillPath(skillName) {
+    const name = skillName.trim();
+    if (!name)
+        return undefined;
+    const candidates = [];
+    const cwd = process.cwd();
+    const home = (() => {
+        try {
+            return os.homedir();
+        }
+        catch {
+            return "";
+        }
+    })();
+    // project-local candidates
+    candidates.push(path.join(cwd, ".pi", "agent", "skills", name, "SKILL.md"));
+    candidates.push(path.join(cwd, ".agents", "skills", name, "SKILL.md"));
+    candidates.push(path.join(cwd, ".pi", "skills", name, "SKILL.md"));
+    candidates.push(path.join(cwd, "skills", name, "SKILL.md"));
+    // user-global candidates
+    if (home) {
+        candidates.push(path.join(home, ".pi", "agent", "skills", name, "SKILL.md"));
+        candidates.push(path.join(home, ".agents", "skills", name, "SKILL.md"));
+        candidates.push(path.join(home, ".pi", ".agents", "skills", name, "SKILL.md"));
+        candidates.push(path.join(home, ".pi", "skills", name, "SKILL.md"));
+        candidates.push(path.join(home, "stowfiles", "dotfiles", ".pi", "agent", "skills", name, "SKILL.md"));
+        candidates.push(path.join(home, "stowfiles", "dotfiles", ".pi", "agent", ".agents", "skills", name, "SKILL.md"));
+    }
+    // subskill candidates (any parent skill -> subskills/<name>)
+    const bases = [
+        path.join(cwd, ".agents", "skills"),
+        path.join(cwd, ".pi", "agent", "skills"),
+        path.join(cwd, ".pi", "skills"),
+        path.join(cwd, "skills"),
+    ];
+    if (home) {
+        bases.push(path.join(home, ".agents", "skills"), path.join(home, ".pi", "agent", "skills"), path.join(home, ".pi", "skills"));
+    }
+    for (const base of bases) {
+        try {
+            const entries = fs.readdirSync(base, { withFileTypes: true });
+            for (const e of entries) {
+                const isDir = e.isDirectory() || e.isSymbolicLink();
+                if (!isDir)
+                    continue;
+                candidates.push(path.join(base, e.name, "subskills", name, "SKILL.md"));
+            }
+        }
+        catch { }
+    }
+    for (const p of candidates) {
+        try {
+            if (fs.existsSync(p))
+                return p;
+        }
+        catch {
+            // ignore
+        }
+    }
+    // fallback to global symlink path so header always shows a path for skills
+    if (home)
+        return path.join(home, ".pi", "agent", "skills", name, "SKILL.md");
+    return path.join(cwd, ".pi", "agent", "skills", name, "SKILL.md");
+}
+function parseInvocation(skillPath) {
+    try {
+        const content = fs.readFileSync(skillPath, "utf-8");
+        const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+        if (!fmMatch)
+            return "model";
+        const fm = fmMatch[1] ?? "";
+        if (/^\s*disable-model-invocation\s*:\s*true\b/m.test(fm))
+            return "human";
+        return "model";
+    }
+    catch {
+        return undefined;
+    }
+}
 function detailItemOf(item) {
-    return {
+    const detail = {
         label: item.label,
         kind: kindOf(item.value),
         description: item.description ?? "",
     };
+    const rawPath = item.path?.trim() ?? "";
+    if (rawPath !== "") {
+        detail.path = rawPath;
+    }
+    else if (item.value.startsWith("skill:")) {
+        const skillName = item.value.slice("skill:".length);
+        const resolved = resolveSkillPath(skillName);
+        if (resolved !== undefined)
+            detail.path = resolved;
+    }
+    if (detail.kind === "skill" && detail.path) {
+        const inv = parseInvocation(detail.path);
+        if (inv)
+            detail.invocation = inv;
+    }
+    return detail;
 }
 export class DetailChrome {
     item = null;
@@ -67,6 +180,8 @@ export class DetailChrome {
             border: (s) => t.fg("border", s),
             highlight: (s) => t.fg("accent", t.bold(s)),
             dim: (s) => t.fg("dim", s),
+            model: (s) => t.fg("success", s),
+            human: (s) => t.fg("warning", s),
         };
         const innerWidth = Math.max(1, width - 4);
         const lines = renderDetail(detailItemOf(item), innerWidth, this.maxLines, this.scrollOffset);