agent-procedures 0.1.0 → 0.3.0

package/lib/auth.js

@@ -0,0 +1,169 @@
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import { Writable } from "node:stream";
+import {
+  PROVIDERS,
+  PROVIDER_NAMES,
+  credentialsFile,
+  readCredentials,
+  reflexHome,
+  resolveCredentials,
+} from "./providers.js";
+
+export const USAGE = `Usage:
+  npx agent-procedures auth login [--provider <name>] [--model <id>] [--key-stdin]
+  npx agent-procedures auth status
+
+Providers: ${PROVIDER_NAMES.join(", ")}
+
+Interactive by default. For scripts/CI, pipe the key on stdin:
+  echo "$OPENAI_API_KEY" | npx agent-procedures auth login --provider openai --key-stdin
+
+The groomer also reads ${PROVIDER_NAMES.map((p) => PROVIDERS[p].envVar).join(" / ")}
+directly, so \`auth login\` is optional if one of those is already set.`;
+
+function parseArgs(args) {
+  const out = { provider: null, model: null, keyStdin: false };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--provider" && args[i + 1]) out.provider = args[++i];
+    else if (a === "--model" && args[i + 1]) out.model = args[++i];
+    else if (a === "--key-stdin") out.keyStdin = true;
+    else throw new Error(`Unknown argument: ${a}\n\n${USAGE}`);
+  }
+  return out;
+}
+
+function ask(question, io) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: io.stdin, output: io.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// Readline with a muted output stream: line editing still works, nothing is echoed.
+function askHidden(question, io) {
+  return new Promise((resolve) => {
+    io.stdout.write(question);
+    const muted = new Writable({ write(_chunk, _enc, cb) { cb(); } });
+    const rl = readline.createInterface({ input: io.stdin, output: muted, terminal: true });
+    rl.question("", (answer) => {
+      rl.close();
+      io.stdout.write("\n");
+      resolve(answer.trim());
+    });
+  });
+}
+
+function readAll(stream) {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    stream.setEncoding("utf8");
+    stream.on("data", (c) => (data += c));
+    stream.on("end", () => resolve(data.trim()));
+    stream.on("error", reject);
+  });
+}
+
+async function chooseProvider(io) {
+  const menu = PROVIDER_NAMES.map((p, i) => `  [${i + 1}] ${PROVIDERS[p].label}`).join("\n");
+  const answer = await ask(`Provider:\n${menu}\n> `, io);
+  const byIndex = PROVIDER_NAMES[Number(answer) - 1];
+  const byName = PROVIDER_NAMES.find((p) => p === answer.toLowerCase());
+  const provider = byIndex || byName;
+  if (!provider) throw new Error(`Unknown provider "${answer}". Choose one of: ${PROVIDER_NAMES.join(", ")}`);
+  return provider;
+}
+
+function saveCredentials(provider, apiKey, model) {
+  const dir = reflexHome();
+  const file = credentialsFile();
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+
+  let creds = { version: 1, providers: {} };
+  try {
+    creds = { ...creds, ...(readCredentials() || {}) };
+  } catch (e) {
+    // corrupt file; start fresh
+  }
+  creds.providers = creds.providers || {};
+  creds.providers[provider] = { apiKey, model };
+  creds.defaultProvider = provider;
+
+  fs.writeFileSync(file, JSON.stringify(creds, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+  fs.chmodSync(file, 0o600); // mode above only applies on create
+  return file;
+}
+
+export async function login(args, io = { stdin: process.stdin, stdout: process.stdout }) {
+  const opts = parseArgs(args);
+  const interactive = Boolean(io.stdin.isTTY) && !opts.keyStdin;
+
+  let provider = opts.provider;
+  if (provider && !PROVIDERS[provider]) {
+    throw new Error(`Unsupported provider "${provider}". Choose one of: ${PROVIDER_NAMES.join(", ")}`);
+  }
+  if (!provider) {
+    if (!interactive) throw new Error(`--provider is required when not running interactively.\n\n${USAGE}`);
+    provider = await chooseProvider(io);
+  }
+  const def = PROVIDERS[provider];
+
+  let apiKey;
+  if (opts.keyStdin) {
+    apiKey = await readAll(io.stdin);
+  } else if (interactive) {
+    apiKey = await askHidden(`${def.label} API key (get one at ${def.keysUrl}): `, io);
+  } else {
+    throw new Error(`No key given. Use --key-stdin when not running interactively.\n\n${USAGE}`);
+  }
+  if (!apiKey) throw new Error("No key given.");
+
+  if (!apiKey.startsWith(def.keyPrefix)) {
+    io.stdout.write(`Warning: ${def.label} keys usually start with "${def.keyPrefix}". Checking anyway.\n`);
+  }
+
+  const model = opts.model || def.defaultModel;
+
+  io.stdout.write(`Checking key with ${def.label}... `);
+  try {
+    await def.verify(apiKey);
+  } catch (e) {
+    io.stdout.write("failed\n");
+    throw new Error(`${def.label} rejected the key: ${e.message}`);
+  }
+  io.stdout.write("ok\n");
+
+  const file = saveCredentials(provider, apiKey, model);
+  io.stdout.write(`Saved to ${file} (readable only by you)\n`);
+  io.stdout.write(`Provider: ${def.label}\nModel: ${model}\n`);
+}
+
+function maskKey(key) {
+  if (key.length <= 8) return "****";
+  return `${key.slice(0, 4)}...${key.slice(-4)}`;
+}
+
+export function status(io = { stdout: process.stdout }, cwd = process.cwd()) {
+  const resolved = resolveCredentials();
+  if (!resolved) {
+    io.stdout.write(
+      `Not configured. Run \`npx agent-procedures auth login\` or set one of: ${PROVIDER_NAMES.map((p) => PROVIDERS[p].envVar).join(", ")}\n`,
+    );
+  } else {
+    const def = PROVIDERS[resolved.provider];
+    const from = resolved.source === "env" ? `env ${def.envVar}` : credentialsFile();
+    io.stdout.write(`Provider: ${def.label}\nModel: ${resolved.model}\nKey: ${maskKey(resolved.apiKey)} (from ${from})\n`);
+  }
+
+  const log = path.join(cwd, ".reflex", "worker.log");
+  if (fs.existsSync(log)) {
+    const lines = fs.readFileSync(log, "utf8").trim().split("\n");
+    const last = lines[lines.length - 1];
+    if (last) io.stdout.write(`Last groomer error: ${last}\n`);
+  }
+}

package/lib/engine.js

@@ -0,0 +1,179 @@
+import {
+  appendProcedure,
+  appendTrace,
+  deleteTrace,
+  readProcedures,
+  readTrace,
+  startTrace,
+} from "./store.js";
+
+/**
+ * Harness-free hot path.
+ *
+ * Normalized event (produced by a harness adapter):
+ *   { type: "prompt", sessionId, promptId, prompt }
+ *   { type: "tool",   sessionId, promptId, tool, target, ok }
+ *   { type: "stop",   sessionId, promptId, interrupted, busy }
+ *
+ * Returns { context: string | null }. `context` is text the harness should
+ * inject into the agent's next turn, if it knows how.
+ */
+export function handleEvent(evt, reflexDir, deps = {}) {
+  if (!evt || !evt.sessionId || !evt.promptId) return { context: null };
+
+  if (evt.type === "prompt") return onPrompt(evt, reflexDir);
+  if (evt.type === "tool") return onTool(evt, reflexDir);
+  if (evt.type === "stop") return onStop(evt, reflexDir, deps);
+  return { context: null };
+}
+
+export const GROOM_THRESHOLD = 5;
+
+// --- prompt: open turn + recall ------------------------------------------
+
+function onPrompt(evt, reflexDir) {
+  const { sessionId, promptId, prompt } = evt;
+  startTrace(reflexDir, sessionId, promptId, { t: "Goal", prompt });
+
+  const hit = recall(prompt, readProcedures(reflexDir));
+  if (!hit) return { context: null };
+
+  appendTrace(reflexDir, sessionId, promptId, { t: "Recall", hit: hit.node.id });
+  return { context: hit.text };
+}
+
+function recall(prompt, procs) {
+  if (!prompt) return null;
+  const p = prompt.toLowerCase();
+  const fmt = (steps) => steps.map((s) => `- ${s.t}: ${s.target}`).join("\n");
+
+  for (const node of procs) {
+    if (node.enabled === false || node.parent_id) continue;
+
+    let match = node.trigger && p.includes(node.trigger.toLowerCase());
+    if (!match && Array.isArray(node.aliases)) {
+      match = node.aliases.some((a) => p.includes(a.toLowerCase()));
+    }
+    if (!match) continue;
+
+    let text = fmt(node.steps);
+    const alt = procs.find((e) => e.parent_id === node.id && e.type === "alt" && e.enabled !== false);
+    const onFail = procs.find((e) => e.parent_id === node.id && e.type === "on_fail" && e.enabled !== false);
+    if (alt) text += "\n\nAlternative path that worked:\n" + fmt(alt.steps);
+    if (onFail) text += "\n\nIf it fails, this recovery worked:\n" + fmt(onFail.steps);
+
+    return {
+      node,
+      text: `Reflex memory found a procedure for this task:\n\n${text}\n\nFollow these steps instead of figuring it out from scratch.`,
+    };
+  }
+  return null;
+}
+
+// --- tool: trace ----------------------------------------------------------
+
+function onTool(evt, reflexDir) {
+  appendTrace(reflexDir, evt.sessionId, evt.promptId, { t: evt.tool, target: evt.target || "", ok: evt.ok });
+  return { context: null };
+}
+
+// --- stop: judge → gate → synthesize → write ------------------------------
+
+function onStop(evt, reflexDir, deps) {
+  const { sessionId, promptId } = evt;
+  const lines = readTrace(reflexDir, sessionId, promptId);
+  if (lines.length === 0) return { context: null };
+
+  let goal = "";
+  let recallHit = null;
+  for (const l of lines) {
+    if (l.t === "Goal") goal = l.prompt;
+    if (l.t === "Recall" && l.hit) recallHit = l.hit;
+  }
+
+  if (judge(lines, evt)) {
+    const steps = synthesize(lines);
+    if (steps.length > 0) {
+      if (!recallHit) {
+        appendProcedure(reflexDir, {
+          id: Math.random().toString(36).slice(2, 11),
+          title: goal,
+          trigger: goal,
+          steps,
+          enabled: true,
+          hits: 0,
+          last_used_at: new Date().toISOString(),
+          created_at: new Date().toISOString(),
+          status: "pending_review",
+        });
+      } else {
+        const parent = readProcedures(reflexDir).find((p) => p.id === recallHit);
+        const parentSteps = parent ? parent.steps : [];
+        const same =
+          parentSteps.length === steps.length &&
+          parentSteps.every((s, i) => s.t === steps[i].t && s.target === steps[i].target);
+        if (!same) {
+          appendProcedure(reflexDir, {
+            parent_id: recallHit,
+            type: "alt",
+            steps,
+            created_at: new Date().toISOString(),
+            status: "pending_review",
+          });
+        }
+      }
+
+      const pending = readProcedures(reflexDir).filter((p) => p.status === "pending_review").length;
+      if (pending >= GROOM_THRESHOLD && deps.spawnGroomer) deps.spawnGroomer();
+    }
+  }
+
+  deleteTrace(reflexDir, sessionId, promptId);
+  return { context: null };
+}
+
+const READ_ONLY_CMDS = ["cat", "ls", "git", "pwd", "head", "tail", "echo", "grep", "find"];
+const PURE_READ_CMDS = ["cat", "ls", "pwd", "head", "tail"];
+
+function isMutating(t, target) {
+  if (t === "Edit" || t === "Write" || t === "NotebookEdit") return true;
+  if (t === "Bash" || t === "bash") {
+    const cmd = (target || "").trim();
+    if (!cmd) return false;
+    const first = cmd.split(" ")[0];
+    if (READ_ONLY_CMDS.includes(first)) {
+      return first === "git" && /\s(commit|push|add|rm|mv)\b/.test(cmd);
+    }
+    return true;
+  }
+  return false;
+}
+
+function judge(lines, evt) {
+  const steps = lines.filter((l) => l.t !== "Goal" && l.t !== "Recall");
+  if (!steps.some((l) => isMutating(l.t, l.target))) return false;
+  if (evt.interrupted || evt.busy) return false;
+
+  const failed = new Set();
+  for (const l of steps) {
+    const key = `${l.t}|${l.target}`;
+    if (l.ok === false) failed.add(key);
+    else if (l.ok === true) failed.delete(key);
+  }
+  return failed.size === 0;
+}
+
+function synthesize(lines) {
+  const steps = [];
+  for (const l of lines) {
+    if (l.t === "Goal" || l.t === "Recall" || l.ok === false) continue;
+    if (l.t === "Read" || l.t === "View") continue;
+    if (l.t === "Bash" || l.t === "bash") {
+      const target = l.target || "";
+      if (PURE_READ_CMDS.includes(target.trim().split(" ")[0])) continue;
+      if (/^git (status|log|diff)/.test(target)) continue;
+    }
+    steps.push({ t: l.t, target: l.target });
+  }
+  return steps;
+}

package/lib/groomer.js

@@ -0,0 +1,129 @@
+import fs from "node:fs";
+import path from "node:path";
+import { PROVIDERS, resolveCredentials } from "./providers.js";
+
+// Silent Failure Logging
+function logError(proceduresFile, msg) {
+  const reflexDir = path.dirname(proceduresFile);
+  const logFile = path.join(reflexDir, "worker.log");
+  const timestamp = new Date().toISOString();
+  try {
+    fs.appendFileSync(logFile, `[${timestamp}] ${msg}\n`, "utf8");
+  } catch (e) {
+    // nowhere to log, silently fail
+  }
+}
+
+export async function runGroomer(proceduresFile) {
+  let creds;
+  try {
+    creds = resolveCredentials();
+  } catch (e) {
+    logError(proceduresFile, e.message);
+    return;
+  }
+  if (!creds) {
+    logError(
+      proceduresFile,
+      "No API key found. Run `npx agent-procedures auth login` or set ANTHROPIC_API_KEY / OPENAI_API_KEY / GEMINI_API_KEY.",
+    );
+    return;
+  }
+  const { provider, apiKey, model } = creds;
+
+  if (!fs.existsSync(proceduresFile)) return;
+
+  const lines = fs
+    .readFileSync(proceduresFile, "utf8")
+    .split("\n")
+    .filter(Boolean);
+  const nodes = lines
+    .map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch (e) {
+        return null;
+      }
+    })
+    .filter(Boolean);
+
+  const pending = nodes.filter((n) => n.status === "pending_review");
+  if (pending.length === 0) return;
+
+  const prompt = `
+Here are ${pending.length} new execution nodes/edges added by a coding agent.
+
+<edges>
+${JSON.stringify(pending, null, 2)}
+</edges>
+
+For each item:
+1) Did the agent verify this worked? (e.g. ran a test, checked a log). If it just wrote code and blindly stopped without checking, it's risky.
+2) Is this a generic/reusable workflow, or a one-off anomaly?
+If it's unverified and risky, or a pure anomaly, decide to DROP it.
+If it's good, KEEP it.
+
+If you KEEP a root node (has no parent_id), generate 5-10 semantic aliases (synonyms) for its 'trigger' text so we can match variations of the user's prompt later.
+
+Return ONLY a JSON array of objects with this schema:
+[
+  {
+    "id": "node_id",
+    "action": "KEEP" | "DROP",
+    "aliases": ["alias1", "alias2"] // only if KEEP and root node
+  }
+]
+`;
+
+  let responseText;
+  try {
+    responseText = await PROVIDERS[provider].complete(apiKey, model, prompt);
+  } catch (err) {
+    logError(proceduresFile, err.message);
+    return;
+  }
+
+  let actions = [];
+  try {
+    const jsonStr = responseText
+      .replace(/```json/g, "")
+      .replace(/```/g, "")
+      .trim();
+    actions = JSON.parse(jsonStr);
+  } catch (e) {
+    logError(
+      proceduresFile,
+      "Failed to parse LLM JSON response: " + responseText,
+    );
+    return;
+  }
+
+  const newNodes = [];
+  for (const node of nodes) {
+    if (node.status === "pending_review") {
+      const actionDef = actions.find((a) => a.id === node.id);
+      if (actionDef) {
+        if (actionDef.action === "DROP") {
+          continue;
+        } else {
+          delete node.status;
+          if (!node.parent_id && actionDef.aliases) {
+            node.aliases = actionDef.aliases;
+          }
+        }
+      }
+    }
+    newNodes.push(node);
+  }
+
+  // Atomic Writes for the Groomer
+  const newFileContent =
+    newNodes.map((n) => JSON.stringify(n)).join("\n") + "\n";
+  const tmpFile = proceduresFile + ".tmp";
+  try {
+    fs.writeFileSync(tmpFile, newFileContent, "utf8");
+    fs.renameSync(tmpFile, proceduresFile);
+  } catch (err) {
+    logError(proceduresFile, `Failed atomic write: ${err.message}`);
+  }
+}

