@really-knows-ai/foundry 2.3.2 → 3.0.0

package/dist/scripts/lib/git-finish/work-finish.js

@@ -0,0 +1,233 @@
+/**
+ * Work branch finisher — reads ATTEST.md, verifies diff SHA, squash-merges.
+ *
+ * ATTEST.md must exist, must be the HEAD commit, and its diff-sha256 must match
+ * a recomputed SHA of the branch diff (merge-base to HEAD~1).
+ */
+
+import { sha256Buffer } from '../attestation/hash.js';
+
+/** Run git command; return { ok, result } or { ok: false, error }. */
+function safeGit(execGit, args) {
+  try {
+    return { ok: true, result: execGit(args).trim() };
+  } catch (err) {
+    return { ok: false, error: err };
+  }
+}
+
+/** Best-effort git call — swallows all errors. */
+function bestEffort(execGit, args) {
+  try { execGit(args); } catch { /* best effort */ }
+}
+
+/** Best-effort rollback: reset, restore branch, delete archive, remove temp file. */
+function rollback({ execGit, branchName, archiveBranch, commitFile, deleteFile }) {
+  bestEffort(execGit, ['reset', '--merge']);
+  bestEffort(execGit, ['checkout', branchName]);
+  bestEffort(execGit, ['branch', '-D', archiveBranch]);
+  if (deleteFile && commitFile) bestEffort(() => deleteFile(commitFile), []);
+}
+
+/** Extract stderr or stdout string from a caught error. */
+function extractStderr(err) {
+  if (!err) return '';
+  if (err.stderr) return String(err.stderr).trim();
+  if (err.stdout) return String(err.stdout).trim();
+  return '';
+}
+
+/** Build an error string from a caught git error. */
+function gitError(prefix, err) {
+  const msg = extractStderr(err);
+  if (msg) return prefix + ' ' + msg;
+  return prefix;
+}
+
+/** Parse the diff-sha256 line from ATTEST.md content. */
+function parseDiffSha(content) {
+  const match = content.match(/^diff-sha256:\s*([0-9a-f]{64})/m);
+  return match ? match[1] : null;
+}
+
+/** Compute the SHA of the branch diff (merge-base to HEAD~1). */
+function computeDiffSha(execGit, baseBranch) {
+  const mergeBase = execGit(['merge-base', 'HEAD', baseBranch]).trim();
+  const diffOutput = execGit(['diff', mergeBase, 'HEAD~1']);
+  const diffBuf = Buffer.isBuffer(diffOutput) ? diffOutput : Buffer.from(diffOutput, 'utf8');
+  return sha256Buffer(diffBuf);
+}
+
+/** Validate ATTEST.md exists and HEAD is the attest commit. */
+function checkAttestFile(cwd, fileExists, execGit) {
+  const attestPath = `${cwd}/ATTEST.md`;
+  if (!fileExists(attestPath)) {
+    return {
+      ok: false,
+      error: 'foundry_git_finish: ATTEST.md not found. Run foundry_attest before finishing the branch.',
+    };
+  }
+  const headLine = execGit(['log', '--oneline', '-1']).trim();
+  if (!headLine.includes('attest: cycle complete')) {
+    return {
+      ok: false,
+      error: `foundry_git_finish: HEAD commit is not the attest commit. Run foundry_attest first. HEAD: ${headLine}`,
+    };
+  }
+  return { ok: true, attestPath };
+}
+
+/** Validate the diff SHA in ATTEST.md matches the recomputed branch diff. */
+function checkDiffSha(attestPath, readAttest, execGit, baseBranch) {
+  const attestContent = readAttest(attestPath);
+  const recordedDiffSha = parseDiffSha(attestContent);
+  if (!recordedDiffSha) {
+    return {
+      ok: false,
+      error: 'foundry_git_finish: ATTEST.md is malformed — no valid diff-sha256 line found.',
+    };
+  }
+  const computedDiffSha = computeDiffSha(execGit, baseBranch);
+  if (computedDiffSha !== recordedDiffSha) {
+    return {
+      ok: false,
+      error: `foundry_git_finish: diff SHA mismatch. Recorded: ${recordedDiffSha}. Computed: ${computedDiffSha}. The branch has changed since attestation.`,
+    };
+  }
+  return { ok: true, attestContent };
+}
+
+/** Checkout the base branch; roll back on failure. */
+function checkoutBase(execGit, baseBranch, branchName, archiveBranch, deleteFile) {
+  const res = safeGit(execGit, ['checkout', baseBranch]);
+  if (!res.ok) {
+    rollback({ execGit, branchName, archiveBranch, deleteFile });
+    return { ok: false, error: gitError('foundry_git_finish: checkout base branch failed.', res.error) };
+  }
+  return { ok: true };
+}
+
+/** Squash-merge the work branch; roll back on failure. */
+function squashMerge(execGit, branchName, branchNameOrig, archiveBranch, deleteFile) {
+  const res = safeGit(execGit, ['merge', '--squash', branchName]);
+  if (!res.ok) {
+    rollback({ execGit, branchName: branchNameOrig, archiveBranch, deleteFile });
+    return { ok: false, error: gitError('foundry_git_finish: squash merge failed.', res.error) };
+  }
+  return { ok: true };
+}
+
+/** Write the commit message file; roll back on failure. */
+function writeCommitMsg({ writeTempMessage, attestContent, execGit, branchName, archiveBranch, deleteFile }) {
+  try {
+    return { ok: true, commitFile: writeTempMessage(attestContent) };
+  } catch (err) {
+    rollback({ execGit, branchName, archiveBranch, deleteFile });
+    return { ok: false, error: `foundry_git_finish: failed to write commit message file. ${err.message ?? String(err)}` };
+  }
+}
+
+/** Create the signed commit; roll back on failure. */
+function doCommit(execGit, commitFile, branchName, archiveBranch, deleteFile) {
+  const res = safeGit(execGit, ['commit', '-S', '-F', commitFile]);
+  if (!res.ok) {
+    rollback({ execGit, branchName, archiveBranch, commitFile, deleteFile });
+    return { ok: false, error: gitError('foundry_git_finish: commit failed.', res.error) };
+  }
+  return { ok: true };
+}
+
+/** Delete the branch; return warning if it fails. */
+function deleteBranch(execGit, branchName) {
+  const res = safeGit(execGit, ['branch', '-D', branchName]);
+  if (!res.ok) {
+    const msg = extractStderr(res.error);
+    return { ok: true, warning: `Branch '${branchName}' could not be deleted. ${msg}`.trim() };
+  }
+  return { ok: true };
+}
+
+/** Build the success result object. */
+function successResult(hash, archiveBranch, tipSha, baseBranch, warning) {
+  const base = { ok: true, hash, archiveBranch, archiveTipSha: tipSha, branch: baseBranch };
+  return warning ? { ...base, warning } : base;
+}
+
+/** Run checkout + squash-merge steps. Returns error result on failure. */
+function runMerge(execGit, branchName, baseBranch, archiveBranch, deleteFile) {
+  const checkout = checkoutBase(execGit, baseBranch, branchName, archiveBranch, deleteFile);
+  if (!checkout.ok) return checkout;
+
+  const merged = squashMerge(execGit, branchName, branchName, archiveBranch, deleteFile);
+  if (!merged.ok) return merged;
+
+  return { ok: true };
+}
+
+/** Run write-commit-message + commit steps. Returns error result on failure. */
+function runCommit({ writeTempMessage, attestContent, execGit, branchName, archiveBranch, deleteFile }) {
+  const msg = writeCommitMsg({ writeTempMessage, attestContent, execGit, branchName, archiveBranch, deleteFile });
+  if (!msg.ok) return msg;
+
+  const committed = doCommit(execGit, msg.commitFile, branchName, archiveBranch, deleteFile);
+  if (!committed.ok) return committed;
+
+  return { ok: true, commitFile: msg.commitFile };
+}
+
+/** Run post-attestation steps: archive, merge, commit, cleanup, delete branch. */
+function runPostAttestation({
+  execGit, branchName, baseBranch, deleteFile, writeTempMessage, shaCheck,
+}) {
+  const tipSha = execGit(['rev-parse', branchName]).trim();
+  const archiveBranch = `archive/${branchName}-${tipSha.slice(0, 7)}`;
+  execGit(['branch', archiveBranch, branchName]);
+
+  const mergeResult = runMerge(execGit, branchName, baseBranch, archiveBranch, deleteFile);
+  if (!mergeResult.ok) return mergeResult;
+
+  const commitResult = runCommit({
+    writeTempMessage,
+    attestContent: shaCheck.attestContent,
+    execGit, branchName, archiveBranch, deleteFile,
+  });
+  if (!commitResult.ok) return commitResult;
+
+  if (deleteFile && commitResult.commitFile) {
+    bestEffort(() => deleteFile(commitResult.commitFile), []);
+  }
+
+  const hash = execGit(['rev-parse', '--short', 'HEAD']).trim();
+  const del = deleteBranch(execGit, branchName);
+
+  return successResult(hash, archiveBranch, tipSha, baseBranch, del.warning);
+}
+
+export async function finishWorkBranchWithArchive({
+  branchName,
+  baseBranch,
+  confirm,
+  execGit,
+  fileExists,
+  readAttest,
+  deleteFile,
+  writeTempMessage,
+  cwd,
+}) {
+  if (confirm !== true) {
+    return {
+      ok: false,
+      error: 'foundry_git_finish requires {confirm: true} to perform destructive operations.',
+    };
+  }
+
+  const fileCheck = checkAttestFile(cwd, fileExists, execGit);
+  if (!fileCheck.ok) return fileCheck;
+
+  const shaCheck = checkDiffSha(fileCheck.attestPath, readAttest, execGit, baseBranch);
+  if (!shaCheck.ok) return shaCheck;
+
+  return runPostAttestation({
+    execGit, branchName, baseBranch, deleteFile, writeTempMessage, shaCheck,
+  });
+}

