opencode-agent-skill 7.7.0

package/lib/context-manifest.mjs

@@ -0,0 +1,101 @@
+import { existsSync } from "node:fs"
+import { readFile, stat } from "node:fs/promises"
+import path from "node:path"
+import { buildRepoGraph } from "./repo-graph.mjs"
+import { taskFiles } from "./task-graph.mjs"
+
+const INSTRUCTION_FILES = ["AGENTS.md", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle", "build.gradle.kts"]
+
+function rel(root, file) {
+  return path.relative(root, file).replaceAll("\\", "/")
+}
+
+function unique(values) {
+  return [...new Set(values.filter(Boolean))]
+}
+
+async function fileInfo(root, relative) {
+  const full = path.resolve(root, relative)
+  if (!full.startsWith(path.resolve(root) + path.sep) && full !== path.resolve(root)) return null
+  const info = await stat(full).catch(() => null)
+  if (!info?.isFile()) return null
+  return { path: rel(root, full), bytes: info.size }
+}
+
+async function excerpt(root, relative, limit) {
+  const full = path.resolve(root, relative)
+  const source = await readFile(full, "utf8").catch(() => "")
+  if (!source) return null
+  return {
+    path: rel(root, full),
+    text: source.length <= limit ? source : source.slice(0, limit) + "\n...[truncated]",
+  }
+}
+
+export async function buildContextManifest(root, task, options = {}) {
+  root = path.resolve(root)
+  const budget = Math.max(4_000, Number(options.budget ?? 24_000))
+  const declared = taskFiles(task)
+  const graph = await buildRepoGraph(root, { maxFiles: options.maxFiles ?? 2500 })
+  const nodeMap = new Map(graph.nodes.map((node) => [node.path, node]))
+  const incoming = new Map()
+  for (const edge of graph.edges) {
+    const list = incoming.get(edge.to) || []
+    list.push(edge.from)
+    incoming.set(edge.to, list)
+  }
+
+  const related = []
+  for (const file of declared) {
+    related.push(...(nodeMap.get(file)?.localImports || []))
+    related.push(...(incoming.get(file) || []))
+  }
+
+  const baseNames = declared.map((file) => path.basename(file, path.extname(file)).toLowerCase())
+  const tests = graph.nodes
+    .map((node) => node.path)
+    .filter((file) => /(^|\/)(test|tests|__tests__|spec)(\/|$)|\.(test|spec)\./i.test(file))
+    .filter((file) => baseNames.some((name) => name && file.toLowerCase().includes(name)))
+    .slice(0, 20)
+
+  const instructions = []
+  for (const name of INSTRUCTION_FILES) {
+    if (existsSync(path.join(root, name))) instructions.push(name)
+  }
+
+  const candidates = unique([...declared, ...related.slice(0, 30), ...tests, ...instructions])
+  const files = []
+  for (const file of candidates) {
+    const info = await fileInfo(root, file)
+    if (info) files.push(info)
+  }
+
+  let remaining = budget
+  const excerpts = []
+  for (const file of unique([...declared, ...tests, ...related.slice(0, 12), ...instructions])) {
+    if (remaining <= 0) break
+    const perFile = Math.min(4_000, remaining)
+    const item = await excerpt(root, file, perFile)
+    if (!item) continue
+    remaining -= item.text.length
+    excerpts.push(item)
+  }
+
+  return {
+    schemaVersion: 1,
+    task: task?.id || null,
+    declared,
+    related: unique(related).filter((file) => !declared.includes(file)).slice(0, 30),
+    tests,
+    instructions,
+    files,
+    excerpts,
+    graph: {
+      scannedFiles: graph.scannedFiles,
+      truncated: graph.truncated,
+      hotspots: graph.hotspots.slice(0, 12),
+    },
+    budget,
+    used: budget - remaining,
+  }
+}

package/lib/control-center.mjs

@@ -0,0 +1,148 @@
+import { existsSync } from "node:fs"
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises"
+import path from "node:path"
+import { readLearningState } from "./learning-engine.mjs"
+
+function escapeHtml(value) {
+  return String(value ?? "")
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+}
+
+async function readJson(file, fallback = null) {
+  try { return JSON.parse(await readFile(file, "utf8")) } catch { return fallback }
+}
+
+async function collectWork(root) {
+  const workRoot = path.join(root, ".ues-work")
+  const entries = await readdir(workRoot, { withFileTypes: true }).catch(() => [])
+  const items = []
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    const dir = path.join(workRoot, entry.name)
+    const [state, plan, evidence] = await Promise.all([
+      readJson(path.join(dir, "STATE.json"), {}),
+      readJson(path.join(dir, "PLAN.json"), {}),
+      readJson(path.join(dir, "EVIDENCE.json"), {}),
+    ])
+    items.push({
+      slug: entry.name,
+      status: state.status || "unknown",
+      goal: state.goal || plan.goal || "",
+      nextAction: state.nextAction || "",
+      blockers: state.blockers || [],
+      tasks: (plan.tasks || []).map((task) => ({
+        id: task.id,
+        title: task.title,
+        risk: task.risk || "medium",
+        state: state.tasks?.[task.id] || {},
+      })),
+      receipts: (evidence.receipts || []).length,
+      updatedAt: state.updatedAt || null,
+    })
+  }
+  return items.sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)))
+}
+
+async function collectEvalSummary(root) {
+  const evalRoot = path.join(root, ".ues-evals")
+  const entries = await readdir(evalRoot, { withFileTypes: true }).catch(() => [])
+  const files = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort().slice(-20)
+  const rows = []
+  for (const name of files) {
+    const payload = await readJson(path.join(evalRoot, name), null)
+    if (!payload) continue
+    rows.push({ file: name, model: payload.model, suite: payload.suite, summary: payload.summary || {} })
+  }
+  return rows.reverse()
+}
+
+export async function collectControlCenterData(root = process.cwd()) {
+  root = path.resolve(root)
+  const [work, learning, evals] = await Promise.all([
+    collectWork(root),
+    readLearningState(root),
+    collectEvalSummary(root),
+  ])
+  return {
+    schemaVersion: 1,
+    generatedAt: new Date().toISOString(),
+    root,
+    work,
+    learning,
+    evals,
+  }
+}
+
+export function renderControlCenter(data) {
+  const payload = JSON.stringify(data).replaceAll("<", "\\u003c")
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>UES Control Center</title>
+<style>
+:root{font-family:Inter,ui-sans-serif,system-ui,sans-serif;color-scheme:dark;background:#0b1020;color:#e7ecf5}
+body{margin:0}.shell{max-width:1200px;margin:auto;padding:28px}.top{display:flex;justify-content:space-between;gap:20px;align-items:end}
+h1{margin:0;font-size:30px}.muted{color:#9da9bd}.grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(280px,1fr));gap:14px;margin-top:20px}
+.card{background:#121a2c;border:1px solid #26324a;border-radius:14px;padding:16px}.pill{display:inline-block;padding:3px 8px;border:1px solid #3b4966;border-radius:999px;font-size:12px}
+.task{display:grid;grid-template-columns:1fr auto;gap:8px;border-top:1px solid #243049;padding:9px 0}.ok{color:#7ee787}.warn{color:#f2cc60}.bad{color:#ff7b72}
+table{width:100%;border-collapse:collapse;margin-top:10px}th,td{text-align:left;padding:8px;border-bottom:1px solid #26324a;font-size:13px}
+pre{white-space:pre-wrap;word-break:break-word;background:#0a0f1c;padding:10px;border-radius:10px}.section{margin-top:28px}
+</style>
+</head>
+<body><div class="shell">
+<div class="top"><div><h1>UES Control Center</h1><div class="muted" id="root"></div></div><div class="muted" id="generated"></div></div>
+<div class="section"><h2>Long-horizon work</h2><div class="grid" id="work"></div></div>
+<div class="section"><h2>Learning loop</h2><div class="grid" id="learning"></div></div>
+<div class="section"><h2>Recent evaluations</h2><div class="card"><table><thead><tr><th>Suite</th><th>Model</th><th>Baseline</th><th>UES</th></tr></thead><tbody id="evals"></tbody></table></div></div>
+</div>
+<script>
+let data=${payload};
+const esc=(v)=>String(v??"").replace(/[&<>"']/g,c=>({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"}[c]));
+function render(next){
+ data=next;
+ document.querySelector("#root").textContent=data.root;
+ document.querySelector("#generated").textContent="Generated "+data.generatedAt;
+ const work=document.querySelector("#work");
+ work.innerHTML="";
+ for(const item of data.work){
+  const tasks=item.tasks.map(t=>'<div class="task"><span>'+esc(t.id)+' · '+esc(t.title||'')+'</span><span class="pill">'+esc(t.state.status||'pending')+'</span></div>').join('');
+  work.insertAdjacentHTML("beforeend",'<div class="card"><div><span class="pill">'+esc(item.status)+'</span></div><h3>'+esc(item.slug)+'</h3><div class="muted">'+esc(item.goal)+'</div><p>'+esc(item.nextAction)+'</p>'+tasks+'<div class="muted">receipts: '+item.receipts+' · blockers: '+item.blockers.length+'</div></div>');
+ }
+ if(!data.work.length) work.innerHTML='<div class="card muted">No .ues-work items found.</div>';
+ const learning=document.querySelector("#learning");
+ learning.innerHTML='<div class="card"><h3>Accepted lessons</h3><strong>'+data.learning.accepted.length+'</strong></div><div class="card"><h3>Proposals</h3><strong>'+data.learning.proposals.length+'</strong></div>';
+ const tbody=document.querySelector("#evals");
+ tbody.innerHTML="";
+ for(const row of data.evals){
+  const fmt=(x)=>x?((x.passed||0)+'/'+(x.total||0)):'—';
+  tbody.insertAdjacentHTML("beforeend",'<tr><td>'+esc(row.suite)+'</td><td>'+esc(row.model)+'</td><td>'+fmt(row.summary.baseline)+'</td><td>'+fmt(row.summary.ues)+'</td></tr>');
+ }
+}
+render(data);
+if(location.protocol==="http:" || location.protocol==="https:"){
+ setInterval(async()=>{
+  try{
+   const response=await fetch("/data.json",{cache:"no-store"});
+   if(response.ok) render(await response.json());
+  }catch{}
+ },3000);
+}
+</script></body></html>`
+}
+
+export async function writeControlCenter(root = process.cwd(), outputDir = null) {
+  root = path.resolve(root)
+  const dir = path.resolve(outputDir || path.join(root, ".ues-dashboard"))
+  await mkdir(dir, { recursive: true })
+  const data = await collectControlCenterData(root)
+  const html = renderControlCenter(data)
+  const file = path.join(dir, "index.html")
+  await writeFile(file, html, "utf8")
+  await writeFile(path.join(dir, "data.json"), JSON.stringify(data, null, 2) + "\n", "utf8")
+  return { dir, file, data }
+}

package/lib/eval-auth.mjs

@@ -0,0 +1,21 @@
+import { existsSync } from "node:fs"
+import { copyFile, mkdir } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+
+export function currentOpenCodeAuthPath(home = os.homedir()) {
+  return path.join(home, ".local", "share", "opencode", "auth.json")
+}
+
+export async function copyCurrentOpenCodeAuth(dataRoot, options = {}) {
+  const source = options.source || currentOpenCodeAuthPath(options.home)
+  const target = path.join(dataRoot, "opencode", "auth.json")
+
+  if (!existsSync(source)) {
+    return { copied: false, source, target, reason: "not-found" }
+  }
+
+  await mkdir(path.dirname(target), { recursive: true })
+  await copyFile(source, target)
+  return { copied: true, source, target }
+}

package/lib/eval-report.mjs

@@ -0,0 +1,72 @@
+export function summarizeEvalResults(results) {
+  const modes = {}
+  for (const item of results) {
+    const mode = item.mode || "unknown"
+    const bucket = modes[mode] ??= {
+      passed: 0,
+      total: 0,
+      durationMs: 0,
+      toolCalls: 0,
+      toolSamples: 0,
+      tokens: 0,
+      tokenSamples: 0,
+      cost: 0,
+      costSamples: 0,
+    }
+    bucket.total += 1
+    if (item.passed) bucket.passed += 1
+    bucket.durationMs += Number(item.durationMs) || 0
+
+    if ((item.telemetry?.jsonLines || 0) > 0) {
+      bucket.toolCalls += Number(item.telemetry?.toolCalls) || 0
+      bucket.toolSamples += 1
+    }
+    if ((item.telemetry?.usageSamples || 0) > 0) {
+      bucket.tokens += Number(item.telemetry?.tokens?.total) || 0
+      bucket.tokenSamples += 1
+    }
+    if ((item.telemetry?.costSamples || 0) > 0) {
+      bucket.cost += Number(item.telemetry?.cost) || 0
+      bucket.costSamples += 1
+    }
+  }
+
+  for (const bucket of Object.values(modes)) {
+    bucket.passRate = bucket.total ? bucket.passed / bucket.total : 0
+    bucket.avgDurationMs = bucket.total ? bucket.durationMs / bucket.total : 0
+    bucket.avgToolCalls = bucket.toolSamples ? bucket.toolCalls / bucket.toolSamples : null
+    bucket.avgTokens = bucket.tokenSamples ? bucket.tokens / bucket.tokenSamples : null
+    bucket.avgCost = bucket.costSamples ? bucket.cost / bucket.costSamples : null
+    bucket.telemetryCoverage = {
+      tools: bucket.total ? bucket.toolSamples / bucket.total : 0,
+      tokens: bucket.total ? bucket.tokenSamples / bucket.total : 0,
+      cost: bucket.total ? bucket.costSamples / bucket.total : 0,
+    }
+    delete bucket.durationMs
+    delete bucket.toolCalls
+    delete bucket.toolSamples
+    delete bucket.tokens
+    delete bucket.tokenSamples
+    delete bucket.cost
+    delete bucket.costSamples
+  }
+
+  const byTaskMap = new Map()
+  for (const item of results) {
+    const task = byTaskMap.get(item.task) || {}
+    const bucket = task[item.mode] || { passed: 0, total: 0 }
+    bucket.total += 1
+    if (item.passed) bucket.passed += 1
+    bucket.passRate = bucket.passed / bucket.total
+    task[item.mode] = bucket
+    byTaskMap.set(item.task, task)
+  }
+
+  const baseline = modes.baseline?.passRate
+  const ues = modes.ues?.passRate
+  return {
+    modes,
+    passRateDelta: typeof baseline === "number" && typeof ues === "number" ? ues - baseline : null,
+    byTask: Object.fromEntries([...byTaskMap.entries()].sort(([a], [b]) => a.localeCompare(b))),
+  }
+}

package/lib/eval-telemetry.mjs

@@ -0,0 +1,155 @@
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0
+}
+
+function normalizedToolName(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : ""
+}
+
+function visit(value, callback, path = []) {
+  if (!value || typeof value !== "object") return
+  callback(value, path)
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => visit(item, callback, [...path, index]))
+    return
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if (child && typeof child === "object") visit(child, callback, [...path, key])
+  }
+}
+
+function usageFromObject(object) {
+  const usage = object?.usage
+  if (!usage || typeof usage !== "object") return null
+
+  const input =
+    asNumber(usage.inputTokens) ||
+    asNumber(usage.input_tokens) ||
+    asNumber(usage.promptTokens) ||
+    asNumber(usage.prompt_tokens) ||
+    asNumber(usage.input)
+
+  const output =
+    asNumber(usage.outputTokens) ||
+    asNumber(usage.output_tokens) ||
+    asNumber(usage.completionTokens) ||
+    asNumber(usage.completion_tokens) ||
+    asNumber(usage.output)
+
+  const total =
+    asNumber(usage.totalTokens) ||
+    asNumber(usage.total_tokens) ||
+    asNumber(usage.total) ||
+    input + output
+
+  if (input === 0 && output === 0 && total === 0) return null
+  return { input, output, total }
+}
+
+function toolCandidate(object) {
+  const type = String(object.type || object.kind || object.event || "").toLowerCase()
+  let name = normalizedToolName(object.tool || object.toolName || object.tool_name)
+
+  if (!name && type.includes("tool")) {
+    name = normalizedToolName(object.name)
+  }
+  if (!name) return null
+
+  const input =
+    object.input && typeof object.input === "object" ? object.input :
+    object.args && typeof object.args === "object" ? object.args :
+    object.arguments && typeof object.arguments === "object" ? object.arguments :
+    {}
+
+  const id =
+    object.callID || object.callId || object.toolCallID || object.toolCallId ||
+    object.id || null
+
+  return { name, input, id: id == null ? null : String(id) }
+}
+
+export function parseOpenCodeTelemetry(stdout) {
+  const lines = String(stdout || "").split(/\r?\n/).filter((line) => line.trim())
+  const parsed = []
+  let parseErrors = 0
+
+  for (const line of lines) {
+    try {
+      parsed.push(JSON.parse(line))
+    } catch {
+      parseErrors += 1
+    }
+  }
+
+  const toolKeys = new Set()
+  const tools = new Map()
+  const skills = new Set()
+  const subagents = new Set()
+  const tokens = { input: 0, output: 0, total: 0 }
+  let cost = 0
+  let usageSamples = 0
+  let costSamples = 0
+
+  parsed.forEach((event, eventIndex) => {
+    let eventUsage = null
+    let eventCost = null
+
+    visit(event, (object, objectPath) => {
+      const tool = toolCandidate(object)
+      if (tool) {
+        const fallbackKey = `${eventIndex}:${objectPath.join(".")}:${tool.name}`
+        const key = tool.id ? `${tool.name}:${tool.id}` : fallbackKey
+        if (!toolKeys.has(key)) {
+          toolKeys.add(key)
+          tools.set(tool.name, (tools.get(tool.name) || 0) + 1)
+
+          if (tool.name === "skill") {
+            const id = tool.input.id || tool.input.skill || tool.input.name
+            if (typeof id === "string" && id) skills.add(id)
+          }
+
+          if (tool.name === "task" || tool.name === "subagent") {
+            const id = tool.input.agent || tool.input.agentID || tool.input.agentId || tool.input.id
+            if (typeof id === "string" && id) subagents.add(id)
+          }
+        }
+      }
+
+      if (!eventUsage) eventUsage = usageFromObject(object)
+      if (eventCost === null) {
+        for (const key of ["cost", "totalCost", "total_cost"]) {
+          if (typeof object[key] === "number" && Number.isFinite(object[key])) {
+            eventCost = object[key]
+            break
+          }
+        }
+      }
+    })
+
+    if (eventUsage) {
+      usageSamples += 1
+      tokens.input += eventUsage.input
+      tokens.output += eventUsage.output
+      tokens.total += eventUsage.total
+    }
+    if (eventCost !== null) {
+      costSamples += 1
+      cost += eventCost
+    }
+  })
+
+  return {
+    schemaVersion: 1,
+    format: "best-effort-opencode-jsonl",
+    jsonLines: parsed.length,
+    parseErrors,
+    toolCalls: [...tools.values()].reduce((sum, value) => sum + value, 0),
+    tools: Object.fromEntries([...tools.entries()].sort(([a], [b]) => a.localeCompare(b))),
+    skillsLoaded: [...skills].sort(),
+    subagents: [...subagents].sort(),
+    tokens,
+    usageSamples,
+    cost,
+    costSamples,
+  }
+}

package/lib/evidence-receipt.mjs

@@ -0,0 +1,50 @@
+import { createHash, randomUUID } from "node:crypto"
+
+function digest(value) {
+  return createHash("sha256").update(String(value || "")).digest("hex")
+}
+
+export function createVerificationReceipt(input = {}) {
+  const command = String(input.command || "").trim()
+  if (!command) throw new Error("verification receipt command is required")
+
+  const exitCode = Number(input.exitCode)
+  if (!Number.isInteger(exitCode)) throw new Error("verification receipt exitCode must be an integer")
+
+  const startedAt = String(input.startedAt || new Date().toISOString())
+  const finishedAt = String(input.finishedAt || new Date().toISOString())
+
+  return {
+    schemaVersion: 1,
+    id: input.id || randomUUID(),
+    task: input.task || null,
+    runId: input.runId || null,
+    command,
+    args: Array.isArray(input.args) ? input.args.map(String) : [],
+    cwd: input.cwd || null,
+    exitCode,
+    passed: exitCode === 0,
+    startedAt,
+    finishedAt,
+    durationMs: Math.max(0, Number(input.durationMs) || 0),
+    stdoutSha256: digest(input.stdout),
+    stderrSha256: digest(input.stderr),
+    workspaceBefore: input.workspaceBefore || null,
+    workspaceAfter: input.workspaceAfter || null,
+  }
+}
+
+export function validateVerificationReceipt(receipt) {
+  const errors = []
+  if (!receipt || typeof receipt !== "object" || Array.isArray(receipt)) {
+    return { valid: false, errors: ["receipt must be an object"] }
+  }
+  if (receipt.schemaVersion !== 1) errors.push("schemaVersion must be 1")
+  if (!String(receipt.id || "").trim()) errors.push("id is required")
+  if (!String(receipt.command || "").trim()) errors.push("command is required")
+  if (!Number.isInteger(receipt.exitCode)) errors.push("exitCode must be an integer")
+  if (typeof receipt.passed !== "boolean") errors.push("passed must be boolean")
+  if (!String(receipt.stdoutSha256 || "").match(/^[a-f0-9]{64}$/)) errors.push("stdoutSha256 is invalid")
+  if (!String(receipt.stderrSha256 || "").match(/^[a-f0-9]{64}$/)) errors.push("stderrSha256 is invalid")
+  return { valid: errors.length === 0, errors }
+}

package/lib/hermes-bridge.mjs

@@ -0,0 +1,28 @@
+import { spawnSync } from "node:child_process"
+
+export function hermesStatus() {
+  const result = spawnSync("hermes", ["--version"], { encoding: "utf8", shell: process.platform === "win32" })
+  return {
+    available: result.status === 0,
+    version: result.status === 0 ? String(result.stdout || result.stderr || "").trim() : null,
+    error: result.status === 0 ? null : String(result.stderr || result.stdout || "Hermes CLI not found").trim(),
+  }
+}
+
+export function buildHermesDelegationPrompt(contextPack) {
+  return [
+    "You are an optional external executor for a UES task.",
+    "Implement exactly the approved task described below.",
+    "Do not broaden scope, merge, push, publish, deploy, or alter durable UES state.",
+    "Run the declared verification and return a concise structured report.",
+    "",
+    JSON.stringify(contextPack, null, 2),
+  ].join("\n")
+}
+
+
+export function hermesOneShotArgs(prompt) {
+  const text = String(prompt || "").trim()
+  if (!text) throw new Error("Hermes one-shot prompt is required")
+  return ["chat", "-q", text]
+}

package/lib/ids.mjs

@@ -0,0 +1,21 @@
+export const SKILL_PREFIX = "ues-"
+
+const RESOURCE_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
+const MANAGED_SKILL_PATTERN = /^ues-[a-z0-9]+(?:-[a-z0-9]+)*$/
+const MANAGED_MARKDOWN_PATTERN = /^ues-[a-z0-9]+(?:-[a-z0-9]+)*\.md$/
+
+function testPattern(pattern, value) {
+  return typeof value === "string" && pattern.test(value)
+}
+
+export function validResourceID(value) {
+  return testPattern(RESOURCE_ID_PATTERN, value)
+}
+
+export function validSkillID(value) {
+  return testPattern(MANAGED_SKILL_PATTERN, value)
+}
+
+export function validManagedMarkdown(value) {
+  return testPattern(MANAGED_MARKDOWN_PATTERN, value)
+}