akm-opencode 0.9.8202609020939 → 0.10.261001-beta

package/shared/akm-version.ts

@@ -1,48 +0,0 @@
-// Single source of truth for the akm-cli version contract.
-//
-// Both the Claude hook (claude/hooks/akm-hook.ts) and the OpenCode plugin
-// (opencode/index.ts) validate the user's installed akm-cli against this exact
-// range. Keeping it here — alongside the vendored semver matcher — means a
-// version bump is a one-line change in one file instead of three drifting
-// copies (a hand-rolled `minor === 8` check previously diverged here).
-//
-// The matcher is the vendored `satisfies()` rather than the npm `semver`
-// package because the Claude hook runs as a bare Bun script with no
-// node_modules at hook-execution time. This module is vendored into the
-// published OpenCode tarball by opencode/scripts/vendor-shared.mjs, so the
-// same code path runs on both sides.
-//
-// A single caret clause anchored at the stable release covers the whole
-// supported line: `^0.9.8` admits stable 0.9.8 and later 0.9.x releases.
-// 0.9.8 is the compatibility floor, and the reason is a one-way one: 0.9.8
-// adds state migrations 025 and 026, so once any 0.9.8 command opens
-// `state.db` an older CLI refuses to open it at all. A home these plugins
-// have driven is therefore a 0.9.8+ home, and admitting 0.9.7 would point
-// the gate at a CLI that cannot read it. Its ref grammar, progressive-search
-// metadata, token-budgeted curate packing, workflow lifecycle, and
-// task/workflow wire contracts are the ones these plugins implement.
-//
-// KNOWN GAP: NO prerelease satisfies this range — not 0.9.8-rc.1, and not a
-// *future* line such as 0.9.9-rc.1. That is node-semver's documented behavior
-// and the vendored matcher reproduces it: a prerelease only satisfies a range
-// whose lower bound is a prerelease with the same major.minor.patch. Admitting
-// a prerelease line again is an explicit one-clause edit here
-// (`^0.9.8 || ^0.9.9-rc.1`) when such a build actually needs testing — a
-// deliberate opt-in rather than a range that silently accepts untested
-// prereleases.
-//
-// Earlier 0.9 releases are deliberately excluded as well: accepting them
-// would silently pass the version gate onto a CLI with retired ref and
-// workflow contracts, or one that cannot open a migrated state.db.
-
-import { satisfies } from "./vendor-semver"
-
-export const AKM_VERSION_RANGE = "^0.9.8"
-
-/**
- * True when `version` is a valid semver string that satisfies
- * {@link AKM_VERSION_RANGE}. Non-strings (e.g. a failed probe) return false.
- */
-export function satisfiesAkmVersionRange(version: string | null | undefined): boolean {
-  return typeof version === "string" && satisfies(version, AKM_VERSION_RANGE)
-}

package/shared/feedback-signals.ts

