trellis 2.1.9 → 3.0.2

package/dist/{index-czecrvvn.js → index-q31hfjja.js}

@@ -42,7 +42,7 @@ import {
   triageIssue,
   unblockIssue,
   updateIssue
-} from "./index-3ejh8k6v.js";
+} from "./index-0q7wbasy.js";
 import {
   getDecision,
   getDecisionChain,
@@ -59,7 +59,7 @@ import {
 import {
   EAVStore,
   init_eav_store
-} from "./index-5bhe57y9.js";
+} from "./index-yhwjgfvj.js";
 import {
   __esm
 } from "./index-a76rekgs.js";
@@ -342,6 +342,646 @@ var init_ingestion = __esm(() => {
   };
 });
 
+// src/scaffold/infer.ts
+import { existsSync, readdirSync, statSync, readFileSync } from "fs";
+import { join as join2 } from "path";
+function detectEcosystem(rootPath) {
+  const indicators = [];
+  let ecosystem = null;
+  let name = null;
+  let description = null;
+  let domain = null;
+  const pkgPath = join2(rootPath, "package.json");
+  if (existsSync(pkgPath)) {
+    indicators.push("package.json");
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      name = pkg.name ?? null;
+      description = pkg.description ?? null;
+      ecosystem = "node";
+      const deps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+        ...pkg.peerDependencies
+      };
+      const depNames = Object.keys(deps);
+      if (pkg.engines?.bun || depNames.includes("@types/bun")) {
+        ecosystem = "bun";
+      }
+      if (depNames.some((d) => d.includes("motion-canvas"))) {
+        domain = "animation-studio";
+      } else if (depNames.some((d) => ["react", "vue", "svelte", "next", "nuxt"].includes(d))) {
+        domain = "web-app";
+      } else if (depNames.some((d) => ["express", "fastify", "hono", "elysia"].includes(d))) {
+        domain = "api-server";
+      } else if (depNames.some((d) => d.includes("@tensorflow") || d.includes("langchain") || d.includes("openai"))) {
+        domain = "ai-ml";
+      }
+    } catch {}
+  }
+  if (existsSync(join2(rootPath, "pyproject.toml"))) {
+    indicators.push("pyproject.toml");
+    ecosystem = ecosystem ?? "python";
+  } else if (existsSync(join2(rootPath, "requirements.txt"))) {
+    indicators.push("requirements.txt");
+    ecosystem = ecosystem ?? "python";
+  }
+  const cargoPath = join2(rootPath, "Cargo.toml");
+  if (existsSync(cargoPath)) {
+    indicators.push("Cargo.toml");
+    ecosystem = ecosystem ?? "rust";
+    try {
+      const cargo = readFileSync(cargoPath, "utf-8");
+      const nameMatch = cargo.match(/^name\s*=\s*"(.+?)"/m);
+      if (nameMatch)
+        name = name ?? nameMatch[1] ?? null;
+    } catch {}
+  }
+  if (existsSync(join2(rootPath, "go.mod"))) {
+    indicators.push("go.mod");
+    ecosystem = ecosystem ?? "go";
+  }
+  if (existsSync(join2(rootPath, "Dockerfile")) || existsSync(join2(rootPath, "docker-compose.yml"))) {
+    indicators.push("Dockerfile");
+    domain = domain ?? "infrastructure";
+  }
+  let framework = null;
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      const deps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+        ...pkg.peerDependencies
+      };
+      const depNames = Object.keys(deps);
+      if (depNames.includes("next")) {
+        framework = "next";
+      } else if (depNames.includes("nuxt")) {
+        framework = "nuxt";
+      } else if (depNames.includes("svelte")) {
+        framework = "svelte";
+      } else if (depNames.includes("vue")) {
+        framework = "vue";
+      } else if (depNames.includes("remotion") || depNames.includes("@remotion/server")) {
+        framework = "remotion";
+      } else if (depNames.includes("expo") || depNames.includes("react-native")) {
+        framework = "expo";
+      } else if (depNames.some((d) => ["commander", "cac", "oclif", "yargs"].includes(d))) {
+        framework = "cli";
+      } else if (depNames.includes("react")) {
+        framework = "react";
+      }
+    } catch {}
+  }
+  return {
+    ecosystem: ecosystem ?? "unknown",
+    name,
+    description,
+    domain,
+    framework,
+    indicators
+  };
+}
+function extractReadmeDescription(rootPath) {
+  const candidates = ["README.md", "README.MD", "readme.md", "README.txt"];
+  for (const candidate of candidates) {
+    const readmePath = join2(rootPath, candidate);
+    if (!existsSync(readmePath))
+      continue;
+    try {
+      const content = readFileSync(readmePath, "utf-8");
+      const lines = content.split(`
+`).slice(0, 60);
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("!") && trimmed.length > 20) {
+          const clean = trimmed.replace(/[*_`[\]]/g, "").replace(/\(https?:\/\/[^\)]+\)/g, "").trim();
+          if (clean.length > 10) {
+            return {
+              description: clean.slice(0, 200),
+              indicators: [candidate]
+            };
+          }
+        }
+      }
+    } catch {}
+  }
+  return { description: null, indicators: [] };
+}
+function shallowFileCount(rootPath, maxDepth = 3) {
+  let count = 0;
+  function walk(dir, depth) {
+    if (depth > maxDepth)
+      return;
+    let entries = [];
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.startsWith(".") || entry === "node_modules" || entry === ".trellis")
+        continue;
+      try {
+        const full = join2(dir, entry);
+        const stat2 = statSync(full);
+        if (stat2.isDirectory()) {
+          walk(full, depth + 1);
+        } else {
+          count++;
+        }
+      } catch {}
+    }
+  }
+  walk(rootPath, 0);
+  return count;
+}
+function computeConfidence(fileCount, indicators) {
+  if (fileCount <= 5)
+    return "high";
+  if (indicators.length >= 2)
+    return "high";
+  if (fileCount >= 1e4)
+    return "low";
+  if (indicators.length === 1)
+    return fileCount <= 500 ? "high" : "medium";
+  return "medium";
+}
+async function inferProjectContext(rootPath, opts) {
+  const fileCount = opts?.precomputedFileCount ?? shallowFileCount(rootPath);
+  const ecosystem = detectEcosystem(rootPath);
+  const readme = extractReadmeDescription(rootPath);
+  const allIndicators = [...ecosystem.indicators, ...readme.indicators];
+  const confidence = computeConfidence(fileCount, allIndicators);
+  return {
+    domain: ecosystem.domain,
+    description: readme.description ?? ecosystem.description,
+    ecosystem: ecosystem.ecosystem,
+    name: ecosystem.name,
+    framework: ecosystem.framework,
+    fileCount,
+    confidence,
+    indicators: allIndicators
+  };
+}
+var init_infer = () => {};
+
+// src/scaffold/profile.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join3 } from "path";
+import { homedir } from "os";
+import { createInterface } from "readline";
+function getProfileDir() {
+  return join3(homedir(), ".trellis");
+}
+function getProfilePath() {
+  return join3(getProfileDir(), "profile.json");
+}
+function loadProfile() {
+  const profilePath = getProfilePath();
+  if (!existsSync2(profilePath))
+    return null;
+  try {
+    const raw = readFileSync2(profilePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveProfile(profile) {
+  const dir = getProfileDir();
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(getProfilePath(), JSON.stringify(profile, null, 2));
+}
+function hasProfile() {
+  return existsSync2(getProfilePath());
+}
+function ask(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer.trim()));
+  });
+}
+async function promptForProfile(hints) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  console.log();
+  console.log("  This takes about 60 seconds and only happens once.");
+  console.log(`  Press Enter to skip any question.
+`);
+  const defaultName = hints?.name ?? "";
+  const namePrompt = defaultName ? `  Your name [${defaultName}]: ` : "  Your name: ";
+  const nameRaw = await ask(rl, namePrompt);
+  const name = nameRaw || defaultName;
+  const bio = await ask(rl, "  In one sentence, what kind of work do you do? ");
+  const skillsRaw = await ask(rl, "  Top 3\u20135 tools or skills (comma-separated): ");
+  const style = await ask(rl, "  How would you describe your working style? ");
+  const verbosityRaw = await ask(rl, "  Preferred response verbosity \u2014 concise / balanced / detailed [balanced]: ");
+  const toneRaw = await ask(rl, "  Preferred AI tone \u2014 peer / mentor / formal [peer]: ");
+  rl.close();
+  const skills = skillsRaw ? skillsRaw.split(",").map((s) => s.trim()).filter(Boolean) : [];
+  const verbosity = ["concise", "balanced", "detailed"].includes(verbosityRaw) ? verbosityRaw : "balanced";
+  const tone = ["peer", "mentor", "formal"].includes(toneRaw) ? toneRaw : "peer";
+  const now = new Date().toISOString();
+  return {
+    name: name || "Unknown",
+    bio: bio || "",
+    skills,
+    style: style || "",
+    preferences: { verbosity, tone },
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function updateProfile(updates) {
+  const existing = loadProfile();
+  const base = existing ?? {
+    name: "Unknown",
+    bio: "",
+    skills: [],
+    style: "",
+    preferences: { verbosity: "balanced", tone: "peer" },
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+  const updated = {
+    ...base,
+    ...updates,
+    preferences: { ...base.preferences, ...updates.preferences ?? {} },
+    updatedAt: new Date().toISOString()
+  };
+  saveProfile(updated);
+  return updated;
+}
+var init_profile = () => {};
+
+// src/scaffold/write.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join4 } from "path";
+function renderAgentsMd(profile, context) {
+  const userName = profile?.name ?? "the user";
+  const userBio = profile?.bio || "(No bio provided \u2014 run `trellis season` to set up your profile.)";
+  const userSkills = profile?.skills?.length ? profile.skills.join(", ") : "(not specified)";
+  const userStyle = profile?.style || "(not specified)";
+  const userVerbosity = profile?.preferences?.verbosity ?? "balanced";
+  const userTone = profile?.preferences?.tone ?? "peer";
+  const projectName = context.name ?? "(unnamed)";
+  const projectDomain = context.domain ?? "(not determined \u2014 run `trellis season` to specify)";
+  const projectDesc = context.description ?? "(no description found)";
+  const projectEco = context.ecosystem ?? "unknown";
+  const confidence = context.confidence;
+  return `# Trellis Agent Context
+
+> This file was generated by \`trellis init\` and should be kept up to date.
+> Inference confidence: **${confidence}**
+
+---
+
+## About the User
+
+| Field | Value |
+|-------|-------|
+| **Name** | ${userName} |
+| **Bio** | ${userBio} |
+| **Skills** | ${userSkills} |
+| **Style** | ${userStyle} |
+| **Preferred verbosity** | ${userVerbosity} |
+| **Preferred tone** | ${userTone} |
+
+---
+
+## About This Project
+
+| Field | Value |
+|-------|-------|
+| **Name** | ${projectName} |
+| **Domain** | ${projectDomain} |
+| **Description** | ${projectDesc} |
+| **Ecosystem** | ${projectEco} |
+| **File count** | ~${context.fileCount} |
+
+---
+
+## Agent Instructions
+
+You are operating in a Trellis-tracked repository. Follow these guidelines:
+
+1. **Read \`agent-context.json\`** in this directory for registered tools, ontologies, and domain settings.
+2. **Check \`skills/\`** for domain-specific operating instructions relevant to this project.
+3. **Check \`workflows/\`** for repeatable task procedures. Favor existing workflows before improvising.
+4. **Update this file** as the project evolves \u2014 new teammates, new goals, new tools.
+5. **Communicate through Trellis** \u2014 prefer writing to the graph kernel over mutating files directly when recording decisions or state.
+6. **Run \`trellis season\`** if context seems incomplete or out of date.
+
+---
+
+## Quick Reference
+
+\`\`\`bash
+trellis status          # Current repo state
+trellis log             # Causal operation history
+trellis milestone       # Create narrative checkpoints
+trellis ask "..."       # Semantic search across the repo
+trellis season          # Re-run domain onboarding
+\`\`\`
+`;
+}
+function renderConfigJson(context) {
+  return {
+    domain: context.domain,
+    ecosystem: context.ecosystem,
+    tools: [],
+    ontologies: [],
+    generatedAt: new Date().toISOString(),
+    confidence: context.confidence
+  };
+}
+function renderSkillsReadme() {
+  return `# Skills
+
+Place domain-specific operating instructions here as \`.md\` files.
+
+Each skill file should follow the format:
+
+\`\`\`markdown
+---
+name: Skill Name
+description: When to use this skill.
+---
+
+# Instructions
+...
+\`\`\`
+
+The agent will discover and read skill files relevant to the current task.
+`;
+}
+function renderWorkflowsReadme() {
+  return `# Workflows
+
+Place repeatable task procedures here as \`.md\` files.
+
+Each workflow file should follow the format:
+
+\`\`\`markdown
+---
+description: Short description of what this workflow does.
+---
+
+## Steps
+
+1. Step one
+2. Step two
+// turbo
+3. Auto-runnable step
+\`\`\`
+
+Add \`// turbo\` above a step to allow the agent to auto-run it without confirmation.
+Add \`// turbo-all\` anywhere in the file to auto-run every step.
+`;
+}
+function writeAgentScaffold(rootPath, input) {
+  const agentsDir = join4(rootPath, ".trellis", "agents");
+  const skillsDir = join4(agentsDir, "skills");
+  const workflowsDir = join4(agentsDir, "workflows");
+  for (const dir of [agentsDir, skillsDir, workflowsDir]) {
+    if (!existsSync3(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+  }
+  writeFileSync2(join4(agentsDir, "AGENTS.md"), renderAgentsMd(input.profile, input.context), "utf-8");
+  writeFileSync2(join4(agentsDir, "agent-context.json"), JSON.stringify(renderConfigJson(input.context), null, 2), "utf-8");
+  const skillsReadmePath = join4(skillsDir, "README.md");
+  if (!existsSync3(skillsReadmePath)) {
+    writeFileSync2(skillsReadmePath, renderSkillsReadme(), "utf-8");
+  }
+  const workflowsReadmePath = join4(workflowsDir, "README.md");
+  if (!existsSync3(workflowsReadmePath)) {
+    writeFileSync2(workflowsReadmePath, renderWorkflowsReadme(), "utf-8");
+  }
+}
+function renderCursorRules(input) {
+  const projectName = input.context.name ?? "this project";
+  const domain = input.context.domain ?? "general";
+  const eco = input.context.ecosystem ?? "unknown";
+  const framework = input.framework && input.framework !== "none" ? input.framework : "vanilla";
+  const plugins = input.plugins.length > 0 ? input.plugins.map((p) => `- ${p}`).join(`
+`) : "(none selected)";
+  return `# Cursor Rules for ${projectName}
+
+> Generated by \`trellis init\`
+
+## Project Context
+- **Domain**: ${domain}
+- **Framework**: ${framework}
+- **Ecosystem**: ${eco}
+- **Confidence**: ${input.context.confidence}
+
+## Selected Features
+${plugins}
+
+## Agent Instructions
+You are working in a Trellis-tracked repository. See \`.trellis/agents/AGENTS.md\` for full context.
+
+## Commands
+- \`trellis status\` \u2014 Check repo state
+- \`trellis seed\` \u2014 Refresh this context file
+- \`trellis log\` \u2014 View causal history
+
+---
+*Auto-generated by Trellis. Run \`trellis seed\` to refresh context.*
+`;
+}
+function renderWindsurfRules(input) {
+  const projectName = input.context.name ?? "this project";
+  const domain = input.context.domain ?? "general";
+  const eco = input.context.ecosystem ?? "unknown";
+  const framework = input.framework && input.framework !== "none" ? input.framework : "vanilla";
+  const plugins = input.plugins.length > 0 ? input.plugins.map((p) => `- ${p}`).join(`
+`) : "(none selected)";
+  return `# Windsurf Rules for ${projectName}
+
+> Generated by \`trellis init\`
+
+## Project Context
+- **Domain**: ${domain}
+- **Framework**: ${framework}
+- **Ecosystem**: ${eco}
+- **Confidence**: ${input.context.confidence}
+
+## Selected Features
+${plugins}
+
+## Agent Instructions
+You are working in a Trellis-tracked repository. See \`.trellis/agents/AGENTS.md\` for full context.
+
+## Commands
+- \`trellis status\` \u2014 Check repo state
+- \`trellis seed\` \u2014 Refresh this context file
+- \`trellis log\` \u2014 View causal history
+
+---
+*Auto-generated by Trellis. Run \`trellis seed\` to refresh context.*
+`;
+}
+function renderClaudeMd(input) {
+  const projectName = input.context.name ?? "this project";
+  const domain = input.context.domain ?? "general";
+  const eco = input.context.ecosystem ?? "unknown";
+  const framework = input.framework && input.framework !== "none" ? input.framework : "vanilla";
+  const plugins = input.plugins.length > 0 ? input.plugins.map((p) => `- ${p}`).join(`
+`) : "(none selected)";
+  return `# Claude Context for ${projectName}
+
+> Generated by \`trellis init\`
+
+## Project Context
+- **Domain**: ${domain}
+- **Framework**: ${framework}
+- **Ecosystem**: ${eco}
+- **Confidence**: ${input.context.confidence}
+
+## Selected Features
+${plugins}
+
+## Agent Instructions
+You are working in a Trellis-tracked repository. See \`.trellis/agents/AGENTS.md\` for full context.
+
+## Commands
+- \`trellis status\` \u2014 Check repo state
+- \`trellis seed\` \u2014 Refresh this context file
+- \`trellis log\` \u2014 View causal history
+
+---
+*Auto-generated by Trellis. Run \`trellis seed\` to refresh context.*
+`;
+}
+function renderCopilotConfig(input) {
+  return {
+    version: "1.0",
+    generatedBy: "trellis init",
+    context: {
+      domain: input.context.domain,
+      framework: input.framework,
+      ecosystem: input.context.ecosystem,
+      projectName: input.context.name,
+      confidence: input.context.confidence
+    },
+    plugins: input.plugins
+  };
+}
+function renderCodexConfig(input) {
+  return {
+    version: "1.0",
+    generatedBy: "trellis init",
+    context: {
+      domain: input.context.domain,
+      framework: input.framework,
+      ecosystem: input.context.ecosystem,
+      projectName: input.context.name,
+      confidence: input.context.confidence
+    },
+    features: input.plugins
+  };
+}
+function renderGeminiConfig(input) {
+  return {
+    version: "1.0",
+    generatedBy: "trellis init",
+    context: {
+      domain: input.context.domain,
+      framework: input.framework,
+      ecosystem: input.context.ecosystem,
+      projectName: input.context.name,
+      confidence: input.context.confidence
+    },
+    features: input.plugins
+  };
+}
+function writeIdeScaffold(rootPath, input) {
+  const { ide, footprint, framework, plugins, context, profile } = input;
+  const fullInput = {
+    ide,
+    footprint,
+    framework,
+    plugins,
+    rootPath,
+    context,
+    profile
+  };
+  switch (ide) {
+    case "cursor": {
+      const cursorDir = join4(rootPath, ".cursor");
+      if (!existsSync3(cursorDir)) {
+        mkdirSync2(cursorDir, { recursive: true });
+      }
+      writeFileSync2(join4(cursorDir, "rules.md"), renderCursorRules(fullInput), "utf-8");
+      break;
+    }
+    case "windsurf": {
+      const windsurfDir = join4(rootPath, ".windsurf");
+      if (!existsSync3(windsurfDir)) {
+        mkdirSync2(windsurfDir, { recursive: true });
+      }
+      writeFileSync2(join4(windsurfDir, "rules.md"), renderWindsurfRules(fullInput), "utf-8");
+      break;
+    }
+    case "claude": {
+      const claudeDir = join4(rootPath, ".claude");
+      if (!existsSync3(claudeDir)) {
+        mkdirSync2(claudeDir, { recursive: true });
+      }
+      writeFileSync2(join4(claudeDir, "settings.md"), renderClaudeMd(fullInput), "utf-8");
+      break;
+    }
+    case "copilot": {
+      const copilotDir = join4(rootPath, ".github");
+      const copilotDirSub = join4(copilotDir, "copilot");
+      if (!existsSync3(copilotDirSub)) {
+        mkdirSync2(copilotDirSub, { recursive: true });
+      }
+      writeFileSync2(join4(copilotDirSub, "config.json"), JSON.stringify(renderCopilotConfig(fullInput), null, 2), "utf-8");
+      break;
+    }
+    case "codex": {
+      const codexDir = join4(rootPath, ".codex");
+      if (!existsSync3(codexDir)) {
+        mkdirSync2(codexDir, { recursive: true });
+      }
+      writeFileSync2(join4(codexDir, "config.json"), JSON.stringify(renderCodexConfig(fullInput), null, 2), "utf-8");
+      break;
+    }
+    case "gemini": {
+      const geminiDir = join4(rootPath, ".gemini");
+      if (!existsSync3(geminiDir)) {
+        mkdirSync2(geminiDir, { recursive: true });
+      }
+      writeFileSync2(join4(geminiDir, "config.json"), JSON.stringify(renderGeminiConfig(fullInput), null, 2), "utf-8");
+      break;
+    }
+    case "none":
+      break;
+  }
+  if (footprint === "full") {
+    const agentsDir = join4(rootPath, ".trellis", "agents");
+    if (existsSync3(agentsDir)) {
+      const current = readFileSync3(join4(agentsDir, "AGENTS.md"), "utf-8");
+      const updated = current.replace(/## Quick Reference[\s\S]*$/, `## Quick Reference
+
+\`\`\`bash
+trellis status          # Current repo state
+trellis log             # Causal operation history
+trellis seed            # Refresh agent context (${ide})
+trellis milestone       # Create narrative checkpoints
+\`\`\`
+`);
+      writeFileSync2(join4(agentsDir, "AGENTS.md"), updated, "utf-8");
+    }
+  }
+}
+var init_write = () => {};
+
 // src/garden/cluster.ts
 function isFileOp(op) {
   return FILE_OP_KINDS.has(op.kind);
@@ -3498,14 +4138,14 @@ var init_semantic = __esm(() => {
 
 // src/engine.ts
 import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync3,
   copyFileSync
 } from "fs";
 import { readFile as readFile2 } from "fs/promises";
-import { join as join2, dirname } from "path";
+import { join as join5, dirname } from "path";
 
 class JsonOpLog {
   ops = [];
@@ -3514,16 +4154,16 @@ class JsonOpLog {
     this.filePath = filePath;
   }
   load() {
-    if (existsSync(this.filePath)) {
-      const raw = readFileSync(this.filePath, "utf-8");
+    if (existsSync4(this.filePath)) {
+      const raw = readFileSync4(this.filePath, "utf-8");
       try {
         this.ops = JSON.parse(raw);
       } catch (err) {
         const backupPath = this.filePath + ".bak";
-        if (existsSync(backupPath)) {
-          const backupRaw = readFileSync(backupPath, "utf-8");
+        if (existsSync4(backupPath)) {
+          const backupRaw = readFileSync4(backupPath, "utf-8");
           this.ops = JSON.parse(backupRaw);
-          writeFileSync(this.filePath, backupRaw);
+          writeFileSync3(this.filePath, backupRaw);
         } else {
           throw new Error(`Corrupted ops.json and no backup found. Run \`trellis repair\` to attempt recovery.`);
         }
@@ -3545,21 +4185,21 @@ class JsonOpLog {
   }
   flush() {
     const dir = dirname(this.filePath);
-    if (!existsSync(dir))
-      mkdirSync(dir, { recursive: true });
-    if (existsSync(this.filePath)) {
+    if (!existsSync4(dir))
+      mkdirSync3(dir, { recursive: true });
+    if (existsSync4(this.filePath)) {
       const backupPath = this.filePath + ".bak";
       try {
         copyFileSync(this.filePath, backupPath);
       } catch {}
     }
-    writeFileSync(this.filePath, JSON.stringify(this.ops, null, 2));
+    writeFileSync3(this.filePath, JSON.stringify(this.ops, null, 2));
   }
   static repair(filePath) {
-    if (!existsSync(filePath)) {
+    if (!existsSync4(filePath)) {
       return { recovered: 0, lost: 0 };
     }
-    const raw = readFileSync(filePath, "utf-8");
+    const raw = readFileSync4(filePath, "utf-8");
     try {
       const ops = JSON.parse(raw);
       return { recovered: ops.length, lost: 0 };
@@ -3567,43 +4207,43 @@ class JsonOpLog {
     const lastHash = raw.lastIndexOf('"hash": "trellis:op:');
     if (lastHash === -1) {
       const bakPath = filePath + ".bak";
-      if (existsSync(bakPath)) {
-        const bakRaw = readFileSync(bakPath, "utf-8");
+      if (existsSync4(bakPath)) {
+        const bakRaw = readFileSync4(bakPath, "utf-8");
         try {
           const ops = JSON.parse(bakRaw);
-          writeFileSync(filePath, bakRaw);
+          writeFileSync3(filePath, bakRaw);
           return { recovered: ops.length, lost: 0 };
         } catch {}
       }
-      writeFileSync(filePath, "[]");
+      writeFileSync3(filePath, "[]");
       return { recovered: 0, lost: -1 };
     }
     const endOfLine = raw.indexOf(`
 `, lastHash);
     const closingBrace = raw.indexOf("  }", endOfLine);
     if (closingBrace === -1) {
-      writeFileSync(filePath, "[]");
+      writeFileSync3(filePath, "[]");
       return { recovered: 0, lost: -1 };
     }
     const fixed = raw.slice(0, closingBrace + 3) + `
 ]`;
     try {
       const ops = JSON.parse(fixed);
-      writeFileSync(filePath + ".corrupted", raw);
-      writeFileSync(filePath, fixed);
+      writeFileSync3(filePath + ".corrupted", raw);
+      writeFileSync3(filePath, fixed);
       return { recovered: ops.length, lost: 0 };
     } catch {
-      writeFileSync(filePath + ".corrupted", raw);
-      writeFileSync(filePath, "[]");
+      writeFileSync3(filePath + ".corrupted", raw);
+      writeFileSync3(filePath, "[]");
       return { recovered: 0, lost: -1 };
     }
   }
 }
 function parseIgnoreFile(filePath) {
-  if (!existsSync(filePath))
+  if (!existsSync4(filePath))
     return [];
   try {
-    const content = readFileSync(filePath, "utf-8");
+    const content = readFileSync4(filePath, "utf-8");
     return content.split(`
 `).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).map((line) => line.replace(/\/$/, ""));
   } catch {
@@ -3612,8 +4252,8 @@ function parseIgnoreFile(filePath) {
 }
 function readIgnorePatterns(rootPath) {
   return [
-    ...parseIgnoreFile(join2(rootPath, ".gitignore")),
-    ...parseIgnoreFile(join2(rootPath, ".trellisignore"))
+    ...parseIgnoreFile(join5(rootPath, ".gitignore")),
+    ...parseIgnoreFile(join5(rootPath, ".trellisignore"))
   ];
 }
 
@@ -3646,15 +4286,15 @@ class TrellisVcsEngine {
     };
     this.agentId = opts.agentId ?? `agent:${process.env.USER ?? "unknown"}`;
     this.store = new EAVStore;
-    this.opLog = new JsonOpLog(join2(this.config.rootPath, ".trellis", "ops.json"));
+    this.opLog = new JsonOpLog(join5(this.config.rootPath, ".trellis", "ops.json"));
   }
   async initRepo(opts) {
-    const trellisDir = join2(this.config.rootPath, ".trellis");
-    if (!existsSync(trellisDir)) {
-      mkdirSync(trellisDir, { recursive: true });
+    const trellisDir = join5(this.config.rootPath, ".trellis");
+    if (!existsSync4(trellisDir)) {
+      mkdirSync3(trellisDir, { recursive: true });
     }
     this._blobStore = new BlobStore(trellisDir);
-    const configPath = join2(trellisDir, "config.json");
+    const configPath = join5(trellisDir, "config.json");
     const persistedConfig = {
       rootPath: this.config.rootPath,
       ignorePatterns: this.config.ignorePatterns,
@@ -3663,7 +4303,7 @@ class TrellisVcsEngine {
       agentId: this.agentId,
       createdAt: new Date().toISOString()
     };
-    writeFileSync(configPath, JSON.stringify(persistedConfig, null, 2));
+    writeFileSync3(configPath, JSON.stringify(persistedConfig, null, 2));
     this.opLog.load();
     const branchOp = await createVcsOp("vcs:branchCreate", {
       agentId: this.agentId,
@@ -3702,7 +4342,7 @@ class TrellisVcsEngine {
     for (const event of events) {
       if (event.contentHash) {
         try {
-          const absPath = join2(this.config.rootPath, event.path);
+          const absPath = join5(this.config.rootPath, event.path);
           const content = await readFile2(absPath);
           await this._blobStore.put(content);
         } catch {}
@@ -3729,21 +4369,32 @@ class TrellisVcsEngine {
       }
     }
     await this.flushAutoCheckpoint();
+    opts?.onProgress?.({
+      phase: "scaffolding",
+      current: 0,
+      total: 1,
+      message: "Inferring project context\u2026"
+    });
+    const context = await inferProjectContext(this.config.rootPath, {
+      precomputedFileCount: events.length
+    });
+    const profile = loadProfile();
+    writeAgentScaffold(this.config.rootPath, { profile, context });
     opts?.onProgress?.({
       phase: "done",
       current: opsCreated,
       total: opsCreated,
       message: `Initialized repository with ${opsCreated} operations`
     });
-    return { opsCreated };
+    return { opsCreated, context };
   }
   open() {
     this.opLog.load();
-    const trellisDir = join2(this.config.rootPath, ".trellis");
+    const trellisDir = join5(this.config.rootPath, ".trellis");
     this._blobStore = new BlobStore(trellisDir);
-    const configPath = join2(this.config.rootPath, ".trellis", "config.json");
-    if (existsSync(configPath)) {
-      const raw = readFileSync(configPath, "utf-8");
+    const configPath = join5(this.config.rootPath, ".trellis", "config.json");
+    if (existsSync4(configPath)) {
+      const raw = readFileSync4(configPath, "utf-8");
       const persisted = JSON.parse(raw);
       this.agentId = persisted.agentId;
       const filePatterns = readIgnorePatterns(this.config.rootPath);
@@ -3773,7 +4424,7 @@ class TrellisVcsEngine {
       onEvent: async (event) => {
         if ((event.type === "add" || event.type === "modify") && event.contentHash && this._blobStore) {
           try {
-            const absPath = join2(this.config.rootPath, event.path);
+            const absPath = join5(this.config.rootPath, event.path);
             const content = await readFile2(absPath);
             await this._blobStore.put(content);
           } catch {}
@@ -3787,7 +4438,7 @@ class TrellisVcsEngine {
         if (!trackedPaths.has(event.path)) {
           if (event.contentHash && this._blobStore) {
             try {
-              const absPath = join2(this.config.rootPath, event.path);
+              const absPath = join5(this.config.rootPath, event.path);
               const content = await readFile2(absPath);
               await this._blobStore.put(content);
             } catch {}
@@ -3854,10 +4505,10 @@ class TrellisVcsEngine {
     return this.config.rootPath;
   }
   static isRepo(rootPath) {
-    return existsSync(join2(rootPath, ".trellis", "config.json"));
+    return existsSync4(join5(rootPath, ".trellis", "config.json"));
   }
   static repair(rootPath) {
-    const opsPath = join2(rootPath, ".trellis", "ops.json");
+    const opsPath = join5(rootPath, ".trellis", "ops.json");
     return JsonOpLog.repair(opsPath);
   }
   async createBranch(name) {
@@ -4187,6 +4838,165 @@ var init_engine = __esm(() => {
   init_decisions();
   init_garden2();
   init_semantic();
+  init_infer();
+  init_profile();
+  init_write();
 });
 
-export { FileWatcher, init_fs_watcher, Ingestion, init_ingestion, TrellisVcsEngine, init_engine };
+// src/scaffold/seed.ts
+init_profile();
+init_infer();
+import { existsSync as existsSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join6 } from "path";
+async function seedContext(opts) {
+  const { rootPath, ide = "none", force = false } = opts;
+  const filesUpdated = [];
+  const timestamp = new Date().toISOString();
+  const profile = loadProfile();
+  const context = await inferProjectContext(rootPath);
+  const agentsDir = join6(rootPath, ".trellis", "agents");
+  if (existsSync5(agentsDir)) {
+    const agentsMdPath = join6(agentsDir, "AGENTS.md");
+    if (existsSync5(agentsMdPath) || force) {
+      const content = renderSeedAgentsMd(profile, context, timestamp);
+      writeFileSync4(agentsMdPath, content, "utf-8");
+      filesUpdated.push(".trellis/agents/AGENTS.md");
+    }
+    const agentContextPath = join6(agentsDir, "agent-context.json");
+    if (existsSync5(agentContextPath) || force) {
+      const config = {
+        domain: context.domain,
+        ecosystem: context.ecosystem,
+        tools: [],
+        ontologies: [],
+        generatedAt: timestamp,
+        confidence: context.confidence,
+        lastSeed: timestamp
+      };
+      writeFileSync4(agentContextPath, JSON.stringify(config, null, 2), "utf-8");
+      filesUpdated.push(".trellis/agents/agent-context.json");
+    }
+  }
+  switch (ide) {
+    case "cursor": {
+      const cursorRulesPath = join6(rootPath, ".cursor", "rules.md");
+      if (existsSync5(cursorRulesPath) || force) {
+        const content = renderSeedIdeRules(profile, context, "cursor", timestamp);
+        writeFileSync4(cursorRulesPath, content, "utf-8");
+        filesUpdated.push(".cursor/rules.md");
+      }
+      break;
+    }
+    case "windsurf": {
+      const windsurfRulesPath = join6(rootPath, ".windsurf", "rules.md");
+      if (existsSync5(windsurfRulesPath) || force) {
+        const content = renderSeedIdeRules(profile, context, "windsurf", timestamp);
+        writeFileSync4(windsurfRulesPath, content, "utf-8");
+        filesUpdated.push(".windsurf/rules.md");
+      }
+      break;
+    }
+    case "claude": {
+      const claudeSettingsPath = join6(rootPath, ".claude", "settings.md");
+      if (existsSync5(claudeSettingsPath) || force) {
+        const content = renderSeedIdeRules(profile, context, "claude", timestamp);
+        writeFileSync4(claudeSettingsPath, content, "utf-8");
+        filesUpdated.push(".claude/settings.md");
+      }
+      break;
+    }
+    case "none":
+      break;
+  }
+  return {
+    success: true,
+    filesUpdated,
+    timestamp
+  };
+}
+function renderSeedAgentsMd(profile, context, timestamp) {
+  const userName = profile?.name ?? "the user";
+  const userBio = profile?.bio ?? "(not provided)";
+  const userSkills = profile?.skills?.length ? profile.skills.join(", ") : "(not specified)";
+  return `# Trellis Agent Context
+
+> This file was seeded by \`trellis seed\` on ${timestamp}
+> Inference confidence: **${context.confidence}**
+
+---
+
+## About the User
+
+| Field | Value |
+|-------|-------|
+| **Name** | ${userName} |
+| **Bio** | ${userBio} |
+| **Skills** | ${userSkills} |
+
+---
+
+## About This Project
+
+| Field | Value |
+|-------|-------|
+| **Name** | ${context.name ?? "(unnamed)"} |
+| **Domain** | ${context.domain ?? "(not determined)"} |
+| **Description** | ${context.description ?? "(no description found)"} |
+| **Ecosystem** | ${context.ecosystem ?? "unknown"} |
+| **File count** | ~${context.fileCount} |
+
+---
+
+## Agent Instructions
+
+You are operating in a Trellis-tracked repository. Follow these guidelines:
+
+1. **Read \`agent-context.json\`** in this directory for registered tools, ontologies, and domain settings.
+2. **Check \`skills/\`** for domain-specific operating instructions relevant to this project.
+3. **Check \`workflows/\`** for repeatable task procedures.
+4. **Run \`trellis seed\`** to refresh this context file when the project evolves.
+
+---
+
+## Quick Reference
+
+\`\`\`bash
+trellis status          # Current repo state
+trellis log             # Causal operation history
+trellis seed            # Refresh this context
+trellis milestone       # Create narrative checkpoints
+\`\`\`
+`;
+}
+function renderSeedIdeRules(profile, context, ide, timestamp) {
+  const ideName = ide.charAt(0).toUpperCase() + ide.slice(1);
+  const projectName = context.name ?? "this project";
+  return `# ${ideName} Rules for ${projectName}
+
+> Generated by \`trellis seed\` on ${timestamp}
+
+## Project Context
+- **Domain**: ${context.domain ?? "(not determined)"}
+- **Ecosystem**: ${context.ecosystem ?? "unknown"}
+- **File count**: ~${context.fileCount}
+- **Confidence**: ${context.confidence}
+
+## Agent Instructions
+You are working in a Trellis-tracked repository. See \`.trellis/agents/AGENTS.md\` for full context.
+
+## Commands
+- \`trellis status\` \u2014 Check repo state
+- \`trellis seed\` \u2014 Refresh this context file
+- \`trellis log\` \u2014 View causal history
+
+---
+*Auto-generated by Trellis. Run \`trellis seed\` to refresh context.*
+`;
+}
+
+// src/scaffold/index.ts
+init_infer();
+init_profile();
+init_write();
+
+export { FileWatcher, init_fs_watcher, Ingestion, init_ingestion, inferProjectContext, loadProfile, saveProfile, hasProfile, promptForProfile, updateProfile, writeAgentScaffold, writeIdeScaffold, TrellisVcsEngine, init_engine, seedContext };