kifaru 1.0.158 → 1.0.161

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 opencode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/extensions/kifaru-coverage-tracker.ts

@@ -0,0 +1,138 @@
+/**
+ * kifaru-coverage-tracker.ts — pi extension: (Asset × VulnClass) coverage.
+ *
+ * Machine-readable counterpart of the kifaru-coverage-method skill: keeps a
+ * durable coverage ledger (terminal states TESTED_SAFE / VERIFIED / GHOST /
+ * JUSTIFIED_BLOCKED, non-terminal PENDING / OBSTRUCTED), records blocked-cell
+ * justifications, and reports what is still open — so hunts cannot silently
+ * skip cells and completion claims are honest.
+ *
+ * State persists through pi.appendEntry (custom entries never enter model
+ * context) and is restored on session_start. Loaded automatically from
+ * .pi/extensions/ (project scope) or via `-e`.
+ *
+ * Surface:
+ *   - tool    kifaru_coverage  { action: "set"|"block"|"list"|"open", ... }
+ *   - command /kifaru-coverage [list|open]
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent"
+import { Type } from "typebox"
+
+export type CoverageState = "TESTED_SAFE" | "VERIFIED" | "GHOST" | "JUSTIFIED_BLOCKED" | "PENDING" | "OBSTRUCTED"
+const TERMINAL: CoverageState[] = ["TESTED_SAFE", "VERIFIED", "GHOST", "JUSTIFIED_BLOCKED"]
+
+export interface CoverageCell {
+  key: string // `${asset}::${vulnClass}`
+  asset: string
+  vulnClass: string
+  state: CoverageState
+  evidence: string // the decisive test / proof / probe / justification
+  updatedAt: number
+}
+
+let cells: CoverageCell[] = []
+
+function cellKey(asset: string, vulnClass: string): string {
+  return `${asset.trim().toLowerCase()}::${vulnClass.trim().toLowerCase()}`
+}
+
+function upsert(cell: Omit<CoverageCell, "key" | "updatedAt">): CoverageCell {
+  const key = cellKey(cell.asset, cell.vulnClass)
+  const existing = cells.find((c) => c.key === key)
+  if (existing) {
+    existing.state = cell.state
+    existing.evidence = cell.evidence
+    existing.updatedAt = Date.now()
+    return existing
+  }
+  const next: CoverageCell = { key, ...cell, updatedAt: Date.now() }
+  cells.push(next)
+  return next
+}
+
+function render(onlyOpen: boolean): string {
+  const open = cells.filter((c) => !TERMINAL.includes(c.state))
+  const list = onlyOpen ? open : cells
+  const lines = []
+  lines.push(`Coverage ledger: ${cells.length} cells (${open.length} open / non-terminal)`)
+  for (const c of list) {
+    lines.push(`  [${c.state}] ${c.asset} × ${c.vulnClass}${c.evidence ? ` — ${c.evidence.slice(0, 140)}` : ""}`)
+  }
+  if (onlyOpen && open.length === 0) lines.push("  (no open cells — all terminal)")
+  return lines.join("\n")
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.on("session_start", async (_event, ctx: ExtensionContext) => {
+    cells = []
+    for (const entry of ctx.sessionManager.getEntries()) {
+      if (entry.type === "custom" && entry.customType === "kifaru-coverage" && Array.isArray(entry.data?.cells)) {
+        cells = entry.data.cells as CoverageCell[]
+      }
+    }
+  })
+
+  const persist = () => pi.appendEntry("kifaru-coverage", { cells })
+
+  pi.registerTool({
+    name: "kifaru_coverage",
+    label: "Kifaru Coverage",
+    description:
+      "Track hunt coverage as (asset × vulnerability class) cells. Terminal states: TESTED_SAFE, VERIFIED, GHOST, JUSTIFIED_BLOCKED. Non-terminal: PENDING, OBSTRUCTED. Use 'block' to justify why a cell cannot be tested (never silently skip), 'list'/'open' to review the ledger. A hunt is not complete while open cells remain.",
+    promptSnippet: "Track (asset × vuln class) coverage cells and record honest blocked justifications",
+    parameters: Type.Object({
+      action: Type.Union([Type.Literal("set"), Type.Literal("block"), Type.Literal("list"), Type.Literal("open")]),
+      asset: Type.Optional(Type.String({ description: "Asset identifier (host, endpoint, repo, app)" })),
+      vulnClass: Type.Optional(Type.String({ description: "Vulnerability class (e.g. idor, sqli, race-condition)" })),
+      state: Type.Optional(
+        Type.Union([
+          Type.Literal("TESTED_SAFE"),
+          Type.Literal("VERIFIED"),
+          Type.Literal("GHOST"),
+          Type.Literal("JUSTIFIED_BLOCKED"),
+          Type.Literal("PENDING"),
+          Type.Literal("OBSTRUCTED"),
+        ]),
+      ),
+      evidence: Type.Optional(Type.String({ description: "Decisive test / minimal proof / probe / justification" })),
+    }),
+    async execute(_toolCallId, params) {
+      if (params.action === "list" || params.action === "open") {
+        return { content: [{ type: "text", text: render(params.action === "open") }], details: { ok: true } }
+      }
+      if (!params.asset || !params.vulnClass || !params.state) {
+        return {
+          content: [{ type: "text", text: "set/block require asset, vulnClass and state." }],
+          details: { ok: false },
+        }
+      }
+      const cell = upsert({
+        asset: params.asset,
+        vulnClass: params.vulnClass,
+        state: params.state,
+        evidence: params.evidence ?? "",
+      })
+      persist()
+      const terminal = TERMINAL.includes(cell.state)
+        ? "terminal"
+        : "NOT terminal — must be resolved, pivoted, or formally justified"
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Recorded [${cell.state}] ${cell.asset} × ${cell.vulnClass} (${terminal}). Open cells: ${cells.filter((c) => !TERMINAL.includes(c.state)).length}`,
+          },
+        ],
+        details: { ok: true },
+      }
+    },
+  })
+
+  pi.registerCommand("kifaru-coverage", {
+    description: "Show the coverage ledger (list|open)",
+    handler: async (args, ctx) => {
+      const onlyOpen = args?.trim()?.toLowerCase() === "open" || args?.trim()?.toLowerCase() === ""
+      pi.sendMessage({ content: render(onlyOpen), display: true, details: {} })
+    },
+  })
+}

package/extensions/kifaru-cve-intel.ts

@@ -0,0 +1,92 @@
+/**
+ * kifaru-cve-intel.ts — pi extension: CVE lookup + version cross-check.
+ *
+ * Provides the vulnerability-intelligence surface (opencode intelligence/
+ * cve-db + cve-feed) for the Pi runtime: a local curated table for the ~15
+ * CVEs Kifaru tooling cites by default, an optional network refresh from the
+ * CIRCL API (guarded by timeout; skipped when PI_OFFLINE=1), and the
+ * RQ-01 version-consistency cross-check reused from kifaru-report-lint.
+ *
+ * Loaded automatically from .pi/extensions/ (project scope) or via `-e`.
+ *
+ * Surface:
+ *   - tool    kifaru_cve_lookup  { cveId, version?, refresh? }
+ *   - command /kifaru-cve  <CVE-ID>
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { Type } from "typebox"
+import { cveVersionCheck } from "./kifaru-report-lint"
+
+async function fetchRemoteCve(cveId: string, signal?: AbortSignal): Promise<string | null> {
+  if (process.env.PI_OFFLINE === "1") return null
+  try {
+    const ctrl = new AbortController()
+    const t = setTimeout(() => ctrl.abort(), 6000)
+    signal?.addEventListener("abort", () => ctrl.abort())
+    const res = await fetch(`https://cve.circl.lu/api/cve/${encodeURIComponent(cveId)}`, { signal: ctrl.signal })
+    clearTimeout(t)
+    if (!res.ok) return null
+    const data = (await res.json()) as {
+      id?: string
+      summary?: string
+      cvss?: number
+      cwe?: string
+      references?: string[]
+    } | null
+    if (!data?.summary) return null
+    return [
+      `CVE: ${data.id ?? cveId}`,
+      `summary: ${data.summary.slice(0, 400)}`,
+      `cvss: ${data.cvss ?? "n/a"}   cwe: ${data.cwe ?? "n/a"}`,
+      `references: ${(data.references ?? []).slice(0, 3).join(" | ")}`,
+    ].join("\n")
+  } catch {
+    return null
+  }
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "kifaru_cve_lookup",
+    label: "Kifaru CVE Lookup",
+    description:
+      "Look up a CVE in the local Kifaru table or via the CIRCL API (when online), and cross-check an observed version against the affected range (RQ-01). Use before citing a CVE in a finding.",
+    promptSnippet: "Look up CVEs and cross-check version compatibility before citing them",
+    parameters: Type.Object({
+      cveId: Type.String({ description: "CVE identifier, e.g. CVE-2021-41773" }),
+      version: Type.Optional(Type.String({ description: "Observed version (banner/manifest) to cross-check" })),
+      refresh: Type.Optional(Type.Boolean({ description: "Fetch fresh data from the CIRCL API" })),
+    }),
+    async execute(_toolCallId, params: { cveId: string; version?: string; refresh?: boolean }, signal?: AbortSignal) {
+      const cveId = params.cveId.toUpperCase()
+      const lines: string[] = []
+      const local = cveVersionCheck(cveId, params.version ?? "")
+      if (params.version) lines.push(`version check: ${local.verdict} — ${local.reason}`)
+      lines.push(`local entry: ${local.name || "not in the curated table (verify against an authoritative feed)"}`)
+      if (params.refresh) {
+        const remote = await fetchRemoteCve(cveId, signal)
+        if (remote) {
+          lines.push("")
+          lines.push(remote)
+        } else {
+          lines.push("remote lookup unavailable (offline or API error); local entry shown only.")
+        }
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }], details: { ok: true } }
+    },
+  })
+
+  pi.registerCommand("kifaru-cve", {
+    description: "Look up a CVE (local table + optional CIRCL refresh)",
+    handler: async (args, ctx) => {
+      const cveId = (args ?? "").trim().toUpperCase()
+      if (!/^CVE-\d{4}-\d{4,7}$/.test(cveId)) {
+        ctx.ui.notify("usage: /kifaru-cve CVE-YYYY-NNNNN", "warning")
+        return
+      }
+      const local = cveVersionCheck(cveId, "")
+      const remote = await fetchRemoteCve(cveId)
+      pi.sendMessage({ content: [local.reason, remote ?? ""].filter(Boolean).join("\n"), display: true, details: {} })
+    },
+  })
+}

package/extensions/kifaru-dossier.ts

@@ -0,0 +1,347 @@
+/**
+ * kifaru-dossier.ts — pi extension: durable target dossier (observations + findings).
+ *
+ * Port of the opencode target_dossier machinery for the Pi runtime:
+ *   - persistence/target-dossier.ts (TargetDossier shape, merge-dedupe updates)
+ *   - tool/target-dossier.ts (load|update surface)
+ *   - tool/hunt-dossier.ts list_targets (target roll-up)
+ *
+ * The dossier JSON keeps the exact opencode `TargetDossier` shape
+ * ({ id, target, observations, findings, lastUpdated }) so either runtime can
+ * consume the same record. Storage is project-scoped at
+ * `.kifaru/dossiers/<slug>.json` (gitignored, cross-session, cross-runtime)
+ * instead of the opencode XDG data dir — the Pi agent is the primary run
+ * channel, and hunt state already lives under this repo's `.kifaru/`.
+ *
+ * Use for preserving target context, findings, and handoff notes across turns.
+ * Do not use for live reconnaissance or vulnerability lookup.
+ *
+ * Loaded automatically from .pi/extensions/ (project scope) or via `-e`.
+ *
+ * Session binding (mirrors opencode maybeHandleHuntBind): the active target is
+ * resolved at session start from KIFARU_TUI_TARGET (set at tui launch), or
+ * detected from the user's first prompt when no target is bound; the dossier is
+ * then bound and a compact dossier context block is injected into the system
+ * prompt once per target. The kifaru_dossier tool/command can re-bind anytime.
+ *
+ * Surface:
+ *   - tool    kifaru_dossier  { action: "load"|"update"|"list", target?, observations?, findings? }
+ *   - command /kifaru-dossier [bind <target>|<target>|list|status]
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import fs from "node:fs/promises"
+import path from "node:path"
+import { Type } from "typebox"
+
+export interface TargetDossier {
+  id: string
+  target: string
+  observations: string[]
+  findings: string[]
+  lastUpdated: number
+}
+
+/** Port of opencode persistence/hunt-dossier `getTargetSlug` (host normalization). */
+export function targetSlug(target: string): string {
+  const raw = target.trim()
+  if (raw.length === 0) return "unknown"
+
+  const clean = raw.replace(/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//, "")
+  const host = clean.split("/")[0] ?? clean
+  const lower = host.toLowerCase()
+  const parts = lower.split(":")
+  const name = parts[0] ?? lower
+  const port = parts[1]
+
+  if (name === "localhost") {
+    if (port && port.length > 0) return `localhost-${port}`
+    return "localhost"
+  }
+
+  const isIp = /^\d{1,3}(\.\d{1,3}){3}$/.test(name)
+  if (isIp) return name
+
+  const safe = name.replace(/[^a-z0-9._-]/g, "-")
+  return safe.length > 0 ? safe : "unknown"
+}
+
+function dossierFile(target: string): string {
+  return path.join(process.cwd(), ".kifaru", "dossiers", `${targetSlug(target)}.json`)
+}
+
+function emptyDossier(target: string): TargetDossier {
+  return { id: target, target: target.trim(), observations: [], findings: [], lastUpdated: Date.now() }
+}
+
+async function loadDossier(target: string): Promise<TargetDossier> {
+  const file = dossierFile(target)
+  const data = await fs
+    .readFile(file, "utf8")
+    .then((text) => JSON.parse(text) as Partial<TargetDossier>)
+    .catch(() => null)
+  if (!data || typeof data !== "object") return emptyDossier(target)
+  return {
+    id: target,
+    target: target.trim(),
+    observations: Array.isArray(data.observations) ? data.observations.filter((s) => typeof s === "string") : [],
+    findings: Array.isArray(data.findings) ? data.findings.filter((s) => typeof s === "string") : [],
+    lastUpdated: Date.now(),
+  }
+}
+
+/** port of opencode mergeList: skip empties, dedupe, preserve existing order. */
+function mergeList(base: string[], extra: string[] | undefined): string[] {
+  const list = extra ?? []
+  if (list.length === 0) return base
+  const set = new Set(base)
+  for (const item of list) {
+    if (typeof item !== "string" || item.trim().length === 0) continue
+    set.add(item.trim())
+  }
+  return [...set]
+}
+
+async function updateDossier(input: {
+  target: string
+  observations?: string[]
+  findings?: string[]
+}): Promise<TargetDossier> {
+  const current = await loadDossier(input.target)
+  const next: TargetDossier = {
+    ...current,
+    observations: mergeList(current.observations, input.observations),
+    findings: mergeList(current.findings, input.findings),
+    lastUpdated: Date.now(),
+  }
+  const file = dossierFile(input.target)
+  await fs.mkdir(path.dirname(file), { recursive: true })
+  // atomic-ish write: temp file + rename so concurrent readers never see a partial JSON
+  const tmp = `${file}.tmp`
+  await fs.writeFile(tmp, JSON.stringify(next, null, 2), "utf8")
+  await fs.rename(tmp, file)
+  return next
+}
+
+async function listTargets(): Promise<
+  Array<{ slug: string; target: string; observations: number; findings: number; lastUpdated: number }>
+> {
+  const root = path.join(process.cwd(), ".kifaru", "dossiers")
+  const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => [])
+  const items: Array<{ slug: string; target: string; observations: number; findings: number; lastUpdated: number }> = []
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json") || entry.name.endsWith(".tmp")) continue
+    const data = await fs
+      .readFile(path.join(root, entry.name), "utf8")
+      .then((text) => JSON.parse(text) as Partial<TargetDossier>)
+      .catch(() => null)
+    if (!data) continue
+    items.push({
+      slug: entry.name.replace(/\.json$/, ""),
+      target: typeof data.target === "string" ? data.target : entry.name.replace(/\.json$/, ""),
+      observations: Array.isArray(data.observations) ? data.observations.length : 0,
+      findings: Array.isArray(data.findings) ? data.findings.length : 0,
+      lastUpdated: typeof data.lastUpdated === "number" ? data.lastUpdated : 0,
+    })
+  }
+  return items.sort((a, b) => b.lastUpdated - a.lastUpdated)
+}
+
+// ---- session binding state (mirrors opencode session/prompt.ts HuntBindState) ----
+
+const HUNT_URL_REGEX = /https?:\/\/[^\s<>")']+/gi
+const HUNT_DOMAIN_REGEX = /\b(?:[a-z0-9-]+\.)+[a-z]{2,}\b/gi
+
+let boundTarget: string | null = null
+const injectedTargets = new Set<string>()
+
+function envTarget(): string | null {
+  const value = process.env.KIFARU_TUI_TARGET ?? process.env.KIFARU_TARGET ?? ""
+  return value.trim().length > 0 ? value.trim() : null
+}
+
+/** Port of opencode detectTarget: first URL, else first domain. */
+function detectTarget(text: string): string | null {
+  const urls = text.match(HUNT_URL_REGEX)
+  if (urls && urls.length > 0) {
+    const url = urls[0]!.trim().replace(/[),.!?;:]$/, "")
+    if (url.length > 0 && url.length < 512) return url
+  }
+  const domains = text.match(HUNT_DOMAIN_REGEX)
+  if (domains && domains.length > 0) {
+    const domain = domains[0]!.trim()
+    if (domain.length > 0 && domain.length < 256) return domain
+  }
+  return null
+}
+
+function dossierContextBlock(target: string, dossier: TargetDossier): string {
+  const lines = [
+    `<kifaru_dossier target="${target}">`,
+    `Bound target dossier: ${dossier.observations.length} observation(s), ${dossier.findings.length} finding(s).`,
+    `Dossier file: ${path.join(process.cwd(), ".kifaru", "dossiers", `${targetSlug(target)}.json`)}`,
+  ]
+  const recentObservations = dossier.observations.slice(-5)
+  if (recentObservations.length > 0) {
+    lines.push(`Recent observations:`)
+    for (const obs of recentObservations) lines.push(`  - ${obs.slice(0, 240)}`)
+  }
+  const recentFindings = dossier.findings.slice(-3)
+  if (recentFindings.length > 0) {
+    lines.push(`Recent findings:`)
+    for (const finding of recentFindings) lines.push(`  - ${finding.slice(0, 240)}`)
+  }
+  lines.push(`Use kifaru_dossier { action: "update", ... } to persist new context; keep entries concise.`)
+  lines.push(`</kifaru_dossier>`)
+  return lines.join("\n")
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.on("session_start", async () => {
+    boundTarget = envTarget()
+    injectedTargets.clear()
+  })
+
+  // Bind the target from the first prompt (opencode hunt-bind interception) and
+  // inject the dossier context once per target — before_agent_start only.
+  pi.on("before_agent_start", async (event) => {
+    const candidate = boundTarget ?? envTarget() ?? detectTarget(event.prompt ?? "")
+    if (!candidate || injectedTargets.has(candidate)) return undefined
+    boundTarget = candidate
+    injectedTargets.add(candidate)
+    const dossier = await updateDossier({ target: candidate })
+    pi.appendEntry("kifaru-dossier", {
+      target: candidate,
+      observations: dossier.observations.length,
+      findings: dossier.findings.length,
+    })
+    return {
+      systemPrompt: `${event.systemPrompt}\n\n${dossierContextBlock(candidate, dossier)}`,
+      message: {
+        customType: "kifaru-dossier",
+        content: `Session bound to target ${candidate}. Dossier created/loaded under .kifaru/dossiers/.`,
+        display: false,
+      },
+    }
+  })
+
+  pi.registerTool({
+    name: "kifaru_dossier",
+    label: "Kifaru Target Dossier",
+    description:
+      "Load or update the persistent target dossier (observations + findings), or list all dossiers. Use to preserve target context, findings, and handoff notes across turns. Not for live reconnaissance or vulnerability lookup.",
+    promptSnippet: "Persist and reload target observations and findings across turns",
+    parameters: Type.Object({
+      action: Type.Union([Type.Literal("load"), Type.Literal("update"), Type.Literal("list")]),
+      target: Type.Optional(Type.String({ description: "Target identifier (host, app, repo, api base url)" })),
+      observations: Type.Optional(Type.Array(Type.String(), { description: "Observations to add (merged, deduped)" })),
+      findings: Type.Optional(Type.Array(Type.String(), { description: "Findings to add (merged, deduped)" })),
+    }),
+    async execute(
+      _toolCallId,
+      params: { action: "load" | "update" | "list"; target?: string; observations?: string[]; findings?: string[] },
+    ) {
+      if (params.action === "list") {
+        const targets = await listTargets()
+        const lines = targets.length
+          ? targets.map(
+              (t) =>
+                `  ${t.slug} — ${t.observations} obs, ${t.findings} findings (${new Date(t.lastUpdated).toISOString()})`,
+            )
+          : ['  (no dossiers yet — kifaru_dossier { action: "update", target, ... } creates one)']
+        return {
+          content: [{ type: "text", text: `Target dossiers: ${targets.length}\n${lines.join("\n")}` }],
+          details: { ok: true, count: targets.length },
+        }
+      }
+      const target = (params.target ?? "").trim()
+      if (!target) {
+        return { content: [{ type: "text", text: "load/update require a non-empty target." }], details: { ok: false } }
+      }
+      // Any explicit dossier action on a target re-binds the session to it.
+      boundTarget = target
+      if (params.action === "load") {
+        const dossier = await loadDossier(target)
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(dossier, null, 2),
+            },
+          ],
+          details: { ok: true, observations: dossier.observations.length, findings: dossier.findings.length },
+        }
+      }
+      const dossier = await updateDossier({ target, observations: params.observations, findings: params.findings })
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(dossier, null, 2),
+          },
+        ],
+        details: { ok: true, observations: dossier.observations.length, findings: dossier.findings.length },
+      }
+    },
+  })
+
+  pi.registerCommand("kifaru-dossier", {
+    description: "Show/bind the target dossier (status, list, bind <target>, or a target slug/URL)",
+    handler: async (args, ctx) => {
+      const arg = (args ?? "").trim()
+      const lower = arg.toLowerCase()
+      if (lower === "status" || !arg) {
+        const target = boundTarget ?? envTarget()
+        if (!target) {
+          ctx.ui.notify(
+            "No target bound yet — start a message with a URL/domain, or use: /kifaru-dossier bind <target>",
+            "info",
+          )
+          return
+        }
+        const dossier = await loadDossier(target)
+        pi.sendMessage({
+          content: `Bound target: ${target}\nObservations: ${dossier.observations.length}\nFindings: ${dossier.findings.length}\nUpdated: ${new Date(dossier.lastUpdated).toISOString()}`,
+          display: true,
+          details: {},
+        })
+        return
+      }
+      if (lower === "bind") {
+        ctx.ui.notify("usage: /kifaru-dossier bind <target>", "warning")
+        return
+      }
+      if (lower.startsWith("bind ")) {
+        const target = arg.slice(5).trim()
+        if (!target) {
+          ctx.ui.notify("usage: /kifaru-dossier bind <target>", "warning")
+          return
+        }
+        boundTarget = target
+        const dossier = await updateDossier({ target })
+        ctx.ui.notify(
+          `Bound target dossier: ${target} (${dossier.observations.length} obs, ${dossier.findings.length} findings)`,
+          "info",
+        )
+        return
+      }
+      if (lower === "list") {
+        const targets = await listTargets()
+        const body = targets.length
+          ? targets.map((t) => `- ${t.slug} (${t.observations} obs, ${t.findings} findings)`).join("\n")
+          : "No dossiers yet."
+        pi.sendMessage({ content: `Target dossiers:\n${body}`, display: true, details: {} })
+        return
+      }
+      const dossier = await loadDossier(arg)
+      const body = [
+        `Target: ${dossier.target}`,
+        `Observations (${dossier.observations.length}):`,
+        ...dossier.observations.map((o) => `  - ${o}`),
+        `Findings (${dossier.findings.length}):`,
+        ...dossier.findings.map((f) => `  - ${f}`),
+        `Last updated: ${new Date(dossier.lastUpdated).toISOString()}`,
+      ].join("\n")
+      pi.sendMessage({ content: body, display: true, details: {} })
+    },
+  })
+}