package/dist/scripts/lib/git-policy.js

@@ -0,0 +1,101 @@
+// scripts/lib/git-policy.js
+//
+// Shared git-commit policy used by the orchestrator's git bridge.
+//
+// The orchestrator commits twice per cycle: a setup commit that configures
+// stages in WORK.md and a post-finalise commit after each stage finalise.
+// This module defines the phase-specific file allow-lists for those commits
+// and reports a structured violation when the worktree contains any other
+// paths.
+//
+// This module accepts raw inputs (porcelain string, allowed pattern list)
+// and returns plain data. The bridge wires these helpers to git plumbing.
+
+import { minimatch } from 'minimatch';
+
+export const TOOL_MANAGED = [
+  'WORK.md',
+  'WORK.history.yaml',
+  'WORK.feedback.yaml',
+  // The plugin's secret bootstrap idempotently appends `.foundry/` to the
+  // project's `.gitignore` (see scripts/lib/secret.js). Treat it as
+  // tool-managed so the orchestrator's setup commit can sweep up that change
+  // without flagging it as an unexpected dirty file.
+  '.gitignore',
+];
+
+const TOOL_MANAGED_PREFIX = ['.foundry/'];
+
+export function isToolManaged(file) {
+  if (TOOL_MANAGED.includes(file)) return true;
+  return TOOL_MANAGED_PREFIX.some((p) => file.startsWith(p));
+}
+
+function addIfNew(seen, result, path) {
+  if (path && !seen.has(path)) {
+    seen.add(path);
+    result.push(path);
+  }
+}
+
+function isRenameOrCopy(status) {
+  return status[0] === 'R' || status[0] === 'C';
+}
+
+/**
+ * Parse `git status -z --porcelain=v1` output into a list of file paths.
+ *
+ * Each record is null-terminated. Renames/copies (R/C) are emitted as two
+ * null-terminated paths: `R  new\0old\0` (i.e. the destination first, then
+ * the source). Per git-status(1), the -z format reverses the usual "from -> to"
+ * order to "to from" for renames. We surface BOTH paths so the caller can refuse
+ * a commit that would carry along an unrelated source path.
+ *
+ * Returns a de-duplicated array of paths in encounter order.
+ */
+export function parsePorcelainZ(out) {
+  if (!out) return [];
+  const seen = new Set();
+  const result = [];
+  const parts = out.split('\0');
+  for (let i = 0; i < parts.length; i++) {
+    const entry = parts[i];
+    if (!entry) continue;
+    const path = entry.slice(3);
+    addIfNew(seen, result, path);
+    if (isRenameOrCopy(entry)) {
+      addIfNew(seen, result, parts[++i]);
+    }
+  }
+  return result;
+}
+
+/**
+ * Partition a list of dirty files into (allowed, unexpected) given the
+ * stage's allowed glob patterns. Tool-managed files are ALWAYS allowed.
+ */
+export function partitionDirty(files, allowedPatterns = []) {
+  const allowed = [];
+  const unexpected = [];
+  for (const f of files) {
+    if (isToolManaged(f)) { allowed.push(f); continue; }
+    if (allowedPatterns.some((p) => minimatch(f, p, { dot: true }))) { allowed.push(f); continue; }
+    unexpected.push(f);
+  }
+  return { allowed, unexpected };
+}
+
+/**
+ * Compute the allowed glob patterns for a given stage.
+ *
+ * - forge: artefact type's file-patterns (caller resolves; passed in).
+ * - assay: writes under foundry-memory/**.
+ * - quench / appraise / human-appraise: no surface files allowed; only
+ *   tool-managed files may change.
+ * - setup (no stage): no surface files allowed.
+ */
+export function allowedPatternsForStage({ stageBase, forgeFilePatterns = [] } = {}) {
+  if (stageBase === 'forge') return forgeFilePatterns;
+  if (stageBase === 'assay') return ['foundry-memory/**'];
+  return [];
+}

