zelari-code 1.14.3 → 1.15.0

package/dist/cli/main.bundled.js

@@ -308,7 +308,7 @@ async function refreshGrokToken(options) {
   return parseTokenResponseBody(obj, accessToken);
 }
 async function openBrowser(url2) {
-  const { spawn: spawn10 } = await import("node:child_process");
+  const { spawn: spawn11 } = await import("node:child_process");
   const cmd = (() => {
     switch (process.platform) {
       case "darwin":
@@ -321,7 +321,7 @@ async function openBrowser(url2) {
   })();
   return new Promise((resolve, reject) => {
     try {
-      const child = spawn10(cmd.bin, cmd.args, {
+      const child = spawn11(cmd.bin, cmd.args, {
         stdio: "ignore",
         detached: true
       });
@@ -1543,10 +1543,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path36) {
-  if (!path36)
+function getElementAtPath(obj, path37) {
+  if (!path37)
     return obj;
-  return path36.reduce((acc, key) => acc?.[key], obj);
+  return path37.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1874,11 +1874,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path36, issues) {
+function prefixIssues(path37, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path36);
+    iss.path.unshift(path37);
     return iss;
   });
 }
@@ -2096,16 +2096,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path36 = []) => {
+  const processError = (error52, path37 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path36, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path37, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path36, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path37, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path36, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path37, ...issue2.path]);
       } else {
-        const fullpath = [...path36, ...issue2.path];
+        const fullpath = [...path37, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -2132,17 +2132,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path36 = []) => {
+  const processError = (error52, path37 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path36, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path37, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path36, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path37, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path36, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path37, ...issue2.path]);
       } else {
-        const fullpath = [...path36, ...issue2.path];
+        const fullpath = [...path37, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -2174,8 +2174,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path36 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path36) {
+  const path37 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path37) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -15678,13 +15678,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path36 = ref.slice(1).split("/").filter(Boolean);
-  if (path36.length === 0) {
+  const path37 = ref.slice(1).split("/").filter(Boolean);
+  if (path37.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path36[0] === defsKey) {
-    const key = path36[1];
+  if (path37[0] === defsKey) {
+    const key = path37[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -17784,11 +17784,11 @@ var init_tools = __esm({
           if (!ctx.addDocument)
             return "Knowledge vault tool not available.";
           const title = args["title"] || "New Document";
-          const path36 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+          const path37 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
           const content = args["content"] || "";
           const tags = args["tags"] || [];
           ctx.addDocument({
-            path: path36,
+            path: path37,
             title,
             content,
             format: "markdown",
@@ -17797,7 +17797,7 @@ var init_tools = __esm({
             workspaceId: ctx.workspaceId
           });
           ctx.addActivity("vault", "created document", title);
-          return `Document "${title}" created at "${path36}".`;
+          return `Document "${title}" created at "${path37}".`;
         }
       }
     ];
@@ -22509,21 +22509,21 @@ function normalizeAuth(auth) {
   return "agent";
 }
 function readSecrets() {
-  const path36 = getSshSecretsPath();
-  if (!existsSync9(path36)) return {};
+  const path37 = getSshSecretsPath();
+  if (!existsSync9(path37)) return {};
   try {
-    return JSON.parse(readFileSync7(path36, "utf8"));
+    return JSON.parse(readFileSync7(path37, "utf8"));
   } catch {
     return {};
   }
 }
 function writeSecrets(data) {
-  const path36 = getSshSecretsPath();
-  mkdirSync6(dirname2(path36), { recursive: true });
-  writeFileSync5(path36, `${JSON.stringify(data, null, 2)}
+  const path37 = getSshSecretsPath();
+  mkdirSync6(dirname2(path37), { recursive: true });
+  writeFileSync5(path37, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
-    chmodSync(path36, 384);
+    chmodSync(path37, 384);
   } catch {
   }
 }
@@ -22552,10 +22552,10 @@ function deleteSshPassword(id) {
   writeSecrets({ passwords });
 }
 function readStore2() {
-  const path36 = getSshTargetsPath();
-  if (!existsSync9(path36)) return [];
+  const path37 = getSshTargetsPath();
+  if (!existsSync9(path37)) return [];
   try {
-    const parsed = JSON.parse(readFileSync7(path36, "utf8"));
+    const parsed = JSON.parse(readFileSync7(path37, "utf8"));
     const list = Array.isArray(parsed.targets) ? parsed.targets : [];
     return list.filter(
       (t) => t && typeof t.id === "string" && typeof t.host === "string" && typeof t.user === "string"
@@ -22570,11 +22570,11 @@ function readStore2() {
   }
 }
 function writeStore2(targets) {
-  const path36 = getSshTargetsPath();
-  mkdirSync6(dirname2(path36), { recursive: true });
+  const path37 = getSshTargetsPath();
+  mkdirSync6(dirname2(path37), { recursive: true });
   const clean = targets.map(({ hasPassword: _hp, ...t }) => t);
   writeFileSync5(
-    path36,
+    path37,
     `${JSON.stringify({ targets: clean }, null, 2)}
 `,
     "utf8"
@@ -22820,11 +22820,11 @@ function formatSshTargetsForPrompt() {
   ];
   for (const t of targets) {
     const tags = t.tags?.length ? ` tags=[${t.tags.join(",")}]` : "";
-    const path36 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
+    const path37 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
     const allow = t.allowedCommands?.length ? ` allowed=${t.allowedCommands.join("|")}` : " allowed=status-only";
     const auth = t.auth === "password" ? " auth=password" : t.auth === "keyPath" ? " auth=key" : " auth=agent";
     lines.push(
-      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path36}${tags}${allow}`
+      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path37}${tags}${allow}`
     );
   }
   return lines.join("\n");
@@ -22949,6 +22949,304 @@ var init_tools6 = __esm({
   }
 });
 
+// src/cli/workspace/worldModel.ts
+import { promises as fs13 } from "node:fs";
+import path23 from "node:path";
+import { spawn as spawn5 } from "node:child_process";
+function worldDir(cwd) {
+  return path23.join(cwd, WORLD_DIR_NAME);
+}
+async function ensureWorldDir(cwd) {
+  const dir = worldDir(cwd);
+  await fs13.mkdir(dir, { recursive: true });
+  return dir;
+}
+async function appendTimeline(cwd, entry) {
+  const dir = await ensureWorldDir(cwd);
+  const line = JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }) + "\n";
+  await fs13.appendFile(path23.join(dir, TIMELINE_FILE), line, "utf8");
+}
+async function readChecks(cwd) {
+  const p3 = path23.join(worldDir(cwd), CHECKS_FILE);
+  try {
+    const raw = await fs13.readFile(p3, "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.checks) ? parsed.checks : [];
+  } catch {
+    return [];
+  }
+}
+function runShell(command, cwd, timeoutMs, signal) {
+  return new Promise((resolve) => {
+    const isWin = process.platform === "win32";
+    const child = spawn5(isWin ? "cmd.exe" : "/bin/sh", isWin ? ["/c", command] : ["-c", command], {
+      cwd,
+      env: process.env,
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (exitCode) => {
+      if (settled) return;
+      settled = true;
+      resolve({ exitCode, stdout, stderr });
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      finish(124);
+    }, timeoutMs);
+    if (signal) {
+      if (signal.aborted) {
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+        clearTimeout(timer);
+        finish(130);
+        return;
+      }
+      signal.addEventListener(
+        "abort",
+        () => {
+          try {
+            child.kill("SIGTERM");
+          } catch {
+          }
+          clearTimeout(timer);
+          finish(130);
+        },
+        { once: true }
+      );
+    }
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString("utf8");
+      if (stdout.length > 32e3) stdout = stdout.slice(0, 32e3);
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString("utf8");
+      if (stderr.length > 32e3) stderr = stderr.slice(0, 32e3);
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      finish(1);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      finish(code ?? 1);
+    });
+  });
+}
+async function runBacktest(cwd, signal) {
+  const checksPath = path23.join(worldDir(cwd), CHECKS_FILE);
+  const hypothesisPath = path23.join(worldDir(cwd), HYPOTHESIS_FILE);
+  const checks = await readChecks(cwd);
+  if (checks.length === 0) {
+    return {
+      ok: false,
+      passed: 0,
+      failed: 0,
+      total: 0,
+      results: [],
+      hypothesisPath,
+      checksPath
+    };
+  }
+  const results = [];
+  for (const c of checks) {
+    const expectExit = c.expectExit ?? 0;
+    const timeoutMs = c.timeoutMs ?? 12e4;
+    const start = Date.now();
+    const { exitCode, stdout, stderr } = await runShell(c.command, cwd, timeoutMs, signal);
+    const combined = `${stdout}${stderr}`;
+    const preview = combined.slice(0, 400);
+    let ok = exitCode === expectExit;
+    let mismatch;
+    if (!ok) {
+      mismatch = `exit ${exitCode} (expected ${expectExit})`;
+    } else if (c.expectStdoutIncludes && !combined.includes(c.expectStdoutIncludes)) {
+      ok = false;
+      mismatch = `stdout missing substring: ${c.expectStdoutIncludes}`;
+    }
+    results.push({
+      id: c.id,
+      command: c.command,
+      ok,
+      exitCode,
+      expectExit,
+      durationMs: Date.now() - start,
+      stdoutPreview: preview,
+      ...mismatch ? { mismatch } : {}
+    });
+  }
+  const passed = results.filter((r) => r.ok).length;
+  const failed = results.length - passed;
+  const summary = {
+    ok: failed === 0 && results.length > 0,
+    passed,
+    failed,
+    total: results.length,
+    results,
+    hypothesisPath,
+    checksPath
+  };
+  await appendTimeline(cwd, { kind: "backtest", ok: summary.ok, passed, failed, total: results.length });
+  return summary;
+}
+function createWorldModelTools() {
+  if (process.env["ZELARI_SCHEMA_LOOP"] === "0") return [];
+  return [
+    updateWorldHypothesisTool,
+    setWorldChecksTool,
+    runBacktestTool,
+    recordWorldObservationTool
+  ];
+}
+var WORLD_DIR_NAME, HYPOTHESIS_FILE, CHECKS_FILE, TIMELINE_FILE, UpdateHypothesisSchema, updateWorldHypothesisTool, WorldCheckSchema, SetChecksSchema, setWorldChecksTool, RunBacktestSchema, runBacktestTool, RecordObsSchema, recordWorldObservationTool;
+var init_worldModel = __esm({
+  "src/cli/workspace/worldModel.ts"() {
+    "use strict";
+    init_zod();
+    init_toolTypes();
+    WORLD_DIR_NAME = path23.join(".zelari", "world");
+    HYPOTHESIS_FILE = "hypothesis.md";
+    CHECKS_FILE = "checks.json";
+    TIMELINE_FILE = "timeline.jsonl";
+    UpdateHypothesisSchema = external_exports.object({
+      content: external_exports.string().min(1).describe("Full markdown hypothesis / working notes (replaces file)."),
+      append: external_exports.boolean().optional().describe("If true, append content under a timestamp instead of replacing.")
+    });
+    updateWorldHypothesisTool = {
+      name: "update_world_hypothesis",
+      description: "Write or append the task world-model hypothesis (Schema-style notes.md) to .zelari/world/hypothesis.md. Use this to record what you believe is true about the bug/system, competing hypotheses, and what experiment would discriminate them. Do NOT claim work is done until run_backtest is green.",
+      permissions: ["write"],
+      timeoutMs: 1e4,
+      inputSchema: UpdateHypothesisSchema,
+      execute: async (args, ctx) => {
+        try {
+          const dir = await ensureWorldDir(ctx.cwd);
+          const file2 = path23.join(dir, HYPOTHESIS_FILE);
+          if (args.append) {
+            const block = `
+
+## ${(/* @__PURE__ */ new Date()).toISOString()}
+
+${args.content}
+`;
+            await fs13.appendFile(file2, block, "utf8");
+          } else {
+            await fs13.writeFile(file2, args.content, "utf8");
+          }
+          const st = await fs13.stat(file2);
+          await appendTimeline(ctx.cwd, { kind: "hypothesis_update", bytes: st.size, append: !!args.append });
+          return typedOk({ path: file2, bytes: st.size });
+        } catch (err) {
+          return typedErr(err instanceof Error ? err.message : String(err));
+        }
+      }
+    };
+    WorldCheckSchema = external_exports.object({
+      id: external_exports.string().min(1),
+      command: external_exports.string().min(1),
+      expectExit: external_exports.number().int().optional(),
+      expectStdoutIncludes: external_exports.string().optional(),
+      timeoutMs: external_exports.number().int().positive().max(6e5).optional()
+    });
+    SetChecksSchema = external_exports.object({
+      checks: external_exports.array(WorldCheckSchema).min(1).describe("List of certifiable shell checks (typecheck, unit tests, smoke scripts).")
+    });
+    setWorldChecksTool = {
+      name: "set_world_checks",
+      description: "Replace .zelari/world/checks.json with certifiable checks used by run_backtest. Each check is a shell command + expected exit code (default 0). Prefer fast, deterministic commands (npm run typecheck, npx vitest run path/to/file).",
+      permissions: ["write"],
+      timeoutMs: 1e4,
+      inputSchema: SetChecksSchema,
+      execute: async (args, ctx) => {
+        try {
+          const dir = await ensureWorldDir(ctx.cwd);
+          const file2 = path23.join(dir, CHECKS_FILE);
+          const body = { checks: args.checks };
+          await fs13.writeFile(file2, JSON.stringify(body, null, 2) + "\n", "utf8");
+          await appendTimeline(ctx.cwd, { kind: "checks_set", count: args.checks.length });
+          return typedOk({ path: file2, count: args.checks.length });
+        } catch (err) {
+          return typedErr(err instanceof Error ? err.message : String(err));
+        }
+      }
+    };
+    RunBacktestSchema = external_exports.object({
+      /** Reserved for future selective runs. */
+      dryRun: external_exports.boolean().optional()
+    });
+    runBacktestTool = {
+      name: "run_backtest",
+      description: "Schema-style certify: run every check in .zelari/world/checks.json and report exact pass/fail (exit code + optional stdout substring). Appends a timeline entry. If total=0, call set_world_checks first. NEVER claim the task is done when ok=false. On mismatch, revise hypothesis (update_world_hypothesis) and the implementation, then re-run.",
+      permissions: ["execute"],
+      timeoutMs: 6e5,
+      inputSchema: RunBacktestSchema,
+      execute: async (args, ctx) => {
+        try {
+          if (args.dryRun) {
+            const checks = await readChecks(ctx.cwd);
+            return typedOk({
+              ok: false,
+              passed: 0,
+              failed: 0,
+              total: checks.length,
+              results: checks.map((c) => ({
+                id: c.id,
+                command: c.command,
+                ok: false,
+                exitCode: -1,
+                expectExit: c.expectExit ?? 0,
+                durationMs: 0,
+                stdoutPreview: "(dryRun)",
+                mismatch: "dryRun"
+              })),
+              hypothesisPath: path23.join(worldDir(ctx.cwd), HYPOTHESIS_FILE),
+              checksPath: path23.join(worldDir(ctx.cwd), CHECKS_FILE)
+            });
+          }
+          const result = await runBacktest(ctx.cwd, ctx.signal);
+          return typedOk(result);
+        } catch (err) {
+          return typedErr(err instanceof Error ? err.message : String(err));
+        }
+      }
+    };
+    RecordObsSchema = external_exports.object({
+      kind: external_exports.string().min(1).describe("Observation kind, e.g. surprise, probe, prediction_mismatch."),
+      summary: external_exports.string().min(1),
+      data: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
+    });
+    recordWorldObservationTool = {
+      name: "record_world_observation",
+      description: "Append one ground-truth observation to .zelari/world/timeline.jsonl (Schema timeline). Use after a surprising tool result (prediction mismatch, unexpected exit code, wrong path) so later deliberation cannot rewrite history.",
+      permissions: ["write"],
+      timeoutMs: 5e3,
+      inputSchema: RecordObsSchema,
+      execute: async (args, ctx) => {
+        try {
+          const dir = await ensureWorldDir(ctx.cwd);
+          const file2 = path23.join(dir, TIMELINE_FILE);
+          await appendTimeline(ctx.cwd, {
+            kind: args.kind,
+            summary: args.summary,
+            ...args.data ? { data: args.data } : {}
+          });
+          return typedOk({ path: file2 });
+        } catch (err) {
+          return typedErr(err instanceof Error ? err.message : String(err));
+        }
+      }
+    };
+  }
+});
+
 // src/cli/toolRegistry.ts
 var toolRegistry_exports = {};
 __export(toolRegistry_exports, {
@@ -23037,6 +23335,17 @@ function createBuiltinToolRegistry(options = {}) {
       });
     }
   }
+  if (!readOnly) {
+    for (const t of createWorldModelTools()) {
+      const safe = wrapWithAudit(t, audit, sessionId);
+      registry3.register(safe);
+      tools.push({
+        name: t.name,
+        description: t.description,
+        permissions: t.permissions ?? []
+      });
+    }
+  }
   if (!readOnly && options.enableTask !== false) {
     const taskTool = createTaskTool({
       createSubAgentContext: async () => {
@@ -23276,6 +23585,7 @@ var init_toolRegistry = __esm({
     init_tools4();
     init_tools5();
     init_tools6();
+    init_worldModel();
     init_openai_compatible();
     init_skills2();
     HARNESS_BUILTIN_NAMES = /* @__PURE__ */ new Set([
@@ -24069,11 +24379,11 @@ var init_synthesisAudit = __esm({
 import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join3 } from "node:path";
 function loadNfrSpec(zelariRoot) {
-  const path36 = join3(zelariRoot, "nfr-spec.json");
-  if (!existsSync11(path36))
+  const path37 = join3(zelariRoot, "nfr-spec.json");
+  if (!existsSync11(path37))
     return null;
   try {
-    const raw = JSON.parse(readFileSync9(path36, "utf8"));
+    const raw = JSON.parse(readFileSync9(path37, "utf8"));
     if (raw.version !== 1 || !Array.isArray(raw.targets))
       return null;
     return raw;
@@ -26321,9 +26631,9 @@ var init_types2 = __esm({
 import { readFileSync as readFileSync14 } from "node:fs";
 import { join as join9 } from "node:path";
 function readLessonsDeduped(zelariRoot) {
-  const path36 = join9(zelariRoot, LESSONS_FILE);
+  const path37 = join9(zelariRoot, LESSONS_FILE);
   try {
-    const raw = readFileSync14(path36, "utf8");
+    const raw = readFileSync14(path37, "utf8");
     const byId = /* @__PURE__ */ new Map();
     for (const line of raw.split(/\r?\n/)) {
       if (!line.trim())
@@ -26424,8 +26734,8 @@ function keywordsFrom(check2, signature) {
   return [.../* @__PURE__ */ new Set([...fromId, ...words])].slice(0, 12);
 }
 function writeLesson(zelariRoot, lesson) {
-  const path36 = join10(zelariRoot, LESSONS_FILE);
-  appendFileSync2(path36, `${JSON.stringify(lesson)}
+  const path37 = join10(zelariRoot, LESSONS_FILE);
+  appendFileSync2(path37, `${JSON.stringify(lesson)}
 `, "utf8");
 }
 function findSimilar(lessons, signature) {
@@ -27933,28 +28243,28 @@ var init_storage = __esm({
     VALID_SCALARS = /^(true|false|null|~)$/i;
     Storage = class {
       /** Read a Markdown file with frontmatter. Throws if not found. */
-      read(path36) {
-        if (!existsSync16(path36)) {
-          throw new Error(`File not found: ${path36}`);
+      read(path37) {
+        if (!existsSync16(path37)) {
+          throw new Error(`File not found: ${path37}`);
         }
-        const md = readFileSync16(path36, "utf8");
+        const md = readFileSync16(path37, "utf8");
         return parseFrontmatter(md);
       }
       /** Read a Markdown file; returns null if not found. */
-      readIfExists(path36) {
-        if (!existsSync16(path36)) return null;
-        return this.read(path36);
+      readIfExists(path37) {
+        if (!existsSync16(path37)) return null;
+        return this.read(path37);
       }
       /**
        * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
        * The meta object is serialized as YAML frontmatter; body as Markdown.
        */
-      write(path36, meta3, body) {
-        mkdirSync8(dirname3(path36), { recursive: true });
-        const tmp = path36 + ".tmp-" + process.pid;
+      write(path37, meta3, body) {
+        mkdirSync8(dirname3(path37), { recursive: true });
+        const tmp = path37 + ".tmp-" + process.pid;
         const md = serializeFrontmatter(meta3, body);
         writeFileSync12(tmp, md, "utf8");
-        renameSync2(tmp, path36);
+        renameSync2(tmp, path37);
       }
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
@@ -28032,8 +28342,8 @@ function readPlan(ctx) {
     } catch {
     }
   }
-  const path36 = workspaceFile(ctx.rootDir, "plan");
-  const doc = ctx.storage.readIfExists(path36);
+  const path37 = workspaceFile(ctx.rootDir, "plan");
+  const doc = ctx.storage.readIfExists(path37);
   if (!doc) return { phases: [], tasks: [], milestones: [] };
   const meta3 = doc.meta;
   return {
@@ -28198,7 +28508,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path36 = join15(ctx.rootDir, "milestones", `${id}.md`);
+  const path37 = join15(ctx.rootDir, "milestones", `${id}.md`);
   const meta3 = {
     kind: "milestone",
     id,
@@ -28215,7 +28525,7 @@ function addMilestoneRecord(ctx, summary, input) {
     `Target version: ${version2}`,
     ""
   ].join("\n");
-  ctx.storage.write(path36, meta3, body);
+  ctx.storage.write(path37, meta3, body);
   return { id, created: true };
 }
 function readPlanSummary(ctx) {
@@ -28419,7 +28729,7 @@ function addIdeaStub(ctx) {
         const tags = args["tags"] ?? [];
         const category = args["category"] ?? "General";
         const id = `${nextAdrId(ctx)}-${slugify3(title)}`;
-        const path36 = workspaceArtifact(ctx.rootDir, "decisions", id);
+        const path37 = workspaceArtifact(ctx.rootDir, "decisions", id);
         const meta3 = {
           kind: "adr",
           status: "proposed",
@@ -28445,7 +28755,7 @@ function addIdeaStub(ctx) {
           ...consequences.map((c) => `- ${c}`),
           ""
         ].join("\n");
-        ctx.storage.write(path36, meta3, body);
+        ctx.storage.write(path37, meta3, body);
         return `ADR ${id} created: "${title}". Status: proposed. Promote to accepted via /update ADR or manual edit.`;
       });
     }
@@ -28527,14 +28837,14 @@ function createDocumentStub(ctx) {
           ctx.storage.write(risksPath, riskMeta, content);
           return `Document "${title}" created at risks.md (workspace root).`;
         }
-        const path36 = workspaceArtifact(ctx.rootDir, "docs", slug);
+        const path37 = workspaceArtifact(ctx.rootDir, "docs", slug);
         const meta3 = {
           kind: "doc",
           id: slug,
           date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
           tags
         };
-        ctx.storage.write(path36, meta3, content);
+        ctx.storage.write(path37, meta3, content);
         return `Document "${title}" created at docs/${slug}.md.`;
       });
     }
@@ -28751,17 +29061,17 @@ __export(updater_exports, {
   resolveBundledNpmCli: () => resolveBundledNpmCli
 });
 import { createRequire as createRequire2 } from "node:module";
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 import { existsSync as existsSync18 } from "node:fs";
-import path23 from "node:path";
+import path24 from "node:path";
 import { fileURLToPath } from "node:url";
 function resolveBundledNpmCli(execPath = process.execPath) {
-  const dir = path23.dirname(execPath);
+  const dir = path24.dirname(execPath);
   const candidates = [
     // Windows: C:\...\node.exe → C:\...\node_modules\npm\bin\npm-cli.js
-    path23.join(dir, "node_modules", "npm", "bin", "npm-cli.js"),
+    path24.join(dir, "node_modules", "npm", "bin", "npm-cli.js"),
     // POSIX: <prefix>/bin/node → <prefix>/lib/node_modules/npm/bin/npm-cli.js
-    path23.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
+    path24.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
   ];
   for (const candidate of candidates) {
     try {
@@ -28778,7 +29088,7 @@ function looksLikeBrokenShim(exitCode, output) {
 }
 function getCurrentVersion() {
   try {
-    const pkgPath = path23.resolve(__dirname2, "..", "..", "package.json");
+    const pkgPath = path24.resolve(__dirname2, "..", "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {
@@ -28838,7 +29148,7 @@ async function checkForUpdate(fetcher = fetch, registryUrl) {
     updateAvailable: cmp < 0
   };
 }
-async function performUpdate(packageName = "zelari-code", executor = spawn5, resolveNpmCli = resolveBundledNpmCli) {
+async function performUpdate(packageName = "zelari-code", executor = spawn6, resolveNpmCli = resolveBundledNpmCli) {
   const args = ["install", "-g", `${packageName}@latest`];
   const primary = await runNpm(executor, args, "shim");
   if (primary.ok) return primary;
@@ -28890,13 +29200,13 @@ var init_updater = __esm({
     "use strict";
     init_cmdline();
     require2 = createRequire2(import.meta.url);
-    __dirname2 = path23.dirname(fileURLToPath(import.meta.url));
+    __dirname2 = path24.dirname(fileURLToPath(import.meta.url));
     REGISTRY_URL = "https://registry.npmjs.org/zelari-code/latest";
   }
 });
 
 // src/cli/mcp/mcpClient.ts
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 var DEFAULT_REQUEST_TIMEOUT_MS, INIT_TIMEOUT_MS, MCP_PROTOCOL_VERSION, McpClient;
 var init_mcpClient = __esm({
   "src/cli/mcp/mcpClient.ts"() {
@@ -28924,10 +29234,10 @@ var init_mcpClient = __esm({
           env: { ...process.env, ...this.config.env ?? {} },
           windowsHide: true
         };
-        const child = process.platform === "win32" ? spawn6(buildCmdLine(this.config.command, this.config.args ?? []), {
+        const child = process.platform === "win32" ? spawn7(buildCmdLine(this.config.command, this.config.args ?? []), {
           ...spawnOpts,
           shell: true
-        }) : spawn6(this.config.command, this.config.args ?? [], spawnOpts);
+        }) : spawn7(this.config.command, this.config.args ?? [], spawnOpts);
         this.child = child;
         child.stdout.setEncoding("utf8");
         child.stdout.on("data", (chunk) => this.onStdout(chunk));
@@ -29076,11 +29386,11 @@ import { join as join16 } from "node:path";
 import { homedir as homedir6 } from "node:os";
 function readMcpConfig(projectRoot = process.cwd()) {
   const merged = {};
-  const paths = [
-    join16(homedir6(), ".zelari-code", "mcp.json"),
-    join16(projectRoot, ".zelari", "mcp.json")
-    // later = higher precedence
-  ];
+  const paths = [];
+  if (process.env["ZELARI_MCP_USER"] !== "0") {
+    paths.push(join16(homedir6(), ".zelari-code", "mcp.json"));
+  }
+  paths.push(join16(projectRoot, ".zelari", "mcp.json"));
   for (const p3 of paths) {
     if (!existsSync19(p3)) continue;
     try {
@@ -29378,10 +29688,10 @@ import { createHash as createHash3 } from "node:crypto";
 import { join as join19 } from "node:path";
 import { readFile as readFile2 } from "node:fs/promises";
 async function readPackageJson2(projectRoot) {
-  const path36 = join19(projectRoot, "package.json");
-  if (!existsSync22(path36)) return null;
+  const path37 = join19(projectRoot, "package.json");
+  if (!existsSync22(path37)) return null;
   try {
-    return JSON.parse(await readFile2(path36, "utf8"));
+    return JSON.parse(await readFile2(path37, "utf8"));
   } catch {
     return null;
   }
@@ -29463,9 +29773,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path36 = join19(ctx.rootDir, "risks.md");
-  if (!existsSync22(path36)) return "_No open questions._";
-  const content = readFileSync21(path36, "utf8");
+  const path37 = join19(ctx.rootDir, "risks.md");
+  if (!existsSync22(path37)) return "_No open questions._";
+  const content = readFileSync21(path37, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -29710,7 +30020,7 @@ var init_completeDesign = __esm({
 });
 
 // src/cli/workspace/projectSmoke.ts
-import { spawn as spawn7 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 import { existsSync as existsSync23, readFileSync as readFileSync22 } from "node:fs";
 import { join as join20 } from "node:path";
 function pickSmokeScript(scripts) {
@@ -29740,12 +30050,12 @@ async function runProjectSmoke(projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS) {
     return { ran: false, reason: "no typecheck/test/build script (skipped)" };
   }
   return await new Promise((resolveRun) => {
-    const child = process.platform === "win32" ? spawn7(buildCmdLine("npm.cmd", ["run", script]), {
+    const child = process.platform === "win32" ? spawn8(buildCmdLine("npm.cmd", ["run", script]), {
       cwd: projectRoot,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env,
       shell: true
-    }) : spawn7("npm", ["run", script], {
+    }) : spawn8("npm", ["run", script], {
       cwd: projectRoot,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env
@@ -29817,7 +30127,7 @@ __export(postCouncilHook_exports, {
   runImplementationVerificationHook: () => runImplementationVerificationHook,
   runPostCouncilHook: () => runPostCouncilHook
 });
-import { spawn as spawn8 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
 import { existsSync as existsSync24, readFileSync as readFileSync23 } from "node:fs";
 import { join as join21 } from "node:path";
 async function runCompleteDesignPostProcessor(ctx, options) {
@@ -29866,7 +30176,7 @@ async function runCompleteDesignPostProcessor(ctx, options) {
     }
   }
   return await new Promise((resolveRun) => {
-    const child = spawn8(process.execPath, [scriptPath], {
+    const child = spawn9(process.execPath, [scriptPath], {
       cwd: ctx.projectRoot,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env
@@ -30032,8 +30342,8 @@ async function runPostCouncilHook(ctx, options) {
           sources: scope.sources
         } : void 0
       });
-      const path36 = writeCouncilCompletion(ctx.rootDir, completion);
-      completionHook = { ran: true, path: path36, completion };
+      const path37 = writeCouncilCompletion(ctx.rootDir, completion);
+      completionHook = { ran: true, path: path37, completion };
     } catch (err) {
       completionHook = {
         ran: true,
@@ -30096,13 +30406,13 @@ __export(councilFeedback_exports, {
   FeedbackStore: () => FeedbackStore
 });
 import {
-  promises as fs13,
+  promises as fs14,
   existsSync as existsSync26,
   readFileSync as readFileSync24,
   writeFileSync as writeFileSync15,
   mkdirSync as mkdirSync10
 } from "node:fs";
-import path24 from "node:path";
+import path25 from "node:path";
 import os8 from "node:os";
 var FeedbackStore;
 var init_councilFeedback = __esm({
@@ -30113,7 +30423,7 @@ var init_councilFeedback = __esm({
       now;
       entries = [];
       constructor(options = {}) {
-        this.file = options.file ?? (process.env.ANATHEMA_COUNCIL_FEEDBACK_FILE ?? path24.join(os8.homedir(), ".tmp", "zelari-code", "council-feedback.json"));
+        this.file = options.file ?? (process.env.ANATHEMA_COUNCIL_FEEDBACK_FILE ?? path25.join(os8.homedir(), ".tmp", "zelari-code", "council-feedback.json"));
         this.now = options.now ?? Date.now;
         this.load();
       }
@@ -30219,7 +30529,7 @@ var init_councilFeedback = __esm({
         }
       }
       save() {
-        mkdirSync10(path24.dirname(this.file), { recursive: true });
+        mkdirSync10(path25.dirname(this.file), { recursive: true });
         writeFileSync15(
           this.file,
           JSON.stringify({ entries: this.entries }, null, 2),
@@ -30229,7 +30539,7 @@ var init_councilFeedback = __esm({
       /** Async variant of load for callers that prefer async IO. */
       async loadAsync() {
         try {
-          const raw = await fs13.readFile(this.file, "utf-8");
+          const raw = await fs14.readFile(this.file, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed && Array.isArray(parsed.entries)) {
             this.entries = parsed.entries.filter(
@@ -30253,8 +30563,8 @@ __export(fileBackend_exports, {
   isMemoryEnabled: () => isMemoryEnabled
 });
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { promises as fs14 } from "node:fs";
-import * as path25 from "node:path";
+import { promises as fs15 } from "node:fs";
+import * as path26 from "node:path";
 function tokenize(text) {
   return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length >= 3);
 }
@@ -30292,9 +30602,9 @@ var init_fileBackend = __esm({
       logPath = "";
       memoryDir = "";
       async init(projectRoot) {
-        this.memoryDir = path25.join(projectRoot, ".zelari", "memory");
-        this.logPath = path25.join(this.memoryDir, "log.jsonl");
-        await fs14.mkdir(this.memoryDir, { recursive: true });
+        this.memoryDir = path26.join(projectRoot, ".zelari", "memory");
+        this.logPath = path26.join(this.memoryDir, "log.jsonl");
+        await fs15.mkdir(this.memoryDir, { recursive: true });
       }
       async add(content, metadata = {}, graph) {
         const fact = {
@@ -30304,7 +30614,7 @@ var init_fileBackend = __esm({
           ...graph ? { graph } : {},
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        await fs14.appendFile(this.logPath, JSON.stringify(fact) + "\n", "utf8");
+        await fs15.appendFile(this.logPath, JSON.stringify(fact) + "\n", "utf8");
         return fact.id;
       }
       async search(query, options = {}) {
@@ -30332,7 +30642,7 @@ var init_fileBackend = __esm({
       async readAll() {
         let raw;
         try {
-          raw = await fs14.readFile(this.logPath, "utf8");
+          raw = await fs15.readFile(this.logPath, "utf8");
         } catch {
           return [];
         }
@@ -30368,7 +30678,7 @@ import { execFile as execFile2 } from "node:child_process";
 import { promisify } from "node:util";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import path26 from "node:path";
+import path27 from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 async function git(cwd, args, env) {
   const { stdout } = await execFileAsync("git", ["-C", cwd, ...args], {
@@ -30388,8 +30698,8 @@ async function isGitRepo(cwd) {
   return await gitSafe(cwd, ["rev-parse", "--is-inside-work-tree"]) === "true";
 }
 async function withTempIndex(fn) {
-  const dir = mkdtempSync(path26.join(tmpdir(), "zelari-ckpt-"));
-  const indexFile = path26.join(dir, "index");
+  const dir = mkdtempSync(path27.join(tmpdir(), "zelari-ckpt-"));
+  const indexFile = path27.join(dir, "index");
   try {
     return await fn(indexFile);
   } finally {
@@ -30480,7 +30790,7 @@ async function restoreCheckpoint(cwd, id) {
     const deleted = [];
     for (const rel2 of added) {
       try {
-        rmSync(path26.join(cwd, rel2), { force: true });
+        rmSync(path27.join(cwd, rel2), { force: true });
         deleted.push(rel2);
       } catch {
       }
@@ -30509,8 +30819,8 @@ __export(zelariMission_exports, {
   runZelariMission: () => runZelariMission
 });
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { promises as fs15 } from "node:fs";
-import * as path27 from "node:path";
+import { promises as fs16 } from "node:fs";
+import * as path28 from "node:path";
 function resolveMaxIterations(env = process.env) {
   const raw = env.ZELARI_MISSION_MAX_ITER;
   const n = raw ? Number.parseInt(raw, 10) : DEFAULT_MAX_ITER;
@@ -30526,10 +30836,10 @@ function isMissionAutoStart(env = process.env) {
   return env.ZELARI_MISSION_AUTO === "1";
 }
 async function writeMissionState(projectRoot, state2) {
-  const dir = path27.join(projectRoot, ".zelari");
-  await fs15.mkdir(dir, { recursive: true });
-  await fs15.writeFile(
-    path27.join(dir, "mission-state.json"),
+  const dir = path28.join(projectRoot, ".zelari");
+  await fs16.mkdir(dir, { recursive: true });
+  await fs16.writeFile(
+    path28.join(dir, "mission-state.json"),
     JSON.stringify(state2, null, 2) + "\n",
     "utf8"
   );
@@ -30977,10 +31287,10 @@ var init_prereqChecks = __esm({
 
 // src/cli/plugins/prefs.ts
 import { existsSync as existsSync28, readFileSync as readFileSync25, writeFileSync as writeFileSync16, mkdirSync as mkdirSync11 } from "node:fs";
-import path29 from "node:path";
+import path30 from "node:path";
 import os9 from "node:os";
 function getPluginPrefsPath() {
-  return process.env.ZELARI_PLUGINS_PREFS_FILE ?? path29.join(os9.homedir(), ".tmp", "zelari-code", "plugins.json");
+  return process.env.ZELARI_PLUGINS_PREFS_FILE ?? path30.join(os9.homedir(), ".tmp", "zelari-code", "plugins.json");
 }
 function getPluginPrefs() {
   const file2 = getPluginPrefsPath();
@@ -31001,7 +31311,7 @@ function getPluginPrefs() {
 }
 function writePluginPrefs(prefs) {
   const file2 = getPluginPrefsPath();
-  mkdirSync11(path29.dirname(file2), { recursive: true });
+  mkdirSync11(path30.dirname(file2), { recursive: true });
   writeFileSync16(file2, JSON.stringify(prefs, null, 2), {
     encoding: "utf-8",
     mode: 384
@@ -31038,7 +31348,7 @@ __export(registry_exports, {
   isBinaryOnPath: () => isBinaryOnPath
 });
 import { existsSync as existsSync29 } from "node:fs";
-import path30 from "node:path";
+import path31 from "node:path";
 function detectLocalBin(bin) {
   return (cwd) => {
     try {
@@ -31056,7 +31366,7 @@ function isBinaryOnPath(bin, opts = {}) {
   const platform = opts.platform ?? process.platform;
   const exists = opts.exists ?? existsSync29;
   const pathEnv = opts.pathEnv ?? process.env.PATH ?? "";
-  const pathMod = platform === "win32" ? path30.win32 : path30.posix;
+  const pathMod = platform === "win32" ? path31.win32 : path31.posix;
   const sep = platform === "win32" ? ";" : ":";
   const dirs = pathEnv.split(sep).filter((d) => d.length > 0);
   const candidates = [bin];
@@ -31208,11 +31518,11 @@ import { execSync as execSync2 } from "node:child_process";
 import { existsSync as existsSync35, readFileSync as readFileSync30, readlinkSync, statSync as statSync6 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import path35 from "node:path";
+import path36 from "node:path";
 function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
-    const candidate = path35.join(dir, "package.json");
+    const candidate = path36.join(dir, "package.json");
     if (existsSync35(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync30(candidate, "utf8"));
@@ -31220,11 +31530,11 @@ function findPackageRoot(start) {
       } catch {
       }
     }
-    const parent = path35.dirname(dir);
+    const parent = path36.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path35.resolve(__dirname3, "..", "..", "..");
+  return path36.resolve(__dirname3, "..", "..", "..");
 }
 function tryExec(cmd) {
   try {
@@ -31238,7 +31548,7 @@ function tryExec(cmd) {
 }
 function readPackageJson3() {
   try {
-    const pkgPath = path35.join(packageRoot, "package.json");
+    const pkgPath = path36.join(packageRoot, "package.json");
     return JSON.parse(readFileSync30(pkgPath, "utf8"));
   } catch {
     return null;
@@ -31254,7 +31564,7 @@ function checkShim(pkgName) {
   }
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
-  const shimPath = path35.join(prefix, shimName);
+  const shimPath = path36.join(prefix, shimName);
   if (!existsSync35(shimPath)) {
     return FAIL(
       `shim not found at ${shimPath}
@@ -31282,8 +31592,8 @@ function checkShim(pkgName) {
          fix:  npm install -g ${pkgName}@latest --force`
       );
     }
-    const resolved = path35.resolve(path35.dirname(shimPath), target);
-    const expected = path35.join(
+    const resolved = path36.resolve(path36.dirname(shimPath), target);
+    const expected = path36.join(
       prefix,
       "node_modules",
       pkgName,
@@ -31322,7 +31632,7 @@ function checkNode(pkg) {
   return OK(`node ${raw}`);
 }
 function checkBundle() {
-  const bundle = path35.join(packageRoot, "dist", "cli", "main.bundled.js");
+  const bundle = path36.join(packageRoot, "dist", "cli", "main.bundled.js");
   if (!existsSync35(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
@@ -31343,7 +31653,7 @@ function checkRuntimeDeps() {
   const missing = [];
   for (const dep of required2) {
     try {
-      const localReq = createRequire3(path35.join(packageRoot, "package.json"));
+      const localReq = createRequire3(path36.join(packageRoot, "package.json"));
       localReq.resolve(dep);
     } catch {
       missing.push(dep);
@@ -31464,7 +31774,7 @@ var init_doctor = __esm({
     "use strict";
     init_prereqChecks();
     require3 = createRequire3(import.meta.url);
-    __dirname3 = path35.dirname(fileURLToPath2(import.meta.url));
+    __dirname3 = path36.dirname(fileURLToPath2(import.meta.url));
     packageRoot = findPackageRoot(__dirname3);
     OK = (message) => ({
       ok: true,
@@ -34512,6 +34822,91 @@ registerCodingSkill(writeUnitTests);
 registerCodingSkill(writeIntegrationTests);
 registerCodingSkill(regressionTest);
 
+// packages/core/dist/agents/skills/builtin/schemaLoop.js
+init_skills();
+var schemaLoop = {
+  id: "schema-loop",
+  version: "1.0.0",
+  name: "Schema Loop (certify before done)",
+  description: "Physicist-style coding harness: keep an explicit hypothesis, define certifiable checks, run_backtest before claiming done, and treat prediction mismatches as plan-voiding surprises. When \u22652 hypotheses remain, run one discriminating experiment first.",
+  category: "debug",
+  requiredRoles: [],
+  requiredTools: [
+    "update_world_hypothesis",
+    "set_world_checks",
+    "run_backtest",
+    "record_world_observation",
+    "bash",
+    "read_file"
+  ],
+  estimatedCost: "medium",
+  enabledByDefault: true,
+  builtin: true,
+  triggers: [
+    "Non-trivial bug or multi-step implementation",
+    "You are about to claim the task is done",
+    "Tests or typecheck failed after edits",
+    "Two or more competing root-cause hypotheses",
+    "Surprising tool result (wrong exit code, missing path, shell mismatch)"
+  ],
+  antiPatterns: [
+    "Trivial one-line typo fix with no uncertainty",
+    "Pure documentation rewrite with no behavior change",
+    "User explicitly asked for a draft-only answer without running tools"
+  ],
+  requires: [],
+  relatedSkills: ["debug-with-rag", "root-cause-five-whys", "reproduce-bug"],
+  tags: ["schema", "backtest", "hypothesis", "verify", "world-model", "debug"],
+  examples: [
+    {
+      input: "Fix the flaky headless test timeout",
+      output: {
+        hypothesis: "Test hangs because registerMcpTools spawns real MCP servers; default 5s timeout is too low.",
+        checks: [
+          { id: "unit", command: "npx vitest run tests/unit/cli-useChatTurn.test.ts" }
+        ],
+        next: "set_world_checks \u2192 implement isolation \u2192 run_backtest \u2192 only then claim done"
+      }
+    }
+  ],
+  outputSchema: "{ hypothesis: string; checks: Array<{ id: string; command: string }>; backtestOk: boolean; surprises?: string[] }",
+  systemPromptFragment: `You are running the **Schema Loop** adapted for software engineering
+(inspired by Schema harness / ARC world-models \u2014 but for repos, not grids).
+
+## Core idea
+The latent model of the task is **explicit files under .zelari/world/**, not only chat context:
+- hypothesis.md \u2014 what you believe (objects = modules, mechanism = bug cause / design)
+- checks.json \u2014 certifiable shell checks (the "reality" oracle)
+- timeline.jsonl \u2014 append-only observations (do not rewrite history)
+
+## Outer loop
+1. **observe** \u2014 read errors, failing tests, tool results
+2. **deliberate** \u2014 update_world_hypothesis; set_world_checks
+3. **execute** \u2014 edit/run tools to change the repo
+4. **record** \u2014 record_world_observation on surprises; run_backtest to certify
+
+## Hard rules (reality outranks the model)
+1. **Never claim done** while the latest run_backtest has ok=false or total=0 without checks.
+2. After any batch of write/edit, prefer run_backtest (or set checks then backtest) before asserting success.
+3. **Surprise = void plan**: if a command exits unexpectedly, shell rejects POSIX on Windows, path missing, or tests fail differently than predicted \u2014 call record_world_observation (kind=surprise), revise hypothesis, do not keep patching blindly.
+4. **Discovery actions**: when \u22652 hypotheses remain consistent with evidence, design ONE discriminating experiment (read/grep/test) whose outcomes diverge; do not spray random edits.
+5. Prefer fast checks (single-file vitest, typecheck) over full suite until the model is stable.
+
+## Predict-then-act (soft)
+Before a risky bash/edit, state a short prediction in hypothesis or observation
+(expect exit 0, files touched). After the tool, if reality mismatches, log surprise.
+
+## Tools
+- update_world_hypothesis \u2014 write/append theory
+- set_world_checks \u2014 define certifiable commands
+- run_backtest \u2014 replay all checks; report exact pass/fail
+- record_world_observation \u2014 timeline ground truth
+
+Kill switch for tools: ZELARI_SCHEMA_LOOP=0.
+${""}`
+};
+registerCodingSkill(schemaLoop);
+
 // src/cli/app.tsx
 init_providerConfig();
 init_harness();
@@ -36914,7 +37309,7 @@ ${formatSkillList(availableSkills)}`
 // src/cli/gitOps.ts
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
-import path28 from "node:path";
+import path29 from "node:path";
 var execFileAsync2 = promisify2(execFile3);
 async function git2(cwd, args) {
   try {
@@ -36960,7 +37355,7 @@ async function undoWorkingChanges(opts = {}) {
   };
 }
 function defaultProjectRoot() {
-  return path28.resolve(__dirname, "..", "..", "..");
+  return path29.resolve(__dirname, "..", "..", "..");
 }
 
 // src/cli/slashHandlers/git.ts
@@ -37269,8 +37664,8 @@ init_registry2();
 // src/cli/plugins/installer.ts
 init_cmdline();
 init_updater();
-import { spawn as spawn9 } from "node:child_process";
-async function installPlugin(spec, cwd, executor = spawn9) {
+import { spawn as spawn10 } from "node:child_process";
+async function installPlugin(spec, cwd, executor = spawn10) {
   const scopeFlag = spec.installScope === "global" ? "-g" : "-D";
   const args = ["install", scopeFlag, spec.npmPackage];
   const primary = await runNpm2(executor, args, cwd, "shim");
@@ -37371,17 +37766,17 @@ ${result.output.split("\n").slice(-8).join("\n")}` : "";
 }
 
 // src/cli/slashHandlers/promoteMember.ts
-import { promises as fs16 } from "node:fs";
-import path31 from "node:path";
+import { promises as fs17 } from "node:fs";
+import path32 from "node:path";
 import os10 from "node:os";
 async function handlePromoteMember(ctx, memberId) {
   try {
     const { promoteMember: promoteMember2 } = await Promise.resolve().then(() => (init_council(), council_exports));
     const { skill, markdown } = promoteMember2(memberId);
-    const skillDir = process.env.ANATHEMA_SKILL_DIR ?? path31.join(os10.homedir(), ".tmp", "zelari-code", "skills");
-    await fs16.mkdir(skillDir, { recursive: true });
-    const filePath = path31.join(skillDir, `${skill.id}.md`);
-    await fs16.writeFile(filePath, markdown, "utf8");
+    const skillDir = process.env.ANATHEMA_SKILL_DIR ?? path32.join(os10.homedir(), ".tmp", "zelari-code", "skills");
+    await fs17.mkdir(skillDir, { recursive: true });
+    const filePath = path32.join(skillDir, `${skill.id}.md`);
+    await fs17.writeFile(filePath, markdown, "utf8");
     appendSystem(
       ctx.setMessages,
       `[promote-member] ${skill.name} (${memberId}) \u2192 ${filePath}
@@ -37397,25 +37792,25 @@ async function handlePromoteMember(ctx, memberId) {
 }
 
 // src/cli/branchManager.ts
-import { promises as fs17, existsSync as existsSync30, readFileSync as readFileSync26, writeFileSync as writeFileSync17, mkdirSync as mkdirSync12, statSync as statSync4, rmSync as rmSync2 } from "node:fs";
-import path32 from "node:path";
+import { promises as fs18, existsSync as existsSync30, readFileSync as readFileSync26, writeFileSync as writeFileSync17, mkdirSync as mkdirSync12, statSync as statSync4, rmSync as rmSync2 } from "node:fs";
+import path33 from "node:path";
 import os11 from "node:os";
 var META_FILENAME = "meta.json";
 var SESSIONS_SUBDIR = "sessions";
 function getBranchesBaseDir() {
-  return process.env.ANATHEMA_BRANCHES_DIR ?? path32.join(os11.homedir(), ".tmp", "zelari-code", "branches");
+  return process.env.ANATHEMA_BRANCHES_DIR ?? path33.join(os11.homedir(), ".tmp", "zelari-code", "branches");
 }
 function getSessionsBaseDir() {
-  return process.env.ANATHEMA_SESSIONS_DIR ?? path32.join(os11.homedir(), ".tmp", "zelari-code", "sessions");
+  return process.env.ANATHEMA_SESSIONS_DIR ?? path33.join(os11.homedir(), ".tmp", "zelari-code", "sessions");
 }
 function branchPathFor(name, baseDir) {
-  return path32.join(baseDir, name);
+  return path33.join(baseDir, name);
 }
 function metaPathFor(name, baseDir) {
-  return path32.join(baseDir, name, META_FILENAME);
+  return path33.join(baseDir, name, META_FILENAME);
 }
 function sessionsPathFor(name, baseDir) {
-  return path32.join(baseDir, name, SESSIONS_SUBDIR);
+  return path33.join(baseDir, name, SESSIONS_SUBDIR);
 }
 function readBranchMeta(name, baseDir) {
   const metaPath = metaPathFor(name, baseDir);
@@ -37440,13 +37835,13 @@ function readBranchMeta(name, baseDir) {
 }
 function writeBranchMeta(name, baseDir, meta3) {
   const metaPath = metaPathFor(name, baseDir);
-  mkdirSync12(path32.dirname(metaPath), { recursive: true });
+  mkdirSync12(path33.dirname(metaPath), { recursive: true });
   writeFileSync17(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
 }
 async function countSessions(name, baseDir) {
   const sessionsPath = sessionsPathFor(name, baseDir);
   try {
-    const entries = await fs17.readdir(sessionsPath);
+    const entries = await fs18.readdir(sessionsPath);
     return entries.filter((e) => e.endsWith(".jsonl")).length;
   } catch (err) {
     if (err.code === "ENOENT") return 0;
@@ -37491,15 +37886,15 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
   if (branchExists(name, baseDir)) {
     throw new BranchAlreadyExistsError(name);
   }
-  const sourcePath = path32.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
+  const sourcePath = path33.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
   if (!existsSync30(sourcePath)) {
     throw new SessionNotFoundError(`Source session "${fromSessionId}" not found at ${sourcePath}`);
   }
   const branchPath = branchPathFor(name, baseDir);
   const branchSessionsPath = sessionsPathFor(name, baseDir);
   mkdirSync12(branchSessionsPath, { recursive: true });
-  const destPath = path32.join(branchSessionsPath, `${fromSessionId}.jsonl`);
-  await fs17.copyFile(sourcePath, destPath);
+  const destPath = path33.join(branchSessionsPath, `${fromSessionId}.jsonl`);
+  await fs18.copyFile(sourcePath, destPath);
   const meta3 = {
     name,
     createdAt: Date.now(),
@@ -37517,7 +37912,7 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
 async function listBranches(baseDir = getBranchesBaseDir()) {
   let entries;
   try {
-    entries = await fs17.readdir(baseDir);
+    entries = await fs18.readdir(baseDir);
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -37598,26 +37993,26 @@ async function handleBranchCheckout(ctx, branchName) {
 }
 
 // src/cli/slashHandlers/workspace.ts
-import { promises as fs18 } from "node:fs";
-import path33 from "node:path";
+import { promises as fs19 } from "node:fs";
+import path34 from "node:path";
 async function handleWorkspaceShow(ctx, what) {
   try {
-    const zelari = path33.join(process.cwd(), ".zelari");
+    const zelari = path34.join(process.cwd(), ".zelari");
     let content;
     switch (what) {
       case "plan": {
-        const planPath = path33.join(zelari, "plan.md");
+        const planPath = path34.join(zelari, "plan.md");
         try {
-          content = await fs18.readFile(planPath, "utf-8");
+          content = await fs19.readFile(planPath, "utf-8");
         } catch {
           content = "(no plan.md yet \u2014 run a council session first)";
         }
         break;
       }
       case "decisions": {
-        const decisionsDir = path33.join(zelari, "decisions");
+        const decisionsDir = path34.join(zelari, "decisions");
         try {
-          const files = (await fs18.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await fs19.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
           if (files.length === 0) {
             content = "(no ADRs yet \u2014 invoke /council to generate some)";
           } else {
@@ -37625,7 +38020,7 @@ async function handleWorkspaceShow(ctx, what) {
 `];
             const { parseFrontmatter: parseFrontmatter2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
             for (const f of files) {
-              const raw = await fs18.readFile(path33.join(decisionsDir, f), "utf-8");
+              const raw = await fs19.readFile(path34.join(decisionsDir, f), "utf-8");
               const { meta: meta3, body } = parseFrontmatter2(raw);
               const title = meta3.title ?? body.split("\n")[0]?.replace(/^#\s*/, "").trim() ?? f;
               lines.push(`- **${f.replace(/\.md$/, "")}** [${meta3.status ?? "unknown"}] ${title}`);
@@ -37638,27 +38033,27 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "risks": {
-        const risksPath = path33.join(zelari, "risks.md");
+        const risksPath = path34.join(zelari, "risks.md");
         try {
-          content = await fs18.readFile(risksPath, "utf-8");
+          content = await fs19.readFile(risksPath, "utf-8");
         } catch {
           content = "(no risks.md yet)";
         }
         break;
       }
       case "agents": {
-        const agentsPath = path33.join(process.cwd(), "AGENTS.MD");
+        const agentsPath = path34.join(process.cwd(), "AGENTS.MD");
         try {
-          content = await fs18.readFile(agentsPath, "utf-8");
+          content = await fs19.readFile(agentsPath, "utf-8");
         } catch {
           content = "(no AGENTS.MD yet at project root \u2014 run `/workspace sync` after a council session)";
         }
         break;
       }
       case "docs": {
-        const docsDir = path33.join(zelari, "docs");
+        const docsDir = path34.join(zelari, "docs");
         try {
-          const files = (await fs18.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await fs19.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
           content = files.length ? `# Docs (${files.length})
 
 ` + files.map((f) => `- ${f}`).join("\n") : "(no docs drafts yet)";
@@ -37698,8 +38093,8 @@ async function handleWorkspaceReset(ctx, force) {
     return;
   }
   try {
-    const target = path33.join(process.cwd(), ".zelari");
-    await fs18.rm(target, { recursive: true, force: true });
+    const target = path34.join(process.cwd(), ".zelari");
+    await fs19.rm(target, { recursive: true, force: true });
     appendSystem(ctx.setMessages, "[workspace] .zelari/ removed");
   } catch (err) {
     appendSystem(ctx.setMessages, `[workspace reset error] ${err instanceof Error ? err.message : String(err)}`);
@@ -38057,16 +38452,16 @@ function handleModelsRefresh(ctx) {
 }
 
 // src/cli/slashHandlers/skills.ts
-import path34 from "node:path";
+import path35 from "node:path";
 import os12 from "node:os";
 
 // src/cli/skillHistory.ts
-import { promises as fs19, existsSync as existsSync31, statSync as statSync5, renameSync as renameSync4, appendFileSync as appendFileSync3, mkdirSync as mkdirSync13 } from "node:fs";
+import { promises as fs20, existsSync as existsSync31, statSync as statSync5, renameSync as renameSync4, appendFileSync as appendFileSync3, mkdirSync as mkdirSync13 } from "node:fs";
 var SKILL_HISTORY_ROTATE_BYTES = 10 * 1024 * 1024;
 async function readSkillHistory(file2) {
   let raw = "";
   try {
-    raw = await fs19.readFile(file2, "utf-8");
+    raw = await fs20.readFile(file2, "utf-8");
   } catch {
     return [];
   }
@@ -38159,7 +38554,7 @@ async function applySteerInterrupt(options) {
 
 // src/cli/slashHandlers/skills.ts
 async function handleSkillStats(ctx, skillId) {
-  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path34.join(os12.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
+  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path35.join(os12.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
   try {
     const records = await readSkillHistory(historyFile);
     const stats = getSkillStats(records, skillId);
@@ -38175,7 +38570,7 @@ async function handleSkillCompare(ctx, ids, fallbackMessage) {
     appendSystem(ctx.setMessages, fallbackMessage ?? "[skill-compare] missing args");
     return;
   }
-  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path34.join(os12.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
+  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path35.join(os12.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
   try {
     const formatted = await compareSkillsFromFile(ids[0], ids[1], historyFile);
     appendSystem(ctx.setMessages, formatted);
@@ -40757,10 +41152,10 @@ function getUserMcpPath() {
 function getProjectMcpPath(projectRoot) {
   return join26(projectRoot, ".zelari", "mcp.json");
 }
-function readFile3(path36) {
-  if (!existsSync34(path36)) return {};
+function readFile3(path37) {
+  if (!existsSync34(path37)) return {};
   try {
-    const parsed = JSON.parse(readFileSync29(path36, "utf8"));
+    const parsed = JSON.parse(readFileSync29(path37, "utf8"));
     const out = {};
     for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
       if (!cfg || typeof cfg.command !== "string" || !cfg.command.trim()) continue;
@@ -40776,10 +41171,10 @@ function readFile3(path36) {
     return {};
   }
 }
-function writeFile(path36, servers) {
-  mkdirSync14(dirname6(path36), { recursive: true });
+function writeFile(path37, servers) {
+  mkdirSync14(dirname6(path37), { recursive: true });
   const body = { mcpServers: servers };
-  writeFileSync18(path36, `${JSON.stringify(body, null, 2)}
+  writeFileSync18(path37, `${JSON.stringify(body, null, 2)}
 `, "utf8");
 }
 function listMcpServers(projectRoot) {
@@ -40812,9 +41207,9 @@ function upsertMcpServer(opts) {
   if (!opts.config.command?.trim()) {
     return { ok: false, error: "command is required" };
   }
-  let path36;
+  let path37;
   if (opts.scope === "user") {
-    path36 = getUserMcpPath();
+    path37 = getUserMcpPath();
   } else {
     const root = opts.projectRoot?.trim();
     if (!root) {
@@ -40823,30 +41218,30 @@ function upsertMcpServer(opts) {
         error: "projectRoot required for project scope (Open Folder first)"
       };
     }
-    path36 = getProjectMcpPath(root);
+    path37 = getProjectMcpPath(root);
   }
-  const current = readFile3(path36);
+  const current = readFile3(path37);
   current[name] = {
     command: opts.config.command.trim(),
     args: opts.config.args,
     env: opts.config.env,
     enabled: opts.config.enabled !== false
   };
-  writeFile(path36, current);
-  return { ok: true, path: path36 };
+  writeFile(path37, current);
+  return { ok: true, path: path37 };
 }
 function removeMcpServer(opts) {
-  const path36 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
-  if (!path36) {
+  const path37 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
+  if (!path37) {
     return { ok: false, error: "projectRoot required for project scope" };
   }
-  const current = readFile3(path36);
+  const current = readFile3(path37);
   if (!(opts.name in current)) {
-    return { ok: false, error: `Server "${opts.name}" not found in ${path36}` };
+    return { ok: false, error: `Server "${opts.name}" not found in ${path37}` };
   }
   delete current[opts.name];
-  writeFile(path36, current);
-  return { ok: true, path: path36 };
+  writeFile(path37, current);
+  return { ok: true, path: path37 };
 }
 
 // src/cli/main.ts