package/lib/harnesses/claude.js

@@ -0,0 +1,75 @@
+import fs from "node:fs";
+import path from "node:path";
+
+// Claude Code adapter. Everything Claude-specific lives here.
+// Docs: https://code.claude.com/docs/en/hooks
+
+const EVENTS = ["UserPromptSubmit", "PostToolUse", "PostToolUseFailure", "Stop"];
+
+export default {
+  id: "claude",
+
+  /** Where the generated hook shim goes, relative to the repo root. */
+  hookFile: ".claude/hooks/reflex.mjs",
+
+  /** Merge our hooks into .claude/settings.json without touching anything else. */
+  register(cwd) {
+    const settingsPath = path.join(cwd, ".claude", "settings.json");
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+      try {
+        settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+      } catch (e) {
+        console.warn("Failed to parse existing .claude/settings.json, overwriting...");
+      }
+    }
+    settings.hooks = settings.hooks || {};
+
+    for (const event of EVENTS) {
+      if (!Array.isArray(settings.hooks[event])) settings.hooks[event] = [];
+      const command = `node "$CLAUDE_PROJECT_DIR/${this.hookFile}" ${event}`;
+      const wired = settings.hooks[event].some((g) => (g.hooks || []).some((h) => h.command === command));
+      if (!wired) settings.hooks[event].push({ hooks: [{ type: "command", command }] });
+    }
+
+    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  },
+
+  /** Claude's stdin payload → normalized engine event, or null to ignore. */
+  normalize(eventName, payload) {
+    const name = payload.hook_event_name || eventName;
+    const base = { sessionId: payload.session_id, promptId: payload.prompt_id };
+
+    if (name === "UserPromptSubmit") {
+      return { type: "prompt", ...base, prompt: payload.prompt };
+    }
+    if (name === "PostToolUse" || name === "PostToolUseFailure") {
+      const tool = payload.tool_name;
+      const input = payload.tool_input || {};
+      let target = "";
+      if (tool === "Bash" || tool === "bash") target = input.command || "";
+      else if (typeof input === "string") target = input;
+      else target = input.target || input.file_path || input.path || "";
+      return { type: "tool", ...base, tool, target, ok: name === "PostToolUse" };
+    }
+    if (name === "Stop") {
+      return {
+        type: "stop",
+        ...base,
+        interrupted: payload.stop_hook_active === true,
+        busy: Array.isArray(payload.background_tasks) && payload.background_tasks.length > 0,
+      };
+    }
+    return null;
+  },
+
+  /** Engine result → what to print on stdout for Claude. */
+  render(evt, result) {
+    if (evt.type !== "prompt") return "";
+    if (!result.context) return "{}";
+    return JSON.stringify({
+      hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: result.context },
+    });
+  },
+};