@@ -1,113 +0,0 @@
-export type AkmFeedbackSignal = {
-  ref: string
-  polarity: "positive" | "negative"
-  confidence: number
-  source:
-    | "explicit_user_feedback"
-    | "tool_success"
-    | "tool_failure"
-    | "retrospective_positive"
-    | "retrospective_negative"
-    | "workflow_completion"
-    | "proposal_acceptance"
-    | "proposal_rejection"
-    | "curator_assessment"
-  note: string
-  sessionId?: string
-  harness: "claude-code" | "opencode"
-}
-
-/**
- * Retrospective feedback matchers. Both plugins classify a user message as
- * after-the-fact praise or complaint about assets the session already touched,
- * so the grammar lives here rather than in one harness: the two sides must
- * agree on what counts as a signal, or the same message produces opposite
- * verdicts depending on the harness.
- *
- * AKM_RETROSPECTIVE_FEEDBACK_PATTERN / AKM_RETROSPECTIVE_NEGATIVE_PATTERN let
- * an operator retune the vocabulary (other languages, project jargon). A
- * user-supplied pattern is untrusted input, so an invalid one falls back to the
- * default instead of throwing at module load and taking the plugin down with
- * it.
- */
-export function createRetrospectiveFeedbackRegex(): RegExp {
-  const pattern = process.env.AKM_RETROSPECTIVE_FEEDBACK_PATTERN ?? "\\b(thanks|perfect|worked)\\b"
-  try {
-    return new RegExp(pattern, "i")
-  } catch {
-    return /\b(thanks|perfect|worked)\b/i
-  }
-}
-
-export function createRetrospectiveNegativeRegex(): RegExp {
-  const pattern = process.env.AKM_RETROSPECTIVE_NEGATIVE_PATTERN ?? "\\b(wrong|failed|broken|didn't work|did not work|bad)\\b"
-  try {
-    return new RegExp(pattern, "i")
-  } catch {
-    return /\b(wrong|failed|broken|didn't work|did not work|bad)\b/i
-  }
-}
-
-/**
- * Explicit corrections ("that was wrong") are a stronger, narrower signal than
- * the tunable negative matcher, so this one is deliberately not overridable.
- */
-export function createExplicitCorrectionRegex(): RegExp {
-  return /\b(this was wrong|that was wrong|you were wrong|incorrect|not correct)\b/i
-}
-
-export function getAutoFeedbackMinConfidence(): number {
-  const raw = Number(process.env.AKM_AUTO_FEEDBACK_MIN_CONFIDENCE ?? "0.6")
-  return Number.isFinite(raw) ? raw : 0.6
-}
-
-export function classifyFeedbackSignal(input: {
-  ref: string
-  polarity: "positive" | "negative"
-  harness: "claude-code" | "opencode"
-  sessionId?: string
-  directInput?: boolean
-  explicitUser?: boolean
-  retrospective?: boolean
-  workflowCompletion?: boolean
-  proposalAction?: "accept" | "reject"
-  curatorAssessment?: boolean
-  note?: string
-}): AkmFeedbackSignal {
-  let source: AkmFeedbackSignal["source"] = input.polarity === "positive" ? "tool_success" : "tool_failure"
-  let confidence = input.directInput ? 0.65 : 0.25
-
-  if (input.explicitUser) {
-    source = "explicit_user_feedback"
-    confidence = 0.95
-  } else if (input.retrospective) {
-    source = input.polarity === "positive" ? "retrospective_positive" : "retrospective_negative"
-    confidence = input.polarity === "positive" ? 0.7 : 0.8
-  } else if (input.workflowCompletion) {
-    source = "workflow_completion"
-    confidence = 0.85
-  } else if (input.proposalAction === "accept") {
-    source = "proposal_acceptance"
-    confidence = 0.95
-  } else if (input.proposalAction === "reject") {
-    source = "proposal_rejection"
-    confidence = 0.85
-  } else if (input.curatorAssessment) {
-    source = "curator_assessment"
-    confidence = 0.75
-  }
-
-  return {
-    ref: input.ref,
-    polarity: input.polarity,
-    confidence,
-    source,
-    note: input.note ?? `${input.harness} auto: source=${source}; confidence=${confidence.toFixed(2)}`,
-    sessionId: input.sessionId,
-    harness: input.harness,
-  }
-}
-
-export function shouldSubmitAutomaticFeedback(signal: AkmFeedbackSignal): boolean {
-  return signal.confidence >= getAutoFeedbackMinConfidence()
-}

package/shared/memory-events.ts

@@ -1,95 +0,0 @@
-import { appendFileSync, existsSync, mkdirSync } from "node:fs"
-import path from "node:path"
-import { redactObject } from "./redaction"
-// Memory events log session activity (refs touched, outcomes, scope). Even
-// post-redaction this is a privileged record, so the directory + file are
-// locked to owner-only and events.jsonl is size-capped like every other
-// append-only state file. Both primitives live in ./state-files so the Claude
-// hook and this module share one implementation.
-import { chmodSafe, rotateIfOversized } from "./state-files"
-
-// Exactly the event names some shipped surface emits. The union used to carry
-// 18 more (workflow_*, candidate_*, session_ended, ...) that no call site ever
-// wrote — a vocabulary describing pipelines that were removed or never built.
-// Keep this list emitter-driven: add a name when something emits it, not in
-// anticipation.
-export type AkmMemoryEventType =
-  | "session_started"
-  | "prompt_recall"
-  | "tool_observation"
-  | "tool_batch_observation"
-  | "tool_ref_observed"
-  | "workflow_step"
-  | "task_created"
-  | "task_completed"
-  | "subagent_started"
-  | "post_compact_summary"
-  | "feedback_recorded"
-  // The opencode write gate (#99) emits exactly one of these per watched
-  // write-tool invocation, with a named reason in `input.reason`. One name, not
-  // two: fire and skip are the same event with different outcome.status.
-  | "write_gate"
-
-export type AkmMemoryEvent = {
-  version: 1
-  timestamp: string
-  harness: "claude-code" | "opencode"
-  event: AkmMemoryEventType
-  eventId?: string
-  sessionId?: string
-  project?: string
-  agent?: string
-  workflowRunId?: string
-  scope?: {
-    user?: string
-    agent?: string
-    run?: string
-    channel?: string
-    project?: string
-    repo?: string
-    branch?: string
-  }
-  input?: Record<string, unknown>
-  memory?: Record<string, unknown>
-  refs?: string[]
-  outcome?: {
-    status: "ok" | "skipped" | "blocked" | "failed"
-    warnings?: string[]
-    error?: string
-  }
-  redaction?: {
-    redacted: boolean
-    categories: string[]
-  }
-}
-
-export function getHarnessStateDir(harness: "claude-code" | "opencode"): string {
-  const root = process.env.XDG_STATE_HOME ?? path.join(process.env.HOME ?? ".", ".local", "state")
-  return path.join(root, harness === "claude-code" ? "akm-claude" : "akm-opencode")
-}
-
-export function getEventLogPath(harness: "claude-code" | "opencode"): string {
-  return path.join(getHarnessStateDir(harness), "events.jsonl")
-}
-
-export function appendMemoryEvent(filePath: string, event: AkmMemoryEvent): { ok: true; redacted: boolean; categories: string[] } | { ok: false; error: string } {
-  try {
-    mkdirSync(path.dirname(filePath), { recursive: true })
-    chmodSafe(path.dirname(filePath), 0o700)
-    rotateIfOversized(filePath)
-    const redacted = redactObject(event)
-    const enriched = {
-      ...redacted.value,
-      redaction: {
-        redacted: redacted.redacted,
-        categories: redacted.categories,
-      },
-    }
-    const created = !existsSync(filePath)
-    appendFileSync(filePath, `${JSON.stringify(enriched)}\n`)
-    if (created) chmodSafe(filePath, 0o600)
-    return { ok: true, redacted: redacted.redacted, categories: redacted.categories }
-  } catch (error: unknown) {
-    return { ok: false, error: error instanceof Error ? error.message : String(error) }
-  }
-}

package/shared/recall-policy.ts

@@ -1,74 +0,0 @@
-export type RecallDecision = {
-  shouldRecall: boolean
-  reason:
-    | "explicit-akm"
-    | "long-prompt"
-    | "memory-intent"
-    | "workflow-intent"
-    | "agent-dispatch"
-    | "command-dispatch"
-    | "wiki-intent"
-    | "proposal-intent"
-    | "release-intent"
-    | "coding-task"
-    | "active-workflow"
-    | "recent-asset-failure"
-    | "skip-short"
-    | "skip-chitchat"
-    | "skip-low-signal"
-  query: string
-  scopeHints?: string[]
-}
-
-import { extractAkmRefsFromString } from "./ref-extraction"
-
-export function shouldRecall(prompt: string, options?: { activeWorkflow?: boolean; recentAssetFailure?: boolean }): RecallDecision {
-  const text = prompt.trim()
-  const lower = text.toLowerCase()
-  const scopeHints: string[] = []
-  if (!text) return { shouldRecall: false, reason: "skip-low-signal", query: "", scopeHints }
-  if (options?.activeWorkflow) return { shouldRecall: true, reason: "active-workflow", query: text, scopeHints: ["workflow"] }
-  if (options?.recentAssetFailure) return { shouldRecall: true, reason: "recent-asset-failure", query: text, scopeHints }
-  if (text.length < 4 || /^(ok|thanks|thank you|yes|no|continue|go ahead|sure|cool)$/i.test(lower)) {
-    return { shouldRecall: false, reason: "skip-short", query: text, scopeHints }
-  }
-  if (/\b(hi|hello|how are you|good morning|good night)\b/i.test(lower) && text.length < 40) {
-    return { shouldRecall: false, reason: "skip-chitchat", query: text, scopeHints }
-  }
-  // Reuse the resolver-facing parser rather than carrying a second, stale
-  // grammar here. AKM 0.9.7 refs are [bundle//]conceptId[#fragment]; retired
-  // type:name strings must not turn an otherwise low-signal prompt into an
-  // explicit AKM recall.
-  if (/\bakm\b|\bbundle\b/.test(lower) || extractAkmRefsFromString(text).length > 0) {
-    return { shouldRecall: true, reason: "explicit-akm", query: text, scopeHints: ["akm"] }
-  }
-  if (/\b(remember|memory|prior session|previous decision)\b/.test(lower)) {
-    return { shouldRecall: true, reason: "memory-intent", query: text, scopeHints: ["memory"] }
-  }
-  if (/\b(workflow|resume|complete step|next step|blocked step)\b/.test(lower)) {
-    return { shouldRecall: true, reason: "workflow-intent", query: text, scopeHints: ["workflow"] }
-  }
-  if (/\b(dispatch|agent|subagent|reviewer|planner|curator)\b/.test(lower)) {
-    return { shouldRecall: true, reason: "agent-dispatch", query: text, scopeHints: ["agent"] }
-  }
-  if (/\b(command|slash command|run the bundle command)\b/.test(lower)) {
-    return { shouldRecall: true, reason: "command-dispatch", query: text, scopeHints: ["command"] }
-  }
-  if (/\b(wiki|docs|knowledge base|ingest|lint)\b/.test(lower)) {
-    return { shouldRecall: true, reason: "wiki-intent", query: text, scopeHints: ["wiki"] }
-  }
-  if (/\b(proposal|accept|reject|diff proposal|review proposals)\b/.test(lower)) {
-    return { shouldRecall: true, reason: "proposal-intent", query: text, scopeHints: ["proposal"] }
-  }
-  if (/\b(release|publish|semver|version bump|bump version|tag the release|cut a release)\b/.test(lower)) {
-    return { shouldRecall: true, reason: "release-intent", query: text, scopeHints: ["workflow", "command"] }
-  }
-  if (
-    text.length >= 16
-    && /\b(review|pull request|\bpr\b|diff|refactor|type hints|typing|readability|readable|debug|diagnose|traceback|exception|exceptions|scaffold|unit test|tests|test|changelog|release notes|deployment|deploy|rollback|runbook|error code|healthcheck|linters|lint|format|formatting|naming conventions|convention|style guide|onboarding|new hire|new engineer|api keys|secrets|plan|design|architecture|tradeoffs|build|implement|fix|update)\b/.test(lower)
-  ) {
-    return { shouldRecall: true, reason: "coding-task", query: text, scopeHints: ["code"] }
-  }
-  if (text.length >= 120) return { shouldRecall: true, reason: "long-prompt", query: text, scopeHints }
-  return { shouldRecall: false, reason: "skip-low-signal", query: text, scopeHints }
-}

package/shared/redaction.ts

@@ -1,292 +0,0 @@
-import { inspect } from "node:util"
-
-export type RedactionResult = {
-  text: string
-  redacted: boolean
-  categories: string[]
-}
-
-export type RedactedObjectResult<T> = {
-  value: T
-  redacted: boolean
-  categories: string[]
-}
-
-const SENSITIVE_KEY_RE = /(?:OPENAI_API_KEY|ANTHROPIC_API_KEY|GITHUB_TOKEN|GH_TOKEN|AWS_ACCESS_KEY_ID|AWS_SECRET_ACCESS_KEY|AWS_SESSION_TOKEN|AZURE_[A-Z0-9_]*KEY|SLACK_BOT_TOKEN|SLACK_TOKEN|PASSWORD|PASSWD|SECRET|CONNECTION_STRING|DATABASE_URL|AKM_[A-Z0-9_]*TOKEN)/i
-const SIMPLE_REPLACEMENTS: Array<{ category: string; pattern: RegExp; replacement: string }> = [
-  {
-    category: "private_key",
-    pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
-    replacement: "[REDACTED:PRIVATE_KEY]",
-  },
-  {
-    category: "bearer_token",
-    pattern: /Bearer\s+[A-Za-z0-9._~+/=-]+/gi,
-    replacement: "[REDACTED:BEARER_TOKEN]",
-  },
-  {
-    category: "github_token",
-    pattern: /\bgh[pousr]_[A-Za-z0-9_]+\b/g,
-    replacement: "[REDACTED:GITHUB_TOKEN]",
-  },
-  {
-    category: "github_pat",
-    pattern: /\bgithub_pat_[A-Za-z0-9_]+\b/g,
-    replacement: "[REDACTED:GITHUB_PAT]",
-  },
-  {
-    category: "openai_key",
-    pattern: /\bsk-[A-Za-z0-9_-]+\b/g,
-    replacement: "[REDACTED:OPENAI_API_KEY]",
-  },
-  {
-    category: "slack_token",
-    pattern: /\bxox[baprs]-[A-Za-z0-9-]+\b/g,
-    replacement: "[REDACTED:SLACK_TOKEN]",
-  },
-  // 0.8.0 release-hardening: AWS access key (AKIA prefix, 16 alphanumerics).
-  // IAM user access keys are 20 chars total starting with AKIA; STS temporary
-  // creds use ASIA but those are paired with a session token and short-lived,
-  // so the AKIA prefix is the high-value leak.
-  {
-    category: "aws_access_key",
-    pattern: /\bAKIA[0-9A-Z]{16}\b/g,
-    replacement: "[REDACTED:AWS_ACCESS_KEY_ID]",
-  },
-  // Google Cloud API key (AIza prefix, 35 base64url-safe chars). Pattern is
-  // documented at cloud.google.com/docs/authentication/api-keys.
-  {
-    category: "google_api_key",
-    pattern: /\bAIza[0-9A-Za-z_-]{35}\b/g,
-    replacement: "[REDACTED:GOOGLE_API_KEY]",
-  },
-  // Stripe live-mode secret/publishable keys (sk_live_, pk_live_). Stripe
-  // documents these as the high-severity leak surface in their API docs.
-  {
-    category: "stripe_live_key",
-    pattern: /\b(?:sk|pk)_live_[0-9a-zA-Z]+\b/g,
-    replacement: "[REDACTED:STRIPE_LIVE_KEY]",
-  },
-  // Stripe test-mode keys (sk_test_, pk_test_). Lower severity but still
-  // sensitive — test keys often grant access to test webhooks and dashboards
-  // that mirror production object shapes.
-  {
-    category: "stripe_test_key",
-    pattern: /\b(?:sk|pk)_test_[0-9a-zA-Z]+\b/g,
-    replacement: "[REDACTED:STRIPE_TEST_KEY]",
-  },
-  // Raw `Authorization: <token>` header without the `Bearer` keyword. Some
-  // services (legacy AWS, internal APIs, OAuth1 signed requests) send the
-  // token directly. The Bearer-form pattern above handles the common case.
-  // We require at least 12 chars of token to avoid matching `Authorization: ?`
-  // or other very short placeholder values.
-  {
-    category: "authorization_header",
-    pattern: /(Authorization:\s+)(?!Bearer\b)([A-Za-z0-9._~+/=-]{12,})/gi,
-    replacement: "$1[REDACTED:AUTHORIZATION]",
-  },
-  // WS-7b: Database connection strings — redact credentials portion.
-  // Matches postgres://, mysql://, mongodb+srv://, mongodb://, redis:// with user:pass@ form.
-  {
-    category: "connection_string",
-    pattern: /((?:postgres|postgresql|mysql|mongodb(?:\+srv)?|redis):\/\/)([^@\s]+@)([^\s"'`,]+)/gi,
-    replacement: "$1[REDACTED:CREDENTIALS]@$3",
-  },
-  // WS-7b: AWS ARN structures with embedded account IDs (12-digit).
-  // Matches arn:aws:...:123456789012:... patterns.
-  {
-    category: "aws_arn",
-    pattern: /arn:aws:[a-z0-9_-]+:[a-z0-9-]*:(\d{12}):[^\s"'`,]*/gi,
-    replacement: "arn:aws:...[REDACTED:ACCOUNT_ID]:...",
-  },
-  // WS-7b: JWT-shaped tokens — three base64url segments separated by dots (eyJ prefix).
-  {
-    category: "jwt_token",
-    pattern: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g,
-    replacement: "[REDACTED:JWT_TOKEN]",
-  },
-]
-
-/**
- * High-entropy string redaction (WS-7b).
- *
- * Generic strings >= 32 chars matching [A-Za-z0-9+/=_-]+ that look like
- * base64/hex secrets. Disabled by default to avoid false positives (e.g.
- * long identifiers, file paths, etc.). Opt in by setting the env var:
- *
- *   AKM_REDACT_HIGH_ENTROPY=1
- *
- * The threshold is 32 chars, configurable via AKM_REDACT_ENTROPY_MIN_LEN.
- */
-const HIGH_ENTROPY_ENABLED = process.env.AKM_REDACT_HIGH_ENTROPY === "1"
-const HIGH_ENTROPY_MIN_LEN = Number.parseInt(process.env.AKM_REDACT_ENTROPY_MIN_LEN ?? "32", 10)
-const HIGH_ENTROPY_RE = HIGH_ENTROPY_ENABLED
-  ? new RegExp(`\\b[A-Za-z0-9+/=_-]{${Math.max(32, HIGH_ENTROPY_MIN_LEN)},}\\b`, "g")
-  : null
-
-/**
- * Opt-in PII redaction patterns. Off by default because financial / phone
- * shapes appear in legitimate logs (timestamps, counters, identifiers) and
- * over-redaction makes session logs unreadable. Enable for hosts that
- * legitimately process PII through the agent loop:
- *
- *   AKM_REDACT_PII=1
- *
- * Patterns covered:
- *   - Credit-card-shaped 13–19 digit sequences with optional `[- ]` delimiters
- *     (Luhn is intentionally NOT verified — we redact aggressively when opt-in)
- *   - US Social Security Numbers in `\d{3}-\d{2}-\d{4}` form (delimited only;
- *     bare 9-digit numbers are too noisy)
- *   - US/international phone numbers in `[\+]?\d{1,3}[- .]?\d{3}[- .]?\d{3}[- .]?\d{4}` form
- */
-const PII_REDACTION_ENABLED = process.env.AKM_REDACT_PII === "1"
-const PII_PATTERNS: Array<{ category: string; pattern: RegExp; replacement: string }> = PII_REDACTION_ENABLED
-  ? [
-      {
-        category: "credit_card",
-        pattern: /\b(?:\d[ -]?){12,18}\d\b/g,
-        replacement: "[REDACTED:CREDIT_CARD]",
-      },
-      {
-        category: "ssn",
-        pattern: /\b\d{3}-\d{2}-\d{4}\b/g,
-        replacement: "[REDACTED:SSN]",
-      },
-      {
-        category: "phone",
-        pattern: /(?<![\w./-])\+?\d{1,3}[- .]?\(?\d{3}\)?[- .]?\d{3}[- .]?\d{4}(?![\w./-])/g,
-        replacement: "[REDACTED:PHONE]",
-      },
-    ]
-  : []
-
-function uniq(values: string[]): string[] {
-  return [...new Set(values)]
-}
-
-function redactAssignments(text: string, categories: string[]): string {
-  const envLineRe = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.+)$/gm
-  let next = text.replace(envLineRe, (match, rawKey: string) => {
-    const key = String(rawKey)
-    if (!SENSITIVE_KEY_RE.test(key)) return match
-    categories.push(key.toLowerCase().includes("password") || key.toLowerCase().includes("passwd") ? "password" : "env_secret")
-    categories.push("env_output")
-    return `${key}: [REDACTED:${key}]`
-  })
-  const inlineAssignmentRe = /\b([A-Za-z_][A-Za-z0-9_]*)\s*=\s*([^\s"'`,;]+)/g
-  next = next.replace(inlineAssignmentRe, (match, rawKey: string) => {
-    const key = String(rawKey)
-    if (!SENSITIVE_KEY_RE.test(key)) return match
-    categories.push(key.toLowerCase().includes("password") || key.toLowerCase().includes("passwd") ? "password" : "env_secret")
-    categories.push("env_output")
-    return `${key}: [REDACTED:${key}]`
-  })
-  return next
-}
-
-function redactJsonLikePairs(text: string, categories: string[]): string {
-  const pairRe = /(["']?)(password|passwd|secret|connectionString|apiKey|token|accessKey|secretKey)(\1\s*[:=]\s*)(["']?)([^\n,}"']+)(["']?)/gi
-  return text.replace(pairRe, (_match, q1: string, key: string, sep: string) => {
-    const upper = key.replace(/[^A-Za-z0-9]+/g, "_").toUpperCase()
-    const category = /connection/i.test(key)
-      ? "connection_string"
-      : /pass/i.test(key)
-        ? "password"
-        : /secret/i.test(key)
-          ? "secret"
-          : "token"
-    categories.push(category)
-    return `${q1}${key}${q1}${sep}[REDACTED:${upper}]`
-  })
-}
-
-// Redact `--flag value` / `-f value` CLI argv shapes where the flag name
-// contains a sensitive substring (password, token, secret, api-key, etc.).
-// This catches a class of leaks that the env-assignment and JSON-pair
-// regexes miss because CLI args use a space separator rather than `=` / `:`.
-function redactCliArgPairs(text: string, categories: string[]): string {
-  const pairRe = /(--?[A-Za-z0-9_-]*?(?:password|passwd|secret|token|api[_-]?key|access[_-]?key|auth)[A-Za-z0-9_-]*)(\s+)(\S+)/gi
-  return text.replace(pairRe, (_match, flag: string, sep: string) => {
-    categories.push("cli_arg_secret")
-    return `${flag}${sep}[REDACTED:CLI_ARG]`
-  })
-}
-
-export function redactSecrets(input: string): RedactionResult {
-  let text = input
-  const categories: string[] = []
-
-  for (const entry of SIMPLE_REPLACEMENTS) {
-    if (!entry.pattern.test(text)) continue
-    categories.push(entry.category)
-    text = text.replace(entry.pattern, entry.replacement)
-  }
-
-  text = redactAssignments(text, categories)
-  text = redactJsonLikePairs(text, categories)
-  text = redactCliArgPairs(text, categories)
-
-  // WS-7b: Optional high-entropy string redaction (opt-in via AKM_REDACT_HIGH_ENTROPY=1).
-  if (HIGH_ENTROPY_RE && HIGH_ENTROPY_RE.test(text)) {
-    categories.push("high_entropy")
-    HIGH_ENTROPY_RE.lastIndex = 0 // reset after .test()
-    text = text.replace(HIGH_ENTROPY_RE, "[REDACTED:HIGH_ENTROPY]")
-  }
-
-  // Opt-in PII redaction (AKM_REDACT_PII=1).
-  for (const entry of PII_PATTERNS) {
-    if (!entry.pattern.test(text)) continue
-    categories.push(entry.category)
-    entry.pattern.lastIndex = 0
-    text = text.replace(entry.pattern, entry.replacement)
-  }
-
-  return {
-    text,
-    redacted: categories.length > 0,
-    categories: uniq(categories),
-  }
-}
-
-function normalizeObjectInput(value: unknown): unknown {
-  if (typeof value === "string") return value
-  if (value == null) return value
-  if (typeof value === "number" || typeof value === "boolean") return value
-  if (Array.isArray(value)) return value.map(normalizeObjectInput)
-  if (typeof value === "object") {
-    const record: Record<string, unknown> = {}
-    for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
-      record[key] = normalizeObjectInput(entry)
-    }
-    return record
-  }
-  return inspect(value, { depth: 4, breakLength: 120 })
-}
-
-function redactUnknown(value: unknown, categories: string[]): unknown {
-  if (typeof value === "string") {
-    const redacted = redactSecrets(value)
-    categories.push(...redacted.categories)
-    return redacted.text
-  }
-  if (Array.isArray(value)) return value.map((entry) => redactUnknown(entry, categories))
-  if (value && typeof value === "object") {
-    const output: Record<string, unknown> = {}
-    for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
-      output[key] = redactUnknown(entry, categories)
-    }
-    return output
-  }
-  return value
-}
-
-export function redactObject<T>(input: T): RedactedObjectResult<T> {
-  const categories: string[] = []
-  const normalized = normalizeObjectInput(input)
-  const value = redactUnknown(normalized, categories) as T
-  return {
-    value,
-    redacted: categories.length > 0,
-    categories: uniq(categories),
-  }
-}