Agentic builds: dsynth evidence capture hooks

README.md

@@ -26,6 +26,8 @@ For a disposable DragonFly chroot development shell, use
 - **scripts/**  
   Shell scripts to generate the final DPorts repository, as well as a copy of the Tinderbox hooks.
 
+  Also includes `scripts/dsynth-hooks/` which provides dsynth hook scripts to capture a bounded, high-signal “evidence bundle” (distilled errors + port context) when a port fails to build.
+
 - **ports/**  
   Contains subdirectories corresponding to Ports categories (e.g., `audio`, `editors`, `devel`, etc.).
 

config/opencode/agent/dports-patch.md

@@ -0,0 +1,62 @@
+---
+description: Applies DeltaPorts workspace fixes and rebuilds
+mode: subagent
+model: opencode/gpt-5-nano
+tools:
+  write: false
+  edit: false
+  bash: false
+  read: false
+  glob: false
+  grep: false
+  webfetch: false
+  task: false
+---
+# DeltaPorts Patch Agent (Workspace Flow)
+
+You operate on the shared DragonFlyBSD workspace using the custom `dports_*` tools. Do NOT output unified diffs or FILE blocks. All edits must be performed via the tools. Never write patch file contents directly; always generate `dragonfly/patch-*` files via `dports_dports_genpatch` and `dports_dports_install_patches` (one patch per source file).
+
+You MUST begin by calling `dports_dports_workspace_verify()` before writing any text. Your first response must be a tool call (no prose). If you do not call tools, your response is invalid.
+
+Always use absolute paths under `/build/synth/agentic-workspace` when calling `dports_dports_get_file` or `dports_dports_put_file`. Do NOT use relative paths.
+For searching across files, use `dports_dports_grep` (not local grep).
+When passing patterns, do NOT use HTML-escaped sequences like `>` or `<`; use raw operators like `->`.
+Do NOT use the `bash` tool; it runs on the opencode host and cannot access the VM workspace.
+
+## Required Workflow
+
+You MUST call the tools below in order. If a tool fails, stop and report the failure.
+
+Do NOT write placeholder content to workspace files. Only write real patch content.
+
+1. `dports_dports_workspace_verify()` to validate workspace + FPORTS pin.
+2. `dports_dports_checkout_branch(origin)` (creates `ai-work/<origin_sanitized>` if missing).
+3. `dports_dports_materialize_closure(origin)` to regenerate `DPorts/<origin>` + MASTERDIR closure.
+4. `dports_dports_extract(origin)` and record `WRKSRC`/`WRKDIR` if needed.
+5. Apply changes using tools:
+   - Source patches: `dports_dports_dupe`, `dports_dports_get_file`, `dports_dports_put_file`, `dports_dports_genpatch`, `dports_dports_install_patches`.
+   - Skeleton diffs: edit `DPorts/<origin>` files and emit `dports_dports_emit_diff`.
+   - Overlay-only changes: edit `DeltaPorts/ports/<origin>` directly.
+6. `dports_dports_commit(origin, message)` and capture the commit hash. Use a single-line message.
+7. `dports_dports_materialize_closure(origin)` again if needed.
+8. `dports_dports_dsynth_build(origin, profile)` using the profile from workspace config.
+
+If any tool fails, stop and report the failure in `## Rebuild Status` and `## Rebuild Proof (JSON)` with `rebuild_ok=false`.
+
+## Required Output Format
+
+Return ONLY the sections below, in this order:
+
+- `## Patch Log`
+- `## Rebuild Status`
+- `## Patch Plan (JSON)` with a ```json block
+- `## Rebuild Proof (JSON)` with a ```json block
+
+### Patch Plan (JSON) keys
+Include: `origin`, `summary`, `steps`, `files`, `tools_used`, `commit_message`.
+
+### Rebuild Proof (JSON) keys
+Include: `origin`, `rebuild_ok`, `dsynth_profile`, `deltaports_branch`, `deltaports_head`, `fports_ref`, `fports_head`, `build_command`, `timestamp_utc`.
+
+## Optional: Snippet Requests
+If more context is needed, add a `## Snippet Requests` section using the documented request grammar.

config/opencode/agent/dports-triage.md

@@ -0,0 +1,40 @@
+---
+description: Triages dsynth build failures for DragonFlyBSD DeltaPorts
+mode: subagent
+model: opencode/gpt-5-nano
+tools:
+  write: false
+  edit: false
+  bash: false
+  read: false
+  glob: false
+  grep: false
+  webfetch: false
+  task: false
+---
+# DeltaPorts Build Failure Triage Agent
+
+You triage DragonFlyBSD dsynth build failures using ONLY the provided evidence.
+
+## Output (exact headings)
+
+## Classification
+One of: compile-error, configure-error, patch-error, plist-error, missing-dep, fetch-error, unknown
+
+## Platform
+One of: dragonfly-specific, freebsd-upstream, generic
+
+## Root Cause
+1-3 sentences.
+
+## Evidence
+- Quote exact log lines from errors.txt that support the root cause.
+
+## Suggested Fix
+Concrete DeltaPorts-style fix plan.
+
+## Confidence
+One of: high, medium, low
+
+## Notes
+Optional.

config/opencode/tool/dports.ts

@@ -0,0 +1,257 @@
+import { tool } from "@opencode-ai/plugin";
+
+const DEFAULT_WORKER_PATH = "/build/synth/DeltaPorts/scripts/agentic-worker";
+
+function requireEnv(name: string) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`Missing ${name} for dports tools`);
+  }
+  return value;
+}
+
+function getWorkerPath() {
+  return process.env.DP_WORKER_PATH ?? DEFAULT_WORKER_PATH;
+}
+
+function sshArgs() {
+  const host = requireEnv("DP_SSH_HOST");
+  const port = process.env.DP_SSH_PORT ?? "22";
+  const key = requireEnv("DP_SSH_KEY");
+  return [
+    "-i",
+    key,
+    "-p",
+    port,
+    "-o",
+    "StrictHostKeyChecking=no",
+    "-o",
+    "UserKnownHostsFile=/dev/null",
+    host,
+  ];
+}
+
+function envArgs() {
+  const envs = [
+    "DP_WORKSPACE_BASE",
+    "DP_WORKSPACE_CONFIG",
+    "DP_FPORTS_DIR",
+    "DP_DELTAPORTS_DIR",
+    "DP_DPORTS_DIR",
+  ];
+  const args: string[] = [];
+  for (const key of envs) {
+    const value = process.env[key];
+    if (!value) {
+      continue;
+    }
+    args.push(`${key}=${value}`);
+  }
+  return args;
+}
+
+async function runWorker(args: string[]) {
+  const cmd = ["ssh", ...sshArgs(), "--", "env", ...envArgs(), getWorkerPath(), ...args];
+  const proc = Bun.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  const exitCode = await proc.exited;
+
+  if (exitCode !== 0 && !stdout.trim()) {
+    throw new Error(stderr.trim() || `Worker failed with exit code ${exitCode}`);
+  }
+
+  let payload;
+  try {
+    payload = JSON.parse(stdout);
+  } catch (err) {
+    throw new Error(`Failed to parse worker output: ${stdout}\n${stderr}`);
+  }
+
+  if (!payload.ok) {
+    throw new Error(payload.error || "Worker returned error");
+  }
+
+  return JSON.stringify(payload.result);
+}
+
+export const dports_workspace_verify = tool({
+  description: "Verify workspace config and pinned FPORTS ref",
+  args: {},
+  async execute() {
+    return await runWorker(["workspace-verify"]);
+  },
+});
+
+export const dports_checkout_branch = tool({
+  description: "Checkout or create per-origin fix branch",
+  args: {
+    origin: tool.schema.string().describe("Port origin (category/port)"),
+  },
+  async execute(args) {
+    return await runWorker(["checkout-branch", "--origin", args.origin]);
+  },
+});
+
+function normalizeCommitMessage(message: string) {
+  return message.replace(/[\r\n]+/g, " ").trim();
+}
+
+export const dports_commit = tool({
+  description: "Commit current DeltaPorts changes",
+  args: {
+    origin: tool.schema.string().describe("Port origin (category/port)"),
+    message: tool.schema.string().describe("Commit message"),
+  },
+  async execute(args) {
+    const message = normalizeCommitMessage(args.message);
+    return await runWorker(["commit", "--origin", args.origin, "--message", message]);
+  },
+});
+
+export const dports_materialize_closure = tool({
+  description: "Materialize port + MASTERDIR closure into staged DPorts",
+  args: {
+    origin: tool.schema.string().describe("Port origin (category/port)"),
+  },
+  async execute(args) {
+    return await runWorker(["materialize-closure", "--origin", args.origin]);
+  },
+});
+
+export const dports_extract = tool({
+  description: "Run make extract and return WRKSRC",
+  args: {
+    origin: tool.schema.string().describe("Port origin (category/port)"),
+  },
+  async execute(args) {
+    return await runWorker(["extract", "--origin", args.origin]);
+  },
+});
+
+export const dports_get_file = tool({
+  description: "Read a file from the workspace (base64)",
+  args: {
+    path: tool.schema.string().describe("Absolute path inside workspace"),
+  },
+  async execute(args) {
+    return await runWorker(["get-file", "--path", args.path]);
+  },
+});
+
+function normalizeContent(content: string) {
+  const compact = content.replace(/\s+/g, "");
+  if (compact.length % 4 === 0 && /^[A-Za-z0-9+/=]+$/.test(compact)) {
+    try {
+      const buf = Buffer.from(compact, "base64");
+      if (buf.toString("base64") === compact) {
+        return compact;
+      }
+    } catch {
+      // fall through to raw encoding
+    }
+  }
+  return Buffer.from(content, "utf8").toString("base64");
+}
+
+export const dports_put_file = tool({
+  description: "Write a file to the workspace (raw text or base64)",
+  args: {
+    path: tool.schema.string().describe("Absolute path inside workspace"),
+    content: tool.schema.string().describe("Raw text or base64-encoded content"),
+    expectedSha256: tool.schema.string().optional().describe("Optional sha256 for optimistic lock"),
+  },
+  async execute(args) {
+    const encoded = normalizeContent(args.content);
+    const workerArgs = ["put-file", "--path", args.path, "--content", encoded];
+    if (args.expectedSha256) {
+      workerArgs.push("--expected-sha256", args.expectedSha256);
+    }
+    return await runWorker(workerArgs);
+  },
+});
+
+export const dports_dupe = tool({
+  description: "Run dupe on a WRKSRC file",
+  args: {
+    path: tool.schema.string().describe("Absolute file path inside workspace"),
+  },
+  async execute(args) {
+    return await runWorker(["dupe", "--path", args.path]);
+  },
+});
+
+export const dports_genpatch = tool({
+  description: "Run genpatch on a WRKSRC file",
+  args: {
+    path: tool.schema.string().describe("Absolute file path inside workspace"),
+  },
+  async execute(args) {
+    return await runWorker(["genpatch", "--path", args.path]);
+  },
+});
+
+export const dports_install_patches = tool({
+  description: "Install patch-* files into DeltaPorts dragonfly/",
+  args: {
+    origin: tool.schema.string().describe("Port origin (category/port)"),
+    patches: tool.schema.array(tool.schema.string()).optional().describe("Optional patch filenames"),
+  },
+  async execute(args) {
+    const workerArgs = ["install-patches", "--origin", args.origin];
+    if (args.patches) {
+      for (const patch of args.patches) {
+        workerArgs.push("--patch", patch);
+      }
+    }
+    return await runWorker(workerArgs);
+  },
+});
+
+export const dports_emit_diff = tool({
+  description: "Emit diffs/*.diff for a port skeleton file",
+  args: {
+    origin: tool.schema.string().describe("Port origin (category/port)"),
+    relpath: tool.schema.string().describe("Relative path under port dir (e.g. Makefile)"),
+  },
+  async execute(args) {
+    return await runWorker(["emit-diff", "--origin", args.origin, "--relpath", args.relpath]);
+  },
+});
+
+export const dports_grep = tool({
+  description: "Search files in workspace using ripgrep",
+  args: {
+    pattern: tool.schema.string().describe("Regex pattern to search"),
+    path: tool.schema.string().describe("Absolute path inside workspace"),
+    include: tool.schema.string().optional().describe("Glob pattern, e.g. *.c"),
+    maxBytes: tool.schema.number().optional().describe("Max bytes of output (default 8192)"),
+  },
+  async execute(args) {
+    const encoded = Buffer.from(args.pattern, "utf8").toString("base64");
+    const workerArgs = ["grep", "--pattern-base64", encoded, "--path", args.path];
+    if (args.include) {
+      workerArgs.push("--include", args.include);
+    }
+    if (args.maxBytes !== undefined) {
+      workerArgs.push("--max-bytes", String(args.maxBytes));
+    }
+    return await runWorker(workerArgs);
+  },
+});
+
+export const dports_dsynth_build = tool({
+  description: "Run dsynth just-build for an origin",
+  args: {
+    origin: tool.schema.string().describe("Port origin (category/port)"),
+    profile: tool.schema.string().optional().describe("dsynth profile name"),
+  },
+  async execute(args) {
+    const workerArgs = ["dsynth-build", "--origin", args.origin];
+    if (args.profile) {
+      workerArgs.push("--profile", args.profile);
+    }
+    return await runWorker(workerArgs);
+  },
+});
+