package/dist/scripts/lib/guards.js

@@ -0,0 +1,125 @@
+import { requireNotFailed } from './failed-flow.js';
+import { appendTraceRecord } from './tracing.js';
+import { DRY_RUN_RE } from './branch-guard.js';
+
+const MAX_ARG_STR = 4096;
+const HEAD_LEN = 256;
+const TAIL_LEN = 256;
+
+function truncateString(v) {
+  const elided = v.length - HEAD_LEN - TAIL_LEN;
+  return v.slice(0, HEAD_LEN)
+    + `...(${elided} chars elided)...`
+    + v.slice(v.length - TAIL_LEN);
+}
+
+function scrubValue(v) {
+  if (typeof v === 'string' && v.length > MAX_ARG_STR) {
+    return truncateString(v);
+  }
+  return v;
+}
+
+function scrub(args) {
+  if (!args || typeof args !== 'object' || Array.isArray(args)) return args;
+  const out = {};
+  for (const [k, v] of Object.entries(args)) {
+    out[k] = scrubValue(v);
+  }
+  return out;
+}
+
+function parseResultMaybeJson(s) {
+  if (typeof s !== 'string') return s;
+  try { return JSON.parse(s); } catch { return s; }
+}
+
+function resolveBranch(branchIo, context) {
+  try {
+    const out = branchIo(context).exec(['git', 'rev-parse', '--abbrev-ref', 'HEAD']);
+    const branch = String(out ?? '').trim();
+    if (!branch || branch === 'HEAD') return null;
+    return branch;
+  } catch {
+    return null;
+  }
+}
+
+function shouldTraceBranch(branch, io) {
+  return branch !== null && DRY_RUN_RE.test(branch) && typeof io === 'function';
+}
+
+async function runGuards(guards, args, context, toolName) {
+  for (const g of guards) {
+    const r = await g(args, context);
+    if (!r.ok) {
+      return JSON.stringify({ error: `${toolName}: ${r.error}` });
+    }
+  }
+  return null;
+}
+
+function buildTraceRecord(opts) {
+  const { ts, toolName, args, result, error, durationMs } = opts;
+  const base = { ts, tool: toolName, args: scrub(args), duration_ms: durationMs };
+  if (error) {
+    return { ...base, error: error.message ?? String(error) };
+  }
+  return { ...base, result: parseResultMaybeJson(result) };
+}
+
+async function writeTraceRecord(opts) {
+  const { branch, record, io } = opts;
+  try {
+    await appendTraceRecord({ branch, record, io });
+  } catch (traceErr) {
+    if (process.env.FOUNDRY_DEBUG) {
+      console.warn(
+        `[foundry] ${opts.toolName}: trace write failed (${traceErr.message ?? String(traceErr)})`,
+      );
+    }
+  }
+}
+
+async function executeAndTrace(opts) {
+  const { branchIo, io, execute, args, context, toolName } = opts;
+  const ts = new Date().toISOString();
+  const t0 = Date.now();
+  const branch = resolveBranch(branchIo, context);
+  const trace = shouldTraceBranch(branch, io);
+
+  let result;
+  let error;
+  try {
+    result = await execute(args, context);
+  } catch (e) {
+    error = e;
+  }
+
+  if (trace) {
+    const record = buildTraceRecord({ ts, toolName, args, result, error, durationMs: Date.now() - t0 });
+    await writeTraceRecord({ branch, record, io: io(context), toolName });
+  }
+
+  if (error) throw error;
+  return result;
+}
+
+export function guarded(toolName, guards, execute, opts = {}) {
+  return async (args, context) => {
+    const guardError = await runGuards(guards, args, context, toolName);
+    if (guardError) return guardError;
+
+    if (!opts.branchIo) {
+      return execute(args, context);
+    }
+
+    return executeAndTrace({ ...opts, execute, args, context, toolName });
+  };
+}
+
+// `makeIO` is provided by the caller, since failed-flow lives in a
+// different layer than the plugin helpers. We accept an io factory.
+export function notFailedGuard(makeSyncIO) {
+  return (_args, context) => requireNotFailed(makeSyncIO(context.worktree));
+}

