@mrciphersmith/keryx 0.2.153 → 0.2.154

package/dist/cli.js

@@ -51578,7 +51578,7 @@ import path47 from "path";
 // package.json
 var package_default = {
   name: "@mrciphersmith/keryx",
-  version: "0.2.153",
+  version: "0.2.154",
   description: "Version-controlled project context for AI coding agents: code graph, architecture wiki, project memory, relevant tests, quality signals, and task flows.",
   private: false,
   publishConfig: {
@@ -51623,7 +51623,7 @@ var package_default = {
     typecheck: "tsc --noEmit",
     "typecheck:scripts": "tsc --project tsconfig.scripts.json --noEmit",
     test: "bun test",
-    "test:core": "bun test src/cli src/core src/shell-source-audits.test.ts src/assets/ src/capability/ src/commands/ src/contracts/ src/ctx/ src/eval/ src/flow/ src/forgetting/ src/gdgraph/ src/gdskills/ src/health/ src/job/ src/lib/ src/mcp/ src/memory/ src/metrics/ src/retention/ src/review/ src/sac/ src/security/ src/standard/ src/sync/ src/testing/ src/wiki/",
+    "test:core": "bun test src/cli src/core src/shell-source-audits.test.ts src/acp/ src/assets/ src/capability/ src/commands/ src/contracts/ src/ctx/ src/eval/ src/flow/ src/forgetting/ src/gdgraph/ src/gdskills/ src/health/ src/job/ src/lib/ src/mcp/ src/memory/ src/metrics/ src/retention/ src/review/ src/sac/ src/security/ src/standard/ src/sync/ src/testing/ src/trigger/ src/wiki/",
     "test:client:terminal": "bun test src/tui/ src/commands/shell",
     "test:client:streaming": "bun test src/harness/provider/",
     "test:client:cancel-resume": "bun test src/harness/run/ src/harness/resume/ src/harness/session/ src/session/ src/bus/ src/commands/sessions",
@@ -73546,6 +73546,20 @@ var COMMAND_DESCRIPTORS = [
       "writes the memory provenance record"
     ]
   },
+  {
+    module: "trigger",
+    command: "trigger run",
+    summary: `Perform exactly one pass of a declared trigger's action (.metaproject/triggers.json). Only "reconcile" ` + '(-> sync --apply) and "rebuild" (-> gdgraph build) run today; "open-flow"/"flow-next" refuse cleanly.',
+    intent: ["\u0437\u0430\u043F\u0443\u0441\u0442\u0438 \u0442\u0440\u0438\u0433\u0433\u0435\u0440", "run trigger", "fire trigger", "trigger run"],
+    args: [{ name: "<name>", type: "string", required: true, desc: "the trigger's name, as declared in .metaproject/triggers.json" }],
+    json: false,
+    read: false,
+    sideEffects: [
+      'reconcile: writes graph/wiki/memory via "keryx sync --apply"',
+      'rebuild: writes the code graph via "keryx gdgraph build"',
+      "briefly writes .metaproject/data/trigger/.run.lock while the action runs"
+    ]
+  },
   {
     module: "testing",
     command: "test analyze",
@@ -111598,12 +111612,1364 @@ Shell:
 `);
 }
 
-// src/commands/bus.ts
+// src/commands/acp.ts
+import { randomUUID as randomUUID37 } from "crypto";
+
+// src/acp/server.ts
+init_agent();
 import { randomUUID as randomUUID36 } from "crypto";
 
+// src/acp/agent-io.ts
+import { randomUUID as randomUUID35 } from "crypto";
+
+// src/acp/permission.ts
+var ACP_PERMISSION_OPTION_IDS = {
+  allowOnce: "allow_once",
+  allowAlways: "allow_always",
+  rejectOnce: "reject_once",
+  rejectAlways: "reject_always"
+};
+var OPTION_ALLOW_ONCE = Object.freeze({
+  optionId: ACP_PERMISSION_OPTION_IDS.allowOnce,
+  name: "Allow once",
+  kind: "allow_once"
+});
+var OPTION_ALLOW_ALWAYS = Object.freeze({
+  optionId: ACP_PERMISSION_OPTION_IDS.allowAlways,
+  name: "Always allow",
+  kind: "allow_always"
+});
+var OPTION_REJECT_ONCE = Object.freeze({
+  optionId: ACP_PERMISSION_OPTION_IDS.rejectOnce,
+  name: "Reject",
+  kind: "reject_once"
+});
+var OPTION_REJECT_ALWAYS = Object.freeze({
+  optionId: ACP_PERMISSION_OPTION_IDS.rejectAlways,
+  name: "Always reject",
+  kind: "reject_always"
+});
+function permissionIsEscalated(meta) {
+  return meta?.destructive === true || meta?.credentials === true || meta?.publishLease === true || meta?.untrustedOrigin === true;
+}
+function permissionOptionsFor(meta) {
+  return permissionIsEscalated(meta) ? [OPTION_ALLOW_ONCE, OPTION_REJECT_ONCE, OPTION_REJECT_ALWAYS] : [OPTION_ALLOW_ONCE, OPTION_ALLOW_ALWAYS, OPTION_REJECT_ONCE, OPTION_REJECT_ALWAYS];
+}
+function kindOf(optionId, options) {
+  return options.find((option) => option.optionId === optionId)?.kind;
+}
+function approvalFromPermissionResponse(response, options, fingerprint) {
+  const raw = response.outcome;
+  if (typeof raw !== "object" || raw === null) {
+    return false;
+  }
+  const outcome = raw;
+  if (outcome.outcome !== "selected") {
+    return false;
+  }
+  switch (kindOf(outcome.optionId, options)) {
+    case "allow_once":
+      return true;
+    case "allow_always":
+      return fingerprint === undefined ? true : { approved: true, fingerprint };
+    default:
+      return false;
+  }
+}
+
+// src/acp/jsonrpc.ts
+var JSONRPC_VERSION = "2.0";
+var JSON_RPC_ERROR_CODES = {
+  parseError: -32700,
+  invalidRequest: -32600,
+  methodNotFound: -32601,
+  invalidParams: -32602,
+  internalError: -32603,
+  requestCancelled: -32800,
+  authRequired: -32000,
+  resourceNotFound: -32002
+};
+
+class AcpError extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.name = "AcpError";
+    this.code = code;
+    this.data = data;
+  }
+  toErrorObject() {
+    return jsonRpcError(this.code, this.message, this.data);
+  }
+  static from(code, message, data) {
+    return new AcpError(code, message, data);
+  }
+}
+function jsonRpcError(code, message, data) {
+  return data === undefined ? { code, message } : { code, message, data };
+}
+function parseError(data) {
+  return jsonRpcError(JSON_RPC_ERROR_CODES.parseError, "Parse error", data);
+}
+function invalidRequest(data) {
+  return jsonRpcError(JSON_RPC_ERROR_CODES.invalidRequest, "Invalid request", data);
+}
+function methodNotFound(method, data) {
+  return jsonRpcError(JSON_RPC_ERROR_CODES.methodNotFound, `Method not found: ${method}`, data);
+}
+function invalidParams(message, data) {
+  return jsonRpcError(JSON_RPC_ERROR_CODES.invalidParams, message, data);
+}
+function internalError(message, data) {
+  return jsonRpcError(JSON_RPC_ERROR_CODES.internalError, message, data);
+}
+function successResponse(id, result) {
+  return { jsonrpc: JSONRPC_VERSION, id, result };
+}
+function errorResponse(id, error) {
+  return { jsonrpc: JSONRPC_VERSION, id, error };
+}
+function requestMessage(id, method, params) {
+  return params === undefined ? { jsonrpc: JSONRPC_VERSION, id, method } : { jsonrpc: JSONRPC_VERSION, id, method, params };
+}
+function notificationMessage(method, params) {
+  return params === undefined ? { jsonrpc: JSONRPC_VERSION, method } : { jsonrpc: JSONRPC_VERSION, method, params };
+}
+function isPlainObject10(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJsonRpcId(value) {
+  return value === null || typeof value === "string" || typeof value === "number";
+}
+function recoverId(value) {
+  if (!isPlainObject10(value)) {
+    return null;
+  }
+  const id = value["id"];
+  return isJsonRpcId(id) ? id : null;
+}
+function classifyJsonRpcMessage(value) {
+  if (!isPlainObject10(value)) {
+    return {
+      kind: "invalid",
+      id: null,
+      error: invalidRequest({ reason: "message is not a JSON object" })
+    };
+  }
+  if (value["jsonrpc"] !== JSONRPC_VERSION) {
+    return {
+      kind: "invalid",
+      id: recoverId(value),
+      error: invalidRequest({
+        reason: `jsonrpc must be "${JSONRPC_VERSION}"`,
+        received: value["jsonrpc"]
+      })
+    };
+  }
+  const hasMethod = "method" in value;
+  const hasResult = "result" in value;
+  const hasError = "error" in value;
+  if (hasMethod) {
+    const method = value["method"];
+    if (typeof method !== "string") {
+      return {
+        kind: "invalid",
+        id: recoverId(value),
+        error: invalidRequest({ reason: "method must be a string", received: method })
+      };
+    }
+    if (!("id" in value)) {
+      const notification = "params" in value ? { jsonrpc: JSONRPC_VERSION, method, params: value["params"] } : { jsonrpc: JSONRPC_VERSION, method };
+      return { kind: "notification", message: notification };
+    }
+    const id = value["id"];
+    if (!isJsonRpcId(id)) {
+      return {
+        kind: "invalid",
+        id: null,
+        error: invalidRequest({ reason: "id must be a string, number or null", received: id })
+      };
+    }
+    const request = "params" in value ? { jsonrpc: JSONRPC_VERSION, id, method, params: value["params"] } : { jsonrpc: JSONRPC_VERSION, id, method };
+    return { kind: "request", message: request };
+  }
+  if (hasResult || hasError) {
+    const id = value["id"];
+    if (!isJsonRpcId(id)) {
+      return {
+        kind: "invalid",
+        id: null,
+        error: invalidRequest({ reason: "response id must be a string, number or null" })
+      };
+    }
+    if (hasError) {
+      const raw = value["error"];
+      const code = isPlainObject10(raw) ? raw["code"] : undefined;
+      const message = isPlainObject10(raw) ? raw["message"] : undefined;
+      if (typeof code !== "number" || typeof message !== "string") {
+        return {
+          kind: "invalid",
+          id,
+          error: invalidRequest({ reason: "error must carry a numeric code and a string message" })
+        };
+      }
+      const data = isPlainObject10(raw) ? raw["data"] : undefined;
+      return { kind: "response", message: errorResponse(id, jsonRpcError(code, message, data)) };
+    }
+    return { kind: "response", message: successResponse(id, value["result"]) };
+  }
+  return {
+    kind: "invalid",
+    id: recoverId(value),
+    error: invalidRequest({ reason: "message carries neither method, result nor error" })
+  };
+}
+
+// src/acp/protocol.ts
+var ACP_PROTOCOL_VERSION = 1;
+var ACP_SUPPORTED_PROTOCOL_VERSIONS = [ACP_PROTOCOL_VERSION];
+var ACP_AGENT_METHODS = {
+  initialize: "initialize",
+  authenticate: "authenticate",
+  logout: "logout",
+  sessionNew: "session/new",
+  sessionLoad: "session/load",
+  sessionResume: "session/resume",
+  sessionPrompt: "session/prompt",
+  sessionCancel: "session/cancel",
+  sessionClose: "session/close",
+  sessionDelete: "session/delete",
+  sessionList: "session/list",
+  sessionSetMode: "session/set_mode",
+  sessionSetConfigOption: "session/set_config_option"
+};
+var ACP_CLIENT_METHODS = {
+  fsReadTextFile: "fs/read_text_file",
+  fsWriteTextFile: "fs/write_text_file",
+  sessionRequestPermission: "session/request_permission",
+  sessionUpdate: "session/update",
+  elicitationCreate: "elicitation/create",
+  elicitationComplete: "elicitation/complete",
+  terminalCreate: "terminal/create",
+  terminalOutput: "terminal/output",
+  terminalKill: "terminal/kill",
+  terminalRelease: "terminal/release",
+  terminalWaitForExit: "terminal/wait_for_exit"
+};
+var ACP_IMPLEMENTED_AGENT_METHODS = [
+  ACP_AGENT_METHODS.initialize,
+  ACP_AGENT_METHODS.sessionNew,
+  ACP_AGENT_METHODS.sessionLoad,
+  ACP_AGENT_METHODS.sessionList,
+  ACP_AGENT_METHODS.sessionPrompt,
+  ACP_AGENT_METHODS.sessionCancel
+];
+var ACP_REFUSED_AGENT_METHODS = new Map([
+  [
+    ACP_AGENT_METHODS.authenticate,
+    {
+      code: JSON_RPC_ERROR_CODES.methodNotFound,
+      reason: "keryx advertises no authMethods; there is nothing to authenticate against"
+    }
+  ],
+  [
+    ACP_AGENT_METHODS.logout,
+    {
+      code: JSON_RPC_ERROR_CODES.methodNotFound,
+      reason: "keryx does not advertise agentCapabilities.auth.logout"
+    }
+  ],
+  [
+    ACP_AGENT_METHODS.sessionResume,
+    {
+      code: JSON_RPC_ERROR_CODES.methodNotFound,
+      reason: "keryx does not advertise sessionCapabilities.resume; use session/load, which replays history"
+    }
+  ],
+  [
+    ACP_AGENT_METHODS.sessionClose,
+    {
+      code: JSON_RPC_ERROR_CODES.methodNotFound,
+      reason: "keryx does not advertise sessionCapabilities.close; sessions are durable on disk"
+    }
+  ],
+  [
+    ACP_AGENT_METHODS.sessionDelete,
+    {
+      code: JSON_RPC_ERROR_CODES.methodNotFound,
+      reason: "keryx does not advertise sessionCapabilities.delete; session retention is an operator decision, not a client one"
+    }
+  ],
+  [
+    ACP_AGENT_METHODS.sessionSetMode,
+    {
+      code: JSON_RPC_ERROR_CODES.methodNotFound,
+      reason: "keryx returns no modes from session/new, so there is no mode to set"
+    }
+  ],
+  [
+    ACP_AGENT_METHODS.sessionSetConfigOption,
+    {
+      code: JSON_RPC_ERROR_CODES.methodNotFound,
+      reason: "keryx returns no configOptions from session/new, so there is no option to set"
+    }
+  ]
+]);
+function refusalError(method) {
+  const refusal = ACP_REFUSED_AGENT_METHODS.get(method);
+  if (refusal === undefined) {
+    return;
+  }
+  return methodNotFound(method, {
+    reason: refusal.reason,
+    protocolVersion: ACP_PROTOCOL_VERSION,
+    implemented: ACP_IMPLEMENTED_AGENT_METHODS
+  });
+}
+function unsupportedVersionError(requested, reason) {
+  return invalidParams(`Unsupported ACP protocol version: ${reason}`, {
+    requested,
+    supported: ACP_SUPPORTED_PROTOCOL_VERSIONS,
+    latest: ACP_PROTOCOL_VERSION
+  });
+}
+function negotiateProtocolVersion(requested) {
+  if (typeof requested !== "number" || !Number.isInteger(requested)) {
+    return {
+      kind: "refuse",
+      error: unsupportedVersionError(requested, "protocolVersion must be an integer")
+    };
+  }
+  if (requested < 0 || requested > 65535) {
+    return {
+      kind: "refuse",
+      error: unsupportedVersionError(requested, "protocolVersion is outside the uint16 range")
+    };
+  }
+  if (ACP_SUPPORTED_PROTOCOL_VERSIONS.includes(requested)) {
+    return { kind: "exact", version: requested };
+  }
+  if (requested > ACP_PROTOCOL_VERSION) {
+    return { kind: "offer", version: ACP_PROTOCOL_VERSION, requested };
+  }
+  return {
+    kind: "refuse",
+    error: unsupportedVersionError(requested, `keryx serves ${ACP_SUPPORTED_PROTOCOL_VERSIONS.join(", ")} and cannot speak anything older`)
+  };
+}
+function textBlock(text) {
+  return { type: "text", text };
+}
+var KERYX_AGENT_CAPABILITIES = Object.freeze({
+  loadSession: true,
+  promptCapabilities: Object.freeze({ image: false, audio: false, embeddedContext: true }),
+  mcpCapabilities: Object.freeze({ http: false, sse: false }),
+  sessionCapabilities: Object.freeze({ list: Object.freeze({}) }),
+  auth: Object.freeze({})
+});
+var KERYX_AUTH_METHODS = Object.freeze([]);
+function requireObjectParams(params, method) {
+  if (typeof params !== "object" || params === null || Array.isArray(params)) {
+    const error = invalidParams(`${method}: params must be an object`, { received: params });
+    throw new AcpError(error.code, error.message, error.data);
+  }
+  return params;
+}
+function requireStringField(params, field, method) {
+  const value = params[field];
+  if (typeof value !== "string" || value === "") {
+    const error = invalidParams(`${method}: ${field} must be a non-empty string`, {
+      field,
+      received: value
+    });
+    throw new AcpError(error.code, error.message, error.data);
+  }
+  return value;
+}
+
+// src/acp/agent-io.ts
+var TOOL_KIND_BY_NAME = {
+  get_cwd: "read",
+  list_dir: "read",
+  read_file: "read",
+  search_code: "search",
+  apply_patch: "edit",
+  shell_exec: "execute",
+  web_fetch: "fetch",
+  web_search: "search"
+};
+function toolKindFor(name) {
+  return TOOL_KIND_BY_NAME[name] ?? "other";
+}
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function createAcpAgentIo(sessionId, send, askPermission) {
+  const pendingByName = new Map;
+  const emit = (update) => send(sessionId, update);
+  const openToolCall = (name, input, claimed) => {
+    const toolCallId = randomUUID35();
+    const queue = pendingByName.get(name) ?? [];
+    queue.push({ toolCallId, input, claimed });
+    pendingByName.set(name, queue);
+    emit({
+      sessionUpdate: "tool_call",
+      toolCallId,
+      title: name,
+      name,
+      kind: toolKindFor(name),
+      status: "in_progress",
+      rawInput: tryParseJson(input)
+    });
+    return toolCallId;
+  };
+  const requestApproval = async (tool, input, meta) => {
+    if (askPermission === undefined) {
+      return false;
+    }
+    const pending = pendingByName.get(tool)?.find((entry) => entry.input === input);
+    const toolCallId = pending?.toolCallId ?? openToolCall(tool, input, false);
+    const options = permissionOptionsFor(meta);
+    const response = await askPermission({
+      toolCall: {
+        toolCallId,
+        title: tool,
+        name: tool,
+        kind: toolKindFor(tool),
+        status: "pending",
+        rawInput: tryParseJson(input)
+      },
+      options
+    });
+    if (response === undefined) {
+      return false;
+    }
+    return approvalFromPermissionResponse(response, options, meta?.fingerprint);
+  };
+  return {
+    ...askPermission !== undefined ? { requestApproval } : {},
+    write: (text) => {
+      if (text.length === 0) {
+        return;
+      }
+      emit({ sessionUpdate: "agent_message_chunk", content: textBlock(text) });
+    },
+    onReasoningDelta: (delta) => {
+      if (delta.redacted === true || delta.text === undefined || delta.text.length === 0) {
+        return;
+      }
+      emit({ sessionUpdate: "agent_thought_chunk", content: textBlock(delta.text) });
+    },
+    onToolCall: (name, input) => {
+      const announcedAhead = pendingByName.get(name)?.find((entry) => !entry.claimed && entry.input === input);
+      if (announcedAhead !== undefined) {
+        announcedAhead.claimed = true;
+        return;
+      }
+      openToolCall(name, input, true);
+    },
+    onToolResult: (name, result) => {
+      const queue = pendingByName.get(name);
+      const index = queue?.findIndex((entry) => entry.claimed) ?? -1;
+      const pending = queue?.splice(index >= 0 ? index : 0, 1)[0];
+      const toolCallId = pending?.toolCallId;
+      emit({
+        sessionUpdate: "tool_call_update",
+        toolCallId: toolCallId ?? randomUUID35(),
+        status: result.isError ? "failed" : "completed",
+        content: [{ type: "content", content: textBlock(result.output) }],
+        rawOutput: result.output
+      });
+    },
+    onSystem: (text) => {
+      if (text.length === 0) {
+        return;
+      }
+      emit({ sessionUpdate: "agent_message_chunk", content: textBlock(text) });
+    }
+  };
+}
+
+// src/acp/capability-tools.ts
+function acpAwareReadFileTool(base, root, clientCapabilities, readViaClient) {
+  if (clientCapabilities?.fs?.readTextFile !== true) {
+    return base;
+  }
+  return {
+    definition: base.definition,
+    invoke: async (input, ctx) => {
+      const requested = typeof input.path === "string" ? input.path : "";
+      if (requested.length === 0) {
+        return base.invoke(input, ctx);
+      }
+      const target = confineToRoot(root, requested);
+      if (target === null) {
+        return base.invoke(input, ctx);
+      }
+      const startLine = typeof input.start_line === "number" ? input.start_line : undefined;
+      const viaClient = await readViaClient(target, startLine);
+      if (viaClient !== undefined) {
+        return { output: viaClient, isError: false };
+      }
+      return base.invoke(input, ctx);
+    }
+  };
+}
+
+// src/acp/client-requests.ts
+class AcpClientRequests {
+  options;
+  pending = new Map;
+  closedReason;
+  constructor(options) {
+    this.options = options;
+  }
+  get pendingCount() {
+    return this.pending.size;
+  }
+  request(method, params, onId) {
+    if (this.closedReason !== undefined) {
+      return Promise.resolve({ kind: "closed", reason: this.closedReason });
+    }
+    const id = `acp-agent-${this.options.idSeq()}`;
+    onId?.(id);
+    return new Promise((resolve) => {
+      this.pending.set(id, resolve);
+      try {
+        this.options.send(requestMessage(id, method, params));
+      } catch (error) {
+        this.pending.delete(id);
+        resolve({
+          kind: "closed",
+          reason: `the request could not be written: ${error instanceof Error ? error.message : String(error)}`
+        });
+      }
+    });
+  }
+  cancel(id, reason) {
+    const settle = this.pending.get(id);
+    if (settle === undefined) {
+      return false;
+    }
+    this.pending.delete(id);
+    settle({ kind: "closed", reason });
+    return true;
+  }
+  resolve(message) {
+    const key = idKey(message.id);
+    if (key === undefined) {
+      return false;
+    }
+    const settle = this.pending.get(key);
+    if (settle === undefined) {
+      return false;
+    }
+    this.pending.delete(key);
+    if ("error" in message) {
+      settle({ kind: "error", error: message.error });
+      return true;
+    }
+    settle({ kind: "result", result: message.result });
+    return true;
+  }
+  close(reason) {
+    this.closedReason ??= reason;
+    const outstanding = [...this.pending.values()];
+    this.pending.clear();
+    for (const settle of outstanding) {
+      settle({ kind: "closed", reason });
+    }
+  }
+}
+function idKey(id) {
+  if (typeof id === "string") {
+    return id;
+  }
+  if (typeof id === "number") {
+    return String(id);
+  }
+  return;
+}
+
+// src/acp/framing.ts
+var ACP_MESSAGE_DELIMITER = `
+`;
+var ACP_DEFAULT_MAX_LINE_BYTES = 64 * 1024 * 1024;
+
+class AcpFramingError extends Error {
+  bufferedBytes;
+  constructor(message, bufferedBytes) {
+    super(message);
+    this.name = "AcpFramingError";
+    this.bufferedBytes = bufferedBytes;
+  }
+}
+function encodeAcpMessage(message) {
+  const json = JSON.stringify(message);
+  if (json === undefined) {
+    throw new AcpFramingError("message is not JSON-serialisable", 0);
+  }
+  if (json.includes(`
+`) || json.includes("\r")) {
+    throw new AcpFramingError("encoded message contains an embedded newline", json.length);
+  }
+  return `${json}${ACP_MESSAGE_DELIMITER}`;
+}
+
+class AcpLineFramer {
+  buffer = "";
+  decoder = new TextDecoder("utf-8");
+  maxLineBytes;
+  constructor(options = {}) {
+    this.maxLineBytes = options.maxLineBytes ?? ACP_DEFAULT_MAX_LINE_BYTES;
+  }
+  get buffered() {
+    return this.buffer.length;
+  }
+  push(chunk) {
+    const text = typeof chunk === "string" ? chunk : this.decoder.decode(chunk, { stream: true });
+    if (text === "") {
+      this.assertWithinLimit();
+      return [];
+    }
+    this.buffer += text;
+    const parts = this.buffer.split(ACP_MESSAGE_DELIMITER);
+    this.buffer = parts.pop() ?? "";
+    this.assertWithinLimit();
+    const lines = [];
+    for (const part of parts) {
+      const line = normaliseLine(part);
+      if (line !== "") {
+        lines.push(line);
+      }
+    }
+    return lines;
+  }
+  flush() {
+    this.buffer += this.decoder.decode();
+    const line = normaliseLine(this.buffer);
+    this.buffer = "";
+    return line === "" ? [] : [line];
+  }
+  assertWithinLimit() {
+    if (this.buffer.length > this.maxLineBytes) {
+      const buffered = this.buffer.length;
+      this.buffer = "";
+      throw new AcpFramingError(`no message delimiter within ${this.maxLineBytes} bytes; dropped the buffer`, buffered);
+    }
+  }
+}
+function normaliseLine(part) {
+  return part.replace(/\r$/, "").trim();
+}
+function decodeAcpLine(line) {
+  try {
+    return { ok: true, value: JSON.parse(line) };
+  } catch (error) {
+    return {
+      ok: false,
+      error: parseError({
+        reason: error instanceof Error ? error.message : String(error)
+      })
+    };
+  }
+}
+
+// src/acp/dispatch.ts
+class AcpDispatcher {
+  requests = new Map;
+  notifications = new Map;
+  options;
+  constructor(handlers = {}, options = {}) {
+    for (const [method, handler] of Object.entries(handlers.requests ?? {})) {
+      this.requests.set(method, handler);
+    }
+    for (const [method, handler] of Object.entries(handlers.notifications ?? {})) {
+      this.notifications.set(method, handler);
+    }
+    this.options = options;
+  }
+  onRequest(method, handler) {
+    this.requests.set(method, handler);
+    return this;
+  }
+  onNotification(method, handler) {
+    this.notifications.set(method, handler);
+    return this;
+  }
+  registeredRequestMethods() {
+    return [...this.requests.keys()].sort();
+  }
+  registeredNotificationMethods() {
+    return [...this.notifications.keys()].sort();
+  }
+  async handleLine(line) {
+    const decoded = decodeAcpLine(line);
+    if (!decoded.ok) {
+      return { kind: "reply", message: errorResponse(null, decoded.error) };
+    }
+    return this.handleMessage(decoded.value);
+  }
+  async handleMessage(value) {
+    const classified = classifyJsonRpcMessage(value);
+    switch (classified.kind) {
+      case "invalid":
+        return { kind: "reply", message: errorResponse(classified.id, classified.error) };
+      case "response":
+        return { kind: "incoming-response", message: classified.message };
+      case "notification":
+        await this.handleNotification(classified.message);
+        return { kind: "none" };
+      case "request":
+        return { kind: "reply", message: await this.handleRequest(classified.message) };
+    }
+  }
+  async handleRequest(message) {
+    const handler = this.requests.get(message.method);
+    if (handler === undefined) {
+      return errorResponse(message.id, this.unknownMethodError(message.method));
+    }
+    try {
+      const result = await handler(message.params, { method: message.method, id: message.id });
+      return successResponse(message.id, result === undefined ? {} : result);
+    } catch (error) {
+      this.options.onHandlerError?.(message.method, error);
+      if (error instanceof AcpError) {
+        return errorResponse(message.id, error.toErrorObject());
+      }
+      return errorResponse(message.id, internalError(error instanceof Error ? error.message : String(error), {
+        method: message.method
+      }));
+    }
+  }
+  async handleNotification(message) {
+    const handler = this.notifications.get(message.method);
+    if (handler === undefined) {
+      this.options.onUnhandledNotification?.(message.method, message.params);
+      return;
+    }
+    try {
+      await handler(message.params, { method: message.method });
+    } catch (error) {
+      this.options.onHandlerError?.(message.method, error);
+    }
+  }
+  unknownMethodError(method) {
+    return refusalError(method) ?? methodNotFound(method, {
+      protocolVersion: ACP_PROTOCOL_VERSION,
+      implemented: ACP_IMPLEMENTED_AGENT_METHODS
+    });
+  }
+}
+
+// src/acp/prompt-content.ts
+function isContentBlock(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function renderAcpPromptContent(blocks) {
+  const parts = [];
+  for (const block of blocks) {
+    if (!isContentBlock(block)) {
+      continue;
+    }
+    switch (block.type) {
+      case "text":
+        parts.push(block.text);
+        break;
+      case "resource": {
+        const resource = block.resource;
+        if ("text" in resource) {
+          parts.push(resource.text);
+        } else {
+          parts.push(`[embedded resource omitted (binary, ${resource.mimeType ?? "unknown type"}): ${resource.uri}]`);
+        }
+        break;
+      }
+      case "resource_link":
+        parts.push(`[resource link: ${block.uri}]`);
+        break;
+      case "image":
+        parts.push("[image content omitted \u2014 keryx does not accept image prompt input (promptCapabilities.image: false)]");
+        break;
+      case "audio":
+        parts.push("[audio content omitted \u2014 keryx does not accept audio prompt input (promptCapabilities.audio: false)]");
+        break;
+      default:
+        break;
+    }
+  }
+  return parts.join(`
+
+`);
+}
+
+// src/acp/session.ts
+class AcpSessionTranscriptUnreadableError extends Error {
+  sessionId;
+  cause;
+  constructor(sessionId, cause) {
+    super(`session ${sessionId}: ${cause.message}`);
+    this.sessionId = sessionId;
+    this.cause = cause;
+    this.name = "AcpSessionTranscriptUnreadableError";
+  }
+}
+
+class AcpSessionRegistry {
+  options;
+  sessions = new Map;
+  constructor(options) {
+    this.options = options;
+  }
+  create(cwd, clientCapabilities) {
+    const resolvedRoot = resolveProjectRoot2(cwd);
+    const handle = createSession({
+      cwd: resolvedRoot,
+      provider: this.options.providerId,
+      model: this.options.modelId,
+      ...this.options.dataDir !== undefined ? { dataDir: this.options.dataDir } : {}
+    });
+    const state = {
+      sessionId: handle.summary.id,
+      requestedCwd: cwd,
+      resolvedRoot,
+      handle,
+      history: [],
+      clientCapabilities
+    };
+    this.sessions.set(state.sessionId, state);
+    return state;
+  }
+  get(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  load(sessionId, cwd, clientCapabilities) {
+    const resolvedRoot = resolveProjectRoot2(cwd);
+    const known = listSessions(cwd, this.options.dataDir).some((summary) => summary.id === sessionId);
+    if (!known) {
+      return;
+    }
+    let opened;
+    try {
+      opened = openSession({
+        cwd,
+        resumeId: sessionId,
+        ...this.options.dataDir !== undefined ? { dataDir: this.options.dataDir } : {},
+        provider: this.options.providerId,
+        model: this.options.modelId
+      });
+    } catch (cause) {
+      if (cause instanceof TranscriptUnreadableError) {
+        throw new AcpSessionTranscriptUnreadableError(sessionId, cause);
+      }
+      throw cause;
+    }
+    const state = {
+      sessionId: opened.handle.summary.id,
+      requestedCwd: cwd,
+      resolvedRoot,
+      handle: opened.handle,
+      history: opened.history,
+      clientCapabilities
+    };
+    this.sessions.set(state.sessionId, state);
+    return state;
+  }
+  updateHandle(sessionId, handle) {
+    const state = this.sessions.get(sessionId);
+    if (state === undefined) {
+      return;
+    }
+    this.sessions.set(sessionId, { ...state, handle });
+  }
+}
+
+// src/acp/server.ts
+var DEFAULT_AGENT_INFO = { name: "keryx", version: "0" };
+function finishReasonToStopReason(finishReason) {
+  switch (finishReason) {
+    case "budget":
+      return "max_tokens";
+    case "tool-call-budget":
+      return "max_turn_requests";
+    case "no-progress":
+    case undefined:
+      return "end_turn";
+  }
+}
+function refuse3(error) {
+  throw new AcpError(error.code, error.message, error.data);
+}
+async function runAcpServer(options) {
+  let initialized = false;
+  let clientCapabilities;
+  const idSeq = options.idSeq ?? (() => randomUUID36());
+  const registry = new AcpSessionRegistry({
+    providerId: options.providerId,
+    modelId: options.modelId,
+    ...options.dataDir !== undefined ? { dataDir: options.dataDir } : {}
+  });
+  const writeMessage = (message) => {
+    options.write(encodeAcpMessage(message));
+  };
+  const sendUpdate = (sessionId, update) => {
+    const notification = { sessionId, update };
+    writeMessage(notificationMessage(ACP_CLIENT_METHODS.sessionUpdate, notification));
+  };
+  const clientRequests = new AcpClientRequests({
+    send: (message) => {
+      options.write(encodeAcpMessage(message));
+    },
+    idSeq
+  });
+  let clientAnswersPermissions = true;
+  const activeTurns = new Map;
+  function refuseIfBusy(method, sessionId) {
+    if (!activeTurns.has(sessionId)) {
+      return;
+    }
+    refuse3(invalidRequest({
+      reason: `${method}: a turn is already running for session ${sessionId}; ` + "wait for its session/prompt response \u2014 send session/cancel first if you do not want to wait for it to finish, " + "then prompt again once the cancelled turn has replied",
+      method,
+      sessionId,
+      condition: "session-busy"
+    }));
+  }
+  const askPermissionFor = (sessionId, turn) => {
+    return async (ask) => {
+      if (!clientAnswersPermissions) {
+        options.logError(`acp: ${ACP_CLIENT_METHODS.sessionRequestPermission} not asked for ${ask.toolCall.name ?? "a tool call"}: ` + "this client already refused the method; the call is denied");
+        return;
+      }
+      const params = {
+        sessionId,
+        toolCall: ask.toolCall,
+        options: [...ask.options]
+      };
+      let requestId;
+      const outcome = await clientRequests.request(ACP_CLIENT_METHODS.sessionRequestPermission, params, (id) => {
+        requestId = id;
+        turn.permissionRequestIds.add(id);
+      });
+      if (requestId !== undefined) {
+        turn.permissionRequestIds.delete(requestId);
+      }
+      if (outcome.kind === "error") {
+        clientAnswersPermissions = false;
+        options.logError(`acp: ${ACP_CLIENT_METHODS.sessionRequestPermission} refused by the client ` + `(${outcome.error.code}: ${outcome.error.message}); the call is denied`);
+        return;
+      }
+      if (outcome.kind === "closed") {
+        options.logError(`acp: ${ACP_CLIENT_METHODS.sessionRequestPermission} went unanswered (${outcome.reason}); the call is denied`);
+        return;
+      }
+      const result = outcome.result;
+      if (typeof result !== "object" || result === null || Array.isArray(result)) {
+        options.logError(`acp: ${ACP_CLIENT_METHODS.sessionRequestPermission} answered with a non-object result; the call is denied`);
+        return;
+      }
+      return result;
+    };
+  };
+  function requireInitialized(method) {
+    if (!initialized) {
+      refuse3(invalidRequest({ reason: `${method}: call initialize before any other request`, method }));
+    }
+  }
+  function handleInitialize(params) {
+    const obj = requireObjectParams(params, ACP_AGENT_METHODS.initialize);
+    const negotiation = negotiateProtocolVersion(obj["protocolVersion"]);
+    if (negotiation.kind === "refuse") {
+      refuse3(negotiation.error);
+    }
+    initialized = true;
+    const rawCaps = obj["clientCapabilities"];
+    clientCapabilities = typeof rawCaps === "object" && rawCaps !== null && !Array.isArray(rawCaps) ? rawCaps : undefined;
+    return {
+      protocolVersion: negotiation.version,
+      agentCapabilities: KERYX_AGENT_CAPABILITIES,
+      authMethods: KERYX_AUTH_METHODS,
+      agentInfo: options.agentInfo ?? DEFAULT_AGENT_INFO
+    };
+  }
+  function handleSessionNew(params) {
+    requireInitialized(ACP_AGENT_METHODS.sessionNew);
+    const obj = requireObjectParams(params, ACP_AGENT_METHODS.sessionNew);
+    const cwd = requireStringField(obj, "cwd", ACP_AGENT_METHODS.sessionNew);
+    const mcpServers = obj["mcpServers"];
+    if (mcpServers !== undefined && !Array.isArray(mcpServers)) {
+      refuse3(invalidParams(`${ACP_AGENT_METHODS.sessionNew}: mcpServers must be an array`, { received: mcpServers }));
+    }
+    if (Array.isArray(mcpServers) && mcpServers.length > 0) {
+      refuse3(invalidParams(`${ACP_AGENT_METHODS.sessionNew}: keryx has no in-memory MCP server registration seam for a single ` + "session; configure servers with `keryx mcp`/`keryx integrate` (project-wide) and omit mcpServers, " + "or send an empty list", { requestedServers: mcpServers.length }));
+    }
+    const state = registry.create(cwd, clientCapabilities);
+    return { sessionId: state.sessionId };
+  }
+  async function handleSessionPrompt(params) {
+    requireInitialized(ACP_AGENT_METHODS.sessionPrompt);
+    const obj = requireObjectParams(params, ACP_AGENT_METHODS.sessionPrompt);
+    const sessionId = requireStringField(obj, "sessionId", ACP_AGENT_METHODS.sessionPrompt);
+    const promptField = obj["prompt"];
+    if (!Array.isArray(promptField)) {
+      refuse3(invalidParams(`${ACP_AGENT_METHODS.sessionPrompt}: prompt must be an array of content blocks`, {
+        received: promptField
+      }));
+    }
+    const state = registry.get(sessionId);
+    if (state === undefined) {
+      refuse3({
+        code: JSON_RPC_ERROR_CODES.resourceNotFound,
+        message: `Unknown ACP session: ${sessionId}`,
+        data: { sessionId }
+      });
+    }
+    refuseIfBusy(ACP_AGENT_METHODS.sessionPrompt, sessionId);
+    const userLine = renderAcpPromptContent(promptField);
+    const readViaClient = async (path, line) => {
+      const params = {
+        sessionId,
+        path,
+        ...line !== undefined ? { line } : {}
+      };
+      const outcome = await clientRequests.request(ACP_CLIENT_METHODS.fsReadTextFile, params);
+      if (outcome.kind !== "result") {
+        return;
+      }
+      const result = outcome.result;
+      if (typeof result !== "object" || result === null) {
+        return;
+      }
+      const content = result.content;
+      return typeof content === "string" ? content : undefined;
+    };
+    const tools = [
+      ...builtinReadOnlyTools(state.resolvedRoot).map((tool) => tool.definition.name === "read_file" ? acpAwareReadFileTool(tool, state.resolvedRoot, state.clientCapabilities, readViaClient) : tool),
+      shellExecTool(state.resolvedRoot),
+      applyPatchTool(state.resolvedRoot)
+    ];
+    const toolNames = tools.map((tool) => tool.definition.name);
+    const deps = {
+      provider: options.provider,
+      providerId: options.providerId,
+      modelId: options.modelId,
+      tools,
+      systemInstruction: buildAgentSystemInstruction(undefined, {
+        providerId: options.providerId,
+        modelId: options.modelId,
+        toolNames
+      }),
+      idSeq
+    };
+    const turn = {
+      controller: new AbortController,
+      cancelled: false,
+      permissionRequestIds: new Set
+    };
+    activeTurns.set(sessionId, turn);
+    try {
+      const io = createAcpAgentIo(sessionId, sendUpdate, askPermissionFor(sessionId, turn));
+      const result = await runAgentTurn(io, deps, state.history, userLine, { signal: turn.controller.signal });
+      const updatedHandle = persistHistory(state.handle, state.history, {
+        provider: options.providerId,
+        model: options.modelId
+      });
+      registry.updateHandle(sessionId, updatedHandle);
+      return { stopReason: turn.cancelled ? "cancelled" : finishReasonToStopReason(result.finishReason) };
+    } finally {
+      if (activeTurns.get(sessionId) === turn) {
+        activeTurns.delete(sessionId);
+      }
+    }
+  }
+  function handleSessionCancel(params) {
+    const obj = requireObjectParams(params, ACP_AGENT_METHODS.sessionCancel);
+    const sessionId = requireStringField(obj, "sessionId", ACP_AGENT_METHODS.sessionCancel);
+    const turn = activeTurns.get(sessionId);
+    if (turn === undefined) {
+      options.logError(`acp: ${ACP_AGENT_METHODS.sessionCancel} for ${sessionId}: no turn is currently running for this session`);
+      return;
+    }
+    turn.cancelled = true;
+    turn.controller.abort();
+    for (const requestId of turn.permissionRequestIds) {
+      clientRequests.cancel(requestId, "the turn was cancelled by session/cancel");
+    }
+    turn.permissionRequestIds.clear();
+  }
+  function handleSessionList(params) {
+    requireInitialized(ACP_AGENT_METHODS.sessionList);
+    const obj = requireObjectParams(params, ACP_AGENT_METHODS.sessionList);
+    const rawCwd = obj["cwd"];
+    if (rawCwd !== undefined && rawCwd !== null && typeof rawCwd !== "string") {
+      refuse3(invalidParams(`${ACP_AGENT_METHODS.sessionList}: cwd must be a string, null or omitted`, { received: rawCwd }));
+    }
+    const cwd = typeof rawCwd === "string" && rawCwd.length > 0 ? rawCwd : process.cwd();
+    const summaries = listSessions(cwd, options.dataDir);
+    const sessions = summaries.map((summary) => ({
+      sessionId: summary.id,
+      cwd: summary.projectPath,
+      title: summary.title,
+      updatedAt: summary.updatedAt
+    }));
+    return { sessions };
+  }
+  function replayHistory(sessionId, history) {
+    for (const message of history) {
+      if (message.role === "system") {
+        continue;
+      }
+      if (message.role === "user") {
+        if (message.content.length > 0) {
+          sendUpdate(sessionId, { sessionUpdate: "user_message_chunk", content: textBlock(message.content) });
+        }
+        continue;
+      }
+      if (message.role === "assistant") {
+        if (message.content.length > 0) {
+          sendUpdate(sessionId, { sessionUpdate: "agent_message_chunk", content: textBlock(message.content) });
+        }
+        for (const call of message.toolCalls ?? []) {
+          sendUpdate(sessionId, {
+            sessionUpdate: "tool_call",
+            toolCallId: call.id,
+            title: call.name,
+            name: call.name,
+            kind: toolKindFor(call.name),
+            status: "pending",
+            rawInput: tryParseJson(call.arguments)
+          });
+        }
+        continue;
+      }
+      const toolCallId = message.toolCallId ?? randomUUID36();
+      sendUpdate(sessionId, {
+        sessionUpdate: "tool_call_update",
+        toolCallId,
+        status: "completed",
+        content: [{ type: "content", content: textBlock(message.content) }],
+        rawOutput: message.content
+      });
+    }
+  }
+  function handleSessionLoad(params) {
+    requireInitialized(ACP_AGENT_METHODS.sessionLoad);
+    const obj = requireObjectParams(params, ACP_AGENT_METHODS.sessionLoad);
+    const sessionId = requireStringField(obj, "sessionId", ACP_AGENT_METHODS.sessionLoad);
+    const cwd = requireStringField(obj, "cwd", ACP_AGENT_METHODS.sessionLoad);
+    const mcpServers = obj["mcpServers"];
+    if (mcpServers !== undefined && !Array.isArray(mcpServers)) {
+      refuse3(invalidParams(`${ACP_AGENT_METHODS.sessionLoad}: mcpServers must be an array`, { received: mcpServers }));
+    }
+    if (Array.isArray(mcpServers) && mcpServers.length > 0) {
+      refuse3(invalidParams(`${ACP_AGENT_METHODS.sessionLoad}: keryx has no in-memory MCP server registration seam for a single ` + "session; configure servers with `keryx mcp`/`keryx integrate` (project-wide) and omit mcpServers, " + "or send an empty list", { requestedServers: mcpServers.length }));
+    }
+    refuseIfBusy(ACP_AGENT_METHODS.sessionLoad, sessionId);
+    let state;
+    try {
+      state = registry.load(sessionId, cwd, clientCapabilities);
+    } catch (cause) {
+      if (!(cause instanceof AcpSessionTranscriptUnreadableError)) {
+        throw cause;
+      }
+      refuse3({
+        code: JSON_RPC_ERROR_CODES.internalError,
+        message: `Cannot load session ${sessionId}: ${cause.cause.message}`,
+        data: { sessionId, cwd, file: cause.cause.file, reason: cause.cause.reason }
+      });
+    }
+    if (state === undefined) {
+      refuse3({
+        code: JSON_RPC_ERROR_CODES.resourceNotFound,
+        message: `Unknown ACP session: ${sessionId}`,
+        data: { sessionId, cwd }
+      });
+    }
+    replayHistory(sessionId, state.history);
+    return {};
+  }
+  const dispatcher = new AcpDispatcher({
+    requests: {
+      [ACP_AGENT_METHODS.initialize]: (params) => handleInitialize(params),
+      [ACP_AGENT_METHODS.sessionNew]: (params) => handleSessionNew(params),
+      [ACP_AGENT_METHODS.sessionPrompt]: (params) => handleSessionPrompt(params),
+      [ACP_AGENT_METHODS.sessionList]: (params) => handleSessionList(params),
+      [ACP_AGENT_METHODS.sessionLoad]: (params) => handleSessionLoad(params)
+    },
+    notifications: {
+      [ACP_AGENT_METHODS.sessionCancel]: (params) => handleSessionCancel(params)
+    }
+  }, {
+    onUnhandledNotification: (method) => options.logError(`acp: unhandled notification ${method}`),
+    onHandlerError: (method, error) => options.logError(`acp: ${method} failed: ${error instanceof Error ? error.message : String(error)}`)
+  });
+  const handleOutcome = (outcome) => {
+    if (outcome.kind === "reply") {
+      writeMessage(outcome.message);
+      return;
+    }
+    if (outcome.kind === "incoming-response") {
+      if (!clientRequests.resolve(outcome.message)) {
+        options.logError(`acp: unexpected response with no pending request: ${JSON.stringify(outcome.message)}`);
+      }
+    }
+  };
+  const inflight = new Set;
+  const dispatch = (line) => {
+    const task = dispatcher.handleLine(line).then(handleOutcome, (error) => {
+      options.logError(`acp: dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+    });
+    inflight.add(task);
+    task.finally(() => {
+      inflight.delete(task);
+    });
+  };
+  const framer = new AcpLineFramer;
+  for await (const chunk of options.input) {
+    let lines;
+    try {
+      lines = framer.push(chunk);
+    } catch (error) {
+      options.logError(`acp: framing error: ${error instanceof Error ? error.message : String(error)}`);
+      continue;
+    }
+    for (const line of lines) {
+      dispatch(line);
+    }
+  }
+  for (const line of framer.flush()) {
+    dispatch(line);
+  }
+  clientRequests.close("the client closed the connection before answering");
+  while (inflight.size > 0) {
+    await Promise.allSettled([...inflight]);
+  }
+}
+
+// src/acp/fixture-provider.ts
+import { readFileSync as readFileSync14 } from "fs";
+function loadAcpFixtureProvider(path) {
+  const raw = readFileSync14(path, "utf-8");
+  const parsed = JSON.parse(raw);
+  const turns = parsed.turns;
+  let call = 0;
+  const description = {
+    capabilities: {
+      streaming: true,
+      toolCalls: true,
+      parallelToolCalls: false,
+      structuredOutput: false,
+      reasoningMetadata: true,
+      promptCaching: false,
+      vision: false,
+      tokenCounting: false,
+      modelListing: false
+    },
+    descriptor: { providerId: "acp-fixture" }
+  };
+  return {
+    describe: () => description,
+    stream: (_request, opts) => {
+      const events = turns[call] ?? [];
+      call += 1;
+      return async function* () {
+        let sequence = 0;
+        for (const partial of events) {
+          yield { sequence: sequence++, attemptId: opts.attemptId, ...partial };
+        }
+      }();
+    }
+  };
+}
+
+// src/commands/acp.ts
+init_make_provider();
+function parseArgs3(args) {
+  let provider = "fake";
+  let model = "fake-model";
+  let baseUrl;
+  let fixture;
+  let dataDir;
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--provider") {
+      provider = args[i += 1] ?? provider;
+    } else if (arg === "--model") {
+      model = args[i += 1] ?? model;
+    } else if (arg === "--base-url") {
+      baseUrl = args[i += 1];
+    } else if (arg === "--fixture") {
+      fixture = args[i += 1];
+    } else if (arg === "--data-dir") {
+      dataDir = args[i += 1];
+    }
+  }
+  return {
+    provider,
+    model,
+    ...baseUrl !== undefined ? { baseUrl } : {},
+    ...fixture !== undefined ? { fixture } : {},
+    ...dataDir !== undefined ? { dataDir } : {}
+  };
+}
+async function acpCommand(args) {
+  if (args[0] === "help" || args.includes("--help") || args.includes("-h")) {
+    printHelp18();
+    return;
+  }
+  const parsed = parseArgs3(args);
+  const provider = parsed.fixture !== undefined ? loadAcpFixtureProvider(parsed.fixture) : makeProvider(parsed.provider, parsed.model, {
+    fetch,
+    env: process.env,
+    ...parsed.baseUrl !== undefined ? { baseUrl: parsed.baseUrl } : {}
+  });
+  await runAcpServer({
+    input: process.stdin,
+    write: (chunk) => {
+      process.stdout.write(chunk);
+    },
+    logError: (line) => {
+      process.stderr.write(`${line}
+`);
+    },
+    provider,
+    providerId: parsed.provider,
+    modelId: parsed.model,
+    agentInfo: { name: "keryx", version: package_default.version },
+    ...parsed.dataDir !== undefined ? { dataDir: parsed.dataDir } : {},
+    idSeq: () => randomUUID37()
+  });
+}
+function printHelp18() {
+  console.log(`keryx acp
+
+Speak the Agent Client Protocol (ACP) v1 over stdio: newline-delimited
+JSON-RPC 2.0 on stdin, the same framing on stdout. Launch this as a
+subprocess from an ACP client (an editor, e.g.) \u2014 it answers initialize,
+session/new, session/prompt (streaming session/update notifications as a
+turn runs rather than only at the end), session/cancel, session/list and
+session/load; every other agent method ACP defines is refused with -32601.
+A gated tool call is asked through session/request_permission \u2014 only an
+explicit allow runs it. Writes and shell execution always stay local; there
+is no fs/write_text_file or terminal/* call in this release. Nothing but
+protocol frames is ever written to stdout; every diagnostic goes to stderr.
+
+Usage:
+  keryx acp [--provider <p>] [--model <m>] [--base-url <url>] [--data-dir <dir>]
+`);
+}
+
+// src/commands/bus.ts
+import { randomUUID as randomUUID39 } from "crypto";
+
 // src/bus/prune.ts
 init_fs();
