opencode-agent-skill 13.0.0-beta.2 → 14.4.0

package/lib/orchestrator-policy.mjs

@@ -1,209 +1,5 @@
-const HIGH_RISK = /(\bauth\b|authorization|authentication|security|permission|payment|migration|schema|database|production|deploy|public api|breaking|secret|credential|phân quyền|bảo mật|thanh toán|cơ sở dữ liệu|triển khai|migrate|migration)/i
-const LONG = /(whole repo|whole repository|whole project|entire repo|entire project|large refactor|major refactor|long[- ](?:running|horizon)|durable state|dependency graph|integration verification|resume|migration|refactor all|toàn bộ repo|toàn bộ repository|toàn bộ dự án|toàn bộ project|refactor lớn|tác vụ dài|nhiều file|nhiều module|tiếp tục công việc|refactor toàn bộ|xác minh tích hợp|kiểm tra tích hợp|chia (?:công việc|task|tác vụ).*(?:dependency|phụ thuộc))/i
-const DEBUG = /(fix|bug|debug|crash|regression|failure|error|broken|sửa lỗi|lỗi|điều tra lỗi|không chạy)/i
-const CONTRACT = /(public api|api contract|openapi|response schema|request schema|breaking api|hợp đồng api|api công khai)/i
-const DATA = /(database|sql|migration|schema|transaction|index|cơ sở dữ liệu|dữ liệu|migrate)/i
-
-function signal(name, matched, weight) {
-  return matched ? { name, weight } : null
-}
-
-function profileFor(mode, risk) {
-  if (mode === "inline" && risk === "low") {
-    return {
-      name: "fast",
-      maxSkills: 2,
-      contextBudget: 8_000,
-      contextStrategy: "incremental-semantic",
-      skillLoading: "direct-only",
-      durableState: false,
-      worktree: "off",
-      critic: "off",
-      verification: "targeted",
-      fullCI: false,
-      containerVerification: "off",
-    }
-  }
-  if (mode === "long-horizon" || risk === "high") {
-    return {
-      name: "deep",
-      maxSkills: 5,
-      contextBudget: 48_000,
-      contextStrategy: "semantic+graph+git",
-      skillLoading: "orchestrated",
-      durableState: true,
-      worktree: "auto-writers",
-      critic: "required-for-high-risk-or-final",
-      verification: "targeted+integration",
-      fullCI: true,
-      containerVerification: risk === "high" ? "preferred-if-capable" : "optional",
-    }
-  }
-  return {
-    name: "standard",
-    maxSkills: 4,
-    contextBudget: 20_000,
-    contextStrategy: "incremental-semantic+git",
-    skillLoading: "selective",
-    durableState: false,
-    worktree: "auto-on-conflict",
-    critic: "on-failure-or-elevated-risk",
-    verification: "targeted+affected",
-    fullCI: false,
-    containerVerification: "off",
-  }
-}
-
-function boundedInt(value, fallback, min, max) {
-  const parsed = Number(value)
-  if (!Number.isFinite(parsed)) return fallback
-  return Math.min(max, Math.max(min, Math.round(parsed)))
-}
-
-export function recoveryPolicyForAttempt(taskPolicy = {}, attempt = 1) {
-  const normalizedAttempt = boundedInt(attempt, 1, 1, 99)
-  const baseBudget = boundedInt(
-    taskPolicy.contextBudget ?? taskPolicy.profile?.contextBudget,
-    20_000,
-    4_000,
-    48_000,
-  )
-  const baseSkills = boundedInt(
-    taskPolicy.maxSkills ?? taskPolicy.profile?.maxSkills,
-    4,
-    1,
-    5,
-  )
-  const baseStrategy = taskPolicy.profile?.contextStrategy || "incremental-semantic+git"
-
-  if (normalizedAttempt <= 1) {
-    return {
-      schemaVersion: 1,
-      stage: "initial",
-      attempt: normalizedAttempt,
-      contextBudget: baseBudget,
-      maxSkills: baseSkills,
-      contextStrategy: baseStrategy,
-      requireDiagnosis: false,
-      requireCritic: false,
-      modelEscalation: false,
-      directives: [],
-    }
-  }
-
-  if (normalizedAttempt === 2) {
-    return {
-      schemaVersion: 1,
-      stage: "diagnose",
-      attempt: normalizedAttempt,
-      contextBudget: Math.min(48_000, Math.max(baseBudget, Math.round(baseBudget * 1.35))),
-      maxSkills: Math.min(5, baseSkills + 1),
-      contextStrategy:
-        taskPolicy.executionProfile === "fast"
-          ? "incremental-semantic+git"
-          : baseStrategy,
-      requireDiagnosis: true,
-      requireCritic: false,
-      modelEscalation: true,
-      directives: [
-        "reproduce or capture the exact previous failure before editing",
-        "inspect the direct caller, nearest test and failure-adjacent evidence",
-        "do not stack another speculative patch on top of the failed attempt",
-      ],
-    }
-  }
-
-  return {
-    schemaVersion: 1,
-    stage: "deep-recovery",
-    attempt: normalizedAttempt,
-    contextBudget: Math.min(48_000, Math.max(20_000, Math.round(baseBudget * 1.75))),
-    maxSkills: Math.min(5, baseSkills + 2),
-    contextStrategy: "semantic+graph+git",
-    requireDiagnosis: true,
-    requireCritic: true,
-    modelEscalation: true,
-    directives: [
-      "re-investigate from fresh evidence and explicitly reject the failed hypothesis",
-      "expand to callers, dependencies, tests and boundary contracts before editing",
-      "challenge the architecture or coupling if repeated fixes expose a wider problem",
-      "run an independent critic or review pass before accepting the recovery",
-    ],
-  }
-}
-
-export function classifyEngineeringTask(text, facts = {}) {
-  const value = String(text || "")
-  const declaredHighRisk =
-    ["high", "critical"].includes(String(facts.risk || "").toLowerCase()) ||
-    /\b(?:risk|rủi ro)\s*[:=\/-]?\s*(?:high|critical|cao|nghiêm trọng)\b/i.test(value) ||
-    /\b(?:high|critical)[-\s]?(?:risk|rủi ro)\b/i.test(value)
-  const declaredLongHorizon =
-    facts.longHorizon === true ||
-    ["long", "long-horizon", "deep"].includes(String(facts.mode || "").toLowerCase())
-  const compoundLongRisk =
-    /\blong\s*[/|,+]\s*(?:high|critical)[-\s]?risk\b/i.test(value) ||
-    /\b(?:high|critical)[-\s]?risk\s*[/|,+]\s*long\b/i.test(value)
-  const explicitLongHorizon = declaredLongHorizon || compoundLongRisk || LONG.test(value)
-  const signals = [
-    signal("long-request-text", value.length > 700, 1),
-    signal("medium-request-text", value.length > 250, 1),
-    signal("high-risk-domain", HIGH_RISK.test(value), 2),
-    signal("declared-high-risk", declaredHighRisk, 2),
-    signal("explicit-long-horizon", explicitLongHorizon, 2),
-    signal("debugging", DEBUG.test(value), 1),
-    signal("public-contract", CONTRACT.test(value) || facts.hasPublicContract, 2),
-    signal("data-migration", (DATA.test(value) && /migration|schema|migrate|di trú|chuyển đổi/i.test(value)) || facts.hasMigration, 2),
-    signal("many-changed-files", Number(facts.changedFiles || 0) > 5, 1),
-    signal("very-many-changed-files", Number(facts.changedFiles || 0) > 12, 1),
-    signal("large-repository", Number(facts.repoFiles || 0) > 1500, 1),
-    signal("monorepo", facts.monorepo === true, 1),
-  ].filter(Boolean)
-
-  const score = signals.reduce((sum, item) => sum + item.weight, 0)
-  const highRisk = declaredHighRisk || HIGH_RISK.test(value) || Boolean(facts.hasMigration) || Boolean(facts.hasPublicContract)
-  const risk = highRisk ? "high" : score >= 3 ? "medium" : "low"
-  const mode = explicitLongHorizon || score >= 4 ? "long-horizon" : score >= 2 ? "standard" : "inline"
-  const modelTier = risk === "high" || mode === "long-horizon" ? "heavy" : score >= 2 ? "standard" : "light"
-  const maxAttempts = risk === "high" ? 2 : 3
-  const profile = profileFor(mode, risk)
-
-  const domains = []
-  if (/(auth|permission|tenant|token|session|phân quyền|xác thực)/i.test(value)) domains.push("auth-security")
-  if (/(payment|checkout|refund|webhook|thanh toán|hoàn tiền)/i.test(value)) domains.push("payment")
-  if (DATA.test(value)) domains.push("database")
-  if (CONTRACT.test(value)) domains.push("api-contract")
-  if (/(react native|expo|android|ios|gradle|xcode)/i.test(value)) domains.push("react-native")
-  else if (/(next\.js|nextjs|app router|server component)/i.test(value)) domains.push("nextjs")
-  else if (/\breact\b|useeffect|usestate|component/i.test(value)) domains.push("react")
-  if (/(docker|kubernetes|terraform|github actions|ci\/cd|deploy|triển khai)/i.test(value)) domains.push("devops")
-
-  return {
-    schemaVersion: 4,
-    score,
-    signals,
-    risk,
-    mode,
-    executionProfile: profile.name,
-    modelTier,
-    maxAttempts,
-    contextBudget: profile.contextBudget,
-    maxSkills: profile.maxSkills,
-    requirePlanCheck: profile.durableState || risk === "high",
-    requireIntegrationVerification: mode !== "inline" || risk === "high",
-    requireFreshEvidence: true,
-    profile,
-    domains: [...new Set(domains)],
-    recovery: {
-      escalateAfterFailure: true,
-      diagnosisBeforePatch: true,
-      deepRecoveryFromAttempt: 3,
-    },
-    antiHallucination: {
-      evidenceFirst: true,
-      noCompletionWithoutVerification: mode !== "inline" || risk === "high",
-      noUnsupportedSemanticClaims: true,
-      failClosedOnMissingCapability: risk === "high",
-    },
-  }
-}
+export {
+  classifyEngineeringTask,
+  recoveryPolicyForAttempt,
+  shouldRunDedicatedDiagnosis,
+} from "./task-policy.mjs"