package/dist/scripts/lib/history.js

@@ -0,0 +1,132 @@
+import yaml from 'js-yaml';
+import { markWorkfileFailed } from './failed-flow.js';
+import { sortPaths } from './attestation/hash.js';
+
+/**
+ * Parse WORK.history.yaml text into an array of entries.
+ * Throws `WORK.history.yaml malformed: ...` on parse failure or non-array root.
+ * Empty/null/undefined input yields [].
+ */
+function parseHistory(text) {
+  let data;
+  try {
+    data = yaml.load(text) || [];
+    if (!Array.isArray(data)) {
+      throw new Error('root is not an array');
+    }
+  } catch (err) {
+    throw new Error(`WORK.history.yaml malformed: ${err.message}`, { cause: err });
+  }
+  return data;
+}
+
+/**
+ * Parse the full WORK.history.yaml text into all entries (no cycle filter).
+ * Returns entries in file declaration order. Throws on malformed YAML or non-array root.
+ * Empty/null/undefined input yields [].
+ */
+export function parseAllHistoryEntries(text) {
+  return parseHistory(text);
+}
+
+function markFailedDefensive(io, msg) {
+  try { markWorkfileFailed(io, msg); } catch { /* WORK.md gone; nothing to mark */ }
+}
+
+function entryTimestamp(entry) {
+  return entry.timestamp ? new Date(entry.timestamp).getTime() : 0;
+}
+
+function entrySeq(entry) {
+  return typeof entry.seq === 'number' ? entry.seq : 0;
+}
+
+function compareEntries(a, b) {
+  const ta = entryTimestamp(a);
+  const tb = entryTimestamp(b);
+  if (ta !== tb) return ta - tb;
+  return entrySeq(a) - entrySeq(b);
+}
+
+/**
+ * Load history entries for a cycle, sorted by timestamp ascending.
+ */
+export function loadHistory(historyPath, cycle, io) {
+  if (!io.exists(historyPath)) return [];
+  let data;
+  try {
+    data = parseHistory(io.readFile(historyPath));
+  } catch (err) {
+    markFailedDefensive(io, err.message);
+    throw err;
+  }
+  const filtered = data.filter(e => e.cycle === cycle);
+  filtered.sort(compareEntries);
+  return filtered;
+}
+
+function requireIteration(value) {
+  if (value === undefined) throw new Error('iteration is required');
+  if (value === null) throw new Error('iteration is required');
+}
+
+function validateAppendArgs({ iteration, comment, route, stage }) {
+  requireIteration(iteration);
+  if (!comment) throw new Error('comment is required');
+  if (route !== undefined && stage !== 'sort') {
+    throw new Error(`route is only valid on stage='sort' entries; got stage='${stage}'`);
+  }
+}
+
+function buildEntry({ cycle, stage, iteration, comment, route, openFeedback, changedFiles }, seq) {
+  const entry = {
+    cycle,
+    stage,
+    iteration,
+    comment,
+    timestamp: new Date().toISOString(),
+    seq,
+    open_feedback: openFeedback ?? 0,
+  };
+  if (route !== undefined) entry.route = route;
+  if (changedFiles !== undefined) {
+    entry.changed_files = sortPaths(changedFiles);
+  }
+  return entry;
+}
+
+/**
+ * Append a history entry with auto-generated ISO timestamp.
+ */
+export function appendEntry(historyPath, entryOpts, io) {
+  validateAppendArgs(entryOpts);
+
+  let existing = [];
+  if (io.exists(historyPath)) {
+    try {
+      existing = parseHistory(io.readFile(historyPath));
+    } catch (err) {
+      markFailedDefensive(io, err.message);
+      throw err;
+    }
+  }
+
+  const entry = buildEntry(entryOpts, existing.length);
+  existing.push(entry);
+
+  const body = yaml.dump(existing);
+  const tmp = `${historyPath}.tmp`;
+  io.writeFile(tmp, body);
+  io.rename(tmp, historyPath);
+}
+
+/**
+ * Count COMPLETED forge stages for a cycle. This includes forges that ran to
+ * completion but whose downstream appraise deadlocked or blocked the cycle —
+ * completion here means "stage_end was called", not "cycle progressed".
+ * Used by sort for max-iterations enforcement.
+ */
+export function getIteration(historyPath, cycle, io) {
+  const history = loadHistory(historyPath, cycle, io);
+  return history.filter(e => (e.stage || '').split(':')[0] === 'forge').length;
+}