-import { randomUUID as randomUUID35 } from "crypto";
+import { randomUUID as randomUUID38 } from "crypto";
 var GONE_PRESENCE_RETENTION_MS = 24 * 60 * 60 * 1000;
 
 class LeaseStillActive extends Error {
@@ -111644,7 +113010,7 @@ async function pruneBus(root, options = {}) {
     const file = leasePath(root, lease.leaseId);
     try {
       await appendEvent(root, {
-        from: { instanceId: randomUUID35(), name: "system", origin: "system" },
+        from: { instanceId: randomUUID38(), name: "system", origin: "system" },
         to: ["*"],
         toLabel: "@all",
         kind: "lease-expired",
@@ -111838,7 +113204,7 @@ ${PAUSE_USAGE3}`);
   if (toLabel === undefined || reason === undefined || reason.length === 0) {
     throw new BusRefusal("invalid-event", PAUSE_USAGE3);
   }
-  const holder = { instanceId: randomUUID36(), name: "cli", origin: "cli" };
+  const holder = { instanceId: randomUUID39(), name: "cli", origin: "cli" };
   const lease = await createPauseLease(busRoot, {
     holder,
     toLabel,
@@ -111860,7 +113226,7 @@ async function resume(args, busRoot, ctx) {
   if (leaseId === undefined) {
     throw new BusRefusal("invalid-event", "usage: keryx bus resume <leaseId> [--json]");
   }
-  await resumePauseLease(busRoot, { leaseId, by: { instanceId: randomUUID36(), name: "cli", origin: "cli" }, now: ctx.now });
+  await resumePauseLease(busRoot, { leaseId, by: { instanceId: randomUUID39(), name: "cli", origin: "cli" }, now: ctx.now });
   if (args.includes("--json")) {
     ctx.out(JSON.stringify({ schemaVersion: 1, leaseId }, null, 2));
   } else {
@@ -112026,7 +113392,7 @@ function buildInitFlags(next, profile) {
 async function modulesCommand(args = []) {
   const sub = args[0];
   if (sub === "--help" || sub === "-h" || sub === "help") {
-    printHelp18();
+    printHelp19();
     return;
   }
   const wantsJson = args.includes("--json") && (sub === undefined || sub === "status" || sub === "list" || sub === "--json");
@@ -112083,7 +113449,7 @@ async function modulesCommand(args = []) {
       }
     }
   } else {
-    printHelp18();
+    printHelp19();
     process.exitCode = 1;
     return;
   }
@@ -112126,7 +113492,7 @@ function setsEqual(a, b) {
   }
   return true;
 }
-function printHelp18() {
+function printHelp19() {
   helpTitle("keryx modules", "view and toggle Metaproject modules");
   helpUsage([
     "keryx modules",
@@ -112145,12 +113511,12 @@ function printHelp18() {
 }
 
 // src/commands/serve.ts
-import { randomUUID as randomUUID39 } from "crypto";
+import { randomUUID as randomUUID42 } from "crypto";
 init_serve_config();
 
 // src/lib/serve-credential.ts
 init_config_dir();
-import { createHash as createHash44, randomBytes as randomBytes5, randomUUID as randomUUID37 } from "crypto";
+import { createHash as createHash44, randomBytes as randomBytes5, randomUUID as randomUUID40 } from "crypto";
 import {
   chmodSync as chmodSync5,
   closeSync as closeSync4,
@@ -112234,7 +113600,7 @@ function readServeCredential(dir) {
 }
 function writeStore(store, dir) {
   const file = serveCredentialPath(dir);
-  const temp = `${file}.${randomUUID37()}.tmp`;
+  const temp = `${file}.${randomUUID40()}.tmp`;
   try {
     ensureKeryxConfigDir(dir);
     const handle = openSync5(temp, "wx", 384);
@@ -112274,7 +113640,7 @@ function mintRecord(now) {
   const salt = randomBytes5(32).toString("hex");
   return {
     token,
-    record: { id: randomUUID37(), algorithm: "sha256", salt, hash: hashToken(salt, token), createdAt: now }
+    record: { id: randomUUID40(), algorithm: "sha256", salt, hash: hashToken(salt, token), createdAt: now }
   };
 }
 function issueServeToken(dir, now = () => new Date().toISOString(), onWaiting) {
@@ -112591,7 +113957,7 @@ function releaseIdempotencyKey(project, idempotencyKey, turnId, dir) {
 }
 
 // src/lib/serve-turn.ts
-import { randomUUID as randomUUID38 } from "crypto";
+import { randomUUID as randomUUID41 } from "crypto";
 import path203 from "path";
 init_service();
 var REMOTE_ORIGIN = "remote:http";
@@ -112710,7 +114076,7 @@ async function redactOut(security, text) {
 async function runRemoteTurn(input) {
   const scanRoot = input.scanRoot;
   const security = createSecurityService(scanRoot);
-  const newId = input.newId ?? (() => randomUUID38());
+  const newId = input.newId ?? (() => randomUUID41());
   const clock = input.clock ?? (() => new Date().toISOString());
   const turnId = input.turnId ?? newId();
   const sessionId = input.request.sessionId ?? newId();
@@ -112853,7 +114219,7 @@ function outcomeOf(status, gate, unresolvedBlockerIds) {
 }
 function createSubmitTurn(deps) {
   return async (request, project) => {
-    const turnId = (deps.newId ?? (() => randomUUID38()))();
+    const turnId = (deps.newId ?? (() => randomUUID41()))();
     const scanned = await scanPrompt(deps.dir, request.prompt);
     if (scanned.rejected) {
       return { kind: "rejected" };
@@ -112908,40 +114274,40 @@ function claimTurnKey(request, turnId, project, dir) {
 // src/lib/serve-server.ts
 init_serve_config();
 var MAX_TURN_BODY_BYTES = 128 * 1024;
-function refuse3(reason, message) {
+function refuse4(reason, message) {
   return { ok: false, state: "refused", reason, message };
 }
 function resolveServeStartup(input) {
   const { config, credential } = input;
   if (config === null) {
-    return refuse3("no-configuration", serveConfigAdvice(input.configState ?? "absent"));
+    return refuse4("no-configuration", serveConfigAdvice(input.configState ?? "absent"));
   }
   if (!config.enabled) {
-    return refuse3("disabled", serveConfigAdvice("valid"));
+    return refuse4("disabled", serveConfigAdvice("valid"));
   }
   if (config.credentialRef.store !== "auth-json") {
-    return refuse3("unsupported-credential-store", `credentialRef.store "${config.credentialRef.store}" is not implemented in this release; only "auth-json" is supported.`);
+    return refuse4("unsupported-credential-store", `credentialRef.store "${config.credentialRef.store}" is not implemented in this release; only "auth-json" is supported.`);
   }
   if (credential.status === "unreadable") {
-    return refuse3("unreadable-credential", `${credential.message}. Inspect it, then run \`keryx serve token rotate\`.`);
+    return refuse4("unreadable-credential", `${credential.message}. Inspect it, then run \`keryx serve token rotate\`.`);
   }
   if (credential.status === "absent") {
-    return refuse3("no-credential", "no serve credential exists. Run `keryx serve token issue` \u2014 the token is printed once and never again.");
+    return refuse4("no-credential", "no serve credential exists. Run `keryx serve token issue` \u2014 the token is printed once and never again.");
   }
   if (credential.record.id !== config.credentialRef.id) {
-    return refuse3("no-credential", "the configured credential reference does not match the credential in the store. Run `keryx serve token rotate` to re-issue and re-point it.");
+    return refuse4("no-credential", "the configured credential reference does not match the credential in the store. Run `keryx serve token rotate` to re-issue and re-point it.");
   }
   const nonLoopback = !isLoopbackAddress(config.bind.address);
   if (nonLoopback && config.bind.acknowledgeNonLoopback !== true) {
-    return refuse3("non-loopback-not-acknowledged", `the configured bind address is reachable beyond loopback. Run \`keryx serve config set --bind ${config.bind.address} --acknowledge-non-loopback\` to acknowledge it explicitly; there is no TLS in this release.`);
+    return refuse4("non-loopback-not-acknowledged", `the configured bind address is reachable beyond loopback. Run \`keryx serve config set --bind ${config.bind.address} --acknowledge-non-loopback\` to acknowledge it explicitly; there is no TLS in this release.`);
   }
   const remoteProfile = resolveRemoteProfile(config.profile);
   if (remoteProfile === null) {
-    return refuse3("unknown-profile", `profile "${config.profile}" is not implemented in this release; valid profiles are ${REMOTE_PROFILE_NAMES.join(", ")}. Run \`keryx serve config set --profile remote-restricted\``);
+    return refuse4("unknown-profile", `profile "${config.profile}" is not implemented in this release; valid profiles are ${REMOTE_PROFILE_NAMES.join(", ")}. Run \`keryx serve config set --profile remote-restricted\``);
   }
   const comparison = compareProfiles((input.localBaseline ?? localBaselineProfile)(), remoteProfile);
   if (!comparison.ok) {
-    return refuse3("widening-profile", `profile "${config.profile}" would grant more than the local profile allows (${comparison.widened.join(", ")}). Run \`keryx serve config set --profile remote-restricted\``);
+    return refuse4("widening-profile", `profile "${config.profile}" would grant more than the local profile allows (${comparison.widened.join(", ")}). Run \`keryx serve config set --profile remote-restricted\``);
   }
   return { ok: true, config, credential: credential.record, nonLoopback, profile: remoteProfile };
 }
@@ -112978,7 +114344,7 @@ function matchRoute(pathname) {
   return { route: "none" };
 }
 var JSON_HEADERS = { "content-type": "application/json; charset=utf-8" };
-function errorResponse(status, code, message, headers = {}) {
+function errorResponse2(status, code, message, headers = {}) {
   return new Response(`${JSON.stringify({ error: { code, message } })}
 `, {
     status,
@@ -112986,7 +114352,7 @@ function errorResponse(status, code, message, headers = {}) {
   });
 }
 function unauthorized() {
-  return errorResponse(401, "unauthorized", "Unauthorized.", { "www-authenticate": "Bearer" });
+  return errorResponse2(401, "unauthorized", "Unauthorized.", { "www-authenticate": "Bearer" });
 }
 function bearerToken(request) {
   const header = request.headers.get("authorization");
@@ -113013,33 +114379,33 @@ function summarizeRegistryWarnings(messages) {
 async function submitTurn(request, ctx) {
   const declared = Number(request.headers.get("content-length") ?? "0");
   if (Number.isFinite(declared) && declared > MAX_TURN_BODY_BYTES) {
-    return errorResponse(413, "too-large", "The request body exceeds the configured bound.");
+    return errorResponse2(413, "too-large", "The request body exceeds the configured bound.");
   }
   const contentType = (request.headers.get("content-type") ?? "").split(";")[0]?.trim().toLowerCase();
   if (contentType !== "application/json") {
-    return errorResponse(400, "invalid-request", "Content-Type must be application/json.");
+    return errorResponse2(400, "invalid-request", "Content-Type must be application/json.");
   }
   const raw = await request.text();
   if (Buffer.byteLength(raw, "utf8") > MAX_TURN_BODY_BYTES) {
-    return errorResponse(413, "too-large", "The request body exceeds the configured bound.");
+    return errorResponse2(413, "too-large", "The request body exceeds the configured bound.");
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch {
-    return errorResponse(400, "invalid-request", "The request body is not valid JSON.");
+    return errorResponse2(400, "invalid-request", "The request body is not valid JSON.");
   }
   const validated = validateTurnRequest(parsed);
   if (!validated.ok) {
-    return errorResponse(validated.problem.status, validated.problem.code, validated.problem.message);
+    return errorResponse2(validated.problem.status, validated.problem.code, validated.problem.message);
   }
   const project = resolveProject(validated.request.project, ctx.dir);
   if (!project.ok) {
-    return errorResponse(404, project.code, project.message);
+    return errorResponse2(404, project.code, project.message);
   }
   const submit = ctx.submitTurn;
   if (submit === undefined) {
-    return errorResponse(503, "unavailable", "Turn execution is not available on this listener.");
+    return errorResponse2(503, "unavailable", "Turn execution is not available on this listener.");
   }
   const outcome = await submit(validated.request, project.project);
   if (outcome.kind === "duplicate") {
@@ -113047,10 +114413,10 @@ async function submitTurn(request, ctx) {
 `, { status: 200, headers: JSON_HEADERS });
   }
   if (outcome.kind === "rejected") {
-    return errorResponse(422, "prompt-rejected", "The prompt was rejected.");
+    return errorResponse2(422, "prompt-rejected", "The prompt was rejected.");
   }
   if (outcome.kind === "unavailable") {
-    return errorResponse(500, "record-unreadable", "The durable record for this turn could not be read.");
+    return errorResponse2(500, "record-unreadable", "The durable record for this turn could not be read.");
   }
   return new Response(`${JSON.stringify({ schemaVersion: "1.0.0", turnId: outcome.turnId, sessionId: outcome.sessionId }, null, 2)}
 `, { status: 202, headers: JSON_HEADERS });
@@ -113061,7 +114427,7 @@ function streamTurnEvents(request, turnId, ctx) {
   const after = Number.isInteger(parsed) && parsed >= 0 ? parsed : -1;
   const events = readTurnEvents(turnId, after, ctx.dir);
   if (!events.ok) {
-    return errorResponse(500, "record-unreadable", "The durable record for this turn could not be read.");
+    return errorResponse2(500, "record-unreadable", "The durable record for this turn could not be read.");
   }
   const body = events.value.map((event) => `id: ${event.seq}
 data: ${JSON.stringify(event)}
@@ -113084,7 +114450,7 @@ async function handleServeRequest(request, ctx) {
 }
 function internalErrorResponse(cause) {
   console.error(`keryx serve: request failed: ${cause instanceof Error ? cause.message : String(cause)}`);
-  return errorResponse(500, "internal-error", "The request could not be completed.");
+  return errorResponse2(500, "internal-error", "The request could not be completed.");
 }
 async function routeServeRequest(request, ctx) {
   const credential = ctx.resolveCredential();
@@ -113094,7 +114460,7 @@ async function routeServeRequest(request, ctx) {
       const standing = ctx.throttle.check(peer);
       const verdict = standing.throttled ? standing : ctx.throttle.recordFailure(peer);
       if (verdict.throttled) {
-        return errorResponse(429, "too-many-requests", "Too many requests.", {
+        return errorResponse2(429, "too-many-requests", "Too many requests.", {
           "retry-after": String(verdict.retryAfterSeconds ?? 60)
         });
       }
@@ -113102,35 +114468,35 @@ async function routeServeRequest(request, ctx) {
     return unauthorized();
   }
   if (ctx.state() === "draining") {
-    return errorResponse(503, "draining", "The server is draining.");
+    return errorResponse2(503, "draining", "The server is draining.");
   }
   const pathname = new URL(request.url).pathname;
   const matched = matchRoute(pathname);
   if (matched.route === "none") {
-    return errorResponse(404, "not-found", "Not found.");
+    return errorResponse2(404, "not-found", "Not found.");
   }
   if (matched.route === "fixed" && pathname === "/v1/turns") {
     if (request.method !== "POST") {
-      return errorResponse(405, "method-not-allowed", "Method not allowed.", { allow: "POST" });
+      return errorResponse2(405, "method-not-allowed", "Method not allowed.", { allow: "POST" });
     }
     return submitTurn(request, ctx);
   }
   if (request.method !== "GET") {
-    return errorResponse(405, "method-not-allowed", "Method not allowed.", { allow: "GET" });
+    return errorResponse2(405, "method-not-allowed", "Method not allowed.", { allow: "GET" });
   }
   if (matched.route === "turn" || matched.route === "turn-events") {
     const record = readTurnRecord(matched.turnId, ctx.dir);
     if (!record.ok) {
       if (isServerFault(record.reason)) {
-        return errorResponse(500, "record-unreadable", "The durable record for this turn could not be read.");
+        return errorResponse2(500, "record-unreadable", "The durable record for this turn could not be read.");
       }
-      return errorResponse(404, "not-found", "Not found.");
+      return errorResponse2(404, "not-found", "Not found.");
     }
     if (matched.route === "turn-events") {
       return streamTurnEvents(request, matched.turnId, ctx);
     }
     if (record.value.result === undefined) {
-      return errorResponse(409, "turn-in-progress", "The turn has not reached a terminal state.");
+      return errorResponse2(409, "turn-in-progress", "The turn has not reached a terminal state.");
     }
     return new Response(`${JSON.stringify(record.value.result, null, 2)}
 `, { headers: JSON_HEADERS });
@@ -113182,11 +114548,11 @@ async function startServeListener(input) {
       error: internalErrorResponse
     });
   } catch (error) {
-    return refuse3("bind-failed", `could not bind ${hostname}:${startup.config.bind.port}: ${error instanceof Error ? error.message : String(error)}`);
+    return refuse4("bind-failed", `could not bind ${hostname}:${startup.config.bind.port}: ${error instanceof Error ? error.message : String(error)}`);
   }
   if (typeof server.port !== "number" || server.port <= 0) {
     await server.stop(true);
-    return refuse3("bind-failed", "the listener reported no bound port");
+    return refuse4("bind-failed", "the listener reported no bound port");
   }
   boundPort = server.port;
   state = "listening";
@@ -113231,7 +114597,7 @@ function assembleSubmitTurn(profile, dir, seams = {}) {
 }
 
 // src/commands/serve.ts
-function parseArgs3(args, valueFlags, booleanFlags) {
+function parseArgs4(args, valueFlags, booleanFlags) {
   const values = new Map;
   const flags = new Set;
   for (let index = 0;index < args.length; index += 1) {
@@ -113277,7 +114643,7 @@ var ENABLE_FLAG = "--enable";
 var DISABLE_FLAG = "--disable";
 async function serveCommand(args = []) {
   if (args.includes("--help") || args.includes("-h") || args[0] === "help") {
-    printHelp19();
+    printHelp20();
     return;
   }
   const sub = args[0];
@@ -113298,14 +114664,14 @@ async function serveCommand(args = []) {
     return;
   }
   console.error(`Unknown serve command: ${sanitizeForDisplay(sub)}`);
-  printHelp19();
+  printHelp20();
   process.exitCode = 1;
 }
 async function runServe(args) {
-  const parsed = parseArgs3(args, BIND_FLAGS, [ACK_FLAG]);
+  const parsed = parseArgs4(args, BIND_FLAGS, [ACK_FLAG]);
   if (!parsed.ok) {
     console.error(parsed.message);
-    printHelp19();
+    printHelp20();
     process.exitCode = 1;
     return;
   }
@@ -113404,10 +114770,10 @@ function readPort(raw, options) {
   return port;
 }
 function runStatus7(args) {
-  const parsed = parseArgs3(args, [], ["--json"]);
+  const parsed = parseArgs4(args, [], ["--json"]);
   if (!parsed.ok) {
     console.error(parsed.message);
-    printHelp19();
+    printHelp20();
     process.exitCode = 1;
     return;
   }
@@ -113451,10 +114817,10 @@ function runStatus7(args) {
 }
 function runToken(args) {
   const sub = args[0];
-  const rest = parseArgs3(args.slice(1), [], []);
+  const rest = parseArgs4(args.slice(1), [], []);
   if (!rest.ok) {
     console.error(rest.message);
-    printHelp19();
+    printHelp20();
     process.exitCode = 1;
     return;
   }
@@ -113495,7 +114861,7 @@ function runToken(args) {
     return;
   }
   console.error(sub === undefined ? "Missing token subcommand" : `Unknown token command: ${sanitizeForDisplay(sub)}`);
-  printHelp19();
+  printHelp20();
   process.exitCode = 1;
 }
 function printTokenOnce(token) {
@@ -113517,10 +114883,10 @@ function pointConfigurationAt(credentialId) {
 function runConfig(args) {
   const sub = args[0];
   if (sub === "init") {
-    const parsed = parseArgs3(args.slice(1), BIND_FLAGS, [ACK_FLAG, FORCE_FLAG]);
+    const parsed = parseArgs4(args.slice(1), BIND_FLAGS, [ACK_FLAG, FORCE_FLAG]);
     if (!parsed.ok) {
       console.error(parsed.message);
-      printHelp19();
+      printHelp20();
       process.exitCode = 1;
       return;
     }
@@ -113541,7 +114907,7 @@ function runConfig(args) {
       return;
     }
     const credential = readServeCredential();
-    const credentialId = credential.status === "ok" ? credential.record.id : randomUUID39();
+    const credentialId = credential.status === "ok" ? credential.record.id : randomUUID42();
     const config = defaultServeConfig(credentialId, {
       address: parsed.parsed.values.get("--bind") ?? DEFAULT_SERVE_BIND_ADDRESS,
       port: port ?? DEFAULT_SERVE_PORT,
@@ -113567,10 +114933,10 @@ function runConfig(args) {
     return;
   }
   if (sub === "show") {
-    const parsed = parseArgs3(args.slice(1), [], ["--json"]);
+    const parsed = parseArgs4(args.slice(1), [], ["--json"]);
     if (!parsed.ok) {
       console.error(parsed.message);
-      printHelp19();
+      printHelp20();
       process.exitCode = 1;
       return;
     }
@@ -113587,14 +114953,14 @@ function runConfig(args) {
     return;
   }
   console.error(sub === undefined ? "Missing config subcommand" : `Unknown config command: ${sanitizeForDisplay(sub)}`);
-  printHelp19();
+  printHelp20();
   process.exitCode = 1;
 }
 function runConfigSet(args) {
-  const parsed = parseArgs3(args, BIND_FLAGS, [ACK_FLAG, NO_ACK_FLAG, ENABLE_FLAG, DISABLE_FLAG]);
+  const parsed = parseArgs4(args, BIND_FLAGS, [ACK_FLAG, NO_ACK_FLAG, ENABLE_FLAG, DISABLE_FLAG]);
   if (!parsed.ok) {
     console.error(parsed.message);
-    printHelp19();
+    printHelp20();
     process.exitCode = 1;
     return;
   }
@@ -113665,7 +115031,7 @@ function printConfig(config) {
   console.log(`  approvals:  expire after ${config.approval.expirySeconds}s, max ${config.approval.maxPendingPerSession} pending per session`);
   console.log(`  non-loopback acknowledged: ${config.bind.acknowledgeNonLoopback === true}`);
 }
-function printHelp19() {
+function printHelp20() {
   helpTitle("keryx serve", "loopback-bound HTTP entry over this install (off by default)");
   helpUsage([
     `keryx serve [--bind <addr>] [--port <n>] [--profile <name>] [${ACK_FLAG}]`,
@@ -113712,7 +115078,7 @@ init_templates3();
 async function updateCommand(args = []) {
   const options = parseUpdateArgs(args);
   if (options.help) {
-    printHelp20();
+    printHelp21();
     return;
   }
   const projectRoot = process.cwd();
@@ -114922,7 +116288,7 @@ function runtimeSourcePath2(relativePath) {
 function escapeRegExp7(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function printHelp20() {
+function printHelp21() {
   helpTitle("keryx update", "refresh .metaproject service files (data left untouched)");
   helpUsage(["keryx update [--skip-runtime] [--hooks] [--no-tasks]"]);
   heading("Default behavior");
@@ -114953,7 +116319,7 @@ async function dashboardCommand(args = []) {
   const options = parseOptions(args);
   const subcommand = options.positionals[0];
   if (!subcommand || options.help) {
-    printHelp21();
+    printHelp22();
     return;
   }
   if (subcommand === "build") {
@@ -114971,7 +116337,7 @@ async function dashboardCommand(args = []) {
     return;
   }
   console.log(`  ${style.red(symbols.cross)} Unknown dashboard command: ${subcommand}`);
-  printHelp21();
+  printHelp22();
   process.exitCode = 1;
 }
 function parseOptions(args) {
@@ -114996,7 +116362,7 @@ async function openFile(filePath) {
     });
   });
 }
-function printHelp21() {
+function printHelp22() {
   helpTitle("keryx dashboard", "build and open the human dashboard");
   helpUsage([
     "keryx dashboard build",
@@ -115010,7 +116376,7 @@ function printHelp21() {
 }
 
 // src/commands/agents.ts
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync15 } from "fs";
 
 // src/agents/bootstrap.ts
 import { mkdir as mkdir66, readFile as readFile102, writeFile as writeFile55 } from "fs/promises";
@@ -115511,7 +116877,7 @@ function monitorCommand(args) {
   }
   let events;
   try {
-    events = parseAgentEvents(readFileSync14(source, "utf8"));
+    events = parseAgentEvents(readFileSync15(source, "utf8"));
   } catch (error) {
     console.error(`Failed to read/parse agent-event source "${source}": ${error.message}`);
     process.exitCode = 1;
@@ -117546,7 +118912,7 @@ async function versionCommand(args, deps = {}) {
 // src/commands/workspace.ts
 init_args();
 init_workspace_service();
-import { randomUUID as randomUUID40 } from "crypto";
+import { randomUUID as randomUUID43 } from "crypto";
 import { writeFile as writeFile57 } from "fs/promises";
 
 // src/sac/fwk-explain.ts
@@ -117617,7 +118983,7 @@ function service6() {
 async function workspaceCommand(args) {
   const subcommand = args[0];
   if (!subcommand || subcommand === "help" || args.includes("--help") || args.includes("-h"))
-    return printHelp22();
+    return printHelp23();
   try {
     if (subcommand === "create") {
       rejectUnknownOptions(args.slice(1), new Set(["--title", "--component"]));
@@ -117626,7 +118992,7 @@ async function workspaceCommand(args) {
       const component = rawComponent === undefined ? undefined : requireWorkspaceReference(rawComponent);
       if (!title)
         throw new Error("Usage: keryx workspace create --title <title> [--component <workspace-relative-ref>]");
-      const workspace = await service6().create({ request: undefined, requestCorrelationId: randomUUID40(), id: newWorkspaceId(), title, ...component ? { component: { kind: "component", uri: component } } : {} });
+      const workspace = await service6().create({ request: undefined, requestCorrelationId: randomUUID43(), id: newWorkspaceId(), title, ...component ? { component: { kind: "component", uri: component } } : {} });
       console.log(JSON.stringify(workspace, null, 2));
       return;
     }
@@ -117656,7 +119022,7 @@ async function workspaceCommand(args) {
       const revision = optionValue(args, "--revision");
       if (!workspaceId || !kind || !rawUri)
         throw new Error("Usage: keryx workspace add-resource <workspace-id> --kind <kind> --uri <workspace-relative-ref> [--revision <revision>]");
-      console.log(JSON.stringify(await service6().addResource({ request: undefined, requestCorrelationId: randomUUID40(), workspaceId, resource: { kind, uri: requireWorkspaceReference(rawUri), ...revision ? { revision } : {} } }), null, 2));
+      console.log(JSON.stringify(await service6().addResource({ request: undefined, requestCorrelationId: randomUUID43(), workspaceId, resource: { kind, uri: requireWorkspaceReference(rawUri), ...revision ? { revision } : {} } }), null, 2));
       return;
     }
     if (subcommand === "archive") {
@@ -117664,7 +119030,7 @@ async function workspaceCommand(args) {
       const workspaceId = args[1];
       if (!workspaceId)
         throw new Error("Usage: keryx workspace archive <workspace-id>");
-      console.log(JSON.stringify(await service6().archive({ request: undefined, requestCorrelationId: randomUUID40(), workspaceId }), null, 2));
+      console.log(JSON.stringify(await service6().archive({ request: undefined, requestCorrelationId: randomUUID43(), workspaceId }), null, 2));
       return;
     }
     if (subcommand === "remove-resource") {
@@ -117673,7 +119039,7 @@ async function workspaceCommand(args) {
       const uri = optionValue(args, "--uri");
       if (!workspaceId || !uri)
         throw new Error("Usage: keryx workspace remove-resource <workspace-id> --uri <workspace-relative-ref>");
-      console.log(JSON.stringify(await service6().removeResource({ request: undefined, requestCorrelationId: randomUUID40(), workspaceId, uri }), null, 2));
+      console.log(JSON.stringify(await service6().removeResource({ request: undefined, requestCorrelationId: randomUUID43(), workspaceId, uri }), null, 2));
       return;
     }
     if (subcommand === "rename") {
@@ -117682,7 +119048,7 @@ async function workspaceCommand(args) {
       const title = optionValue(args, "--title");
       if (!workspaceId || !title)
         throw new Error("Usage: keryx workspace rename <workspace-id> --title <title>");
-      console.log(JSON.stringify(await service6().rename({ request: undefined, requestCorrelationId: randomUUID40(), workspaceId, title }), null, 2));
+      console.log(JSON.stringify(await service6().rename({ request: undefined, requestCorrelationId: randomUUID43(), workspaceId, title }), null, 2));
       return;
     }
     if (subcommand === "overview") {
@@ -117694,7 +119060,7 @@ async function workspaceCommand(args) {
       const maxTokens = Number(optionValue(args, "--max-tokens") ?? "4096");
       if (!Number.isInteger(maxItems) || !Number.isInteger(maxTokens) || maxItems < 0 || maxTokens < 0)
         throw new Error("--max-items and --max-tokens must be non-negative integers");
-      const result = await createLocalFwkReadService(process.cwd()).overview({ workspaceId, request: undefined, requestCorrelationId: randomUUID40(), budget: { maxItems, maxTokens } });
+      const result = await createLocalFwkReadService(process.cwd()).overview({ workspaceId, request: undefined, requestCorrelationId: randomUUID43(), budget: { maxItems, maxTokens } });
       const normalized = normalizeFwkResult(result);
       console.log(JSON.stringify(normalized, null, 2));
       if (args.includes("--explain"))
@@ -117711,7 +119077,7 @@ async function workspaceCommand(args) {
       const maxTokens = Number(optionValue(args, "--max-tokens") ?? "4096");
       if (!Number.isInteger(maxItems) || !Number.isInteger(maxTokens) || maxItems < 0 || maxTokens < 0)
         throw new Error("--max-items and --max-tokens must be non-negative integers");
-      const result = await createLocalFwkReadService(process.cwd()).read({ workspaceId, itemId, request: undefined, requestCorrelationId: randomUUID40(), budget: { maxItems, maxTokens } });
+      const result = await createLocalFwkReadService(process.cwd()).read({ workspaceId, itemId, request: undefined, requestCorrelationId: randomUUID43(), budget: { maxItems, maxTokens } });
       const normalized = normalizeFwkResult(result);
       console.log(JSON.stringify(normalized, null, 2));
       if (args.includes("--explain"))
@@ -117733,14 +119099,14 @@ async function workspaceCommand(args) {
       const session = findSession(cwd, sessionRef);
       if (!session)
         throw new Error(`no session matching "${sessionRef}" in this project \u2014 use \`keryx sessions list\``);
-      const proposalId = `proposal-${randomUUID40().replace(/-/g, "").slice(0, 16)}`;
+      const proposalId = `proposal-${randomUUID43().replace(/-/g, "").slice(0, 16)}`;
       const notePath = proposalNotePath(cwd, workspaceId, proposalId);
       const materializedNote = note === undefined ? undefined : prepareOutputForPersistence(await guardOutput({ cwd, content: note, target: "task", source: "generated", path: notePath }), note);
       if (materializedNote !== undefined && !materializedNote.allowed)
         throw new Error(materializedNote.reason);
       const persistedNote = materializedNote?.allowed ? materializedNote.content : undefined;
       const { service, wrapUpAuthority, authorizationServer } = createHarnessProposalLifecycleService(cwd, { workspaceId, ...persistedNote ? { note: persistedNote } : {} });
-      const requestCorrelationId = randomUUID40();
+      const requestCorrelationId = randomUUID43();
       const actor = await authorizationServer.actorContextFor(undefined, requestCorrelationId);
       if (!actor)
         throw new Error("trusted ActorContext is required");
@@ -117781,13 +119147,13 @@ async function workspaceCommand(args) {
       const proposalId = args[2];
       const decision = optionValue(args, "--decision");
       const reason = optionValue(args, "--reason");
-      const idempotencyKey = optionValue(args, "--idempotency-key") ?? randomUUID40();
+      const idempotencyKey = optionValue(args, "--idempotency-key") ?? randomUUID43();
       const confirmToken = optionValue(args, "--confirm-token");
       if (!workspaceId || !proposalId || !decision)
         throw new Error("Usage: keryx workspace review <workspace-id> <proposal-id> --decision <accepted|rejected|dismissed> [--reason <reason>] [--idempotency-key <key>] [--confirm-token <token>]");
       if (decision === "accepted" && !confirmToken)
         throw new Error("--decision accepted requires --confirm-token \u2014 run `keryx workspace confirm-review " + workspaceId + " " + proposalId + "` first");
-      const result = await createHarnessProposalLifecycleService(process.cwd(), { workspaceId }).service.review({ request: undefined, requestCorrelationId: randomUUID40(), workspaceId, proposalId, decision, idempotencyKey, interactive: true, ...reason ? { reason } : {}, ...confirmToken ? { confirmToken } : {} });
+      const result = await createHarnessProposalLifecycleService(process.cwd(), { workspaceId }).service.review({ request: undefined, requestCorrelationId: randomUUID43(), workspaceId, proposalId, decision, idempotencyKey, interactive: true, ...reason ? { reason } : {}, ...confirmToken ? { confirmToken } : {} });
       console.log(JSON.stringify(normalizeProposalLifecycleResult(result), null, 2));
       return;
     }
@@ -117812,7 +119178,7 @@ async function workspaceCommand(args) {
       const artifactRef = optionValue(args, "--artifact");
       if (!workspaceId || !to || !artifactRef)
         throw new Error("Usage: keryx workspace handoff <workspace-id> --to <subject> --artifact <ref>");
-      const activity = await createLocalCollaborationService(process.cwd()).record({ request: undefined, requestCorrelationId: randomUUID40(), workspaceId, activity: { kind: "handoff-recorded", handoff: { to, artifactRef } } });
+      const activity = await createLocalCollaborationService(process.cwd()).record({ request: undefined, requestCorrelationId: randomUUID43(), workspaceId, activity: { kind: "handoff-recorded", handoff: { to, artifactRef } } });
       console.log(JSON.stringify(activity, null, 2));
       return;
     }
@@ -117821,7 +119187,7 @@ async function workspaceCommand(args) {
       const workspaceId = args[1];
       if (!workspaceId)
         throw new Error("Usage: keryx workspace collaboration <workspace-id>");
-      console.log(JSON.stringify(await createLocalCollaborationService(process.cwd()).overview({ workspaceId, request: undefined, requestCorrelationId: randomUUID40() }), null, 2));
+      console.log(JSON.stringify(await createLocalCollaborationService(process.cwd()).overview({ workspaceId, request: undefined, requestCorrelationId: randomUUID43() }), null, 2));
       return;
     }
     if (subcommand === "policy-readiness") {
@@ -117848,7 +119214,7 @@ async function workspaceCommand(args) {
       const workspaceId = args[1];
       const cwd = process.cwd();
       const authorizationServer = localWorkspaceAuthorizationServer();
-      const actor = await authorizationServer.actorContextFor(undefined, randomUUID40());
+      const actor = await authorizationServer.actorContextFor(undefined, randomUUID43());
       if (!actor)
         throw new Error("trusted ActorContext is required");
       if (workspaceId) {
@@ -117906,7 +119272,7 @@ function booleanFlagDefaultTrue(args, name) {
     return false;
   throw new Error(`Unknown value for ${name}: "${value}" \u2014 expected true or false`);
 }
-function printHelp22() {
+function printHelp23() {
   console.log(`keryx workspace create --title <title> [--component <workspace-relative-ref>]
 keryx workspace list [--include-archived]
 keryx workspace show <workspace-id>
@@ -118090,7 +119456,7 @@ function runAuthStatus(args) {
 
 // src/commands/retention.ts
 init_args();
-function printHelp23() {
+function printHelp24() {
   console.log(`keryx retention status|sweep \u2014 bound the size of stores that grow with every routed search or refused write
 
 Usage:
@@ -118143,7 +119509,7 @@ function numericOption(args, name) {
 async function retentionCommand(args = [], deps = {}) {
   const subcommand = args[0];
   if (subcommand === undefined || subcommand === "--help" || subcommand === "-h") {
-    printHelp23();
+    printHelp24();
     return;
   }
   const cwd = deps.cwd ?? process.cwd();
@@ -118159,7 +119525,7 @@ async function retentionCommand(args = [], deps = {}) {
       return;
     default:
       console.error(`Unknown retention command: ${subcommand}`);
-      printHelp23();
+      printHelp24();
       process.exitCode = 1;
   }
 }
@@ -118241,7 +119607,7 @@ init_args();
 async function forgettingCommand(args) {
   const command = args[0];
   if (!command || command === "--help" || command === "-h" || args.includes("--help")) {
-    printHelp24();
+    printHelp25();
     return;
   }
   if (command === "trail") {
@@ -118253,7 +119619,7 @@ async function forgettingCommand(args) {
     return;
   }
   console.error(`Unknown forgetting command: ${command}`);
-  printHelp24();
+  printHelp25();
   process.exitCode = 1;
 }
 async function runTrail(args) {
@@ -118343,7 +119709,7 @@ function positional4(args) {
   }
   return;
 }
-function printHelp24() {
+function printHelp25() {
   console.log(`keryx forgetting
 
 Read the deletion trail (.metaproject/data/forgetting/journal.jsonl): what was
@@ -118365,6 +119731,1000 @@ ${TRAIL_SCOPE_CAVEAT}
 `);
 }
 
+// src/commands/trigger.ts
+init_gdgraph();
+init_service8();
+
+// src/trigger/run.ts
+init_fs();
+import path211 from "path";
+
+// src/trigger/config.ts
+init_config_dir();
+import { existsSync as existsSync37 } from "fs";
+import path209 from "path";
+var TRIGGER_EVENT_NAMES = ["post-merge", "post-commit", "post-checkout", "ci"];
+var TRIGGER_ACTION_KINDS = ["reconcile", "rebuild", "open-flow", "flow-next"];
+var TRIGGER_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+var CRON_FIELD_PATTERN = /^[0-9*/,-]+$|^[A-Za-z]{3}(?:[,-][A-Za-z]{3})*$/;
+function looksLikeCron(value) {
+  const fields = value.trim().split(/\s+/);
+  if (fields.length < 5 || fields.length > 6)
+    return false;
+  return fields.every((field) => CRON_FIELD_PATTERN.test(field));
+}
+var TRIGGERS_SCHEMA_VERSION = 1;
+function fireProblems(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return ["on: must be an object naming an event or a schedule"];
+  }
+  const raw = value;
+  if (raw.kind === "event") {
+    if (typeof raw.event !== "string" || raw.event.length === 0) {
+      return ["on.event: required, non-empty string"];
+    }
+    if (!TRIGGER_EVENT_NAMES.includes(raw.event)) {
+      return [`on.event: unknown event "${raw.event}" (expected one of ${TRIGGER_EVENT_NAMES.join(", ")})`];
+    }
+    return [];
+  }
+  if (raw.kind === "schedule") {
+    if (typeof raw.cron !== "string" || raw.cron.trim().length === 0) {
+      return ["on.cron: required, non-empty string"];
+    }
+    if (!looksLikeCron(raw.cron)) {
+      return [`on.cron: "${raw.cron}" does not look like a 5- or 6-field cron expression`];
+    }
+    return [];
+  }
+  return ['on.kind: must be "event" or "schedule"'];
+}
+function actionProblems(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return ["action: must be an object naming what the trigger does"];
+  }
+  const raw = value;
+  if (typeof raw.kind !== "string" || !TRIGGER_ACTION_KINDS.includes(raw.kind)) {
+    return [`action.kind: must be one of ${TRIGGER_ACTION_KINDS.join(", ")}`];
+  }
+  if (raw.kind === "open-flow") {
+    const problems = [];
+    if (typeof raw.template !== "string" || raw.template.length === 0) {
+      problems.push("action.template: required, non-empty string");
+    }
+    if (raw.skipIfOpen !== undefined && typeof raw.skipIfOpen !== "boolean") {
+      problems.push("action.skipIfOpen: must be a boolean when present");
+    }
+    return problems;
+  }
+  if (raw.kind === "flow-next") {
+    if (typeof raw.flow !== "string" || raw.flow.length === 0) {
+      return ["action.flow: required, non-empty string"];
+    }
+    return [];
+  }
+  return [];
+}
+function triggerEntryProblems(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return ["entry: must be an object"];
+  }
+  const raw = value;
+  const problems = [];
+  if (typeof raw.name !== "string" || raw.name.length === 0) {
+    problems.push("name: required, non-empty string");
+  } else if (!TRIGGER_NAME_PATTERN.test(raw.name)) {
+    problems.push(`name: "${raw.name}" must start with a letter or digit and contain only letters, digits, "-", "_" or "." (max 64 chars) \u2014 it is passed as the \`keryx trigger run <name>\` argument`);
+  }
+  if (raw.on === undefined) {
+    problems.push("on: required");
+  } else {
+    problems.push(...fireProblems(raw.on));
+  }
+  if (raw.action === undefined) {
+    problems.push("action: required");
+  } else {
+    problems.push(...actionProblems(raw.action));
+  }
+  if (raw.enabled !== undefined && typeof raw.enabled !== "boolean") {
+    problems.push("enabled: must be a boolean when present");
+  }
+  return problems;
+}
+function parseTriggerEntry(value) {
+  try {
+    if (triggerEntryProblems(value).length > 0)
+      return;
+    const raw = value;
+    const fire = raw.on.kind === "event" ? { kind: "event", event: raw.on.event } : { kind: "schedule", cron: raw.on.cron };
+    return {
+      name: raw.name,
+      fire,
+      action: raw.action,
+      enabled: raw.enabled ?? true
+    };
+  } catch {
+    return;
+  }
+}
+function triggersConfigPath(projectRoot) {
+  return path209.join(projectRoot, ".metaproject", "triggers.json");
+}
+function loadTriggersConfig(projectRoot) {
+  const empty = (fileProblem) => ({
+    triggers: [],
+    rejected: [],
+    fileProblem
+  });
+  const file = triggersConfigPath(projectRoot);
+  if (!existsSync37(file)) {
+    return empty("absent");
+  }
+  const read = readConfigFile(file);
+  if (!read.ok) {
+    return empty("unreadable");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(read.text);
+  } catch {
+    return empty("not-json");
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return empty("not-an-object");
+  }
+  const raw = parsed;
+  if (raw.schemaVersion !== TRIGGERS_SCHEMA_VERSION) {
+    return empty("wrong-schema-version");
+  }
+  if (!Array.isArray(raw.triggers)) {
+    return empty("triggers-not-an-array");
+  }
+  const triggers = [];
+  const rejected = [];
+  const seenNames = new Set;
+  raw.triggers.forEach((candidate, index) => {
+    let reasons;
+    try {
+      reasons = triggerEntryProblems(candidate);
+    } catch (error) {
+      reasons = [`entry: threw during validation (${error instanceof Error ? error.message : String(error)})`];
+    }
+    const candidateName = candidate !== null && typeof candidate === "object" && typeof candidate.name === "string" ? candidate.name : undefined;
+    if (reasons.length === 0 && candidateName !== undefined && seenNames.has(candidateName)) {
+      reasons = [`name: "${candidateName}" is already used by an earlier entry in this file`];
+    }
+    if (reasons.length > 0) {
+      rejected.push({ index, name: candidateName, reasons });
+      return;
+    }
+    const entry = parseTriggerEntry(candidate);
+    if (entry === undefined) {
+      rejected.push({ index, name: candidateName, reasons: ["entry: failed to parse after passing validation"] });
+      return;
+    }
+    seenNames.add(entry.name);
+    triggers.push(entry);
+  });
+  return { triggers, rejected, fileProblem: undefined };
+}
+
+// src/trigger/record.ts
+init_fs();
+import { appendFile as appendFile10, mkdir as mkdir68, readFile as readFile104, stat as stat21 } from "fs/promises";
+import path210 from "path";
+var TRIGGER_RUN_RECORD_VERSION = 1;
+function triggerDataDir(projectRoot) {
+  return path210.join(projectRoot, ".metaproject", "data", "trigger");
+}
+function triggerRunsPath(projectRoot) {
+  return path210.join(triggerDataDir(projectRoot), "runs.jsonl");
+}
+var NO_MODEL_COST = {
+  recorded: false,
+  reason: "this action does not call a model \u2014 reconcile/rebuild are deterministic, no spend to record"
+};
+async function appendTriggerRunRecord(projectRoot, record) {
+  const file = triggerRunsPath(projectRoot);
+  const full = { v: TRIGGER_RUN_RECORD_VERSION, ...record };
+  try {
+    await mkdir68(path210.dirname(file), { recursive: true });
+    await appendFile10(file, `${JSON.stringify(full)}
+`, "utf8");
+    return { status: "appended", path: file, record: full };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      status: "failed",
+      path: file,
+      reason: `the trigger run record could not be appended (${message}). The run's own outcome above is still what ` + "happened \u2014 this failure is only about the record of it, and it must not be reported as recorded."
+    };
+  }
+}
+async function readTriggerRuns(projectRoot) {
+  const file = triggerRunsPath(projectRoot);
+  try {
+    await stat21(file);
+  } catch (error) {
+    if (isNotFound(error))
+      return { state: "absent", path: file };
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      state: "unreadable",
+      path: file,
+      reason: `the trigger run record could not be examined (${message}). This is not the same as "nothing has ever fired".`
+    };
+  }
+  let content;
+  try {
+    content = await readFile104(file, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      state: "unreadable",
+      path: file,
+      reason: `the trigger run record exists but could not be read (${message}). Its records are on disk, not absent.`
+    };
+  }
+  const records = [];
+  let damaged = 0;
+  for (const line of content.split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0)
+      continue;
+    const parsed = parseRecord2(trimmed);
+    if (parsed)
+      records.push(parsed);
+    else
+      damaged += 1;
+  }
+  if (damaged > 0) {
+    return {
+      state: "unreadable",
+      path: file,
+      reason: `the trigger run record holds ${damaged} line${damaged === 1 ? "" : "s"} that could not be parsed. ` + "The readable remainder is not reported as the whole history."
+    };
+  }
+  return { state: "present", path: file, records };
+}
+function latestRunByTrigger(records) {
+  const latest = new Map;
+  for (const record of records)
+    latest.set(record.trigger, record);
+  return latest;
+}
+function parseRecord2(line) {
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return null;
+  const raw = value;
+  if (typeof raw["at"] !== "string" || typeof raw["trigger"] !== "string" || typeof raw["outcome"] !== "string") {
+    return null;
+  }
+  return raw;
+}
+
+// src/trigger/run.ts
+function resolveTriggerForRun(projectRoot, name) {
+  const loaded = loadTriggersConfig(projectRoot);
+  if (loaded.fileProblem === "absent") {
+    return { kind: "config-absent" };
+  }
+  if (loaded.fileProblem !== undefined) {
+    return { kind: "config-broken", fileProblem: loaded.fileProblem };
+  }
+  const entry = loaded.triggers.find((candidate) => candidate.name === name);
+  if (entry !== undefined) {
+    return entry.enabled ? { kind: "ready", entry } : { kind: "disabled", entry };
+  }
+  const rejected = loaded.rejected.find((candidate) => candidate.name === name);
+  if (rejected !== undefined) {
+    return { kind: "rejected", reasons: rejected.reasons };
+  }
+  return { kind: "unknown-name", known: loaded.triggers.map((candidate) => candidate.name) };
+}
+function triggerRunLockPath(projectRoot) {
+  return path211.join(projectRoot, ".metaproject", "data", "trigger", ".run.lock");
+}
+var LOCK_TIMEOUT_PREFIX = "Timed out waiting for lock:";
+async function withTriggerRunLock(projectRoot, fn) {
+  try {
+    const result = await withFileLock(triggerRunLockPath(projectRoot), async () => {
+      const holdMs = Number(process.env["KERYX_TRIGGER_RUN_HOLD_MS"] ?? "");
+      if (Number.isFinite(holdMs) && holdMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, holdMs));
+      }
+      return fn();
+    }, { timeoutMs: 0 });
+    return { acquired: true, result };
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith(LOCK_TIMEOUT_PREFIX)) {
+      return {
+        acquired: false,
+        reason: "another `keryx trigger run` holds this project's trigger lock \u2014 refusing rather than waiting, " + "so this run stays exactly one pass (AC2) instead of blocking on another run's schedule. Retry on the next fire."
+      };
+    }
+    throw error;
+  }
+}
+async function recordedTriggerSpend(projectRoot) {
+  const read = await readTriggerRuns(projectRoot);
+  if (read.state === "absent")
+    return { known: true, usd: 0 };
+  if (read.state === "unreadable")
+    return { known: false, reason: read.reason };
+  const usd = read.records.reduce((sum, record) => sum + (record.cost.recorded ? record.cost.usd : 0), 0);
+  return { known: true, usd };
+}
+async function evaluateTriggerBudget(projectRoot, actionKind, options = {}) {
+  const spend = await recordedTriggerSpend(projectRoot);
+  if (!spend.known) {
+    const evaluation = evaluateSpendCap(undefined, options);
+    return {
+      allowed: false,
+      evaluation,
+      reason: `this project's fired-trigger run record could not be read (${spend.reason}) \u2014 spend cannot be verified ` + `against the ${evaluation.currency} ${evaluation.ceiling} spend ceiling, so refusing to start "${actionKind}" ` + "rather than proceed on an unknown ledger. Fix or restore `runs.jsonl` (see `keryx trigger status`), then retry."
+    };
+  }
+  const evaluation = evaluateSpendCap(spend.usd, options);
+  if (!evaluation.stop) {
+    return { allowed: true, evaluation };
+  }
+  return {
+    allowed: false,
+    evaluation,
+    reason: `this project has $${evaluation.spent} ${evaluation.currency} recorded against a $${evaluation.ceiling} ` + `${evaluation.currency} spend ceiling (over by $${evaluation.overBy}) \u2014 refusing to start "${actionKind}" ` + "rather than risk spending further. Raise the ceiling, or review `keryx trigger status`'s recorded cost, before retrying."
+  };
+}
+
+// src/lib/managed-hook.ts
+init_fs();
+init_git_hooks();
+import { chmod as chmod8, mkdir as mkdir69, readFile as readFile105, writeFile as writeFile58 } from "fs/promises";
+import path212 from "path";
+function escapeRegExp8(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function blockPatternFor(blockId) {
+  const start = `# keryx:${blockId}:begin`;
+  const end = `# keryx:${blockId}:end`;
+  return new RegExp(`${escapeRegExp8(start)}[\\s\\S]*?${escapeRegExp8(end)}`);
+}
+async function installManagedHook3(projectRoot, hookName, blockId, content) {
+  const hooksRoot = await resolveGitHooksRoot(projectRoot);
+  if (!hooksRoot)
+    return false;
+  await mkdir69(hooksRoot, { recursive: true });
+  const hookPath = path212.join(hooksRoot, hookName);
+  const managedBlock = `# keryx:${blockId}:begin
+${content.trim()}
+# keryx:${blockId}:end`;
+  const existing = await pathExists(hookPath) ? await readFile105(hookPath, "utf8") : `#!/usr/bin/env sh
+`;
+  const pattern = blockPatternFor(blockId);
+  const next = pattern.test(existing) ? existing.replace(pattern, () => managedBlock) : `${existing.trimEnd()}
+
+${managedBlock}
+`;
+  await writeFile58(hookPath, next, "utf8");
+  await chmod8(hookPath, 493);
+  return true;
+}
+async function removeManagedHook3(projectRoot, hookName, blockId) {
+  const hooksRoot = await resolveGitHooksRoot(projectRoot);
+  if (!hooksRoot)
+    return false;
+  const hookPath = path212.join(hooksRoot, hookName);
+  if (!await pathExists(hookPath))
+    return false;
+  const existing = await readFile105(hookPath, "utf8");
+  const start = `# keryx:${blockId}:begin`;
+  const end = `# keryx:${blockId}:end`;
+  const pattern = new RegExp(`\\n*${escapeRegExp8(start)}[\\s\\S]*?${escapeRegExp8(end)}\\n*`);
+  if (!pattern.test(existing))
+    return false;
+  await writeFile58(hookPath, `${existing.replace(pattern, `
+`).trimEnd()}
+`, "utf8");
+  await chmod8(hookPath, 493);
+  return true;
+}
+async function hasManagedHook(projectRoot, hookName, blockId) {
+  const hooksRoot = await resolveGitHooksRoot(projectRoot);
+  if (!hooksRoot)
+    return false;
+  const hookPath = path212.join(hooksRoot, hookName);
+  if (!await pathExists(hookPath))
+    return false;
+  const existing = await readFile105(hookPath, "utf8");
+  return blockPatternFor(blockId).test(existing);
+}
+
+// src/trigger/hooks.ts
+init_git_hooks();
+var HOOKABLE_EVENTS = ["post-merge", "post-commit", "post-checkout"];
+function isHookable(entry) {
+  return entry.fire.kind === "event" && HOOKABLE_EVENTS.includes(entry.fire.event);
+}
+function blockId(name) {
+  return `trigger-${name}`;
+}
+function hookBody2(name, hookName) {
+  const fn = `keryx_trigger_${name.replace(/[^a-zA-Z0-9_]/g, "_")}_${hookName.replace(/-/g, "_")}`;
+  const guard = hookName === "post-checkout" ? '  [ "${3:-1}" = "1" ] || return 0\n' : "";
+  return `${fn}() {
+  git rev-parse --is-inside-work-tree >/dev/null 2>&1 || return 0
+${guard}  command -v keryx >/dev/null 2>&1 || return 0
+  # Fired trigger "${name}" \u2014 see .metaproject/triggers.json. Never fails the
+  # git operation: the run's own outcome (including a failure) is recorded by
+  # \`keryx trigger run\` itself (AC4), not surfaced as a hook error here.
+  keryx trigger run ${name} >/dev/null 2>&1 || true
+  return 0
+}
+${fn} "$@"`;
+}
+async function installTriggerHooks(projectRoot) {
+  const { triggers } = loadTriggersConfig(projectRoot);
+  const results = [];
+  for (const entry of triggers) {
+    if (!isHookable(entry))
+      continue;
+    const hookName = entry.fire.event;
+    const wrote = await installManagedHook3(projectRoot, hookName, blockId(entry.name), hookBody2(entry.name, hookName));
+    results.push({ name: entry.name, hook: hookName, wrote });
+  }
+  return results;
+}
+async function uninstallTriggerHooks(projectRoot) {
+  const { triggers } = loadTriggersConfig(projectRoot);
+  const results = [];
+  for (const entry of triggers) {
+    if (!isHookable(entry))
+      continue;
+    const hookName = entry.fire.event;
+    const wrote = await removeManagedHook3(projectRoot, hookName, blockId(entry.name));
+    results.push({ name: entry.name, hook: hookName, wrote });
+  }
+  return results;
+}
+async function isTriggerHookInstalled(projectRoot, entry) {
+  if (!isHookable(entry))
+    return false;
+  return hasManagedHook(projectRoot, entry.fire.event, blockId(entry.name));
+}
+async function hasGitHooksRoot(projectRoot) {
+  return await resolveGitHooksRoot(projectRoot) !== null;
+}
+
+// src/trigger/schedule.ts
+import path213 from "path";
+function resolveKeryxInvocation() {
+  const script = process.argv[1];
+  return {
+    execPath: process.execPath,
+    scriptPath: script ? path213.resolve(script) : process.execPath
+  };
+}
+function resolveScheduleEntry(projectRoot, name) {
+  const { triggers, fileProblem } = loadTriggersConfig(projectRoot);
+  if (fileProblem !== undefined)
+    return { kind: "config-absent" };
+  const entry = triggers.find((candidate) => candidate.name === name);
+  if (entry === undefined)
+    return { kind: "unknown-name", known: triggers.map((t) => t.name) };
+  if (entry.fire.kind !== "schedule")
+    return { kind: "not-a-schedule", entry };
+  return { kind: "ready", entry };
+}
+function shQuote2(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function systemdQuote(value) {
+  if (!/[\s"\\]/.test(value))
+    return value;
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function systemdEscapePercent(value) {
+  return value.replace(/%/g, "%%");
+}
+function systemdValue(value) {
+  return systemdQuote(systemdEscapePercent(value));
+}
+function cronEscapePercent(value) {
+  return value.replace(/%/g, "\\%");
+}
+function renderScheduleLines(params) {
+  const { projectRoot, name, cron, invocation } = params;
+  const interpreterDir = path213.dirname(invocation.execPath);
+  const assumedPath = [interpreterDir, "/usr/local/bin", "/usr/bin", "/bin"].join(":");
+  const logDir = path213.join(projectRoot, ".metaproject", "data", "trigger");
+  const logPath = path213.join(logDir, `${name}.schedule.log`);
+  const cronCommand = `cd ${shQuote2(projectRoot)} && mkdir -p ${shQuote2(logDir)} && PATH=${shQuote2(assumedPath)} ` + `${shQuote2(invocation.execPath)} ${shQuote2(invocation.scriptPath)} trigger run ${shQuote2(name)} ` + `>> ${shQuote2(logPath)} 2>&1`;
+  const cronLine = `${cron} ${cronEscapePercent(cronCommand)}`;
+  const serviceUnitName = `keryx-trigger-${name}.service`;
+  const timerUnitName = `keryx-trigger-${name}.timer`;
+  const descriptionName = systemdEscapePercent(name);
+  const descriptionProjectRoot = systemdEscapePercent(projectRoot);
+  const systemdService = `# ${serviceUnitName} \u2014 install under /etc/systemd/system/ (or ~/.config/systemd/user/ for --user)
+[Unit]
+Description=keryx trigger "${descriptionName}" (${descriptionProjectRoot})
+
+[Service]
+Type=oneshot
+WorkingDirectory=${systemdEscapePercent(projectRoot)}
+Environment=${systemdQuote(systemdEscapePercent(`PATH=${assumedPath}`))}
+# Same reason as the cron line's own \`mkdir -p\`: StandardOutput=append: does
+# not create a missing PARENT directory, only a missing file. The leading "-"
+# means systemd ignores this step's own exit status.
+ExecStartPre=-/bin/mkdir -p ${systemdValue(logDir)}
+ExecStart=${systemdValue(invocation.execPath)} ${systemdValue(invocation.scriptPath)} trigger run ${systemdValue(name)}
+StandardOutput=append:${systemdEscapePercent(logPath)}
+StandardError=append:${systemdEscapePercent(logPath)}
+`;
+  const systemdTimer = `# ${timerUnitName} \u2014 install alongside ${serviceUnitName}
+[Unit]
+Description=Schedule for keryx trigger "${descriptionName}"
+
+[Timer]
+# Translate the cron expression "${cron}" into OnCalendar= syntax, e.g. with
+# \`systemd-analyze calendar '<expression>'\` to verify it, then uncomment:
+# OnCalendar=
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+  return { assumedPath, cronCommand, cronLine, systemdService, systemdTimer, serviceUnitName, timerUnitName, logPath };
+}
+
+// src/commands/trigger.ts
+var flowService2 = null;
+function getFlowService2() {
+  flowService2 ??= createFlowService(flowServiceDeps());
+  return flowService2;
+}
+async function triggerCommand(args) {
+  const sub = args[0];
+  if (!sub || sub === "--help" || sub === "-h") {
+    printHelp26();
+    return;
+  }
+  switch (sub) {
+    case "run":
+      return runSubcommand(args);
+    case "install":
+      return installSubcommand();
+    case "uninstall":
+      return uninstallSubcommand();
+    case "list":
+      return listSubcommand();
+    case "status":
+      return statusSubcommand(args);
+    case "schedule":
+      return scheduleSubcommand(args);
+    default:
+      console.error(`Unknown trigger command: ${sub}. See \`keryx trigger --help\`.`);
+      printHelp26();
+      process.exitCode = 1;
+      return;
+  }
+}
+async function runSubcommand(args) {
+  const name = args[1];
+  if (args[1] === "--help" || args[1] === "-h") {
+    printHelp26();
+    return;
+  }
+  if (!name) {
+    console.error("Usage: keryx trigger run <name>");
+    process.exitCode = 1;
+    return;
+  }
+  await runTrigger(process.cwd(), name);
+}
+async function runTrigger(projectRoot, name) {
+  const resolution = resolveTriggerForRun(projectRoot, name);
+  switch (resolution.kind) {
+    case "config-absent": {
+      console.log(`keryx trigger run ${name}: no trigger config declared for this project ` + `(${triggersConfigPath(projectRoot)} not found) \u2014 nothing to do.`);
+      return;
+    }
+    case "config-broken": {
+      console.error(`keryx trigger run ${name}: ${triggersConfigPath(projectRoot)} could not be read as a trigger ` + `config (${resolution.fileProblem}) \u2014 fix the file and retry.`);
+      process.exitCode = 1;
+      return;
+    }
+    case "unknown-name": {
+      console.error(`keryx trigger run: unknown trigger "${name}". ` + (resolution.known.length > 0 ? `Known: ${resolution.known.join(", ")}` : "This project declares no valid triggers."));
+      process.exitCode = 1;
+      return;
+    }
+    case "rejected": {
+      console.error(`keryx trigger run: "${name}" is declared but malformed, so it cannot run:`);
+      for (const reason of resolution.reasons)
+        console.error(`  - ${reason}`);
+      process.exitCode = 1;
+      return;
+    }
+    case "disabled": {
+      console.log(`keryx trigger run ${name}: disabled \u2014 nothing to do.`);
+      await recordRun(projectRoot, resolution.entry, {
+        outcome: "no-op",
+        detail: "disabled \u2014 nothing to do.",
+        cost: { recorded: false, reason: "trigger is disabled \u2014 its action never ran" }
+      });
+      return;
+    }
+    case "ready": {
+      await runReadyTrigger(projectRoot, name, resolution);
+      return;
+    }
+  }
+}
+async function runReadyTrigger(projectRoot, name, resolution) {
+  const { entry } = resolution;
+  const { action } = entry;
+  if (action.kind === "open-flow") {
+    await runOpenFlow(projectRoot, name, entry, action);
+    return;
+  }
+  if (action.kind === "flow-next") {
+    await runFlowNext(projectRoot, name, entry, action);
+    return;
+  }
+  const outcome = await withTriggerRunLock(projectRoot, async () => {
+    const before = process.exitCode;
+    process.exitCode = 0;
+    if (action.kind === "reconcile") {
+      await syncCommand(["--apply"]);
+    } else {
+      await gdgraphCommand(["build"]);
+    }
+    const failed = (process.exitCode ?? 0) !== 0;
+    process.exitCode = before;
+    return { failed };
+  });
+  if (!outcome.acquired) {
+    console.log(`keryx trigger run ${name}: ${outcome.reason}`);
+    await recordRun(projectRoot, entry, {
+      outcome: "lock-refused",
+      detail: outcome.reason,
+      cost: { recorded: false, reason: "run was refused before the action could start" }
+    });
+    return;
+  }
+  if (outcome.result.failed) {
+    console.error(`keryx trigger run ${name}: action "${action.kind}" failed (see output above).`);
+    process.exitCode = 1;
+    await recordRun(projectRoot, entry, {
+      outcome: "failed",
+      detail: `action "${action.kind}" failed (see command output above for detail).`,
+      cost: NO_MODEL_COST
+    });
+    return;
+  }
+  console.log(`keryx trigger run ${name}: ok \u2014 "${action.kind}" completed.`);
+  await recordRun(projectRoot, entry, {
+    outcome: "ok",
+    detail: `action "${action.kind}" completed.`,
+    cost: NO_MODEL_COST
+  });
+}
+function findEquivalentOpenFlow(flows, template) {
+  return flows.find((flow) => flow.title === template && flow.status !== "done");
+}
+function noModelCost(reason) {
+  return { recorded: false, reason };
+}
+var OPEN_FLOW_NO_MODEL_COST = noModelCost('action "open-flow" does not call a model \u2014 opening a flow is deterministic bookkeeping (a new flow.json plus scaffold ' + "files), no spend to record.");
+var FLOW_NEXT_NO_MODEL_COST = noModelCost('action "flow-next" does not call a model in this build \u2014 it only reports the next task into this record; it never ' + "dispatches an agent turn, so there is nothing to record a cost for.");
+async function runOpenFlow(projectRoot, name, entry, action) {
+  const budget = await evaluateTriggerBudget(projectRoot, "open-flow");
+  if (!budget.allowed) {
+    await refuseOnBudget(projectRoot, name, entry, budget.reason);
+    return;
+  }
+  const service = getFlowService2();
+  let outcome;
+  try {
+    outcome = await withTriggerRunLock(projectRoot, async () => {
+      if (action.skipIfOpen) {
+        const flows = await service.list({ cwd: projectRoot });
+        const equivalent = findEquivalentOpenFlow(flows, action.template);
+        if (equivalent) {
+          return { kind: "skipped", equivalent };
+        }
+      }
+      const result = await service.init({ cwd: projectRoot, title: action.template });
+      return { kind: "opened", flowId: result.flow.id, dir: result.dir };
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`keryx trigger run ${name}: action "open-flow" failed: ${message}`);
+    process.exitCode = 1;
+    await recordRun(projectRoot, entry, {
+      outcome: "failed",
+      detail: `action "open-flow" failed: ${message}`,
+      cost: OPEN_FLOW_NO_MODEL_COST
+    });
+    return;
+  }
+  if (!outcome.acquired) {
+    console.log(`keryx trigger run ${name}: ${outcome.reason}`);
+    await recordRun(projectRoot, entry, {
+      outcome: "lock-refused",
+      detail: outcome.reason,
+      cost: { recorded: false, reason: "run was refused before the action could start" }
+    });
+    return;
+  }
+  if (outcome.result.kind === "skipped") {
+    const { equivalent } = outcome.result;
+    const detail = `flow ${equivalent.id} ("${equivalent.title}", status: ${equivalent.status}) is already open for ` + `template "${action.template}" and \`skipIfOpen\` is set \u2014 not opening a second one.`;
+    console.log(`keryx trigger run ${name}: ${detail}`);
+    await recordRun(projectRoot, entry, { outcome: "no-op", detail, cost: OPEN_FLOW_NO_MODEL_COST });
+    return;
+  }
+  const { flowId, dir } = outcome.result;
+  const detail = `opened flow ${flowId} ("${action.template}") at ${dir}.`;
+  console.log(`keryx trigger run ${name}: ok \u2014 ${detail}`);
+  await recordRun(projectRoot, entry, { outcome: "ok", detail, cost: OPEN_FLOW_NO_MODEL_COST });
+}
+async function runFlowNext(projectRoot, name, entry, action) {
+  const budget = await evaluateTriggerBudget(projectRoot, "flow-next");
+  if (!budget.allowed) {
+    await refuseOnBudget(projectRoot, name, entry, budget.reason);
+    return;
+  }
+  const service = getFlowService2();
+  try {
+    const decision = await service.next({ cwd: projectRoot, id: action.flow });
+    const detail = describeNextTaskDecision(action.flow, decision);
+    console.log(`keryx trigger run ${name}: ok \u2014 ${detail}`);
+    await recordRun(projectRoot, entry, { outcome: "ok", detail, cost: FLOW_NEXT_NO_MODEL_COST });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`keryx trigger run ${name}: action "flow-next" failed: ${message}`);
+    process.exitCode = 1;
+    await recordRun(projectRoot, entry, {
+      outcome: "failed",
+      detail: `action "flow-next" failed: ${message}`,
+      cost: FLOW_NEXT_NO_MODEL_COST
+    });
+  }
+}
+function describeNextTaskDecision(flowId, decision) {
+  const unresolvedNote = decision.unresolved.length > 0 ? ` (${decision.unresolved.length} other not-done task(s) carry an open, unresolved attempt.)` : "";
+  if (decision.kind === "ready") {
+    return `flow ${flowId}'s next task is ${decision.task.id} ("${decision.task.title}"), resume: ${decision.resume.kind}.` + unresolvedNote;
+  }
+  if (decision.kind === "blocked") {
+    const waiting = decision.blocked.map((entry) => `${entry.task.id} (waiting on ${entry.waitingOn.join(", ")})`).join("; ");
+    return `flow ${flowId} has work remaining but nothing startable \u2014 blocked: ${waiting}.${unresolvedNote}`;
+  }
+  return `flow ${flowId} has no undone task \u2014 nothing to report.${unresolvedNote}`;
+}
+async function refuseOnBudget(projectRoot, name, entry, reason) {
+  console.log(`keryx trigger run ${name}: ${reason}`);
+  await recordRun(projectRoot, entry, {
+    outcome: "budget-refused",
+    detail: reason,
+    cost: { recorded: false, reason: "run was refused on the spend ceiling before the action could start" }
+  });
+}
+async function recordRun(projectRoot, entry, outcome) {
+  const append = await appendTriggerRunRecord(projectRoot, {
+    at: new Date().toISOString(),
+    trigger: entry.name,
+    firedBy: entry.fire,
+    action: entry.action,
+    outcome: outcome.outcome,
+    detail: outcome.detail,
+    cost: outcome.cost
+  });
+  if (append.status === "failed") {
+    console.error(`keryx trigger run ${entry.name}: ! ${append.reason}`);
+  }
+}
+async function installSubcommand() {
+  const cwd = process.cwd();
+  if (!await hasGitHooksRoot(cwd)) {
+    console.log("No .git directory \u2014 nothing installed.");
+    return;
+  }
+  const results = await installTriggerHooks(cwd);
+  if (results.length === 0) {
+    console.log("keryx trigger install: no event-fired trigger declared " + `(${triggersConfigPath(cwd)}) \u2014 nothing to install. Schedule-fired and \`ci\`-fired entries install no hook; ` + "see `keryx trigger schedule <name>` for a schedule entry.");
+    return;
+  }
+  console.log(`keryx trigger install: installed ${results.length} hook block(s), extending the existing hook file(s):`);
+  for (const result of results) {
+    console.log(`  - ${result.name} -> ${result.hook} (${result.wrote ? "written" : "NOT written"})`);
+  }
+  console.log("\nOther managed blocks already in these hook files (e.g. `keryx sync install-hooks`'s `keryx-sync` block, " + "or a `keryx update`-installed `*-post-commit` block) are untouched and still run.");
+}
+async function uninstallSubcommand() {
+  const cwd = process.cwd();
+  const results = await uninstallTriggerHooks(cwd);
+  const removed = results.filter((r) => r.wrote);
+  console.log(removed.length > 0 ? `keryx trigger uninstall: removed ${removed.length} hook block(s): ${removed.map((r) => `${r.name} (${r.hook})`).join(", ")}` : "keryx trigger uninstall: no installed trigger hook block found to remove.");
+}
+async function listSubcommand() {
+  const cwd = process.cwd();
+  const { triggers, rejected, fileProblem } = loadTriggersConfig(cwd);
+  if (fileProblem === "absent") {
+    console.log(`keryx trigger list: no trigger config declared (${triggersConfigPath(cwd)} not found).`);
+    return;
+  }
+  if (fileProblem !== undefined) {
+    console.error(`keryx trigger list: ${triggersConfigPath(cwd)} could not be read as a trigger config (${fileProblem}).`);
+    process.exitCode = 1;
+    return;
+  }
+  if (triggers.length === 0 && rejected.length === 0) {
+    console.log("keryx trigger list: the trigger config declares no entries.");
+    return;
+  }
+  console.log(`keryx trigger list (${triggersConfigPath(cwd)}):`);
+  for (const entry of triggers) {
+    const hookNote = await describeHookInstalled(cwd, entry);
+    console.log(`  - ${entry.name}  [${entry.enabled ? "enabled" : "disabled"}]  ${describeFire(entry.fire)}  -> ${describeAction(entry.action)}  hook: ${hookNote}`);
+  }
+  for (const bad of rejected) {
+    console.log(`  - ${bad.name ?? `(entry #${bad.index})`}  [REJECTED]  ${bad.reasons.join("; ")}`);
+  }
+}
+async function describeHookInstalled(cwd, entry) {
+  if (entry.fire.kind === "schedule") {
+    return `n/a (schedule \u2014 see \`keryx trigger schedule ${entry.name}\`)`;
+  }
+  if (entry.fire.event === "ci") {
+    return "n/a (ci \u2014 fired by a CI job's own `keryx trigger run` call)";
+  }
+  return await isTriggerHookInstalled(cwd, entry) ? `installed (${entry.fire.event})` : `NOT installed (${entry.fire.event})`;
+}
+async function statusSubcommand(args) {
+  const filterName = args[1];
+  const cwd = process.cwd();
+  const { triggers, fileProblem } = loadTriggersConfig(cwd);
+  if (fileProblem === "absent") {
+    console.log(`keryx trigger status: no trigger config declared (${triggersConfigPath(cwd)} not found).`);
+    return;
+  }
+  if (fileProblem !== undefined) {
+    console.error(`keryx trigger status: ${triggersConfigPath(cwd)} could not be read as a trigger config (${fileProblem}).`);
+    process.exitCode = 1;
+    return;
+  }
+  const runsRead = await readTriggerRuns(cwd);
+  if (runsRead.state === "unreadable") {
+    console.error(`keryx trigger status: ${runsRead.reason}`);
+    process.exitCode = 1;
+    return;
+  }
+  const latest = latestRunByTrigger(runsRead.state === "present" ? runsRead.records : []);
+  const entries = filterName ? triggers.filter((entry) => entry.name === filterName) : triggers;
+  if (filterName && entries.length === 0) {
+    console.error(`keryx trigger status: unknown trigger "${filterName}". Known: ${triggers.map((t) => t.name).join(", ") || "(none)"}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (entries.length === 0) {
+    console.log("keryx trigger status: the trigger config declares no entries.");
+    return;
+  }
+  console.log(`keryx trigger status (reading ${runsRead.state === "present" ? runsRead.path : "no run record yet"}):`);
+  for (const entry of entries) {
+    console.log(`  - ${entry.name}  [${entry.enabled ? "enabled" : "disabled"}]  ${describeFire(entry.fire)}  -> ${describeAction(entry.action)}`);
+    const record = latest.get(entry.name);
+    console.log(`      ${record ? describeRecord(record) : "never fired \u2014 no record yet"}`);
+  }
+}
+function describeRecord(record) {
+  const cost = record.cost.recorded ? `cost: $${record.cost.usd.toFixed(4)}` : `cost: n/a (${record.cost.reason})`;
+  return `last: ${record.at} \u2014 ${record.outcome} \u2014 ${record.detail} [${cost}]`;
+}
+function describeFire(fire) {
+  return fire.kind === "event" ? `event:${fire.event}` : `schedule:"${fire.cron}"`;
+}
+function describeAction(action) {
+  if (action.kind === "open-flow")
+    return `open-flow(${action.template}${action.skipIfOpen ? ", skipIfOpen" : ""})`;
+  if (action.kind === "flow-next")
+    return `flow-next(${action.flow})`;
+  return action.kind;
+}
+async function scheduleSubcommand(args) {
+  const name = args[1];
+  if (args[1] === "--help" || args[1] === "-h") {
+    console.log("Usage: keryx trigger schedule <name>");
+    return;
+  }
+  if (!name) {
+    console.error("Usage: keryx trigger schedule <name>");
+    process.exitCode = 1;
+    return;
+  }
+  const cwd = process.cwd();
+  const resolution = resolveScheduleEntry(cwd, name);
+  switch (resolution.kind) {
+    case "config-absent": {
+      console.error(`keryx trigger schedule: no trigger config declared (${triggersConfigPath(cwd)} not found).`);
+      process.exitCode = 1;
+      return;
+    }
+    case "unknown-name": {
+      console.error(`keryx trigger schedule: unknown trigger "${name}". ` + (resolution.known.length > 0 ? `Known: ${resolution.known.join(", ")}` : "This project declares no valid triggers."));
+      process.exitCode = 1;
+      return;
+    }
+    case "not-a-schedule": {
+      console.error(`keryx trigger schedule: "${name}" is ${describeFire(resolution.entry.fire)}, not a schedule entry \u2014 ` + "there is nothing to print. Event-fired entries are installed as git hooks with `keryx trigger install`.");
+      process.exitCode = 1;
+      return;
+    }
+    case "ready": {
+      const lines = renderScheduleLines({
+        projectRoot: cwd,
+        name,
+        cron: resolution.entry.fire.cron,
+        invocation: resolveKeryxInvocation()
+      });
+      console.log(`keryx trigger schedule ${name}: keryx runs no daemon for this \u2014 install ONE of the two below with your own scheduler.
+`);
+      console.log(`# --- cron (crontab -e) --------------------------------------------------`);
+      console.log(lines.cronLine);
+      console.log(`# cron-command-only: ${lines.cronCommand}`);
+      console.log(`
+# --- systemd (an alternative to cron) -------------------------------------`);
+      console.log(lines.systemdService);
+      console.log(lines.systemdTimer);
+      console.log(`# Assumed PATH baked into both: ${lines.assumedPath}`);
+      console.log(`# Output is appended to: ${lines.logPath}`);
+      return;
+    }
+  }
+}
+function printHelp26() {
+  console.log(`keryx trigger \u2014 fire, install and inspect this project's declared triggers
+
+Usage:
+  keryx trigger run <name>        Perform exactly one pass of <name>'s action
+  keryx trigger install           Install a git hook block for every event-fired entry
+  keryx trigger uninstall         Remove those hook blocks (other managed blocks are untouched)
+  keryx trigger list              List declared entries: enabled state, fire, action, hook status
+  keryx trigger status [<name>]   Show the last recorded outcome for one or every entry (AC4)
+  keryx trigger schedule <name>   Print the cron line / systemd timer unit for a schedule entry
+
+Triggers are declared by hand in .metaproject/triggers.json (keryx never
+writes it) and loaded by name. \`run\`:
+  - exits 0 and says "nothing to do" when there is no trigger config, or the
+    named trigger is disabled;
+  - exits non-zero when the name is unknown, the matching entry is malformed,
+    or the action itself fails;
+  - refuses cleanly (exit 0) when another \`trigger run\` already holds this
+    project's trigger lock ("reconcile"/"rebuild" only), or when the
+    project's recorded trigger spend is at or over its spend ceiling
+    ("open-flow"/"flow-next" only \u2014 see \`keryx trigger status\` for the
+    recorded cost).
+
+Four actions run today: "reconcile" (-> \`keryx sync --apply\`), "rebuild"
+(-> \`keryx gdgraph build\`), "open-flow" (opens a flow from
+\`action.template\`, skipping a second one while an equivalent flow is
+already open when \`action.skipIfOpen\` is set), and "flow-next" (reports
+\`action.flow\`'s next task into the record \u2014 it does not dispatch an agent
+to work it). \`install\` writes hooks for event-fired entries only; a
+schedule entry's line comes from \`trigger schedule\`, and keryx never runs a
+daemon of its own for it.
+`);
+}
+
 // src/cli.ts
 var VERSION2 = package_default.version;
 var CLI_ROUTES = {
@@ -118405,18 +120765,20 @@ var CLI_ROUTES = {
   shell: shellCommand,
   sessions: sessionsCommand,
   session: sessionsCommand,
+  acp: acpCommand,
   bus: busCommand,
   version: versionCommand,
   workspace: workspaceCommand,
   retention: retentionCommand,
-  forgetting: forgettingCommand
+  forgetting: forgettingCommand,
+  trigger: triggerCommand
 };
 async function main() {
   setModelTurnPort(async (request) => runModelTurn(request));
   const args = process.argv.slice(2);
   const command = args[0];
   if (command === "--help" || command === "-h" || command === "help" || !command) {
-    printHelp25();
+    printHelp27();
     return;
   }
   if (command === "--version" || command === "-v") {
@@ -118439,7 +120801,7 @@ ${usage}
     return;
   }
   console.error(`Unknown command: ${command}`);
-  printHelp25();
+  printHelp27();
   process.exitCode = 1;
 }
 var USAGE_BODY = `Usage:
@@ -118448,6 +120810,8 @@ var USAGE_BODY = `Usage:
                                                Start TUI agent shell (sessions are per-project)
   keryx sessions list|fork <id>|export <id>|path
                                                List / branch / export sessions for the current project
+  keryx acp [--provider <p>] [--model <m>] [--base-url <url>] [--data-dir <dir>]
+                                               Agent Client Protocol agent server over stdio
   keryx bus list [--json] | log [--since <seq>] [--limit N] [--json] | send <@name|@all> [--kind <k>] [--reply-to <id>] <text> | prune
                                                Agent bus: peers, events and messages shared across this clone's worktrees
   keryx version check [--json]                 Check npm latest (advisory; never installs)
@@ -118562,12 +120926,15 @@ var USAGE_BODY = `Usage:
   keryx forgetting lookup "<ref-or-path>" [--layer <layer>] [--search] [--json]
                                                Read the deletion trail: what was removed, when, at
                                                whose request, on what basis
+  keryx trigger run <name>                      Perform exactly one pass of a declared trigger's
+                                               action (.metaproject/triggers.json)
   keryx --version
 
 Commands:
   shell     Start the interactive TUI agent harness. Use --no-tui or --chat to opt out.
             Sessions: -c continue last in this project, -r [id] resume (per-project).
   sessions  List or export per-project shell sessions
+  acp       Speak ACP v1 (newline-delimited JSON-RPC) over stdio, for an ACP client (e.g. an editor)
   bus       Agent bus: list peers and leases, read the log, send a message, prune
   version   Check whether a newer npm release is available
   harness   Run a single provider turn (harness run) and print structured events
@@ -118606,8 +120973,9 @@ Commands:
   workspace Shared Agent Context: workspaces, FWK reads, propose/review (module sac)
   retention Bound stores that grow without bound (gdctx raw/artifacts, owner write-conflict sidecars)
   forgetting Read the deletion trail \u2014 was this removed, or did it never exist?
+  trigger   Fire one declared project trigger (git hook, cron line, CI job) \u2014 one pass, one exit code
 `;
-function printHelp25() {
+function printHelp27() {
   console.log(`keryx ${VERSION2}
 
 ${USAGE_BODY}`);