package/lib/performance-fabric.mjs

@@ -0,0 +1,229 @@
+import { putEvidence } from "./evidence-store.mjs"
+
+const DEFAULT_LIMIT = 64 * 1024
+const SIGNAL_LINE = /\b(error|errors|failed|failure|fail|fatal|exception|warning|warn|assert|timeout|timed out|panic|traceback|mismatch|conflict|rejected|passed|pass|tests?|exit(?: code)?|changed)\b/i
+
+function clampInt(value, fallback, min, max) {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.max(min, Math.min(max, Math.trunc(parsed)))
+}
+
+function uniqueSignalLines(text, limit = 48) {
+  const seen = new Set()
+  const rows = []
+  for (const raw of String(text || "").split(/\r?\n/)) {
+    const line = raw.trimEnd()
+    if (!line || !SIGNAL_LINE.test(line) || seen.has(line)) continue
+    seen.add(line)
+    rows.push(line)
+    if (rows.length >= limit) break
+  }
+  return rows
+}
+
+function testSummaryLines(source, limit = 80) {
+  const rows = []
+  const seen = new Set()
+  const patterns = [
+    /^FAIL\b/i,
+    /^PASS\b/i,
+    /^Test Suites:/i,
+    /^Tests:/i,
+    /^Snapshots:/i,
+    /^Time:/i,
+    /^Ran all test suites/i,
+    /Jest did not exit/i,
+    /Exceeded timeout/i,
+    /^\s*●\s+/,
+    /^\s*at\s+.+:\d+:\d+/,
+    /(?:AssertionError|Expected|Received|Traceback|panic:|FAILED\s)/i,
+  ]
+  for (const raw of String(source || "").split(/\r?\n/)) {
+    const line = raw.trimEnd()
+    if (!line || seen.has(line) || !patterns.some((re) => re.test(line))) continue
+    seen.add(line)
+    rows.push(line)
+    if (rows.length >= limit) break
+  }
+  return rows
+}
+
+function gitSummaryLines(source, limit = 120) {
+  const rows = []
+  for (const raw of String(source || "").split(/\r?\n/)) {
+    if (
+      /^diff --git /.test(raw) ||
+      /^@@ /.test(raw) ||
+      /^(?:---|\+\+\+) /.test(raw) ||
+      /^fatal:/i.test(raw) ||
+      /^error:/i.test(raw) ||
+      /^CONFLICT\b/i.test(raw)
+    ) {
+      rows.push(raw)
+      if (rows.length >= limit) break
+    }
+  }
+  return rows
+}
+
+
+function lintSummaryLines(source, limit = 100) {
+  const rows = []
+  const seen = new Set()
+  const patterns = [
+    /\b(?:error|warning)\b/i,
+    /\b\d+\s+problems?\b/i,
+    /\b\d+\s+errors?\b/i,
+    /\b\d+\s+warnings?\b/i,
+    /\b(?:eslint|ruff|flake8|pylint|clippy)\b/i,
+    /:\d+:\d+\b/,
+    /^✖\s+/,
+  ]
+  for (const raw of String(source || "").split(/\r?\n/)) {
+    const line = raw.trimEnd()
+    if (!line || seen.has(line) || !patterns.some((pattern) => pattern.test(line))) continue
+    seen.add(line)
+    rows.push(line)
+    if (rows.length >= limit) break
+  }
+  return rows
+}
+
+function buildSummaryLines(source, limit = 100) {
+  const rows = []
+  const seen = new Set()
+  const patterns = [
+    /\berror\s+TS\d+\b/i,
+    /\b(?:compile|compiled|compilation|build)\b.*\b(?:failed|success|succeeded|complete|completed)\b/i,
+    /\b(?:failed|fatal|exception|panic)\b/i,
+    /\bwarning\b/i,
+    /:\d+:\d+\b/,
+    /\b(?:ELIFECYCLE|ERR_|exit code)\b/i,
+  ]
+  for (const raw of String(source || "").split(/\r?\n/)) {
+    const line = raw.trimEnd()
+    if (!line || seen.has(line) || !patterns.some((pattern) => pattern.test(line))) continue
+    seen.add(line)
+    rows.push(line)
+    if (rows.length >= limit) break
+  }
+  return rows
+}
+
+function jsonSummaryLines(source, limit = 80) {
+  const text = String(source || "").trim()
+  if (!text || text.length > 4 * 1024 * 1024 || !/^[\[{]/.test(text)) return []
+  let value
+  try { value = JSON.parse(text) } catch { return [] }
+
+  const rows = []
+  const visit = (current, prefix, depth) => {
+    if (rows.length >= limit || depth > 3) return
+    if (Array.isArray(current)) {
+      rows.push(`${prefix || "$"}: array(${current.length})`)
+      current.slice(0, 8).forEach((item, index) => visit(item, `${prefix || "$"}[${index}]`, depth + 1))
+      return
+    }
+    if (current && typeof current === "object") {
+      const keys = Object.keys(current)
+      rows.push(`${prefix || "$"}: object(${keys.length}) keys=[${keys.slice(0, 16).join(", ")}]`)
+      for (const key of keys.slice(0, 12)) {
+        visit(current[key], prefix ? `${prefix}.${key}` : key, depth + 1)
+        if (rows.length >= limit) break
+      }
+      return
+    }
+    const rendered = JSON.stringify(current)
+    rows.push(`${prefix || "$"}: ${String(rendered).slice(0, 160)}`)
+  }
+  visit(value, "", 0)
+  return rows
+}
+
+function structuredSignalLines(source, options = {}) {
+  const hint = String(options.kind || options.source || options.command || "").toLowerCase()
+  if (/(jest|vitest|pytest|test|spec)/.test(hint)) {
+    const rows = testSummaryLines(source)
+    if (rows.length) return { kind: "test", rows }
+  }
+  if (/(eslint|lint|ruff|flake8|pylint|clippy)/.test(hint)) {
+    const rows = lintSummaryLines(source)
+    if (rows.length) return { kind: "lint", rows }
+  }
+  if (/(typecheck|tsc|compile|build|gradle|maven|cargo check|dotnet build)/.test(hint)) {
+    const rows = buildSummaryLines(source)
+    if (rows.length) return { kind: "build", rows }
+  }
+  if (/(git|diff|status)/.test(hint)) {
+    const rows = gitSummaryLines(source)
+    if (rows.length) return { kind: "git", rows }
+  }
+  if (/(json|--json)/.test(hint) || /^[\s]*[\[{]/.test(String(source || ""))) {
+    const rows = jsonSummaryLines(source)
+    if (rows.length) return { kind: "json", rows }
+  }
+  const rows = uniqueSignalLines(source)
+  return { kind: rows.length ? "signal" : "generic", rows }
+}
+
+function boundedPreview(text, maxChars, options = {}) {
+  const source = String(text || "")
+  const headBudget = Math.max(2048, Math.floor(maxChars * 0.24))
+  const tailBudget = Math.max(4096, Math.floor(maxChars * 0.30))
+  const signalBudget = Math.max(2048, maxChars - headBudget - tailBudget - 1800)
+  const head = source.slice(0, headBudget)
+  const tail = source.slice(Math.max(head.length, source.length - tailBudget))
+  const structured = structuredSignalLines(source, options)
+  let signalText = structured.rows.join("\n")
+  if (signalText.length > signalBudget) signalText = signalText.slice(0, signalBudget) + "\n...[signal lines truncated]"
+  return { head, tail, signalText, signalKind: structured.kind }
+}
+
+export async function compactReversibleOutput(root, text, options = {}) {
+  const source = String(text ?? "")
+  const maxChars = clampInt(options.maxChars, DEFAULT_LIMIT, 8 * 1024, 256 * 1024)
+  if (source.length <= maxChars) {
+    return {
+      schemaVersion: 1,
+      compacted: false,
+      strategy: "raw",
+      originalChars: source.length,
+      returnedChars: source.length,
+      evidenceRef: null,
+      text: source,
+    }
+  }
+
+  const evidence = await putEvidence(root, source, {
+    kind: options.kind || "raw-tool-output",
+    source: options.source || "ues-performance-fabric",
+    summary: options.summary || `Raw output preserved before model-visible compaction (${source.length} chars)`,
+  })
+  const { head, tail, signalText, signalKind } = boundedPreview(source, maxChars, options)
+  const recovery = `Raw captured output: ${evidence.ref}. Recover exact captured bytes in slices with: ues store get ${evidence.ref} --start N --max 24000`
+  let preview = [
+    `[UES reversible output compaction: ${source.length} -> <=${maxChars} chars; reducer=${signalKind}]`,
+    recovery,
+    "",
+    "--- head ---",
+    head,
+    signalText ? "\n--- high-signal lines ---\n" + signalText : "",
+    "\n--- tail ---",
+    tail,
+  ].filter(Boolean).join("\n")
+  if (preview.length > maxChars) {
+    const reserve = Math.min(1400, recovery.length + 160)
+    preview = preview.slice(0, Math.max(0, maxChars - reserve)) + `\n...[model-visible preview truncated]\n${recovery}`
+  }
+
+  return {
+    schemaVersion: 1,
+    compacted: true,
+    strategy: `reversible-head-${signalKind}-tail`,
+    originalChars: source.length,
+    returnedChars: preview.length,
+    evidenceRef: evidence.ref,
+    text: preview,
+  }
+}