package/dist/scripts/lib/memory/admin/create-edge-type.js

@@ -0,0 +1,91 @@
+import { memoryPaths } from '../paths.js';
+import { loadSchema, writeSchema, bumpVersion, hashFrontmatter } from '../schema.js';
+import { invalidateStore } from '../singleton.js';
+import { withLiveMemoryDb, createLiveEdgeType } from './live-store.js';
+
+const IDENT = /^[a-z][a-z0-9_]*$/;
+
+function deduplicateFirstOccurrence(list) {
+  const seen = new Set();
+  const out = [];
+  for (const name of list) {
+    if (seen.has(name)) continue;
+    seen.add(name);
+    out.push(name);
+  }
+  return out;
+}
+
+function normaliseList(v, key) {
+  if (v === 'any') return 'any';
+  if (!Array.isArray(v) || v.length === 0 || !v.every((s) => typeof s === 'string' && s)) {
+    throw new Error(`'${key}' must be 'any' or a non-empty list of entity type names`);
+  }
+  // Deduplicate while preserving first-occurrence order. `[class, class]` is a
+  // user mistake, not a meaningful declaration.
+  return deduplicateFirstOccurrence(v);
+}
+
+function renderFrontmatter(fm) {
+  const lines = [`type: ${fm.type}`];
+  for (const key of ['sources', 'targets']) {
+    const v = fm[key];
+    lines.push(v === 'any' ? `${key}: any` : `${key}: [${v.join(', ')}]`);
+  }
+  return lines.join('\n');
+}
+
+function validateEdgeTypeInputs(name, body) {
+  if (!IDENT.test(name)) throw new Error(`invalid identifier: '${name}'`);
+  if (typeof body !== 'string' || !body.trim()) throw new Error(`body must be non-empty`);
+}
+
+async function assertNoDuplicateDeclaration(name, schema, p, io) {
+  if (schema.edges[name]) throw new Error(`edge type '${name}' already exists`);
+  if (schema.entities[name]) throw new Error(`'${name}' is already declared as an entity type`);
+  if (await io.exists(p.edgeTypeFile(name))) throw new Error(`edge type file already exists on disk`);
+}
+
+function assertEntityTypesExist(lists, entities) {
+  for (const list of lists) {
+    if (list === 'any') continue;
+    for (const t of list) {
+      if (!entities[t]) throw new Error(`entity type '${t}' is not declared`);
+    }
+  }
+}
+
+async function validateEdgeTypeCreation({ name, srcs, tgts, schema, p, io }) {
+  await assertNoDuplicateDeclaration(name, schema, p, io);
+  assertEntityTypesExist([srcs, tgts], schema.entities);
+}
+
+export async function createEdgeType({ worktreeRoot, io, name, sources, targets, body }) {
+  validateEdgeTypeInputs(name, body);
+  const srcs = normaliseList(sources, 'sources');
+  const tgts = normaliseList(targets, 'targets');
+
+  const foundryDir = 'foundry';
+  const p = memoryPaths(foundryDir);
+  const schema = await loadSchema(foundryDir, io);
+
+  await validateEdgeTypeCreation({ name, body, srcs, tgts, schema, p, io });
+
+  const frontmatter = { type: name, sources: srcs, targets: tgts };
+  const fileContent = `---\n${renderFrontmatter(frontmatter)}\n---\n\n${body.trim()}\n`;
+  await io.writeFile(p.edgeTypeFile(name), fileContent);
+  await io.writeFile(p.relationFile(name), '');
+
+  schema.edges[name] = { frontmatterHash: hashFrontmatter(frontmatter) };
+  bumpVersion(schema);
+  await writeSchema(foundryDir, schema, io);
+
+  try {
+    await withLiveMemoryDb({ worktreeRoot, io }, async (db) => {
+      await createLiveEdgeType(db, name);
+    });
+  } finally {
+    invalidateStore(worktreeRoot);
+  }
+  return { type: name, sources: srcs, targets: tgts };
+}