agenttwin 0.2.2 → 0.3.0

package/dist/cli.js

@@ -9,6 +9,236 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/runtime/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+async function captureGit(cwd, previousHead) {
+  const exec = promisify(execFile);
+  const git = async (...args) => (await exec("git", args, { cwd, timeout: 5e3, maxBuffer: 1024 * 1024 })).stdout.trim();
+  try {
+    const head = await git("rev-parse", "HEAD");
+    const [branch, total, status, history] = await Promise.all([git("branch", "--show-current"), git("rev-list", "--count", "HEAD"), git("status", "--porcelain", "--untracked-files=no"), git("log", "--since=14 days ago", "-100", "--format=%H %cI")]);
+    let changed = await git("diff", "--name-only", "HEAD");
+    if (previousHead && /^[a-f0-9]{40,64}$/.test(previousHead) && previousHead !== head) {
+      try {
+        changed += "\n" + await git("diff", "--name-only", previousHead, head);
+      } catch {
+        previousHead = void 0;
+      }
+    }
+    return { head, branch: branch || "detached HEAD", totalCommits: Number(total), dirty: !!status, capturedAt: (/* @__PURE__ */ new Date()).toISOString(), commits: history ? history.split("\n").map((line) => {
+      const [sha, date] = line.split(" ");
+      return { sha, date };
+    }) : [], changedFiles: [...new Set(changed.split("\n").filter(Boolean))].slice(0, 1e3), ...previousHead ? { previousHead } : {} };
+  } catch {
+    return void 0;
+  }
+}
+function validateGit(value) {
+  if (value === void 0) return void 0;
+  const g = value;
+  const sha = (s) => typeof s === "string" && /^[a-f0-9]{40,64}$/.test(s);
+  const date = (s) => typeof s === "string" && s.length <= 40 && Number.isFinite(Date.parse(s));
+  if (!g || !sha(g.head) || g.previousHead !== void 0 && !sha(g.previousHead) || typeof g.branch !== "string" || g.branch.length > 240 || /[\x00-\x1f]/.test(g.branch) || !Number.isSafeInteger(g.totalCommits) || g.totalCommits < 0 || typeof g.dirty !== "boolean" || !date(g.capturedAt) || !Array.isArray(g.commits) || g.commits.length > 100 || g.commits.some((c) => !sha(c.sha) || !date(c.date)) || !Array.isArray(g.changedFiles) || g.changedFiles.length > 1e3 || g.changedFiles.some((p) => typeof p !== "string" || p.length > 500 || p.startsWith("/") || p.includes("\\") || p.split("/").includes("..") || /[\x00-\x1f]/.test(p))) throw new Error("Invalid Git metadata");
+  return { head: g.head, branch: g.branch, totalCommits: g.totalCommits, dirty: g.dirty, capturedAt: g.capturedAt, commits: g.commits.map((c) => ({ sha: c.sha, date: c.date })), changedFiles: [...g.changedFiles], ...g.previousHead ? { previousHead: g.previousHead } : {} };
+}
+var init_git = __esm({
+  "src/runtime/git.ts"() {
+    "use strict";
+  }
+});
+
+// src/inventory/dashboard-transfer.ts
+function discoveryTransfer(value) {
+  const input = value;
+  if (!input || input.schema !== "company-inventory/v1" || typeof input.name !== "string" || !Array.isArray(input.tools) || !Array.isArray(input.workflows) || input.tools.length > 1e3 || input.workflows.length > 5e3) throw new Error("Invalid discovery metadata");
+  const text = (v, limit = 240) => {
+    if (typeof v !== "string" || v.length > limit || /[\x00-\x1f]/.test(v)) throw new Error("Invalid discovery string");
+    return v;
+  };
+  const strings = (v) => {
+    if (!Array.isArray(v) || v.length > 1e3) throw new Error("Invalid discovery list");
+    return v.map((s) => text(s));
+  };
+  const entrypoint = (v) => {
+    const path = text(v, 500);
+    if (path.startsWith("/") || path.includes("\\") || /(^|[\/])\.\.([\/#]|$)/.test(path) || /^[A-Za-z][A-Za-z0-9+.-]*:/.test(path)) throw new Error("Entrypoint must be relative to the project");
+    return path;
+  };
+  const tools = input.tools.map((raw) => {
+    const t = raw;
+    return { id: text(t.id), title: text(t.title), kind: text(t.kind), category: text(t.category), confidence: text(t.confidence), interface: text(t.interface) };
+  });
+  const workflows = input.workflows.map((raw) => {
+    const w = raw;
+    if (!Array.isArray(w.steps) || w.steps.length > 1e3) throw new Error("Invalid workflow steps");
+    return { id: text(w.id), title: text(w.title), confidence: text(w.confidence), supported: w.supported === true, verified: false, tools: strings(w.tools), steps: w.steps.map((rawStep) => {
+      const step = rawStep;
+      return { tool: text(step.tool), operations: strings(step.operations) };
+    }), ...w.entrypoint ? { entrypoint: entrypoint(w.entrypoint) } : {} };
+  });
+  if (new Set(tools.map((t) => t.id)).size !== tools.length || new Set(workflows.map((w) => w.id)).size !== workflows.length) throw new Error("Duplicate discovery IDs");
+  const ids = new Set(tools.map((t) => t.id));
+  if (workflows.some((w) => w.tools.some((id) => !ids.has(id)) || w.steps.some((s) => !ids.has(s.tool)))) throw new Error("Unknown workflow tool");
+  const result = { schema: "company-inventory/v1", name: text(input.name), generatedAt: input.generatedAt ? text(input.generatedAt) : "", tools, workflows, ...input.git !== void 0 ? { git: validateGit(input.git) } : {} };
+  if (Buffer.byteLength(JSON.stringify(result)) > 2 * 1024 * 1024) throw new Error("Discovery exceeds 2 MiB");
+  return result;
+}
+var init_dashboard_transfer = __esm({
+  "src/inventory/dashboard-transfer.ts"() {
+    "use strict";
+    init_git();
+  }
+});
+
+// src/inspect/sanitize.ts
+function stripUrlCredentials(value) {
+  return value.replace(URL_CREDENTIALS, "$1");
+}
+function sanitizeOutput(value) {
+  return stripUrlCredentials(value).replace(TOKENISH, (m) => `${m.slice(0, 4)}***`).replace(EMAIL, "$1***$2");
+}
+function excerpt(value, max = 200) {
+  const clean = sanitizeOutput(value).replace(/\s+/g, " ").trim();
+  return clean.length > max ? `${clean.slice(0, max)}\u2026` : clean;
+}
+var URL_CREDENTIALS, TOKENISH, EMAIL;
+var init_sanitize = __esm({
+  "src/inspect/sanitize.ts"() {
+    "use strict";
+    URL_CREDENTIALS = /(https?:\/\/)([^/@\s:]+)(:[^/@\s]+)?@/gi;
+    TOKENISH = /\b(sk|rk|pk|ghp|gho|ghs|glpat|xox[baprs]|AKIA|AIza)[A-Za-z0-9_-]{6,}\b/g;
+    EMAIL = /([A-Za-z0-9._%+-])[A-Za-z0-9._%+-]*(@[A-Za-z0-9.-]+\.[A-Za-z]{2,})/g;
+  }
+});
+
+// src/commands/dashboard.ts
+import { cp, mkdir, readFile as readFile3, writeFile } from "fs/promises";
+import { basename, join as join3 } from "path";
+import { fileURLToPath } from "url";
+function dashboardInventory(cwd, inventory) {
+  return JSON.parse(sanitizeOutput(JSON.stringify({
+    schema: "company-inventory/v1",
+    generatedAt: inventory.generatedAt,
+    name: basename(cwd),
+    tools: inventory.tools.map((t) => ({
+      id: t.id,
+      title: t.title,
+      kind: t.kind,
+      category: t.category,
+      confidence: t.confidence ?? "low",
+      interface: t.kind === "runtime" ? "terminal" : "api"
+    })),
+    workflows: inventory.workflows.map((w) => ({ id: w.id, title: w.title ?? w.id, confidence: w.confidence ?? "low", supported: w.supported, verified: false, ...w.entrypoint ? { entrypoint: w.entrypoint } : {}, tools: w.tools, steps: w.steps.map((s) => ({ tool: s.tool, operations: s.operations })) }))
+  })));
+}
+async function writeDashboard(cwd, inventory) {
+  const directory = join3(cwd, ".agenttwin", "dashboard");
+  let bundle = fileURLToPath(new URL("./dashboard/", import.meta.url));
+  try {
+    await readFile3(join3(bundle, "index.html"));
+  } catch {
+    bundle = fileURLToPath(new URL("../../../../site/", import.meta.url));
+  }
+  await mkdir(join3(directory, "assets", "dashboard"), { recursive: true });
+  const html = await readFile3(join3(bundle, bundle.endsWith("/site/") ? "dashboard.html" : "index.html"), "utf8");
+  for (const folder of ["dashboard", "icons", "logo", "fonts", "vendor"]) {
+    await cp(join3(bundle, "assets", folder), join3(directory, "assets", folder), { recursive: true });
+  }
+  await cp(join3(bundle, "assets", "brand.css"), join3(directory, "assets", "brand.css"));
+  const data = await loadDashboardDiscovery(cwd, inventory);
+  const payload = JSON.stringify(data).replace(/</g, "\\u003c");
+  const page2 = html.replaceAll('type="module"', "defer").replace('<script src="assets/dashboard/dashboard.js', `<script id="agenttwin-discovery" type="application/json">${payload}</script><script src="assets/dashboard/dashboard.js`).replace(/href="index.html"/g, 'href="../report.html"').replace(/href="docs\/"/g, 'href="../report.html"').replace("Docs \u2197", "Discovery report \u2197").replace("Runtime documentation \u2197", "Coverage report \u2197").replace("Back to website \u2197", "Discovery report \u2197");
+  await writeFile(join3(directory, "index.html"), page2, "utf8");
+  await writeFile(join3(directory, "assets", "dashboard", "inventory.json"), JSON.stringify(data), "utf8");
+  await writeFile(join3(directory, "assets", "dashboard", "runs.json"), '{"runs":[]}', "utf8");
+  return join3(directory, "index.html");
+}
+var init_dashboard = __esm({
+  "src/commands/dashboard.ts"() {
+    "use strict";
+    init_session();
+    init_sanitize();
+  }
+});
+
+// src/commands/session.ts
+var session_exports = {};
+__export(session_exports, {
+  installedOpenCode: () => installedOpenCode,
+  launchSession: () => launchSession,
+  loadDashboardDiscovery: () => loadDashboardDiscovery,
+  sessionTask: () => sessionTask,
+  writeSessionTask: () => writeSessionTask
+});
+import { spawn, spawnSync } from "child_process";
+import { writeFile as writeFile2, readFile as readFile4 } from "fs/promises";
+import { join as join4 } from "path";
+function sessionTask() {
+  return `# Prepare this repository for AgentTwin
+
+Read project instructions and .agenttwin/inventory.json first. Inspect tracked application source and configuration; skip secrets, .env values, private data, dependencies and build outputs. Use your configured coding-agent provider and normal permission controls.
+
+Find distinct business workflows across the repository, including routes, queues, schedules, agent tools and exported functions. Do not cap discovery at a handful of examples. Trace callers and side effects across files. For each candidate record its real relative entrypoint, intent, inputs, dependency operations, expected observable outcome and plausible production failures. Distinguish observed code from hypotheses. Do not claim discovery is exhaustive; report skipped files and unresolved dynamic paths.
+
+Write a human-readable .agenttwin/WORKFLOWS.md. For dashboard handoff, write .agenttwin/agent-discovery.json using the metadata-only company-inventory/v1 schema below. Start with the tools in .agenttwin/dashboard/assets/dashboard/inventory.json and retain their IDs; add candidates to workflows. Include no source bodies, credentials, PII or absolute paths. Never mark a candidate verified or executable merely because it was discovered.
+
+Example shape (replace these descriptive placeholders with evidence from this repo):
+{"schema":"company-inventory/v1","name":"project","tools":[],"workflows":[{"id":"agent:unique_workflow","title":"Workflow intent","entrypoint":"src/path.ts#function","confidence":"medium","supported":false,"verified":false,"tools":[],"steps":[]}]}
+Each tool must have id, title, kind, category, confidence, interface. Each step must have tool (an existing tool ID) and operations (string array).
+
+Before execution, ask the user for missing input, expected outcomes and any required synthetic fixtures. Prepare one real workflow at a time: an executable Node entrypoint plus its required application files, reviewed dependency mappings, synthetic starting state, assertions and an explicit fault when appropriate. Read agenttwin prepare --help and the existing preparation schema rather than guessing fields. The CLI runtime supports bundled Node workflows, bounded Slack operations and explicit custom JSON collections. PostgreSQL/Redis worlds require an explicitly selected cloud runner. Unsupported vendor SDKs, browser and desktop interactions are blockers; never represent generic JSON endpoints as full vendor twins.
+
+Do not start Docker or containers locally. Run reviewed supported Node workflows through npx agenttwin run using in-process twins; this executes on the user\u2019s machine and is not a VM security boundary. Do not access production accounts or copy production data. Do not print credentials. Use --runtime hosted or --runtime e2b explicitly only for workflows that require a cloud machine. Never launch a cloud VM merely to analyze code or render dashboard results. Upload application files only after the user reviews the bundle. When a run fails, use the actual run receipt, logs, failed assertions and source digests to propose a fix. Explain uncertainty, edit the approved code, rebuild the bundle and retest using the appropriate runner; never report success without passing evidence.
+
+After review, npx agenttwin sync sends discovery, Git metadata and CLI run evidence to the account dashboard using AGENTTWIN_TOKEN (and optional AGENTTWIN_API_URL). Review run evidence before syncing; it includes synthetic state and application output. It does not upload application source. The dashboard will list all candidate workflows and populate the environment map from these findings.
+`;
+}
+function installedOpenCode() {
+  return spawnSync("opencode", ["--version"], { stdio: "ignore", timeout: 5e3 }).status === 0;
+}
+async function writeSessionTask(cwd) {
+  const path = join4(cwd, ".agenttwin/AGENT-TASK.md");
+  await writeFile2(path, sessionTask(), "utf8");
+  return path;
+}
+async function launchSession(cwd) {
+  if (!installedOpenCode()) throw new Error("OpenCode is not installed. Open .agenttwin/AGENT-TASK.md with your coding agent, or install OpenCode and retry init --agent opencode.");
+  const prompt = "Read .agenttwin/AGENT-TASK.md and follow it to discover and prepare this project for AgentTwin. Start by analyzing the repository and presenting workflow findings and missing execution requirements.";
+  await new Promise((resolve5, reject) => {
+    const child = spawn("opencode", ["--prompt", prompt], { cwd, stdio: "inherit", shell: false });
+    child.once("error", reject);
+    child.once("exit", (code, signal) => code === 0 ? resolve5() : reject(new Error(`Coding session ended ${signal || `with exit code ${code}`}. Discovery files remain available.`)));
+  });
+}
+async function loadDashboardDiscovery(cwd, inventory) {
+  const base = discoveryTransfer(dashboardInventory(cwd, inventory));
+  let raw;
+  try {
+    raw = await readFile4(join4(cwd, ".agenttwin/agent-discovery.json"), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return base;
+    throw error;
+  }
+  if (Buffer.byteLength(raw) > 2 * 1024 * 1024) throw new Error("Agent discovery exceeds 2 MiB");
+  const extra = discoveryTransfer(JSON.parse(raw));
+  const tools = new Map(base.tools.map((t) => [t.id, t]));
+  for (const tool of extra.tools) if (!tools.has(tool.id)) tools.set(tool.id, tool);
+  const workflows = new Map(base.workflows.map((w) => [w.id, w]));
+  for (const workflow of extra.workflows) if (!workflows.has(workflow.id)) workflows.set(workflow.id, { ...workflow, supported: false, verified: false });
+  const result = discoveryTransfer({ ...base, tools: [...tools.values()], workflows: [...workflows.values()] });
+  const ids = new Set(result.tools.map((t) => t.id));
+  if (result.workflows.some((w) => w.tools.some((id) => !ids.has(id)) || w.steps.some((s) => !ids.has(s.tool)))) throw new Error("Agent discovery references unknown tools. Correct .agenttwin/agent-discovery.json before syncing.");
+  return result;
+}
+var init_session = __esm({
+  "src/commands/session.ts"() {
+    "use strict";
+    init_dashboard_transfer();
+    init_dashboard();
+  }
+});
+
 // src/discovery/questions/answers.ts
 var answers_exports = {};
 __export(answers_exports, {
@@ -53,17 +283,56 @@ var init_answers = __esm({
 
 // src/cli.ts
 import { readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname4, join as join17 } from "path";
+import { dirname as dirname4, join as join18 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { parseArgs } from "util";
 
 // src/commands/sync.ts
-import { readFile as readFile4 } from "fs/promises";
-import { join as join4 } from "path";
+init_git();
+import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import { join as join5 } from "path";
 
-// src/runtime/remote.ts
-import { readFile } from "fs/promises";
+// src/runtime/receipt-sync.ts
+init_git();
+import { readFile, readdir } from "fs/promises";
 import { join } from "path";
+function portableLocalReceipt(value) {
+  const r = value;
+  const uuid = (v) => typeof v === "string" && /^[a-f0-9-]{36}$/.test(v);
+  if (!r || r.schema !== "agenttwin/run-v1" || r.runtime !== "local" || !uuid(r.runId) || typeof r.name !== "string" || !/^[a-z][a-z0-9_]{0,39}$/.test(r.name) || typeof r.project !== "string" || r.project.length > 240 || /[\x00-\x1f]/.test(r.project) || !["passed", "failed", "error", "incomplete"].includes(r.status) || typeof r.createdAt !== "string" || !Number.isFinite(Date.parse(r.createdAt)) || !Number.isFinite(r.durationMs) || r.durationMs < 0 || !r.application || !Array.isArray(r.application.command) || r.application.command[0] !== "node" || r.application.command.some((v) => typeof v !== "string") || !Array.isArray(r.assertions) || !r.assertions.length || r.assertions.length > 100 || r.assertions.some((a) => typeof a.service !== "string" || typeof a.path !== "string" || typeof a.passed !== "boolean" || !Number.isSafeInteger(a.count) || a.count < 0 || !Number.isSafeInteger(a.actual) || a.actual < 0 || a.passed !== (a.count === a.actual)) || !Array.isArray(r.events) || r.events.length > 5e4 || !r.finalState || typeof r.finalState !== "object" || !r.initialState || typeof r.initialState !== "object" || !r.sourceDigests || typeof r.sourceDigests !== "object" || !/^[a-f0-9]{64}$/.test(r.specDigest)) throw new Error("Invalid CLI receipt");
+  if (r.status === "passed" && (r.application.exitCode !== 0 || r.application.timedOut || r.assertions.some((a) => !a.passed) || r.unsupported?.length || r.fault && !r.fault.triggered)) throw new Error("Passed receipt contradicts recorded evidence");
+  if (Array.isArray(r.sourceDigests) || Object.keys(r.sourceDigests).length > 100 || Object.entries(r.sourceDigests).some(([path, digest]) => path.startsWith("/") || path.split("/").includes("..") || typeof digest !== "string" || !/^[a-f0-9]{64}$/.test(digest)) || Object.values(r.finalState).some((paths) => !paths || typeof paths !== "object" || Array.isArray(paths) || Object.values(paths).some((rows) => !Array.isArray(rows))) || typeof r.application.stdout !== "string" || typeof r.application.stderr !== "string" || r.application.stdout.length > 65536 || r.application.stderr.length > 65536 || r.events.some((e) => !e || !Number.isSafeInteger(e.sequence) || typeof e.service !== "string" || typeof e.operation !== "string" || typeof e.path !== "string" || typeof e.detail !== "string")) throw new Error("Invalid CLI evidence fields");
+  const git = validateGit(r.git);
+  const fields = ["schema", "runId", "name", "workflowId", "project", "createdAt", "durationMs", "status", "application", "assertions", "infrastructureAssertions", "fault", "initialState", "finalState", "events", "unsupported", "coverage", "sourceDigests", "specDigest"];
+  const result = Object.fromEntries(fields.filter((k) => r[k] !== void 0).map((k) => [k, r[k]]));
+  Object.assign(result, { runtime: "local", provenance: "CLI-reported execution; not independently attested", isolation: { kind: "process", network: "host network; not isolated", rootFilesystem: "host-accessible" }, ...git ? { git } : {} });
+  if (Buffer.byteLength(JSON.stringify(result)) > 2 * 1024 * 1024) throw new Error("CLI receipt exceeds 2 MiB");
+  return result;
+}
+async function syncReceipts(cwd, base, token) {
+  let names;
+  try {
+    names = await readdir(join(cwd, ".agenttwin/runs"));
+  } catch (error) {
+    if (error.code === "ENOENT") return 0;
+    throw error;
+  }
+  let synced = 0;
+  for (const name of names.filter((n) => /^[a-f0-9-]{36}$/.test(n)).slice(-100)) {
+    const path = join(cwd, ".agenttwin/runs", name, "run.json");
+    const r = JSON.parse(await readFile(path, "utf8"));
+    if (r.runtime !== "local") continue;
+    const receipt = portableLocalReceipt(r);
+    const response = await fetch(base + "/v1/receipts", { method: "POST", headers: { authorization: "Bearer " + token, "content-type": "application/json" }, body: JSON.stringify(receipt), redirect: "error", signal: AbortSignal.timeout(2e4) });
+    if (!response.ok) throw new Error("Run evidence sync failed: " + response.status);
+    synced++;
+  }
+  return synced;
+}
+
+// src/runtime/remote.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
 
 // src/lib/exit.ts
 var EXIT = {
@@ -136,14 +405,14 @@ function apiBase(value) {
   if (url.username || url.password || url.search || url.hash || url.protocol !== "https:" && !(url.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname))) throw new CliError("AgentTwin API requires HTTPS (loopback HTTP allowed for development)", { code: EXIT.USAGE });
   return value.replace(/\/$/, "");
 }
-async function executeRemote(stage, spec, log) {
+async function executeRemote(stage, spec, log, metadata = {}) {
   const base = apiBase(process.env.AGENTTWIN_API_URL ?? "");
   const token = process.env.AGENTTWIN_TOKEN;
   if (!token) throw new CliError("AGENTTWIN_TOKEN is not configured", { code: EXIT.BLOCKED });
   const files = /* @__PURE__ */ Object.create(null);
-  for (const file of spec.files) files[file] = (await readFile(join(stage, "app", file))).toString("base64");
+  for (const file of spec.files) files[file] = (await readFile2(join2(stage, "app", file))).toString("base64");
   const headers = { authorization: `Bearer ${token}`, "content-type": "application/json" };
-  const response = await fetch(`${base}/v1/runs`, { method: "POST", headers, body: JSON.stringify({ spec, files }), redirect: "error", signal: AbortSignal.timeout(15e3) });
+  const response = await fetch(`${base}/v1/runs`, { method: "POST", headers, body: JSON.stringify({ spec, files, ...metadata }), redirect: "error", signal: AbortSignal.timeout(15e3) });
   if (!response.ok) throw new CliError(`AgentTwin API rejected run (${response.status}): ${await response.text()}`, { code: response.status === 401 || response.status === 429 ? EXIT.BLOCKED : EXIT.ERROR });
   const job = await response.json();
   if (!/^[a-f0-9-]{36}$/.test(job.id)) throw new CliError("API returned an invalid run ID");
@@ -163,206 +432,303 @@ async function executeRemote(stage, spec, log) {
   throw new CliError(`Timed out waiting for hosted run ${job.id}; inspect this run in the API before retrying`);
 }
 
-// src/commands/session.ts
-import { spawn, spawnSync } from "child_process";
-import { writeFile as writeFile2, readFile as readFile3 } from "fs/promises";
-import { join as join3 } from "path";
-
-// src/inventory/dashboard-transfer.ts
-function discoveryTransfer(value) {
-  const input = value;
-  if (!input || input.schema !== "company-inventory/v1" || typeof input.name !== "string" || !Array.isArray(input.tools) || !Array.isArray(input.workflows) || input.tools.length > 1e3 || input.workflows.length > 5e3) throw new Error("Invalid discovery metadata");
-  const text = (v, limit = 240) => {
-    if (typeof v !== "string" || v.length > limit || /[\x00-\x1f]/.test(v)) throw new Error("Invalid discovery string");
-    return v;
-  };
-  const strings = (v) => {
-    if (!Array.isArray(v) || v.length > 1e3) throw new Error("Invalid discovery list");
-    return v.map((s) => text(s));
-  };
-  const entrypoint = (v) => {
-    const path = text(v, 500);
-    if (path.startsWith("/") || path.includes("\\") || /(^|[\/])\.\.([\/#]|$)/.test(path) || /^[A-Za-z][A-Za-z0-9+.-]*:/.test(path)) throw new Error("Entrypoint must be relative to the project");
-    return path;
-  };
-  const tools = input.tools.map((raw) => {
-    const t = raw;
-    return { id: text(t.id), title: text(t.title), kind: text(t.kind), category: text(t.category), confidence: text(t.confidence), interface: text(t.interface) };
-  });
-  const workflows = input.workflows.map((raw) => {
-    const w = raw;
-    if (!Array.isArray(w.steps) || w.steps.length > 1e3) throw new Error("Invalid workflow steps");
-    return { id: text(w.id), title: text(w.title), confidence: text(w.confidence), supported: w.supported === true, verified: false, tools: strings(w.tools), steps: w.steps.map((rawStep) => {
-      const step = rawStep;
-      return { tool: text(step.tool), operations: strings(step.operations) };
-    }), ...w.entrypoint ? { entrypoint: entrypoint(w.entrypoint) } : {} };
-  });
-  if (new Set(tools.map((t) => t.id)).size !== tools.length || new Set(workflows.map((w) => w.id)).size !== workflows.length) throw new Error("Duplicate discovery IDs");
-  const ids = new Set(tools.map((t) => t.id));
-  if (workflows.some((w) => w.tools.some((id) => !ids.has(id)) || w.steps.some((s) => !ids.has(s.tool)))) throw new Error("Unknown workflow tool");
-  const result = { schema: "company-inventory/v1", name: text(input.name), generatedAt: input.generatedAt ? text(input.generatedAt) : "", tools, workflows };
-  if (Buffer.byteLength(JSON.stringify(result)) > 2 * 1024 * 1024) throw new Error("Discovery exceeds 2 MiB");
-  return result;
-}
-
-// src/commands/dashboard.ts
-import { cp, mkdir, readFile as readFile2, writeFile } from "fs/promises";
-import { basename, join as join2 } from "path";
-import { fileURLToPath } from "url";
-
-// src/inspect/sanitize.ts
-var URL_CREDENTIALS = /(https?:\/\/)([^/@\s:]+)(:[^/@\s]+)?@/gi;
-var TOKENISH = /\b(sk|rk|pk|ghp|gho|ghs|glpat|xox[baprs]|AKIA|AIza)[A-Za-z0-9_-]{6,}\b/g;
-var EMAIL = /([A-Za-z0-9._%+-])[A-Za-z0-9._%+-]*(@[A-Za-z0-9.-]+\.[A-Za-z]{2,})/g;
-function stripUrlCredentials(value) {
-  return value.replace(URL_CREDENTIALS, "$1");
-}
-function sanitizeOutput(value) {
-  return stripUrlCredentials(value).replace(TOKENISH, (m) => `${m.slice(0, 4)}***`).replace(EMAIL, "$1***$2");
-}
-function excerpt(value, max = 200) {
-  const clean = sanitizeOutput(value).replace(/\s+/g, " ").trim();
-  return clean.length > max ? `${clean.slice(0, max)}\u2026` : clean;
-}
-
-// src/commands/dashboard.ts
-function dashboardInventory(cwd, inventory) {
-  return JSON.parse(sanitizeOutput(JSON.stringify({
-    schema: "company-inventory/v1",
-    generatedAt: inventory.generatedAt,
-    name: basename(cwd),
-    tools: inventory.tools.map((t) => ({
-      id: t.id,
-      title: t.title,
-      kind: t.kind,
-      category: t.category,
-      confidence: t.confidence ?? "low",
-      interface: t.kind === "runtime" ? "terminal" : "api"
-    })),
-    workflows: inventory.workflows.map((w) => ({ id: w.id, title: w.title ?? w.id, confidence: w.confidence ?? "low", supported: w.supported, verified: false, ...w.entrypoint ? { entrypoint: w.entrypoint } : {}, tools: w.tools, steps: w.steps.map((s) => ({ tool: s.tool, operations: s.operations })) }))
-  })));
-}
-async function writeDashboard(cwd, inventory) {
-  const directory = join2(cwd, ".agenttwin", "dashboard");
-  let bundle = fileURLToPath(new URL("./dashboard/", import.meta.url));
-  try {
-    await readFile2(join2(bundle, "index.html"));
-  } catch {
-    bundle = fileURLToPath(new URL("../../../../site/", import.meta.url));
-  }
-  await mkdir(join2(directory, "assets", "dashboard"), { recursive: true });
-  const html = await readFile2(join2(bundle, bundle.endsWith("/site/") ? "dashboard.html" : "index.html"), "utf8");
-  for (const folder of ["dashboard", "icons", "logo", "fonts"]) {
-    await cp(join2(bundle, "assets", folder), join2(directory, "assets", folder), { recursive: true });
-  }
-  await cp(join2(bundle, "assets", "brand.css"), join2(directory, "assets", "brand.css"));
-  const data = await loadDashboardDiscovery(cwd, inventory);
-  const payload = JSON.stringify(data).replace(/</g, "\\u003c");
-  const page2 = html.replace('type="module"', "defer").replace('<script src="assets/dashboard/dashboard.js', `<script id="agenttwin-discovery" type="application/json">${payload}</script><script src="assets/dashboard/dashboard.js`).replace(/href="index.html"/g, 'href="../report.html"').replace(/href="docs\/"/g, 'href="../report.html"').replace("Docs \u2197", "Discovery report \u2197").replace("Runtime documentation \u2197", "Coverage report \u2197").replace("Back to website \u2197", "Discovery report \u2197");
-  await writeFile(join2(directory, "index.html"), page2, "utf8");
-  await writeFile(join2(directory, "assets", "dashboard", "inventory.json"), JSON.stringify(data), "utf8");
-  await writeFile(join2(directory, "assets", "dashboard", "runs.json"), '{"runs":[]}', "utf8");
-  return join2(directory, "index.html");
-}
-
-// src/commands/session.ts
-function sessionTask() {
-  return `# Prepare this repository for AgentTwin
-
-Read project instructions and .agenttwin/inventory.json first. Inspect tracked application source and configuration; skip secrets, .env values, private data, dependencies and build outputs. Use your configured coding-agent provider and normal permission controls.
-
-Find distinct business workflows across the repository, including routes, queues, schedules, agent tools and exported functions. Do not cap discovery at a handful of examples. Trace callers and side effects across files. For each candidate record its real relative entrypoint, intent, inputs, dependency operations, expected observable outcome and plausible production failures. Distinguish observed code from hypotheses. Do not claim discovery is exhaustive; report skipped files and unresolved dynamic paths.
-
-Write a human-readable .agenttwin/WORKFLOWS.md. For dashboard handoff, write .agenttwin/agent-discovery.json using the metadata-only company-inventory/v1 schema below. Start with the tools in .agenttwin/dashboard/assets/dashboard/inventory.json and retain their IDs; add candidates to workflows. Include no source bodies, credentials, PII or absolute paths. Never mark a candidate verified or executable merely because it was discovered.
-
-Example shape (replace these descriptive placeholders with evidence from this repo):
-{"schema":"company-inventory/v1","name":"project","tools":[],"workflows":[{"id":"agent:unique_workflow","title":"Workflow intent","entrypoint":"src/path.ts#function","confidence":"medium","supported":false,"verified":false,"tools":[],"steps":[]}]}
-Each tool must have id, title, kind, category, confidence, interface. Each step must have tool (an existing tool ID) and operations (string array).
-
-Before execution, ask the user for missing input, expected outcomes and any required synthetic fixtures. Prepare one real workflow at a time: an executable Node entrypoint plus its required application files, reviewed dependency mappings, synthetic starting state, assertions and an explicit fault when appropriate. Read agenttwin prepare --help and the existing preparation schema rather than guessing fields. The current hosted runtime supports Node, PostgreSQL, Redis, bounded Slack operations and explicit custom JSON collections. Unsupported vendor SDKs, browser and desktop interactions are blockers; never represent generic JSON endpoints as full vendor twins.
-
-Do not run application workflows, Docker or containers locally. Do not access production accounts or copy production data. Do not print credentials. Execute reviewed workflows only through npx agenttwin run in a fresh hosted sandbox with AgentTwin account credentials or E2B credentials. Upload application files only after the user reviews the bundle. When a run fails, use the actual run receipt, logs, failed assertions and source digests to propose a fix. Explain uncertainty, edit the approved code, rebuild the bundle and retest in a new sandbox; never report success without passing evidence.
-
-After review, npx agenttwin sync sends discovery metadata to the account dashboard using AGENTTWIN_TOKEN (and optional AGENTTWIN_API_URL). It does not upload application source. The dashboard will list all candidate workflows and populate the environment map from these findings.
-`;
-}
-function installedOpenCode() {
-  return spawnSync("opencode", ["--version"], { stdio: "ignore", timeout: 5e3 }).status === 0;
-}
-async function writeSessionTask(cwd) {
-  const path = join3(cwd, ".agenttwin/AGENT-TASK.md");
-  await writeFile2(path, sessionTask(), "utf8");
-  return path;
-}
-async function launchSession(cwd) {
-  if (!installedOpenCode()) throw new Error("OpenCode is not installed. Open .agenttwin/AGENT-TASK.md with your coding agent, or install OpenCode and retry init --agent opencode.");
-  const prompt = "Read .agenttwin/AGENT-TASK.md and follow it to discover and prepare this project for AgentTwin. Start by analyzing the repository and presenting workflow findings and missing execution requirements.";
-  await new Promise((resolve5, reject) => {
-    const child = spawn("opencode", ["--prompt", prompt], { cwd, stdio: "inherit", shell: false });
-    child.once("error", reject);
-    child.once("exit", (code, signal) => code === 0 ? resolve5() : reject(new Error(`Coding session ended ${signal || `with exit code ${code}`}. Discovery files remain available.`)));
-  });
-}
-async function loadDashboardDiscovery(cwd, inventory) {
-  const base = discoveryTransfer(dashboardInventory(cwd, inventory));
-  let raw;
-  try {
-    raw = await readFile3(join3(cwd, ".agenttwin/agent-discovery.json"), "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT") return base;
-    throw error;
-  }
-  if (Buffer.byteLength(raw) > 2 * 1024 * 1024) throw new Error("Agent discovery exceeds 2 MiB");
-  const extra = discoveryTransfer(JSON.parse(raw));
-  const tools = new Map(base.tools.map((t) => [t.id, t]));
-  for (const tool of extra.tools) if (!tools.has(tool.id)) tools.set(tool.id, tool);
-  const workflows = new Map(base.workflows.map((w) => [w.id, w]));
-  for (const workflow of extra.workflows) if (!workflows.has(workflow.id)) workflows.set(workflow.id, { ...workflow, supported: false, verified: false });
-  const result = discoveryTransfer({ ...base, tools: [...tools.values()], workflows: [...workflows.values()] });
-  const ids = new Set(result.tools.map((t) => t.id));
-  if (result.workflows.some((w) => w.tools.some((id) => !ids.has(id)) || w.steps.some((s) => !ids.has(s.tool)))) throw new Error("Agent discovery references unknown tools. Correct .agenttwin/agent-discovery.json before syncing.");
-  return result;
-}
-
 // src/commands/sync.ts
+init_session();
 async function runSync(cwd) {
   const token = process.env.AGENTTWIN_TOKEN;
   if (!token || !/^at_user_[a-f0-9]{64}$/.test(token)) throw new Error("Set AGENTTWIN_TOKEN to your individual account token.");
   const base = apiBase(process.env.AGENTTWIN_API_URL || "https://agenttwin-api.212.56.40.125.sslip.io");
-  const inventory = JSON.parse(await readFile4(join4(cwd, ".agenttwin/inventory.json"), "utf8"));
+  const inventory = JSON.parse(await readFile5(join5(cwd, ".agenttwin/inventory.json"), "utf8"));
   const payload = await loadDashboardDiscovery(cwd, inventory);
+  let previousHead;
+  try {
+    previousHead = JSON.parse(await readFile5(join5(cwd, ".agenttwin/git.json"), "utf8")).head;
+  } catch {
+  }
+  const git = await captureGit(cwd, previousHead);
+  Object.assign(payload, git ? { git } : {});
   const response = await fetch(base + "/v1/discovery", { method: "POST", headers: { authorization: "Bearer " + token, "content-type": "application/json" }, body: JSON.stringify(payload), redirect: "error", signal: AbortSignal.timeout(2e4) });
   const result = await response.json();
   if (!response.ok) throw new Error(result.error || "Discovery sync failed: " + response.status);
-  return { synced: true, tools: payload.tools.length, workflows: payload.workflows.length, dashboard: "https://agenttwin.212.56.40.125.sslip.io/site/dashboard.html", uploaded: "discovery metadata only; no source files or credentials" };
+  if (git) await writeFile3(join5(cwd, ".agenttwin/git.json"), JSON.stringify(git) + "\n", { mode: 384 });
+  const receipts = await syncReceipts(cwd, base, token);
+  return { receipts, synced: true, tools: payload.tools.length, workflows: payload.workflows.length, dashboard: "https://agenttwin.si/site/dashboard.html", uploaded: "discovery, Git metadata and run evidence; no application source or credentials" };
 }
 
 // src/commands/prepare.ts
-import { mkdir as mkdir3, mkdtemp as mkdtemp2, readFile as readFile7, writeFile as writeFile4, rm as rm2 } from "fs/promises";
-import { join as join7, resolve as resolve2, dirname as dirname2 } from "path";
+init_git();
+import { mkdir as mkdir3, mkdtemp as mkdtemp2, readFile as readFile8, writeFile as writeFile5, rm as rm2 } from "fs/promises";
+import { join as join8, resolve as resolve2, dirname as dirname2 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
 
 // src/commands/run.ts
-import { mkdtemp, mkdir as mkdir2, readFile as readFile6, writeFile as writeFile3, realpath, lstat, rm, copyFile } from "fs/promises";
+import { mkdtemp, mkdir as mkdir2, readFile as readFile7, writeFile as writeFile4, realpath, lstat, rm, copyFile } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname, isAbsolute, join as join6, relative, resolve, sep } from "path";
+import { basename as basename2, dirname, isAbsolute, join as join7, relative, resolve, sep } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createHash, randomUUID } from "crypto";
 
+// src/runtime/local.ts
+import { spawn as spawn2 } from "child_process";
+
+// src/runtime/http-world.ts
+import { createServer } from "http";
+import { randomBytes } from "crypto";
+var HttpWorld = class {
+  constructor(spec) {
+    this.spec = spec;
+  }
+  spec;
+  events = [];
+  state = /* @__PURE__ */ Object.create(null);
+  credentials = /* @__PURE__ */ Object.create(null);
+  unsupported = [];
+  servers = [];
+  timers = /* @__PURE__ */ new Set();
+  fired = false;
+  record(service, operation, path, detail) {
+    if (this.events.length >= 5e4) return;
+    this.events.push({ sequence: this.events.length + 1, service, operation, path, detail });
+  }
+  async start() {
+    for (const service of this.spec.services) {
+      const token = `at_world_${randomBytes(24).toString("hex")}`;
+      const data = /* @__PURE__ */ Object.create(null);
+      this.state[service.name] = data;
+      for (const c of service.collections) data[c.path] = structuredClone(c.seed);
+      const keys = /* @__PURE__ */ new Map();
+      const server = createServer(async (req, res) => {
+        const send = (code, body) => {
+          if (!res.destroyed) {
+            res.writeHead(code, { "content-type": "application/json" });
+            res.end(JSON.stringify(body));
+          }
+        };
+        try {
+          if (req.headers.authorization !== `Bearer ${token}`) {
+            this.record(service.name, "auth-denied", req.url ?? "", "invalid test credential");
+            send(401, { error: "invalid_test_credential" });
+            return;
+          }
+          if (this.events.length >= 5e4 || this.unsupported.length >= 1e3) {
+            send(429, { error: "world_capacity" });
+            return;
+          }
+          const url = new URL(req.url ?? "/", "http://localhost");
+          let path = url.pathname;
+          const slack = service.adapter === "slack";
+          const slackMethod = path.replace(/^\/api\//, "");
+          let payload;
+          if (req.method === "POST") {
+            const chunks = [];
+            let bytes = 0;
+            for await (const chunk of req) {
+              bytes += chunk.length;
+              if (bytes > 1024 * 1024) {
+                send(413, { error: "body_too_large" });
+                return;
+              }
+              chunks.push(Buffer.from(chunk));
+            }
+            const text = Buffer.concat(chunks).toString("utf8");
+            let parsed;
+            try {
+              parsed = slack && req.headers["content-type"]?.startsWith("application/x-www-form-urlencoded") ? Object.fromEntries(new URLSearchParams(text)) : JSON.parse(text);
+            } catch {
+              send(400, { error: "expected_json_object" });
+              return;
+            }
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+              send(400, { error: "expected_json_object" });
+              return;
+            }
+            payload = parsed;
+          }
+          if (slack) {
+            const params = payload ?? Object.fromEntries(url.searchParams);
+            const allowed = slackMethod === "chat.postMessage" ? ["channel", "text"] : slackMethod === "conversations.history" ? ["channel"] : [];
+            if (Object.keys(params).some((k) => !allowed.includes(k))) {
+              this.unsupported.push(`${service.name}: unsupported parameters for ${slackMethod}`);
+              send(501, { ok: false, error: "unsupported_parameters", forwardedToProduction: false });
+              return;
+            }
+            if (slackMethod === "chat.postMessage" && req.method === "POST") path = "/messages";
+            else if (slackMethod === "conversations.history" && ["GET", "POST"].includes(req.method ?? "")) path = "/messages";
+            else if (slackMethod === "conversations.list" && ["GET", "POST"].includes(req.method ?? "")) path = "/channels";
+            else {
+              this.unsupported.push(`${service.name}: ${req.method} ${url.pathname}`);
+              send(501, { ok: false, error: "unsupported_operation" });
+              return;
+            }
+          }
+          if (!Object.hasOwn(data, path) || !["GET", "POST"].includes(req.method ?? "")) {
+            this.unsupported.push(`${service.name}: ${req.method} ${path}`);
+            send(501, { error: "unsupported_operation", forwardedToProduction: false });
+            return;
+          }
+          if (req.method === "GET" || slack && slackMethod !== "chat.postMessage") {
+            this.record(service.name, "read", path, `${data[path].length} records`);
+            if (slack && path === "/channels") send(200, { ok: true, channels: data[path], response_metadata: { next_cursor: "" } });
+            else if (slack) {
+              const channel = payload?.channel ?? url.searchParams.get("channel");
+              if (!data["/channels"].some((c) => c.id === channel)) send(200, { ok: false, error: "channel_not_found" });
+              else send(200, { ok: true, messages: data[path].filter((m) => m.channel === channel), has_more: false });
+            } else send(200, { data: data[path] });
+            return;
+          }
+          const body = payload;
+          if (slack) {
+            const message = body;
+            if (!data["/channels"].some((c) => c.id === message.channel)) {
+              send(200, { ok: false, error: "channel_not_found" });
+              return;
+            }
+            if (typeof message.text !== "string" || !message.text) {
+              send(200, { ok: false, error: "no_text" });
+              return;
+            }
+          }
+          if (data[path].length >= 1e4 || this.events.length >= 5e4) {
+            send(429, { error: "world_capacity" });
+            return;
+          }
+          const keyHeader = slack ? void 0 : req.headers["idempotency-key"];
+          const key = typeof keyHeader === "string" ? `${path}:${keyHeader}` : void 0;
+          const signature = JSON.stringify(body);
+          const previous = key ? keys.get(key) : void 0;
+          if (previous) {
+            if (previous.body !== signature) {
+              send(409, { error: "idempotency_conflict" });
+              return;
+            }
+            this.record(service.name, "replay", path, "same-key response replay");
+            send(200, previous.record);
+            return;
+          }
+          let index = data[path].length + 1;
+          while (data[path].some((r) => r.id === `${service.name}_${index}`)) index++;
+          const row = { ...body, id: `${service.name}_${index}` };
+          if (slack) row.ts = `${index}.000001`;
+          const reply = slack ? { ok: true, channel: row.channel, ts: row.ts, message: row } : row;
+          data[path].push(row);
+          if (key) keys.set(key, { body: signature, record: row });
+          this.record(service.name, "write", path, String(row.id));
+          const fault = this.spec.fault;
+          if (!this.fired && fault?.service === service.name && fault.path === path) {
+            this.fired = true;
+            this.record(service.name, "fault", path, `write committed; response delayed ${fault.delayMs}ms`);
+            const timer = setTimeout(() => {
+              this.timers.delete(timer);
+              send(slack ? 200 : 201, reply);
+            }, fault.delayMs);
+            this.timers.add(timer);
+          } else send(slack ? 200 : 201, reply);
+        } catch {
+          send(500, { error: "world_request_error" });
+        }
+      });
+      server.requestTimeout = 1e4;
+      await new Promise((resolve5, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", resolve5);
+      });
+      this.servers.push(server);
+      this.credentials[service.name] = { endpoint: `http://127.0.0.1:${server.address().port}`, token };
+    }
+    return this.credentials;
+  }
+  assertions() {
+    return this.spec.assertions.map((a) => {
+      const rows = this.state[a.service][a.path].filter((row) => !a.where || Object.entries(a.where).every(([k, v]) => JSON.stringify(row[k]) === JSON.stringify(v)));
+      return { ...a, actual: rows.length, passed: rows.length === a.count };
+    });
+  }
+  get faultTriggered() {
+    return this.fired;
+  }
+  async close() {
+    for (const timer of this.timers) clearTimeout(timer);
+    this.timers.clear();
+    await Promise.all(this.servers.map((server) => new Promise((resolve5) => {
+      server.close(() => resolve5());
+      server.closeAllConnections();
+    })));
+  }
+};
+
+// src/runtime/local.ts
+async function executeLocal(app, spec, signal) {
+  if (spec.postgres || spec.redis) throw new Error("This world needs PostgreSQL or Redis. Use --runtime hosted or --runtime e2b, or prepare a workflow using HTTP twins only. No local containers are started.");
+  signal?.throwIfAborted();
+  const world = new HttpWorld(spec), started = Date.now();
+  try {
+    const credentials = await world.start();
+    const env = { PATH: process.env.PATH ?? "", NODE_ENV: "test" };
+    for (const [name, c] of Object.entries(credentials)) {
+      env[`AGENTTWIN_${name.toUpperCase()}_URL`] = c.endpoint;
+      env[`AGENTTWIN_${name.toUpperCase()}_TOKEN`] = c.token;
+    }
+    let stdout = "", stderr = "", timedOut = false;
+    const child = spawn2(process.execPath, spec.command.slice(1), { cwd: app, env, stdio: ["ignore", "pipe", "pipe"], detached: process.platform !== "win32" });
+    child.stdout.on("data", (b) => {
+      stdout = (stdout + b.toString()).slice(-65536);
+    });
+    child.stderr.on("data", (b) => {
+      stderr = (stderr + b.toString()).slice(-65536);
+    });
+    const kill = () => {
+      if (child.pid) {
+        try {
+          process.platform === "win32" ? child.kill("SIGKILL") : process.kill(-child.pid, "SIGKILL");
+        } catch {
+        }
+      }
+    };
+    const abort = () => kill();
+    signal?.addEventListener("abort", abort, { once: true });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      kill();
+    }, spec.timeoutSeconds * 1e3);
+    const exitCode = await new Promise((resolve5, reject) => {
+      child.once("error", reject);
+      child.once("close", resolve5);
+    }).finally(() => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      kill();
+    });
+    signal?.throwIfAborted();
+    await world.close();
+    for (const c of Object.values(credentials)) {
+      stdout = stdout.split(c.token).join("[test-token]");
+      stderr = stderr.split(c.token).join("[test-token]");
+    }
+    const assertions = world.assertions();
+    const status = world.unsupported.length || spec.fault && !world.faultTriggered ? "incomplete" : timedOut || exitCode !== 0 ? "error" : assertions.every((a) => a.passed) ? "passed" : "failed";
+    return { schema: "agenttwin/run-v1", name: spec.name, workflowId: spec.workflowId, status, application: { command: spec.command, exitCode, timedOut, stdout, stderr }, assertions, infrastructureAssertions: [], fault: spec.fault ? { ...spec.fault, triggered: world.faultTriggered } : null, initialState: Object.fromEntries(spec.services.map((s) => [s.name, Object.fromEntries(s.collections.map((c) => [c.path, c.seed]))])), finalState: world.state, events: world.events, unsupported: world.unsupported, durationMs: Date.now() - started, coverage: "CLI Node execution with fresh in-process HTTP collections and bounded Slack operations. Not a VM or network/filesystem isolation boundary. No production environment variables inherited; reviewed code can still access the host filesystem and network.", isolation: { kind: "process", productionCredentialsInherited: false, network: "host network; not isolated", rootFilesystem: "host-accessible; explicit files staged in temporary directory" } };
+  } finally {
+    await world.close();
+  }
+}
+
+// src/commands/run.ts
+init_git();
+
 // src/runtime/e2b.ts
 import { Sandbox } from "e2b";
-import { readFile as readFile5 } from "fs/promises";
-import { randomBytes } from "crypto";
+import { readFile as readFile6 } from "fs/promises";
+import { randomBytes as randomBytes2 } from "crypto";
 import { homedir } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 async function executeE2B(stage, spec, log, signal) {
   signal?.throwIfAborted();
   const apiKey = process.env.E2B_API_KEY;
   if (!apiKey) throw new CliError("E2B_API_KEY is not configured", { code: EXIT.BLOCKED, action: "Set E2B_API_KEY in your shell. It remains on the host and is never passed to the application." });
   let saved = {};
   try {
-    saved = JSON.parse(await readFile5(join5(homedir(), ".agenttwin/runtime.json"), "utf8"));
+    saved = JSON.parse(await readFile6(join6(homedir(), ".agenttwin/runtime.json"), "utf8"));
   } catch {
   }
   const template = process.env.E2B_TEMPLATE_ID ?? saved.templateId;
@@ -381,12 +747,12 @@ async function executeE2B(stage, spec, log, signal) {
     signal?.throwIfAborted();
     await sandbox.commands.run("mkdir -p /input/app && chmod 755 /input /input/app", { user: "root" });
     for (const file of ["world.json", "worker.js", ...spec.files.map((f) => `app/${f}`)]) {
-      await sandbox.files.write(`/input/${file}`, new Uint8Array(await readFile5(join5(stage, file))).buffer, { user: "root" });
+      await sandbox.files.write(`/input/${file}`, new Uint8Array(await readFile6(join6(stage, file))).buffer, { user: "root" });
     }
     await sandbox.commands.run("chmod -R a+rX /input", { user: "root" });
     const runtimeEnv = {};
     if (spec.postgres) {
-      const password = randomBytes(24).toString("hex");
+      const password = randomBytes2(24).toString("hex");
       secrets.push(password);
       await sandbox.commands.run("pg_ctlcluster --skip-systemctl-redirect 15 main start -o '-c ssl=off -c listen_addresses=127.0.0.1'", { user: "root" });
       await sandbox.files.write("/tmp/agenttwin-init.sql", `CREATE ROLE agenttwin LOGIN PASSWORD '${password}';
@@ -400,7 +766,7 @@ CREATE DATABASE agenttwin OWNER agenttwin;
       }
     }
     if (spec.redis) {
-      const password = randomBytes(24).toString("hex");
+      const password = randomBytes2(24).toString("hex");
       secrets.push(password);
       await sandbox.files.write("/tmp/agenttwin-redis.conf", `bind 127.0.0.1
 port 6379
@@ -504,12 +870,12 @@ async function stageApplication(root, files, destination) {
     const source = await realpath(resolve(canonicalRoot, file));
     const rel = relative(canonicalRoot, source);
     if (rel.startsWith(`..${sep}`) || rel === ".." || isAbsolute(rel) || source !== resolve(canonicalRoot, file) || !(await lstat(source)).isFile()) throw new CliError(`Files must be regular files within the project, without symlinks: ${file}`, { code: EXIT.USAGE });
-    const contents = await readFile6(source);
+    const contents = await readFile7(source);
     bytes += contents.length;
     if (bytes > 20 * 1024 * 1024) throw new CliError("Application files exceed 20 MiB; supply a smaller built bundle", { code: EXIT.USAGE });
-    const target = join6(destination, file);
+    const target = join7(destination, file);
     await mkdir2(dirname(target), { recursive: true });
-    await writeFile3(target, contents, { mode: 420 });
+    await writeFile4(target, contents, { mode: 420 });
     digests[file] = createHash("sha256").update(contents).digest("hex");
   }
   return digests;
@@ -518,40 +884,67 @@ async function runWorld(cwd, opts) {
   const file = resolve(cwd, opts.file ?? "agenttwin.world.json");
   let spec;
   try {
-    spec = parseWorld(JSON.parse(await readFile6(file, "utf8")));
+    spec = parseWorld(JSON.parse(await readFile7(file, "utf8")));
   } catch (error) {
     throw new CliError(String(error), { code: EXIT.USAGE, action: "Create agenttwin.world.json; run agenttwin example --out ./agenttwin-example for a working example." });
   }
   if (spec.workflowId) {
     let inventory;
     try {
-      inventory = JSON.parse(await readFile6(join6(cwd, ".agenttwin/inventory.json"), "utf8"));
+      inventory = JSON.parse(await readFile7(join7(cwd, ".agenttwin/inventory.json"), "utf8"));
     } catch {
       throw new CliError("Linked workflow needs discovery inventory; run init first", { code: EXIT.BLOCKED });
     }
-    if (!inventory.workflows?.some((w) => w.id === spec.workflowId)) throw new CliError("workflowId is absent from the current inventory", { code: EXIT.BLOCKED });
+    if (!inventory.workflows?.some((w) => w.id === spec.workflowId)) {
+      const { loadDashboardDiscovery: loadDashboardDiscovery2 } = await Promise.resolve().then(() => (init_session(), session_exports));
+      const discovery = await loadDashboardDiscovery2(cwd, inventory);
+      if (!discovery.workflows.some((w) => w.id === spec.workflowId)) throw new CliError("workflowId is absent from the current inventory", { code: EXIT.BLOCKED });
+    }
   }
-  const runtime = opts.runtime ?? (process.env.AGENTTWIN_API_URL ? "hosted" : "e2b");
-  if (!["e2b", "hosted"].includes(runtime)) throw new CliError("runtime must be hosted or e2b; no local application execution", { code: EXIT.USAGE });
+  const runtime = opts.runtime ?? "local";
+  if (!["local", "e2b", "hosted"].includes(runtime)) throw new CliError("runtime must be local, hosted or e2b", { code: EXIT.USAGE });
   if (runtime === "e2b" && !process.env.E2B_API_KEY) throw new CliError("E2B_API_KEY is not configured", { code: EXIT.BLOCKED, action: "Configure your E2B key in the shell; it will not be uploaded." });
-  const stage = await mkdtemp(join6(tmpdir(), "agenttwin-world-"));
+  const stage = await mkdtemp(join7(tmpdir(), "agenttwin-world-"));
   try {
-    const sourceDigests = await stageApplication(dirname(file), spec.files, join6(stage, "app"));
-    await writeFile3(join6(stage, "world.json"), JSON.stringify(spec), { mode: 420 });
-    const worker = join6(dirname(fileURLToPath2(import.meta.url)), "worker.js");
-    await copyFile(worker, join6(stage, "worker.js"));
+    const sourceDigests = await stageApplication(dirname(file), spec.files, join7(stage, "app"));
+    await writeFile4(join7(stage, "world.json"), JSON.stringify(spec), { mode: 420 });
+    const git = await captureGit(cwd);
+    let project;
+    try {
+      project = JSON.parse(await readFile7(join7(cwd, ".agenttwin/inventory.json"), "utf8")).name ?? basename2(cwd);
+    } catch {
+    }
+    if (runtime === "local") {
+      opts.log("Testing through the CLI with in-process service twins. No cloud VM or containers.");
+      const report2 = await executeLocal(join7(stage, "app"), spec, opts.signal);
+      const runId2 = randomUUID();
+      const receipt2 = { ...report2, runId: runId2, runtime, project, git, createdAt: (/* @__PURE__ */ new Date()).toISOString(), sourceDigests, specDigest: createHash("sha256").update(JSON.stringify(spec)).digest("hex"), provenance: "CLI-reported execution" };
+      const out2 = resolve(cwd, opts.out ?? `.agenttwin/runs/${runId2}`);
+      await mkdir2(out2, { recursive: true });
+      const evidencePath = join7(out2, "run.json"), reportPath = join7(out2, "report.md");
+      await writeFile4(evidencePath, JSON.stringify(receipt2, null, 2) + "\n", { mode: 384 });
+      await writeFile4(reportPath, `# ${spec.name}: ${receipt2.status}
+
+Runner: CLI
+Git: ${git?.head ?? "unavailable"}
+
+` + receipt2.assertions.map((a) => `- ${a.passed ? "PASS" : "FAIL"} ${a.service}${a.path}: expected ${a.count}, observed ${a.actual}`).join("\n") + "\n\nSee run.json for activities, fault and initial/final state.\n");
+      return { ...receipt2, reportPath, evidencePath };
+    }
+    const worker = join7(dirname(fileURLToPath2(import.meta.url)), "worker.js");
+    await copyFile(worker, join7(stage, "worker.js"));
     if (runtime === "hosted") {
-      const receipt2 = await executeRemote(stage, spec, opts.log);
+      const receipt2 = await executeRemote(stage, spec, opts.log, { git, project });
       if (receipt2.schema !== "agenttwin/run-v1" || typeof receipt2.runId !== "string" || !/^[a-f0-9-]{36}$/.test(receipt2.runId) || !["passed", "failed", "error", "incomplete"].includes(String(receipt2.status))) throw new CliError("Invalid hosted receipt");
       const expectedSpec = createHash("sha256").update(JSON.stringify(spec)).digest("hex");
       const reportedSources = receipt2.sourceDigests;
       if (receipt2.specDigest !== expectedSpec || !reportedSources || Object.keys(reportedSources).length !== Object.keys(sourceDigests).length || Object.entries(sourceDigests).some(([path, digest]) => reportedSources[path] !== digest)) throw new CliError("Hosted receipt does not match the submitted source/specification");
       const out2 = resolve(cwd, opts.out ?? `.agenttwin/runs/${receipt2.runId}`);
       await mkdir2(out2, { recursive: true });
-      const evidencePath = join6(out2, "run.json");
-      const reportPath = join6(out2, "report.md");
-      await writeFile3(evidencePath, JSON.stringify(receipt2, null, 2) + "\n", { mode: 384 });
-      await writeFile3(reportPath, `# ${spec.name}: ${receipt2.status}
+      const evidencePath = join7(out2, "run.json");
+      const reportPath = join7(out2, "report.md");
+      await writeFile4(evidencePath, JSON.stringify(receipt2, null, 2) + "\n", { mode: 384 });
+      await writeFile4(reportPath, `# ${spec.name}: ${receipt2.status}
 
 Run: ${receipt2.runId}
 
@@ -571,6 +964,8 @@ See run.json for assertions, service state, application output and isolation met
     const runId = randomUUID();
     const receipt = {
       ...report,
+      project,
+      git,
       ...spec.workflowId ? { workflowId: spec.workflowId } : {},
       runId,
       runtime,
@@ -584,17 +979,18 @@ See run.json for assertions, service state, application output and isolation met
     };
     const out = resolve(cwd, opts.out ?? `.agenttwin/runs/${runId}`);
     await mkdir2(out, { recursive: true });
-    await writeFile3(join6(out, "run.json"), JSON.stringify(receipt, null, 2) + "\n", { mode: 384 });
-    await writeFile3(join6(out, "world.json"), JSON.stringify(spec, null, 2) + "\n", { mode: 384 });
+    await writeFile4(join7(out, "run.json"), JSON.stringify(receipt, null, 2) + "\n", { mode: 384 });
+    await writeFile4(join7(out, "world.json"), JSON.stringify(spec, null, 2) + "\n", { mode: 384 });
     const summary = [`# ${spec.name}: ${report.status}`, "", `Run: ${runId}`, `Image: ${image}`, "", "## Assertions", "", ...report.assertions.map((a) => `- ${a.passed ? "PASS" : "FAIL"} ${a.service}${a.path}: expected ${a.count}, observed ${a.actual}`), "", "## Infrastructure assertions", "", ...(report.infrastructureAssertions ?? []).map((a) => `- ${a.passed ? "PASS" : "FAIL"} ${a.service}: ${JSON.stringify(a.actual)}`), "", "## Coverage", "", report.coverage, "", "External networking disabled. Only explicitly listed source files were uploaded. New state and tokens are created for each run.", "", "See run.json for application output, faults, events, and initial/final state.", ""].join("\n");
-    await writeFile3(join6(out, "report.md"), summary);
-    return { ...receipt, reportPath: join6(out, "report.md"), evidencePath: join6(out, "run.json") };
+    await writeFile4(join7(out, "report.md"), summary);
+    return { ...receipt, reportPath: join7(out, "report.md"), evidencePath: join7(out, "run.json") };
   } finally {
     await rm(stage, { recursive: true, force: true });
   }
 }
 
 // src/commands/prepare.ts
+init_session();
 function reviewPreparation(inventory, input) {
   const fail2 = (message) => {
     throw new CliError(message, { code: EXIT.USAGE });
@@ -641,36 +1037,36 @@ function reviewPreparation(inventory, input) {
 async function runPrepare(cwd, opts) {
   if (!opts.file) throw new CliError("prepare requires --file preparation.json", { code: EXIT.USAGE });
   const file = resolve2(cwd, opts.file);
-  const inventory = JSON.parse(await readFile7(join7(cwd, ".agenttwin/inventory.json"), "utf8"));
+  const inventory = JSON.parse(await readFile8(join8(cwd, ".agenttwin/inventory.json"), "utf8"));
   const discovered = await loadDashboardDiscovery(cwd, inventory);
   const known = new Set(inventory.workflows.map((w) => w.id));
   for (const w of discovered.workflows) if (!known.has(w.id)) {
     inventory.workflows.push({ ...w, confidence: "low", apps: [], sharedEntities: [], evidence: [{ source: "agent-analysis", ref: ".agenttwin/agent-discovery.json" }], steps: w.steps.map((s) => ({ ...s, app: "", evidence: [] })), risk: "high", rank: 0, supported: false, hypothesis: true, linkingSignals: ["Coding-agent analysis requires user review"], scopeUncertain: true, verified: false });
   }
   for (const t of discovered.tools) if (!inventory.tools.some((tool) => tool.id === t.id)) throw new Error("Agent-discovered dependencies must be classified in init before preparation. Review the additional tool, then rerun init.");
-  const { spec, workflow, mappings } = reviewPreparation(inventory, JSON.parse(await readFile7(file, "utf8")));
+  const { spec, workflow, mappings } = reviewPreparation(inventory, JSON.parse(await readFile8(file, "utf8")));
   const directory = resolve2(cwd, opts.out ?? `.agenttwin/prepared/${spec.name}-${randomUUID2().slice(0, 8)}`);
-  const stage = await mkdtemp2(join7(tmpdir2(), "agenttwin-prepare-"));
+  const stage = await mkdtemp2(join8(tmpdir2(), "agenttwin-prepare-"));
   try {
     const sourceDigests = await stageApplication(dirname2(file), spec.files, stage);
     const files = /* @__PURE__ */ Object.create(null);
-    for (const name of spec.files) files[name] = (await readFile7(join7(stage, name))).toString("base64");
-    const manifest = { schema: "agenttwin/prepared-v1", workflowId: workflow.id, invocation: spec.command, sourceDigests, specDigest: createHash2("sha256").update(JSON.stringify(spec)).digest("hex"), mappings, provenance: "user-reviewed invocation and operation contracts; discovery does not verify runtime fidelity", createdAt: (/* @__PURE__ */ new Date()).toISOString() };
-    await writeFile4(join7(stage, "agenttwin.world.json"), JSON.stringify(spec, null, 2) + "\n", { mode: 384 });
-    await writeFile4(join7(stage, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n", { mode: 384 });
-    await writeFile4(join7(stage, "agenttwin.bundle.json"), JSON.stringify({ schema: "agenttwin/upload-v1", spec, files, manifest }, null, 2) + "\n", { mode: 384 });
-    await mkdir3(join7(stage, ".agenttwin"), { recursive: true });
-    await writeFile4(join7(stage, ".agenttwin/inventory.json"), JSON.stringify({ workflows: [{ id: workflow.id }] }), { mode: 384 });
+    for (const name of spec.files) files[name] = (await readFile8(join8(stage, name))).toString("base64");
+    const manifest = { project: discovered.name, git: await captureGit(cwd), schema: "agenttwin/prepared-v1", workflowId: workflow.id, invocation: spec.command, sourceDigests, specDigest: createHash2("sha256").update(JSON.stringify(spec)).digest("hex"), mappings, provenance: "user-reviewed invocation and operation contracts; discovery does not verify runtime fidelity", createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await writeFile5(join8(stage, "agenttwin.world.json"), JSON.stringify(spec, null, 2) + "\n", { mode: 384 });
+    await writeFile5(join8(stage, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n", { mode: 384 });
+    await writeFile5(join8(stage, "agenttwin.bundle.json"), JSON.stringify({ schema: "agenttwin/upload-v1", spec, files, manifest }, null, 2) + "\n", { mode: 384 });
+    await mkdir3(join8(stage, ".agenttwin"), { recursive: true });
+    await writeFile5(join8(stage, ".agenttwin/inventory.json"), JSON.stringify({ name: discovered.name, workflows: [{ id: workflow.id }] }), { mode: 384 });
     await mkdir3(dirname2(directory), { recursive: true });
     await mkdir3(directory, { mode: 448 });
     try {
-      const { cp: cp2, readdir: readdir2 } = await import("fs/promises");
-      for (const entry of await readdir2(stage)) await cp2(join7(stage, entry), join7(directory, entry), { recursive: true, force: false, errorOnExist: true });
+      const { cp: cp2, readdir: readdir3 } = await import("fs/promises");
+      for (const entry of await readdir3(stage)) await cp2(join8(stage, entry), join8(directory, entry), { recursive: true, force: false, errorOnExist: true });
     } catch (error) {
       await rm2(directory, { recursive: true, force: true });
       throw error;
     }
-    return { directory, worldPath: join7(directory, "agenttwin.world.json"), bundlePath: join7(directory, "agenttwin.bundle.json"), manifest };
+    return { directory, worldPath: join8(directory, "agenttwin.world.json"), bundlePath: join8(directory, "agenttwin.bundle.json"), manifest };
   } finally {
     await rm2(stage, { recursive: true, force: true });
   }
@@ -678,9 +1074,9 @@ async function runPrepare(cwd, opts) {
 
 // src/commands/setup.ts
 import { Template } from "e2b";
-import { mkdir as mkdir4, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir4, writeFile as writeFile6 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 async function runSetup(log) {
   if (!process.env.E2B_API_KEY) throw new CliError("Set E2B_API_KEY before creating your hosted runtime template", { code: EXIT.BLOCKED });
   log("Building the AgentTwin template on E2B (Node 22, PostgreSQL 15, Redis). No local containers are used.");
@@ -688,16 +1084,16 @@ async function runSetup(log) {
   const result = await Template.build(template, "agenttwin-node-v2", { apiKey: process.env.E2B_API_KEY, cpuCount: 2, memoryMB: 2048, onBuildLogs: (entry) => {
     if (!entry.message.includes("[stdout]") && !entry.message.includes("[stderr]")) log(entry.message);
   } });
-  const directory = join8(homedir2(), ".agenttwin");
+  const directory = join9(homedir2(), ".agenttwin");
   await mkdir4(directory, { recursive: true, mode: 448 });
-  const path = join8(directory, "runtime.json");
-  await writeFile5(path, JSON.stringify({ provider: "e2b", templateId: result.templateId, buildId: result.buildId }, null, 2) + "\n", { mode: 384 });
+  const path = join9(directory, "runtime.json");
+  await writeFile6(path, JSON.stringify({ provider: "e2b", templateId: result.templateId, buildId: result.buildId }, null, 2) + "\n", { mode: 384 });
   return { provider: "e2b", templateId: result.templateId, buildId: result.buildId, configPath: path };
 }
 
 // src/commands/example.ts
-import { mkdir as mkdir5, writeFile as writeFile6, stat } from "fs/promises";
-import { resolve as resolve3, join as join9 } from "path";
+import { mkdir as mkdir5, writeFile as writeFile7, stat } from "fs/promises";
+import { resolve as resolve3, join as join10 } from "path";
 var exampleSource = `// Replace this file with your own bundled Node workflow.
 const safe = process.argv.includes('--safe');
 const crm = process.env.AGENTTWIN_CRM_URL;
@@ -742,26 +1138,26 @@ async function runExample(cwd, out) {
   const directory = resolve3(cwd, out ?? "agenttwin-example");
   if (await stat(directory).then(() => true, () => false)) throw new CliError(`Destination exists: ${directory}`, { code: EXIT.USAGE, action: "Choose a new --out directory." });
   await mkdir5(directory, { recursive: true });
-  await writeFile6(join9(directory, "workflow.mjs"), exampleSource);
-  await writeFile6(join9(directory, "agenttwin.world.json"), JSON.stringify(exampleWorld(), null, 2) + "\n");
-  await writeFile6(join9(directory, "safe.world.json"), JSON.stringify(exampleWorld(true), null, 2) + "\n");
-  await writeFile6(join9(directory, "README.md"), `# Support workflow
+  await writeFile7(join10(directory, "workflow.mjs"), exampleSource);
+  await writeFile7(join10(directory, "agenttwin.world.json"), JSON.stringify(exampleWorld(), null, 2) + "\n");
+  await writeFile7(join10(directory, "safe.world.json"), JSON.stringify(exampleWorld(true), null, 2) + "\n");
+  await writeFile7(join10(directory, "README.md"), `# Support workflow
 
-Run with agenttwin run --file agenttwin.world.json (expected FAIL), then --file safe.world.json (expected PASS). Requires AGENTTWIN_API_URL and AGENTTWIN_TOKEN, or your own E2B_API_KEY plus a template from agenttwin setup. Each run creates a fresh hosted sandbox and deletes it afterward.
+Run with agenttwin run --file agenttwin.world.json (expected FAIL), then --file safe.world.json (expected PASS). Runs through the CLI with in-process service twins by default. No VM or containers. Use --runtime hosted or --runtime e2b explicitly only when a cloud machine is needed.
 
 This is actual application code using a synthetic custom ticket API plus the supported Slack JSON subset. It is not a clone of a CRM vendor. Replace workflow.mjs with your own built code and edit the explicit file list, endpoints, seed records and assertions. No npm install runs in the sandbox; dependencies must be bundled into your application.
 `);
-  return { directory, worldPath: join9(directory, "agenttwin.world.json") };
+  return { directory, worldPath: join10(directory, "agenttwin.world.json") };
 }
 
 // src/commands/init.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { writeFile as writeFile10 } from "fs/promises";
-import { join as join16 } from "path";
+import { writeFile as writeFile11 } from "fs/promises";
+import { join as join17 } from "path";
 
 // src/lib/files.ts
-import { readdir, readFile as readFile8, stat as stat2 } from "fs/promises";
-import { join as join10, relative as relative2, sep as sep2 } from "path";
+import { readdir as readdir2, readFile as readFile9, stat as stat2 } from "fs/promises";
+import { join as join11, relative as relative2, sep as sep2 } from "path";
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   ".git",
   ".agenttwin",
@@ -812,14 +1208,14 @@ async function walkDir(root, maxFiles, budgetMs) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = await readdir(dir, { withFileTypes: true });
+      entries = await readdir2(dir, { withFileTypes: true });
     } catch {
       limits.push(`Directory could not be read: ${relative2(root, dir) || "."}`);
       continue;
     }
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const full = join10(dir, entry.name);
+      const full = join11(dir, entry.name);
       if (entry.isDirectory()) {
         if (!shouldIgnoreDir(entry.name)) stack.push(full);
       } else if (entry.isFile()) {
@@ -853,7 +1249,7 @@ var RepoFileIndex = class {
   }
   async exists(path) {
     try {
-      await stat2(join10(this.cwd, path));
+      await stat2(join11(this.cwd, path));
       return true;
     } catch {
       return false;
@@ -862,7 +1258,7 @@ var RepoFileIndex = class {
   async read(path, maxBytes = MAX_BYTES) {
     const cached = this.cache.contents.get(path);
     if (cached !== void 0) return cached;
-    const full = join10(this.cwd, path);
+    const full = join11(this.cwd, path);
     try {
       const info2 = await stat2(full);
       if (!info2.isFile()) return void 0;
@@ -870,7 +1266,7 @@ var RepoFileIndex = class {
         this.cache.limits.push(`File excluded by size limit (${maxBytes} bytes): ${path}`);
         return void 0;
       }
-      const text = await readFile8(full, "utf8");
+      const text = await readFile9(full, "utf8");
       this.cache.contents.set(path, text);
       return text;
     } catch {
@@ -1687,10 +2083,10 @@ var ciDetector = {
 };
 
 // src/discovery/detectors/containers.ts
-import { execFile } from "child_process";
+import { execFile as execFile2 } from "child_process";
 function dockerImages() {
   return new Promise((resolve5) => {
-    execFile(
+    execFile2(
       "docker",
       ["ps", "--format", "{{.Image}}"],
       { timeout: 2e3 },
@@ -1730,13 +2126,13 @@ var containerDetector = {
 // src/discovery/detectors/cloud-creds.ts
 import { stat as stat3 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 var CREDENTIALS = [
-  { path: join11(homedir3(), ".aws", "config"), subject: "aws", title: "AWS" },
-  { path: join11(homedir3(), ".aws", "credentials"), subject: "aws", title: "AWS" },
-  { path: join11(homedir3(), ".config", "gcloud"), subject: "gcp", title: "Google Cloud" },
-  { path: join11(homedir3(), ".azure"), subject: "azure", title: "Azure" },
-  { path: join11(homedir3(), ".kube", "config"), subject: "kubernetes", title: "Kubernetes" }
+  { path: join12(homedir3(), ".aws", "config"), subject: "aws", title: "AWS" },
+  { path: join12(homedir3(), ".aws", "credentials"), subject: "aws", title: "AWS" },
+  { path: join12(homedir3(), ".config", "gcloud"), subject: "gcp", title: "Google Cloud" },
+  { path: join12(homedir3(), ".azure"), subject: "azure", title: "Azure" },
+  { path: join12(homedir3(), ".kube", "config"), subject: "kubernetes", title: "Kubernetes" }
 ];
 async function exists(path) {
   try {
@@ -2295,12 +2691,12 @@ var SimpleDetectorRegistry = class {
 };
 
 // src/discovery/passes/runtime.ts
-import { spawn as spawn2 } from "child_process";
-import { createServer } from "http";
+import { spawn as spawn3 } from "child_process";
+import { createServer as createServer2 } from "http";
 import { connect } from "net";
 import { readFileSync, rmSync, writeFileSync } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 var EGRESS_HOOK = `
 const fs = require('fs');
 const dns = require('dns');
@@ -2342,7 +2738,7 @@ function delay(ms) {
 }
 function startProxy(onHost) {
   return new Promise((resolve5) => {
-    const server = createServer((req, res) => {
+    const server = createServer2((req, res) => {
       const host = (req.headers.host ?? "").split(":")[0];
       if (host) onHost(host);
       res.writeHead(502);
@@ -2370,8 +2766,8 @@ function startProxy(onHost) {
 async function observeEgress(opts) {
   const hosts = /* @__PURE__ */ new Set();
   const { server, url } = await startProxy((host) => hosts.add(host));
-  const logFile = join12(tmpdir3(), `agenttwin-egress-${process.pid}.log`);
-  const hookFile = join12(tmpdir3(), `agenttwin-egress-hook-${process.pid}.cjs`);
+  const logFile = join13(tmpdir3(), `agenttwin-egress-${process.pid}.log`);
+  const hookFile = join13(tmpdir3(), `agenttwin-egress-hook-${process.pid}.cjs`);
   try {
     writeFileSync(hookFile, EGRESS_HOOK, "utf8");
     writeFileSync(logFile, "", "utf8");
@@ -2380,7 +2776,7 @@ async function observeEgress(opts) {
   let child;
   if (opts.run) {
     opts.log(`Observing egress: spawning \`${opts.run}\` through ${url}`);
-    child = spawn2(opts.run, {
+    child = spawn3(opts.run, {
       shell: true,
       env: {
         ...process.env,
@@ -3621,8 +4017,8 @@ async function buildInventory({
 }
 
 // src/inventory/store.ts
-import { mkdir as mkdir6, readFile as readFile9, writeFile as writeFile7 } from "fs/promises";
-import { join as join13 } from "path";
+import { mkdir as mkdir6, readFile as readFile10, writeFile as writeFile8 } from "fs/promises";
+import { join as join14 } from "path";
 var STORE_DIR = ".agenttwin";
 var STORE_GITIGNORE = [
   "inventory.json",
@@ -3638,24 +4034,24 @@ var STORE_GITIGNORE = [
   ""
 ].join("\n");
 function storeDir(cwd) {
-  return join13(cwd, STORE_DIR);
+  return join14(cwd, STORE_DIR);
 }
 function storePath(cwd, name) {
-  return join13(storeDir(cwd), name);
+  return join14(storeDir(cwd), name);
 }
 async function ensureStore(cwd) {
   await mkdir6(storeDir(cwd), { recursive: true });
-  await writeFile7(storePath(cwd, ".gitignore"), STORE_GITIGNORE, "utf8");
+  await writeFile8(storePath(cwd, ".gitignore"), STORE_GITIGNORE, "utf8");
 }
 async function readJson(path) {
   try {
-    return JSON.parse(await readFile9(path, "utf8"));
+    return JSON.parse(await readFile10(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 async function writeJson(path, value) {
-  await writeFile7(path, `${JSON.stringify(value, null, 2)}
+  await writeFile8(path, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 var readInventory = (cwd) => readJson(storePath(cwd, "inventory.json"));
@@ -3858,13 +4254,14 @@ var REGISTRY = [
 ];
 
 // src/inspect/runner.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
+init_sanitize();
 function runCommand(spec, cwd, signal) {
   return new Promise((resolve5) => {
     if (signal.aborted) {
       return resolve5({ code: null, stdout: "", stderr: "", missing: false, timedOut: false, cancelled: true });
     }
-    const child = spawn3(spec.cmd, spec.args, {
+    const child = spawn4(spec.cmd, spec.args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env
@@ -4402,12 +4799,12 @@ async function runExport(opts) {
   const plan = await readPlan(opts.cwd);
   const bundle = { schema: "export/v1", inventory, plan: plan ?? null };
   if (opts.out) {
-    const { mkdir: mkdir8, writeFile: writeFile11 } = await import("fs/promises");
-    const { join: join18 } = await import("path");
+    const { mkdir: mkdir8, writeFile: writeFile12 } = await import("fs/promises");
+    const { join: join19 } = await import("path");
     await mkdir8(opts.out, { recursive: true });
-    await writeFile11(join18(opts.out, "inventory.json"), `${JSON.stringify(inventory, null, 2)}
+    await writeFile12(join19(opts.out, "inventory.json"), `${JSON.stringify(inventory, null, 2)}
 `, "utf8");
-    if (plan) await writeFile11(join18(opts.out, "plan.json"), `${JSON.stringify(plan, null, 2)}
+    if (plan) await writeFile12(join19(opts.out, "plan.json"), `${JSON.stringify(plan, null, 2)}
 `, "utf8");
     return { schema: "export/v1", out: opts.out, wrote: ["inventory.json", ...plan ? ["plan.json"] : []] };
   }
@@ -4807,16 +5204,16 @@ async function askQuestions(questions) {
 init_answers();
 
 // src/lib/config.ts
-import { readFile as readFile10, writeFile as writeFile8 } from "fs/promises";
-import { join as join14 } from "path";
+import { readFile as readFile11, writeFile as writeFile9 } from "fs/promises";
+import { join as join15 } from "path";
 var CONFIG_FILENAME = "agenttwin.config.json";
 var CONFIG_VERSION = 2;
 function configPath(cwd) {
-  return join14(cwd, CONFIG_FILENAME);
+  return join15(cwd, CONFIG_FILENAME);
 }
 async function readConfig(cwd) {
   try {
-    const text = await readFile10(configPath(cwd), "utf8");
+    const text = await readFile11(configPath(cwd), "utf8");
     return JSON.parse(text);
   } catch {
     return void 0;
@@ -4852,17 +5249,22 @@ function buildConfigFromInventory(inventory, existing) {
 }
 async function writeConfig(cwd, config, _options = {}) {
   const path = configPath(cwd);
-  await writeFile8(path, `${JSON.stringify(config, null, 2)}
+  await writeFile9(path, `${JSON.stringify(config, null, 2)}
 `, "utf8");
   return { path };
 }
 
+// src/commands/init.ts
+init_dashboard();
+init_session();
+
 // src/commands/preview.ts
-import { mkdir as mkdir7, readFile as readFile11, writeFile as writeFile9 } from "fs/promises";
-import { dirname as dirname3, join as join15, resolve as resolve4 } from "path";
+import { mkdir as mkdir7, readFile as readFile12, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname3, join as join16, resolve as resolve4 } from "path";
 
 // src/preview/html.ts
-import { randomBytes as randomBytes2 } from "crypto";
+init_sanitize();
+import { randomBytes as randomBytes3 } from "crypto";
 function escapeHtml(value) {
   return sanitizeOutput(String(value ?? "")).replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
 }
@@ -4888,7 +5290,7 @@ const feedback=$('feedback-form');
 if(feedback)feedback.addEventListener('submit',event=>{event.preventDefault();const note=$('review-note').value.trim();if(!note){$('feedback-status').textContent='Add a note before downloading.';return}download('agenttwin-feedback.json',{schema:'preview-feedback/v1',createdAt:new Date().toISOString(),rating:$('review-rating').value,note,source:'local-browser-report'});$('feedback-status').textContent='Downloaded locally. Review the file, then share it with the person who invited you. Nothing was sent automatically.'});
 `;
 function page(title, content, data, navigation) {
-  const nonce = randomBytes2(16).toString("base64");
+  const nonce = randomBytes3(16).toString("base64");
   const json = JSON.stringify(data).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
   return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'nonce-${nonce}'; style-src 'nonce-${nonce}'; base-uri 'none'; form-action 'none'; connect-src 'none'"><title>${h(title)} \xB7 AgentTwin</title><style nonce="${nonce}">${STYLE}</style></head><body><header><strong>agenttwin</strong><span class="badge">Local preview</span></header><nav>${navigation.map(([id, label]) => `<a href="#${h(id)}">${h(label)}</a>`).join("")}<a href="#feedback">Leave feedback</a></nav><main>${content}${feedbackSection()}<footer>This report runs locally. No telemetry, remote fonts, or automatic uploads. Discovery results can contain internal system names; review before sharing.</footer></main><script type="application/json" id="report-data" nonce="${nonce}">${json}</script><script nonce="${nonce}">${SCRIPT}</script></body></html>`;
 }
@@ -4916,16 +5318,17 @@ function renderBrowserReport(inventory, plan) {
 }
 
 // src/preview/refund.ts
-import { createServer as createServer2 } from "http";
-import { randomBytes as randomBytes3 } from "crypto";
+import { createServer as createServer3 } from "http";
+import { randomBytes as randomBytes4 } from "crypto";
 
 // src/commands/preview.ts
+init_sanitize();
 async function writeBrowserReport(cwd, inventory, plan, out) {
   const path = out ? resolve4(cwd, out) : storePath(cwd, "report.html");
   await mkdir7(dirname3(path), { recursive: true });
   const cleanInventory = JSON.parse(sanitizeOutput(JSON.stringify(inventory)));
   const cleanPlan = JSON.parse(sanitizeOutput(JSON.stringify(plan)));
-  await writeFile9(path, renderBrowserReport(cleanInventory, cleanPlan), "utf8");
+  await writeFile10(path, renderBrowserReport(cleanInventory, cleanPlan), "utf8");
   return path;
 }
 async function runReport(cwd, out) {
@@ -4940,13 +5343,13 @@ async function runFeedback(cwd, note) {
   const path = storePath(cwd, "feedback.json");
   let entries = [];
   try {
-    const existing = JSON.parse(await readFile11(path, "utf8"));
+    const existing = JSON.parse(await readFile12(path, "utf8"));
     entries = Array.isArray(existing.items) ? existing.items : [];
   } catch (error) {
     if (error.code !== "ENOENT") throw new CliError("Existing feedback could not be read; it was not overwritten");
   }
   entries.push({ createdAt: (/* @__PURE__ */ new Date()).toISOString(), note: sanitizeOutput(note.trim()) });
-  await writeFile9(path, `${JSON.stringify({ schema: "preview-feedback/v1", items: entries }, null, 2)}
+  await writeFile10(path, `${JSON.stringify({ schema: "preview-feedback/v1", items: entries }, null, 2)}
 `, "utf8");
   return { schema: "feedback-result/v1", saved: true, uploaded: false, path, notes: entries.length };
 }
@@ -5099,8 +5502,8 @@ async function runInit(opts) {
     await writeInventory(opts.cwd, finalInventory);
     await writePlan(opts.cwd, plan);
     await writeConfig(opts.cwd, config, { force: opts.force });
-    await writeFile10(join16(opts.cwd, "ENVIRONMENT.md"), renderEnvironment(finalInventory), "utf8");
-    await writeFile10(join16(opts.cwd, "REPLICATION.md"), renderReplication(finalInventory, plan), "utf8");
+    await writeFile11(join17(opts.cwd, "ENVIRONMENT.md"), renderEnvironment(finalInventory), "utf8");
+    await writeFile11(join17(opts.cwd, "REPLICATION.md"), renderReplication(finalInventory, plan), "utf8");
     reportPath = await writeBrowserReport(opts.cwd, finalInventory, plan);
     dashboardPath = await writeDashboard(opts.cwd, finalInventory);
     wrote = true;
@@ -5164,7 +5567,7 @@ async function runInit(opts) {
 function readVersion() {
   const here = dirname4(fileURLToPath3(import.meta.url));
   const pkg = JSON.parse(
-    readFileSync3(join17(here, "..", "package.json"), "utf8")
+    readFileSync3(join18(here, "..", "package.json"), "utf8")
   );
   return pkg.version ?? "0.0.0";
 }
@@ -5179,9 +5582,9 @@ function helpText() {
     bold("Commands"),
     `  ${"setup".padEnd(12)}Build your hosted E2B runtime template (once per account)`,
     `  ${"prepare".padEnd(12)}Bundle a reviewed discovered workflow (--file preparation.json)`,
-    `  ${"run".padEnd(12)}Execute your Node workflow in a hosted E2B sandbox (--file world.json)`,
+    `  ${"run".padEnd(12)}Test your Node workflow through the CLI (--file world.json)`,
     `  ${"example".padEnd(12)}Write an editable multi-service workflow (--out directory)`,
-    `  ${"sync".padEnd(12)}Send discovery metadata to your account dashboard`,
+    `  ${"sync".padEnd(12)}Sync discovery, Git metadata and CLI test results to your dashboard`,
     `  ${"init".padEnd(12)}Discover and write agenttwin.config.json + reports`,
     `  ${"discover".padEnd(12)}Build the company inventory (writes .agenttwin/inventory.json)`,
     `  ${"decide".padEnd(12)}Apply structured decisions (--file or --stdin)`,
@@ -5203,7 +5606,7 @@ function helpText() {
     `  ${"--yes / --non-interactive".padEnd(20)}Never prompt`,
     `  ${"--dry-run".padEnd(20)}init: discover without writing any files`,
     `  ${"--out <path>".padEnd(20)}run/example: output directory; report: HTML file`,
-    `  ${"--runtime <hosted|e2b>".padEnd(20)}run: hosted API or direct E2B; defaults to configured API, otherwise E2B`,
+    `  ${"--runtime <local|hosted|e2b>".padEnd(20)}run: local CLI by default; hosted API or E2B when a cloud VM is needed`,
     `  ${"-v, --version".padEnd(20)}Print the installed version`,
     `  ${"-h, --help".padEnd(20)}Show this help`
   ].join("\n");
@@ -5318,7 +5721,7 @@ Run: agenttwin run --file "${result.worldPath}"`);
       }
       case "sync": {
         const result = await runSync(cwd);
-        printResult(result, `Synced ${result.tools} resources and ${result.workflows} workflow candidates.
+        printResult(result, `Synced ${result.tools} resources, ${result.workflows} workflow candidates and ${result.receipts} CLI run receipts.
 ${result.dashboard}
 ${result.uploaded}`);
         return;
@@ -5357,7 +5760,7 @@ ${result.uploaded}`);
           result,
           [
             `Discovered ${counts.tools} tools (${counts.classified} classified) \xB7 ${counts.unclassified} unclassified \xB7 ${counts.withTwin} with twins`,
-            `Wrote ${join17(".agenttwin", "inventory.json")}`,
+            `Wrote ${join18(".agenttwin", "inventory.json")}`,
             result.blocked.length > 0 ? `Blocked: ${result.blocked.join("; ")}` : "",
             result.opportunities.length > 0 ? `Opportunities: ${result.opportunities.join("; ")}` : "",
             result.reconciliation.splits.length > 0 ? `Splits: ${result.reconciliation.splits.map((s) => s.from).join(", ")}` : ""
@@ -5380,7 +5783,7 @@ ${result.uploaded}`);
         printResult(
           result,
           `Plan: ${result.plan.items.length} tools \xB7 ${Object.entries(byStrategy).map(([k, v]) => `${k} ${v}`).join(", ")}
-Wrote ${join17(".agenttwin", "plan.json")}`
+Wrote ${join18(".agenttwin", "plan.json")}`
         );
         return;
       }