package/lib/harnesses/index.js

@@ -0,0 +1,15 @@
+import claude from "./claude.js";
+
+// To add a harness: write lib/harnesses/<id>.js with the same shape as claude.js
+// (id, hookFile, register, normalize, render) and list it here.
+export const HARNESSES = { claude };
+
+export const DEFAULT_HARNESS = "claude";
+
+export function getHarness(id = DEFAULT_HARNESS) {
+  const h = HARNESSES[id];
+  if (!h) {
+    throw new Error(`Unknown harness "${id}". Available: ${Object.keys(HARNESSES).join(", ")}`);
+  }
+  return h;
+}

package/lib/init.js

@@ -1,11 +1,13 @@
 import fs from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { DEFAULT_HARNESS, getHarness } from "./harnesses/index.js";
+
+const LIB_DIR = path.dirname(fileURLToPath(import.meta.url));
 
 const DEFAULT_CONFIG = {
   version: 1,
-  harness: "cursor",
-  recall: true,
-  capture: true,
+  harness: "claude",
   minConfidence: 0.7,
   store: {
     procedures: "procedures.jsonl",
@@ -29,9 +31,14 @@ function writeIfMissing(filePath, contents) {
   return "created";
 }
 
+function writeAlways(filePath, contents) {
+  fs.writeFileSync(filePath, contents, "utf8");
+  return "updated";
+}
+
 function ensureGitignore(cwd) {
   const gitignorePath = path.join(cwd, ".gitignore");
-  const entry = ".reflex/";
+  const entry = ".reflex/traces/";
 
   if (!fs.existsSync(gitignorePath)) {
     fs.writeFileSync(gitignorePath, `${entry}\n`, "utf8");
@@ -41,7 +48,8 @@ function ensureGitignore(cwd) {
   const current = fs.readFileSync(gitignorePath, "utf8");
   const lines = current.split(/\r?\n/);
   const alreadyIgnored = lines.some(
-    (line) => line.trim() === ".reflex/" || line.trim() === ".reflex"
+    (line) =>
+      line.trim() === ".reflex/traces/" || line.trim() === ".reflex/traces",
   );
 
   if (alreadyIgnored) {
@@ -53,18 +61,62 @@ function ensureGitignore(cwd) {
   return "updated";
 }
 
-export function init(cwd = process.cwd()) {
+// One bundled file, built by `npm run build` into dist/runtime.js.
+// npx doesn't leave the package behind, so the repo carries this artifact.
+const RUNTIME_SRC = path.join(LIB_DIR, "..", "dist", "runtime.js");
+
+function installRuntime(reflexDir) {
+  if (!fs.existsSync(RUNTIME_SRC)) {
+    throw new Error("Missing dist/runtime.js. Run `npm run build` in the agent-procedures repo first.");
+  }
+  fs.copyFileSync(RUNTIME_SRC, path.join(reflexDir, "runtime.js"));
+  const engineDir = path.join(reflexDir, "engine");
+  if (fs.existsSync(engineDir)) fs.rmSync(engineDir, { recursive: true, force: true });
+  return "updated";
+}
+
+// A few lines that point the harness's hook at the shared engine.
+function writeShim(cwd, harness) {
+  const hookPath = path.join(cwd, harness.hookFile);
+  const enginePath = path.join(cwd, ".reflex", "runtime.js");
+  let rel = path.relative(path.dirname(hookPath), enginePath).split(path.sep).join("/");
+  if (!rel.startsWith(".")) rel = "./" + rel;
+
+  ensureDir(path.dirname(hookPath));
+  writeAlways(
+    hookPath,
+    `#!/usr/bin/env node
+// Generated by agent-procedures init. Re-run init to refresh; do not edit.
+import { run } from "${rel}";
+await run(${JSON.stringify(harness.id)});
+`,
+  );
+  fs.chmodSync(hookPath, 0o755);
+}
+
+export function init(cwd = process.cwd(), { harness: harnessId = DEFAULT_HARNESS } = {}) {
+  const harness = getHarness(harnessId);
   const reflexDir = path.join(cwd, ".reflex");
+  const tracesDir = path.join(reflexDir, "traces");
+
+  ensureDir(reflexDir);
+  ensureDir(tracesDir);
+
   const results = {
-    dir: ensureDir(reflexDir),
+    dir: "exists",
     config: writeIfMissing(
       path.join(reflexDir, "config.json"),
-      `${JSON.stringify(DEFAULT_CONFIG, null, 2)}\n`
+      `${JSON.stringify({ ...DEFAULT_CONFIG, harness: harness.id }, null, 2)}\n`,
     ),
     procedures: writeIfMissing(path.join(reflexDir, "procedures.jsonl"), ""),
     runs: writeIfMissing(path.join(reflexDir, "runs.jsonl"), ""),
     gitignore: ensureGitignore(cwd),
+    runtime: installRuntime(reflexDir),
   };
 
+  writeShim(cwd, harness);
+  harness.register(cwd);
+  results.hooks = "updated";
+
   return results;
 }