feat(agent): generic ACP runtime + omp backend

scripts/gen-notice-copy.mjs

@@ -0,0 +1,48 @@
+// Generate the backend-readable mirror of the notice copy that lives in the
+// i18n catalogs.
+//
+// `src/i18n/{en,zh}.ts` stay authoritative (AGENTS.md: user-facing strings go
+// only through those two). Some notices are posted by detached backend tasks
+// that have no locale, so they emit a stable TOKEN and each consumer renders
+// it; the webview reads its catalogs directly, while the IM bridge is Rust and
+// cannot. This writes what Rust bakes in.
+//
+// Run after editing any listed key. `tests/frontend/noticeCopy.test.ts` fails
+// if the generated file drifts from the catalogs, so it cannot go stale
+// unnoticed.
+import { writeFileSync } from "node:fs";
+import { en } from "../src/i18n/en.ts";
+import { zh } from "../src/i18n/zh.ts";
+
+/** Backend token -> the catalog key holding its copy. */
+const TOKENS = {
+  "acp.force_reset_notice": "needs.acpForceResetNotice",
+};
+
+const OUT = new URL("../src-tauri/src/bus/notices.generated.json", import.meta.url);
+
+function lookup(catalog, key) {
+  return key.split(".").reduce((node, part) => node?.[part], catalog);
+}
+
+export function buildNoticeCopy() {
+  const out = {};
+  for (const [token, key] of Object.entries(TOKENS)) {
+    const enCopy = lookup(en, key);
+    const zhCopy = lookup(zh, key);
+    if (typeof enCopy !== "string" || typeof zhCopy !== "string") {
+      throw new Error(`${token}: ${key} is missing from en or zh`);
+    }
+    out[token] = { en: enCopy, zh: zhCopy };
+  }
+  return out;
+}
+
+export function serialize(copy) {
+  return `${JSON.stringify(copy, null, 2)}\n`;
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  writeFileSync(OUT, serialize(buildNoticeCopy()));
+  console.log(`wrote ${OUT.pathname}`);
+}

src-tauri/src/acp/backends/mod.rs

@@ -0,0 +1,103 @@
+//! Per-CLI ACP backend descriptors.
+//!
+//! The runtime is generic; only this layer knows binary names and capability
+//! quirks. Adding agent N+1 = new file + register + product enum entries.
+
+use std::sync::{Arc, LazyLock};
+
+use serde_json::Value;
+
+mod omp;
+
+pub use omp::OmpBackend;
+
+/// HTTP MCP server Weft injects into `session/new|resume`.
+#[derive(Debug, Clone)]
+pub struct McpServerSpec {
+    pub name: String,
+    pub url: String,
+}
+
+/// Thin per-tool ACP identity. No process I/O.
+pub trait AcpBackend: Send + Sync + 'static {
+    /// Stable tool identity (also the process-pool key), e.g. `"omp"`.
+    fn id(&self) -> &'static str;
+
+    /// `(program, args)` to spawn the ACP server. `command` is the resolved
+    /// binary/alias from Settings (e.g. `"omp"` or a user override).
+    fn spawn_argv(&self, command: &str) -> (String, Vec<String>);
+
+    /// `clientCapabilities` object for `initialize`.
+    fn client_capabilities(&self) -> Value;
+
+    /// Whether `session/fork` is advertised/usable for rewind helpers.
+    fn supports_fork(&self) -> bool {
+        true
+    }
+
+    /// Paint Weft MCP specs into the wire `mcpServers` array shape this agent accepts.
+    fn paint_mcp_servers(&self, servers: Vec<McpServerSpec>) -> Vec<Value> {
+        servers
+            .into_iter()
+            .map(|s| {
+                serde_json::json!({
+                    "type": "http",
+                    "name": s.name,
+                    "url": s.url,
+                })
+            })
+            .collect()
+    }
+}
+
+static REGISTRY: LazyLock<Vec<Arc<dyn AcpBackend>>> =
+    LazyLock::new(|| vec![Arc::new(OmpBackend) as Arc<dyn AcpBackend>]);
+
+fn registry() -> &'static Vec<Arc<dyn AcpBackend>> {
+    &REGISTRY
+}
+
+/// Look up an ACP backend by tool identity. `None` → not an ACP tool.
+pub fn backend_for(tool: &str) -> Option<Arc<dyn AcpBackend>> {
+    registry().iter().find(|b| b.id() == tool).cloned()
+}
+
+/// All registered ACP tool ids (for detect/tests).
+pub fn registered_ids() -> Vec<&'static str> {
+    registry().iter().map(|b| b.id()).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn omp_is_registered() {
+        let b = backend_for("omp").expect("omp backend");
+        assert_eq!(b.id(), "omp");
+        let (prog, args) = b.spawn_argv("omp");
+        assert_eq!(prog, "omp");
+        assert_eq!(args, vec!["acp"]);
+        assert!(b.supports_fork());
+        let caps = b.client_capabilities();
+        assert_eq!(caps["session"]["requestPermission"], true);
+    }
+
+    #[test]
+    fn unknown_tool_is_none() {
+        assert!(backend_for("claude").is_none());
+        assert!(backend_for("codex").is_none());
+    }
+
+    #[test]
+    fn paints_http_mcp() {
+        let b = backend_for("omp").unwrap();
+        let painted = b.paint_mcp_servers(vec![McpServerSpec {
+            name: "weft_bus".into(),
+            url: "http://127.0.0.1:9/bus/1/1/mcp".into(),
+        }]);
+        assert_eq!(painted.len(), 1);
+        assert_eq!(painted[0]["type"], "http");
+        assert_eq!(painted[0]["name"], "weft_bus");
+    }
+}

src-tauri/src/acp/backends/omp.rs

@@ -0,0 +1,36 @@
+//! omp (Oh My Pi) ACP backend descriptor.
+
+use serde_json::{json, Value};
+
+use super::AcpBackend;
+
+pub struct OmpBackend;
+
+impl AcpBackend for OmpBackend {
+    fn id(&self) -> &'static str {
+        "omp"
+    }
+
+    fn spawn_argv(&self, command: &str) -> (String, Vec<String>) {
+        (command.to_string(), vec!["acp".into()])
+    }
+
+    fn client_capabilities(&self) -> Value {
+        // fs/terminal off — agent runs tools locally in the worktree.
+        // requestPermission on so bash/edit gates surface to Weft Ask.
+        json!({
+            "fs": {
+                "readTextFile": false,
+                "writeTextFile": false,
+            },
+            "session": {
+                "requestPermission": true,
+            },
+        })
+    }
+
+    fn supports_fork(&self) -> bool {
+        // Full-history fork only; cut-before rewind uses jsonl rewrite + load.
+        true
+    }
+}