@versatly/workgraph 0.3.0 → 1.1.0

package/dist/chunk-TOFSHG5S.js

@@ -0,0 +1,3107 @@
+import {
+  __export,
+  allClaims,
+  append,
+  checkpoint,
+  create,
+  createRun,
+  createThread,
+  historyOf,
+  keywordSearch,
+  list,
+  listReadyThreads,
+  listRuns,
+  listTypes,
+  loadPolicyRegistry,
+  loadRegistry,
+  queryPrimitives,
+  read,
+  readAll,
+  recent,
+  refreshWikiLinkGraphIndex,
+  release,
+  saveRegistry,
+  stop,
+  update
+} from "./chunk-OTSECVE5.js";
+
+// src/workspace.ts
+var workspace_exports = {};
+__export(workspace_exports, {
+  initWorkspace: () => initWorkspace,
+  isWorkgraphWorkspace: () => isWorkgraphWorkspace,
+  workspaceConfigPath: () => workspaceConfigPath
+});
+import fs2 from "fs";
+import path2 from "path";
+
+// src/bases.ts
+var bases_exports = {};
+__export(bases_exports, {
+  generateBasesFromPrimitiveRegistry: () => generateBasesFromPrimitiveRegistry,
+  primitiveRegistryManifestPath: () => primitiveRegistryManifestPath,
+  readPrimitiveRegistryManifest: () => readPrimitiveRegistryManifest,
+  syncPrimitiveRegistryManifest: () => syncPrimitiveRegistryManifest
+});
+import fs from "fs";
+import path from "path";
+import YAML from "yaml";
+var REGISTRY_MANIFEST_FILE = ".workgraph/primitive-registry.yaml";
+var DEFAULT_BASES_DIR = ".workgraph/bases";
+function primitiveRegistryManifestPath(workspacePath) {
+  return path.join(workspacePath, REGISTRY_MANIFEST_FILE);
+}
+function readPrimitiveRegistryManifest(workspacePath) {
+  const manifestPath = primitiveRegistryManifestPath(workspacePath);
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error(`Primitive registry manifest not found: ${manifestPath}`);
+  }
+  const raw = fs.readFileSync(manifestPath, "utf-8");
+  return YAML.parse(raw);
+}
+function syncPrimitiveRegistryManifest(workspacePath) {
+  const registry = loadRegistry(workspacePath);
+  const manifest = {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    primitives: Object.values(registry.types).map((primitive) => ({
+      name: primitive.name,
+      directory: primitive.directory,
+      canonical: primitive.builtIn,
+      builtIn: primitive.builtIn,
+      fields: Object.entries(primitive.fields).map(([name, field]) => ({
+        name,
+        type: field.type,
+        ...field.required ? { required: true } : {},
+        ...field.description ? { description: field.description } : {}
+      }))
+    })).sort((a, b) => a.name.localeCompare(b.name))
+  };
+  const manifestPath = primitiveRegistryManifestPath(workspacePath);
+  ensureDirectory(path.dirname(manifestPath));
+  fs.writeFileSync(manifestPath, YAML.stringify(manifest), "utf-8");
+  return manifest;
+}
+function generateBasesFromPrimitiveRegistry(workspacePath, options = {}) {
+  const manifest = readPrimitiveRegistryManifest(workspacePath);
+  const includeNonCanonical = options.includeNonCanonical === true;
+  const outputDirectory = path.join(workspacePath, options.outputDirectory ?? DEFAULT_BASES_DIR);
+  ensureDirectory(outputDirectory);
+  const generated = [];
+  const primitives = manifest.primitives.filter(
+    (primitive) => includeNonCanonical ? true : primitive.canonical
+  );
+  for (const primitive of primitives) {
+    const relBasePath = `${primitive.name}.base`;
+    const absBasePath = path.join(outputDirectory, relBasePath);
+    const content = renderBaseFile(primitive);
+    fs.writeFileSync(absBasePath, content, "utf-8");
+    generated.push(path.relative(workspacePath, absBasePath).replace(/\\/g, "/"));
+  }
+  return {
+    outputDirectory: path.relative(workspacePath, outputDirectory).replace(/\\/g, "/"),
+    generated: generated.sort()
+  };
+}
+function renderBaseFile(primitive) {
+  const columnFields = primitive.fields.map((field) => field.name).filter((name, idx, arr) => arr.indexOf(name) === idx);
+  const baseDoc = {
+    id: primitive.name,
+    title: `${titleCase(primitive.name)} Base`,
+    source: {
+      type: "folder",
+      path: primitive.directory,
+      extension: "md"
+    },
+    views: [
+      {
+        id: "table",
+        type: "table",
+        name: "All",
+        columns: ["file.name", ...columnFields]
+      }
+    ]
+  };
+  return YAML.stringify(baseDoc);
+}
+function ensureDirectory(dirPath) {
+  if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
+}
+function titleCase(value) {
+  return value.split(/[-_]/g).filter(Boolean).map((segment) => segment[0].toUpperCase() + segment.slice(1)).join(" ");
+}
+
+// src/workspace.ts
+var WORKGRAPH_CONFIG_FILE = ".workgraph.json";
+function workspaceConfigPath(workspacePath) {
+  return path2.join(workspacePath, WORKGRAPH_CONFIG_FILE);
+}
+function isWorkgraphWorkspace(workspacePath) {
+  return fs2.existsSync(workspaceConfigPath(workspacePath));
+}
+function initWorkspace(targetPath, options = {}) {
+  const resolvedPath = path2.resolve(targetPath);
+  const configPath = workspaceConfigPath(resolvedPath);
+  if (fs2.existsSync(configPath)) {
+    throw new Error(`Workgraph workspace already initialized at ${resolvedPath}`);
+  }
+  const createdDirectories = [];
+  ensureDir(resolvedPath, createdDirectories);
+  ensureDir(path2.join(resolvedPath, ".workgraph"), createdDirectories);
+  const registry = loadRegistry(resolvedPath);
+  saveRegistry(resolvedPath, registry);
+  syncPrimitiveRegistryManifest(resolvedPath);
+  if (options.createTypeDirs !== false) {
+    const types = listTypes(resolvedPath);
+    for (const typeDef of types) {
+      ensureDir(path2.join(resolvedPath, typeDef.directory), createdDirectories);
+    }
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const config = {
+    name: options.name ?? path2.basename(resolvedPath),
+    version: "1.0.0",
+    mode: "workgraph",
+    createdAt: now,
+    updatedAt: now
+  };
+  fs2.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  if (options.createReadme !== false) {
+    writeReadmeIfMissing(resolvedPath, config.name);
+  }
+  const bases = options.createBases === false ? { generated: [] } : generateBasesFromPrimitiveRegistry(resolvedPath);
+  loadPolicyRegistry(resolvedPath);
+  refreshWikiLinkGraphIndex(resolvedPath);
+  return {
+    workspacePath: resolvedPath,
+    configPath,
+    config,
+    createdDirectories,
+    seededTypes: listTypes(resolvedPath).map((t) => t.name),
+    generatedBases: bases.generated,
+    primitiveRegistryManifestPath: ".workgraph/primitive-registry.yaml"
+  };
+}
+function ensureDir(dirPath, createdDirectories) {
+  if (fs2.existsSync(dirPath)) return;
+  fs2.mkdirSync(dirPath, { recursive: true });
+  createdDirectories.push(dirPath);
+}
+function writeReadmeIfMissing(workspacePath, name) {
+  const readmePath = path2.join(workspacePath, "README.md");
+  if (fs2.existsSync(readmePath)) return;
+  const content = `# ${name}
+
+Agent-first workgraph workspace for multi-agent coordination.
+
+## Quickstart
+
+\`\`\`bash
+workgraph thread list --json
+workgraph thread next --claim --actor agent-a --json
+workgraph ledger show --count 20 --json
+\`\`\`
+`;
+  fs2.writeFileSync(readmePath, content, "utf-8");
+}
+
+// src/command-center.ts
+var command_center_exports = {};
+__export(command_center_exports, {
+  generateCommandCenter: () => generateCommandCenter
+});
+import fs3 from "fs";
+import path3 from "path";
+function generateCommandCenter(workspacePath, options = {}) {
+  const actor = options.actor ?? "system";
+  const recentCount = options.recentCount ?? 15;
+  const relOutputPath = options.outputPath ?? "Command Center.md";
+  const absOutputPath = resolvePathWithinWorkspace(workspacePath, relOutputPath);
+  const normalizedOutputPath = path3.relative(workspacePath, absOutputPath).replace(/\\/g, "/");
+  const allThreads = list(workspacePath, "thread");
+  const openThreads = allThreads.filter((thread) => thread.fields.status === "open");
+  const activeThreads = allThreads.filter((thread) => thread.fields.status === "active");
+  const blockedThreads = allThreads.filter((thread) => thread.fields.status === "blocked");
+  const doneThreads = allThreads.filter((thread) => thread.fields.status === "done");
+  const claims = allClaims(workspacePath);
+  const recentEvents = recent(workspacePath, recentCount);
+  const content = renderCommandCenter({
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    openThreads,
+    activeThreads,
+    blockedThreads,
+    doneThreads,
+    claims: [...claims.entries()].map(([target, owner]) => ({ target, owner })),
+    recentEvents
+  });
+  const parentDir = path3.dirname(absOutputPath);
+  if (!fs3.existsSync(parentDir)) fs3.mkdirSync(parentDir, { recursive: true });
+  const existed = fs3.existsSync(absOutputPath);
+  fs3.writeFileSync(absOutputPath, content, "utf-8");
+  append(
+    workspacePath,
+    actor,
+    existed ? "update" : "create",
+    normalizedOutputPath,
+    "command-center",
+    {
+      generated: true,
+      open_threads: openThreads.length,
+      active_claims: claims.size,
+      recent_events: recentEvents.length
+    }
+  );
+  return {
+    outputPath: normalizedOutputPath,
+    stats: {
+      totalThreads: allThreads.length,
+      openThreads: openThreads.length,
+      activeThreads: activeThreads.length,
+      blockedThreads: blockedThreads.length,
+      doneThreads: doneThreads.length,
+      activeClaims: claims.size,
+      recentEvents: recentEvents.length
+    },
+    content
+  };
+}
+function resolvePathWithinWorkspace(workspacePath, outputPath) {
+  const base = path3.resolve(workspacePath);
+  const resolved = path3.resolve(base, outputPath);
+  if (!resolved.startsWith(base + path3.sep) && resolved !== base) {
+    throw new Error(`Invalid command-center output path: ${outputPath}`);
+  }
+  return resolved;
+}
+function renderCommandCenter(input) {
+  const header = [
+    "# Workgraph Command Center",
+    "",
+    `Generated: ${input.generatedAt}`,
+    ""
+  ];
+  const statusBlock = [
+    "## Thread Status",
+    "",
+    `- Open: ${input.openThreads.length}`,
+    `- Active: ${input.activeThreads.length}`,
+    `- Blocked: ${input.blockedThreads.length}`,
+    `- Done: ${input.doneThreads.length}`,
+    ""
+  ];
+  const openTable = [
+    "## Open Threads",
+    "",
+    "| Priority | Title | Path |",
+    "|---|---|---|",
+    ...input.openThreads.length > 0 ? input.openThreads.map((thread) => `| ${String(thread.fields.priority ?? "medium")} | ${String(thread.fields.title ?? "Untitled")} | \`${thread.path}\` |`) : ["| - | None | - |"],
+    ""
+  ];
+  const claimsSection = [
+    "## Active Claims",
+    "",
+    ...input.claims.length > 0 ? input.claims.map((claim) => `- ${claim.owner} -> \`${claim.target}\``) : ["- None"],
+    ""
+  ];
+  const blockedSection = [
+    "## Blocked Threads",
+    "",
+    ...input.blockedThreads.length > 0 ? input.blockedThreads.map((thread) => {
+      const deps = Array.isArray(thread.fields.deps) ? thread.fields.deps.join(", ") : "";
+      return `- ${String(thread.fields.title ?? thread.path)} (\`${thread.path}\`)${deps ? ` blocked by: ${deps}` : ""}`;
+    }) : ["- None"],
+    ""
+  ];
+  const recentSection = [
+    "## Recent Ledger Activity",
+    "",
+    ...input.recentEvents.length > 0 ? input.recentEvents.map((event) => `- ${event.ts} ${event.op} ${event.actor} -> \`${event.target}\``) : ["- No activity"],
+    ""
+  ];
+  return [
+    ...header,
+    ...statusBlock,
+    ...openTable,
+    ...claimsSection,
+    ...blockedSection,
+    ...recentSection
+  ].join("\n");
+}
+
+// src/skill.ts
+var skill_exports = {};
+__export(skill_exports, {
+  listSkills: () => listSkills,
+  loadSkill: () => loadSkill,
+  promoteSkill: () => promoteSkill,
+  proposeSkill: () => proposeSkill,
+  skillDiff: () => skillDiff,
+  skillHistory: () => skillHistory,
+  writeSkill: () => writeSkill
+});
+import fs4 from "fs";
+import path4 from "path";
+function writeSkill(workspacePath, title, body, actor, options = {}) {
+  const slug = skillSlug(title);
+  const bundleSkillPath = folderSkillPath(slug);
+  const legacyPath = legacySkillPath(slug);
+  const existing = read(workspacePath, bundleSkillPath) ?? read(workspacePath, legacyPath);
+  const status = options.status ?? existing?.fields.status ?? "draft";
+  if (existing && options.expectedUpdatedAt) {
+    const currentUpdatedAt = String(existing.fields.updated ?? "");
+    if (currentUpdatedAt !== options.expectedUpdatedAt) {
+      throw new Error(`Concurrent skill update detected for ${existing.path}. Expected updated="${options.expectedUpdatedAt}" but found "${currentUpdatedAt}".`);
+    }
+  }
+  if (!existing) {
+    ensureSkillBundleScaffold(workspacePath, slug);
+    const created = create(workspacePath, "skill", {
+      title,
+      owner: options.owner ?? actor,
+      version: options.version ?? "0.1.0",
+      status,
+      distribution: options.distribution ?? "tailscale-shared-vault",
+      tailscale_path: options.tailscalePath,
+      reviewers: options.reviewers ?? [],
+      depends_on: options.dependsOn ?? [],
+      tags: options.tags ?? []
+    }, body, actor, {
+      pathOverride: bundleSkillPath
+    });
+    writeSkillManifest(workspacePath, slug, created, actor);
+    return created;
+  }
+  const updated = update(workspacePath, existing.path, {
+    title,
+    owner: options.owner ?? existing.fields.owner ?? actor,
+    version: options.version ?? existing.fields.version ?? "0.1.0",
+    status,
+    distribution: options.distribution ?? existing.fields.distribution ?? "tailscale-shared-vault",
+    tailscale_path: options.tailscalePath ?? existing.fields.tailscale_path,
+    reviewers: options.reviewers ?? existing.fields.reviewers ?? [],
+    depends_on: options.dependsOn ?? existing.fields.depends_on ?? [],
+    tags: options.tags ?? existing.fields.tags ?? []
+  }, body, actor);
+  writeSkillManifest(workspacePath, slug, updated, actor);
+  return updated;
+}
+function loadSkill(workspacePath, skillRef) {
+  const normalizedCandidates = normalizeSkillRefCandidates(skillRef);
+  const skill = normalizedCandidates.map((candidate) => read(workspacePath, candidate)).find((entry) => entry !== null);
+  if (!skill) throw new Error(`Skill not found: ${skillRef}`);
+  if (skill.type !== "skill") throw new Error(`Target is not a skill primitive: ${skillRef}`);
+  return skill;
+}
+function listSkills(workspacePath, options = {}) {
+  let skills = list(workspacePath, "skill");
+  if (options.status) {
+    skills = skills.filter((skill) => skill.fields.status === options.status);
+  }
+  if (options.updatedSince) {
+    const threshold = Date.parse(options.updatedSince);
+    if (Number.isFinite(threshold)) {
+      skills = skills.filter((skill) => {
+        const updatedAt = Date.parse(String(skill.fields.updated ?? ""));
+        return Number.isFinite(updatedAt) && updatedAt >= threshold;
+      });
+    }
+  }
+  return skills;
+}
+function proposeSkill(workspacePath, skillRef, actor, options = {}) {
+  const skill = loadSkill(workspacePath, skillRef);
+  const slug = skillSlug(String(skill.fields.title ?? skillRef));
+  let proposalThread = options.proposalThread;
+  if (!proposalThread && options.createThreadIfMissing !== false) {
+    const createdThread = createThread(
+      workspacePath,
+      `Review skill: ${String(skill.fields.title)}`,
+      `Review and approve skill ${skill.path} for activation.`,
+      actor,
+      {
+        priority: "medium",
+        space: options.space,
+        context_refs: [skill.path]
+      }
+    );
+    proposalThread = createdThread.path;
+  }
+  const updated = update(workspacePath, skill.path, {
+    status: "proposed",
+    proposal_thread: proposalThread ?? skill.fields.proposal_thread,
+    proposed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    reviewers: options.reviewers ?? skill.fields.reviewers ?? []
+  }, void 0, actor);
+  writeSkillManifest(workspacePath, slug, updated, actor);
+  return updated;
+}
+function skillHistory(workspacePath, skillRef, options = {}) {
+  const skill = loadSkill(workspacePath, skillRef);
+  const entries = historyOf(workspacePath, skill.path);
+  if (options.limit && options.limit > 0) {
+    return entries.slice(-options.limit);
+  }
+  return entries;
+}
+function skillDiff(workspacePath, skillRef) {
+  const skill = loadSkill(workspacePath, skillRef);
+  const entries = historyOf(workspacePath, skill.path).filter((entry) => entry.op === "create" || entry.op === "update");
+  const latest = entries.length > 0 ? entries[entries.length - 1] : null;
+  const previous = entries.length > 1 ? entries[entries.length - 2] : null;
+  const changedFields = Array.isArray(latest?.data?.changed) ? latest.data.changed.map((value) => String(value)) : latest?.op === "create" ? Object.keys(skill.fields) : [];
+  return {
+    path: skill.path,
+    latestEntryTs: latest?.ts ?? null,
+    previousEntryTs: previous?.ts ?? null,
+    changedFields
+  };
+}
+function promoteSkill(workspacePath, skillRef, actor, options = {}) {
+  const skill = loadSkill(workspacePath, skillRef);
+  const slug = skillSlug(String(skill.fields.title ?? skillRef));
+  const currentVersion = String(skill.fields.version ?? "0.1.0");
+  const nextVersion = options.version ?? bumpPatchVersion(currentVersion);
+  const updated = update(workspacePath, skill.path, {
+    status: "active",
+    version: nextVersion,
+    promoted_at: (/* @__PURE__ */ new Date()).toISOString()
+  }, void 0, actor);
+  writeSkillManifest(workspacePath, slug, updated, actor);
+  return updated;
+}
+function skillSlug(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
+}
+function normalizeSkillRefCandidates(skillRef) {
+  const raw = skillRef.trim();
+  if (!raw) return [];
+  if (raw.includes("/")) {
+    const normalized = raw.endsWith(".md") ? raw : `${raw}.md`;
+    if (normalized.endsWith("/SKILL.md")) return [normalized];
+    if (normalized.endsWith("/SKILL")) return [`${normalized}.md`];
+    if (normalized.endsWith(".md")) {
+      const noExt = normalized.slice(0, -3);
+      return [normalized, `${noExt}/SKILL.md`];
+    }
+    return [normalized, `${normalized}/SKILL.md`];
+  }
+  const slug = skillSlug(raw);
+  return [folderSkillPath(slug), legacySkillPath(slug)];
+}
+function bumpPatchVersion(version) {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!match) return "0.1.0";
+  const major = Number.parseInt(match[1], 10);
+  const minor = Number.parseInt(match[2], 10);
+  const patch = Number.parseInt(match[3], 10) + 1;
+  return `${major}.${minor}.${patch}`;
+}
+function folderSkillPath(slug) {
+  return `skills/${slug}/SKILL.md`;
+}
+function legacySkillPath(slug) {
+  return `skills/${slug}.md`;
+}
+function ensureSkillBundleScaffold(workspacePath, slug) {
+  const skillRoot = path4.join(workspacePath, "skills", slug);
+  fs4.mkdirSync(skillRoot, { recursive: true });
+  for (const subdir of ["scripts", "examples", "tests", "assets"]) {
+    fs4.mkdirSync(path4.join(skillRoot, subdir), { recursive: true });
+  }
+}
+function writeSkillManifest(workspacePath, slug, skill, actor) {
+  const manifestPath = path4.join(workspacePath, "skills", slug, "skill-manifest.json");
+  const dir = path4.dirname(manifestPath);
+  fs4.mkdirSync(dir, { recursive: true });
+  const manifest = {
+    version: 1,
+    slug,
+    title: String(skill.fields.title ?? slug),
+    primitivePath: skill.path,
+    owner: String(skill.fields.owner ?? actor),
+    skillVersion: String(skill.fields.version ?? "0.1.0"),
+    status: String(skill.fields.status ?? "draft"),
+    dependsOn: Array.isArray(skill.fields.depends_on) ? skill.fields.depends_on.map((value) => String(value)) : [],
+    components: {
+      skillDoc: "SKILL.md",
+      scriptsDir: "scripts/",
+      examplesDir: "examples/",
+      testsDir: "tests/",
+      assetsDir: "assets/"
+    },
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs4.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+}
+
+// src/lens.ts
+var lens_exports = {};
+__export(lens_exports, {
+  generateContextLens: () => generateContextLens,
+  listContextLenses: () => listContextLenses,
+  materializeContextLens: () => materializeContextLens
+});
+import fs5 from "fs";
+import path5 from "path";
+var DEFAULT_LOOKBACK_HOURS = 24;
+var DEFAULT_STALE_HOURS = 24;
+var DEFAULT_LIMIT = 10;
+var PRIORITY_ORDER = {
+  urgent: 0,
+  high: 1,
+  medium: 2,
+  low: 3
+};
+var HIGH_RISK_PRIORITIES = /* @__PURE__ */ new Set(["urgent", "high"]);
+var HIGH_RISK_SEVERITIES = /* @__PURE__ */ new Set(["sev0", "sev1", "sev2"]);
+var BUILT_IN_LENSES = [
+  {
+    id: "my-work",
+    description: "Actor workload, blockers, stale claims, and ready-next queue"
+  },
+  {
+    id: "team-risk",
+    description: "High-risk blockers, stale active claims, failed runs, and incidents"
+  },
+  {
+    id: "customer-health",
+    description: "Customer-tagged delivery health, blockers, and related incidents"
+  },
+  {
+    id: "exec-brief",
+    description: "Top priorities, momentum, risks, and recent decisions"
+  }
+];
+function listContextLenses() {
+  return BUILT_IN_LENSES.map((lens) => ({ ...lens }));
+}
+function generateContextLens(workspacePath, lensId, options = {}) {
+  const normalizedLensId = normalizeLensId(lensId);
+  const normalizedOptions = normalizeLensOptions(options);
+  switch (normalizedLensId) {
+    case "my-work":
+      return buildMyWorkLens(workspacePath, normalizedOptions);
+    case "team-risk":
+      return buildTeamRiskLens(workspacePath, normalizedOptions);
+    case "customer-health":
+      return buildCustomerHealthLens(workspacePath, normalizedOptions);
+    case "exec-brief":
+      return buildExecBriefLens(workspacePath, normalizedOptions);
+    default:
+      return assertNever(normalizedLensId);
+  }
+}
+function materializeContextLens(workspacePath, lensId, options) {
+  const result = generateContextLens(workspacePath, lensId, options);
+  const absOutputPath = resolvePathWithinWorkspace2(workspacePath, options.outputPath);
+  const relOutputPath = path5.relative(workspacePath, absOutputPath).replace(/\\/g, "/");
+  const parentDir = path5.dirname(absOutputPath);
+  if (!fs5.existsSync(parentDir)) fs5.mkdirSync(parentDir, { recursive: true });
+  const existed = fs5.existsSync(absOutputPath);
+  fs5.writeFileSync(absOutputPath, result.markdown, "utf-8");
+  append(
+    workspacePath,
+    options.actor ?? result.actor ?? "system",
+    existed ? "update" : "create",
+    relOutputPath,
+    "lens",
+    {
+      lens: result.lens,
+      sections: result.sections.length
+    }
+  );
+  return {
+    ...result,
+    outputPath: relOutputPath,
+    created: !existed
+  };
+}
+function buildMyWorkLens(workspacePath, options) {
+  const actor = options.actor;
+  const nowMs = Date.now();
+  const staleCutoffMs = nowMs - options.staleHours * 60 * 60 * 1e3;
+  const claims = [...allClaims(workspacePath).entries()];
+  const myClaimedThreads = claims.filter(([, owner]) => owner === actor).map(([target]) => read(workspacePath, target)).filter((instance) => !!instance && instance.type === "thread").sort(compareThreadsByPriorityThenUpdated);
+  const myBlockedThreads = myClaimedThreads.filter((instance) => String(instance.fields.status ?? "") === "blocked").slice(0, options.limit);
+  const staleClaims = myClaimedThreads.filter((instance) => isStale(instance, staleCutoffMs)).slice(0, options.limit);
+  const nextReady = listReadyThreads(workspacePath).filter((instance) => !instance.fields.owner).sort(compareThreadsByPriorityThenUpdated).slice(0, options.limit);
+  const sections = [
+    {
+      id: "my_claims",
+      title: `Claimed Threads (${actor})`,
+      items: myClaimedThreads.slice(0, options.limit).map((instance) => toThreadItem(instance, nowMs))
+    },
+    {
+      id: "my_blockers",
+      title: `Blocked Threads (${actor})`,
+      items: myBlockedThreads.map((instance) => toThreadItem(instance, nowMs))
+    },
+    {
+      id: "stale_claims",
+      title: `Stale Claims (${options.staleHours}h+)`,
+      items: staleClaims.map((instance) => toThreadItem(instance, nowMs))
+    },
+    {
+      id: "next_ready",
+      title: "Next Ready Threads",
+      items: nextReady.map((instance) => toThreadItem(instance, nowMs))
+    }
+  ];
+  return finalizeLensResult("my-work", {
+    actor,
+    options,
+    metrics: {
+      myClaims: myClaimedThreads.length,
+      blocked: myBlockedThreads.length,
+      staleClaims: staleClaims.length,
+      nextReady: nextReady.length
+    },
+    sections
+  });
+}
+function buildTeamRiskLens(workspacePath, options) {
+  const nowMs = Date.now();
+  const staleCutoffMs = nowMs - options.staleHours * 60 * 60 * 1e3;
+  const lookbackCutoffMs = nowMs - options.lookbackHours * 60 * 60 * 1e3;
+  const threads = list(workspacePath, "thread");
+  const blockedHighPriority = threads.filter((instance) => String(instance.fields.status ?? "") === "blocked").filter((instance) => HIGH_RISK_PRIORITIES.has(normalizePriority(instance.fields.priority))).sort(compareThreadsByPriorityThenUpdated).slice(0, options.limit);
+  const staleActiveClaims = [...allClaims(workspacePath).entries()].map(([target, owner]) => ({ owner, instance: read(workspacePath, target) })).filter((entry) => !!entry.instance && entry.instance.type === "thread").filter((entry) => String(entry.instance.fields.status ?? "") === "active").filter((entry) => isStale(entry.instance, staleCutoffMs)).slice(0, options.limit);
+  const failedRuns = listRuns(workspacePath, { status: "failed" }).filter((run) => parseTimestamp(run.updatedAt) >= lookbackCutoffMs).slice(0, options.limit);
+  const highSeverityIncidents = list(workspacePath, "incident").filter((incident) => String(incident.fields.status ?? "") === "active").filter((incident) => HIGH_RISK_SEVERITIES.has(normalizeSeverity(incident.fields.severity))).slice(0, options.limit);
+  const sections = [
+    {
+      id: "blocked_high_priority_threads",
+      title: "High Priority Blocked Threads",
+      items: blockedHighPriority.map((instance) => toThreadItem(instance, nowMs))
+    },
+    {
+      id: "stale_active_claims",
+      title: `Stale Active Claims (${options.staleHours}h+)`,
+      items: staleActiveClaims.map((entry) => ({
+        ...toThreadItem(entry.instance, nowMs),
+        owner: entry.owner
+      }))
+    },
+    {
+      id: "failed_runs",
+      title: `Failed Runs (${options.lookbackHours}h window)`,
+      items: failedRuns.map(toRunItem)
+    },
+    {
+      id: "active_high_severity_incidents",
+      title: "Active High-Severity Incidents",
+      items: highSeverityIncidents.map((incident) => toIncidentItem(incident, nowMs))
+    }
+  ];
+  return finalizeLensResult("team-risk", {
+    actor: options.actor,
+    options,
+    metrics: {
+      blockedHighPriority: blockedHighPriority.length,
+      staleActiveClaims: staleActiveClaims.length,
+      failedRuns: failedRuns.length,
+      activeHighSeverityIncidents: highSeverityIncidents.length
+    },
+    sections
+  });
+}
+function buildCustomerHealthLens(workspacePath, options) {
+  const nowMs = Date.now();
+  const customerThreads = list(workspacePath, "thread").filter(isCustomerLinked).sort(compareThreadsByPriorityThenUpdated);
+  const activeCustomerThreads = customerThreads.filter((instance) => ["open", "active"].includes(String(instance.fields.status ?? ""))).slice(0, options.limit);
+  const blockedCustomerThreads = customerThreads.filter((instance) => String(instance.fields.status ?? "") === "blocked").slice(0, options.limit);
+  const customerIncidents = list(workspacePath, "incident").filter((incident) => String(incident.fields.status ?? "") === "active").filter(isCustomerLinked).slice(0, options.limit);
+  const clients = list(workspacePath, "client").slice(0, options.limit);
+  const sections = [
+    {
+      id: "active_customer_threads",
+      title: "Active Customer Threads",
+      items: activeCustomerThreads.map((instance) => toThreadItem(instance, nowMs))
+    },
+    {
+      id: "blocked_customer_threads",
+      title: "Blocked Customer Threads",
+      items: blockedCustomerThreads.map((instance) => toThreadItem(instance, nowMs))
+    },
+    {
+      id: "customer_incidents",
+      title: "Customer Incidents",
+      items: customerIncidents.map((incident) => toIncidentItem(incident, nowMs))
+    },
+    {
+      id: "client_records",
+      title: "Client Records",
+      items: clients.map((instance) => ({
+        title: String(instance.fields.title ?? instance.path),
+        path: instance.path,
+        status: stringOrUndefined(instance.fields.status),
+        detail: stringOrUndefined(instance.fields.health ?? instance.fields.risk),
+        ageHours: ageHours(instance, nowMs)
+      }))
+    }
+  ];
+  return finalizeLensResult("customer-health", {
+    actor: options.actor,
+    options,
+    metrics: {
+      activeCustomerThreads: activeCustomerThreads.length,
+      blockedCustomerThreads: blockedCustomerThreads.length,
+      customerIncidents: customerIncidents.length,
+      clients: clients.length
+    },
+    sections
+  });
+}
+function buildExecBriefLens(workspacePath, options) {
+  const nowMs = Date.now();
+  const lookbackCutoffMs = nowMs - options.lookbackHours * 60 * 60 * 1e3;
+  const threads = list(workspacePath, "thread");
+  const topPriorities = threads.filter((instance) => ["open", "active"].includes(String(instance.fields.status ?? ""))).sort(compareThreadsByPriorityThenUpdated).slice(0, options.limit);
+  const momentum = threads.filter((instance) => String(instance.fields.status ?? "") === "done").filter((instance) => parseTimestamp(instance.fields.updated) >= lookbackCutoffMs).sort(compareThreadsByPriorityThenUpdated).slice(0, options.limit);
+  const blockedHighPriority = threads.filter((instance) => String(instance.fields.status ?? "") === "blocked").filter((instance) => HIGH_RISK_PRIORITIES.has(normalizePriority(instance.fields.priority))).sort(compareThreadsByPriorityThenUpdated).slice(0, options.limit);
+  const failedRuns = listRuns(workspacePath, { status: "failed" }).filter((run) => parseTimestamp(run.updatedAt) >= lookbackCutoffMs).slice(0, options.limit);
+  const decisions = list(workspacePath, "decision").filter((instance) => ["proposed", "approved", "active"].includes(String(instance.fields.status ?? ""))).filter((instance) => parseTimestamp(instance.fields.updated ?? instance.fields.date) >= lookbackCutoffMs).slice(0, options.limit);
+  const sections = [
+    {
+      id: "top_priorities",
+      title: "Top Priorities",
+      items: topPriorities.map((instance) => toThreadItem(instance, nowMs))
+    },
+    {
+      id: "momentum",
+      title: `Momentum (${options.lookbackHours}h completed)`,
+      items: momentum.map((instance) => toThreadItem(instance, nowMs))
+    },
+    {
+      id: "key_risks",
+      title: "Key Risks",
+      items: [
+        ...blockedHighPriority.map((instance) => toThreadItem(instance, nowMs)),
+        ...failedRuns.map(toRunItem)
+      ].slice(0, options.limit)
+    },
+    {
+      id: "recent_decisions",
+      title: `Decisions (${options.lookbackHours}h window)`,
+      items: decisions.map((instance) => ({
+        title: String(instance.fields.title ?? instance.path),
+        path: instance.path,
+        status: stringOrUndefined(instance.fields.status),
+        detail: stringOrUndefined(instance.fields.date),
+        ageHours: ageHours(instance, nowMs)
+      }))
+    }
+  ];
+  return finalizeLensResult("exec-brief", {
+    actor: options.actor,
+    options,
+    metrics: {
+      topPriorities: topPriorities.length,
+      momentumDone: momentum.length,
+      risks: blockedHighPriority.length + failedRuns.length,
+      decisions: decisions.length
+    },
+    sections
+  });
+}
+function finalizeLensResult(lens, input) {
+  const base = {
+    lens,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    actor: input.actor,
+    options: {
+      lookbackHours: input.options.lookbackHours,
+      staleHours: input.options.staleHours,
+      limit: input.options.limit
+    },
+    metrics: input.metrics,
+    sections: input.sections
+  };
+  return {
+    ...base,
+    markdown: renderLensMarkdown(base)
+  };
+}
+function toThreadItem(instance, nowMs) {
+  return {
+    title: String(instance.fields.title ?? instance.path),
+    path: instance.path,
+    status: stringOrUndefined(instance.fields.status),
+    priority: stringOrUndefined(instance.fields.priority),
+    owner: stringOrUndefined(instance.fields.owner),
+    detail: renderThreadDependencies(instance),
+    ageHours: ageHours(instance, nowMs)
+  };
+}
+function toIncidentItem(instance, nowMs) {
+  return {
+    title: String(instance.fields.title ?? instance.path),
+    path: instance.path,
+    status: stringOrUndefined(instance.fields.status),
+    priority: stringOrUndefined(instance.fields.severity),
+    owner: stringOrUndefined(instance.fields.owner),
+    ageHours: ageHours(instance, nowMs)
+  };
+}
+function toRunItem(run) {
+  return {
+    title: run.objective,
+    path: `runs/${run.id}.md`,
+    status: run.status,
+    owner: run.actor,
+    detail: run.error ?? run.output,
+    ageHours: ageHoursFromIso(run.updatedAt)
+  };
+}
+function renderLensMarkdown(input) {
+  const lines = [
+    `# Workgraph Context Lens: ${input.lens}`,
+    "",
+    `Generated: ${input.generatedAt}`,
+    ...input.actor ? [`Actor: ${input.actor}`] : [],
+    `Lookback: ${input.options.lookbackHours}h`,
+    `Stale threshold: ${input.options.staleHours}h`,
+    `Section limit: ${input.options.limit}`,
+    "",
+    "## Metrics",
+    "",
+    ...Object.entries(input.metrics).map(([metric, value]) => `- ${metric}: ${value}`),
+    ""
+  ];
+  for (const section of input.sections) {
+    lines.push(`## ${section.title}`);
+    lines.push("");
+    if (section.items.length === 0) {
+      lines.push("- None");
+      lines.push("");
+      continue;
+    }
+    for (const item of section.items) {
+      lines.push(`- ${renderLensItem(item)}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function renderLensItem(item) {
+  const components = [item.title];
+  if (item.path) components.push(`(\`${item.path}\`)`);
+  const metadata = [];
+  if (item.status) metadata.push(`status=${item.status}`);
+  if (item.priority) metadata.push(`priority=${item.priority}`);
+  if (item.owner) metadata.push(`owner=${item.owner}`);
+  if (typeof item.ageHours === "number") metadata.push(`age=${item.ageHours.toFixed(1)}h`);
+  if (metadata.length > 0) components.push(`[${metadata.join(", ")}]`);
+  if (item.detail) components.push(`- ${item.detail}`);
+  return components.join(" ");
+}
+function resolvePathWithinWorkspace2(workspacePath, outputPath) {
+  const base = path5.resolve(workspacePath);
+  const resolved = path5.resolve(base, outputPath);
+  if (!resolved.startsWith(base + path5.sep) && resolved !== base) {
+    throw new Error(`Invalid lens output path: ${outputPath}`);
+  }
+  return resolved;
+}
+function normalizeLensId(value) {
+  const normalized = String(value).trim().toLowerCase().replace(/^lens:\/\//, "");
+  if (normalized === "my-work") return "my-work";
+  if (normalized === "team-risk") return "team-risk";
+  if (normalized === "customer-health") return "customer-health";
+  if (normalized === "exec-brief") return "exec-brief";
+  const valid = BUILT_IN_LENSES.map((item) => item.id).join(", ");
+  throw new Error(`Unknown context lens "${value}". Valid lenses: ${valid}`);
+}
+function normalizeLensOptions(options) {
+  return {
+    actor: String(options.actor ?? "anonymous").trim() || "anonymous",
+    lookbackHours: parsePositiveNumber(options.lookbackHours, "lookbackHours", DEFAULT_LOOKBACK_HOURS),
+    staleHours: parsePositiveNumber(options.staleHours, "staleHours", DEFAULT_STALE_HOURS),
+    limit: parsePositiveInteger(options.limit, "limit", DEFAULT_LIMIT)
+  };
+}
+function parsePositiveNumber(value, fieldName, defaultValue) {
+  if (value === void 0 || value === null) return defaultValue;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Invalid ${fieldName}: expected a positive number.`);
+  }
+  return parsed;
+}
+function parsePositiveInteger(value, fieldName, defaultValue) {
+  if (value === void 0 || value === null) return defaultValue;
+  const parsed = Number.parseInt(String(value), 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`Invalid ${fieldName}: expected a positive integer.`);
+  }
+  return parsed;
+}
+function compareThreadsByPriorityThenUpdated(a, b) {
+  const priorityDelta = rankPriority(a) - rankPriority(b);
+  if (priorityDelta !== 0) return priorityDelta;
+  return parseTimestamp(b.fields.updated) - parseTimestamp(a.fields.updated);
+}
+function rankPriority(instance) {
+  const priority = normalizePriority(instance.fields.priority);
+  return PRIORITY_ORDER[priority] ?? PRIORITY_ORDER.medium;
+}
+function normalizePriority(value) {
+  return String(value ?? "medium").trim().toLowerCase();
+}
+function normalizeSeverity(value) {
+  return String(value ?? "sev4").trim().toLowerCase();
+}
+function isStale(instance, staleCutoffMs) {
+  const updatedAt = parseTimestamp(instance.fields.updated ?? instance.fields.created);
+  if (!Number.isFinite(updatedAt)) return false;
+  return updatedAt <= staleCutoffMs;
+}
+function parseTimestamp(value) {
+  const parsed = Date.parse(String(value ?? ""));
+  return Number.isFinite(parsed) ? parsed : Number.NEGATIVE_INFINITY;
+}
+function ageHours(instance, nowMs) {
+  const updatedAt = parseTimestamp(instance.fields.updated ?? instance.fields.created);
+  if (!Number.isFinite(updatedAt)) return void 0;
+  return Math.max(0, (nowMs - updatedAt) / (60 * 60 * 1e3));
+}
+function ageHoursFromIso(value) {
+  const nowMs = Date.now();
+  const ts = parseTimestamp(value);
+  if (!Number.isFinite(ts)) return void 0;
+  return Math.max(0, (nowMs - ts) / (60 * 60 * 1e3));
+}
+function renderThreadDependencies(instance) {
+  const deps = instance.fields.deps;
+  if (!Array.isArray(deps) || deps.length === 0) return void 0;
+  const visible = deps.slice(0, 3).map((value) => String(value));
+  const suffix = deps.length > visible.length ? ` +${deps.length - visible.length} more` : "";
+  return `deps: ${visible.join(", ")}${suffix}`;
+}
+function isCustomerLinked(instance) {
+  const tags = normalizeTags(instance.fields.tags);
+  if (tags.includes("customer") || tags.includes("client")) return true;
+  const candidateFields = ["client", "client_ref", "customer", "customer_ref", "account", "account_ref"];
+  return candidateFields.some((key) => {
+    const value = instance.fields[key];
+    return typeof value === "string" && value.trim().length > 0;
+  });
+}
+function normalizeTags(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => String(item).trim().toLowerCase()).filter(Boolean);
+}
+function stringOrUndefined(value) {
+  if (value === void 0 || value === null) return void 0;
+  const normalized = String(value).trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function assertNever(value) {
+  throw new Error(`Unhandled lens variant: ${String(value)}`);
+}
+
+// src/board.ts
+var board_exports = {};
+__export(board_exports, {
+  generateKanbanBoard: () => generateKanbanBoard,
+  syncKanbanBoard: () => syncKanbanBoard
+});
+import fs6 from "fs";
+import path6 from "path";
+function generateKanbanBoard(workspacePath, options = {}) {
+  const threads = list(workspacePath, "thread");
+  const grouped = groupThreads(threads);
+  const includeCancelled = options.includeCancelled === true;
+  const lanes = [
+    { title: "Backlog", items: grouped.open, checkChar: " " },
+    { title: "In Progress", items: grouped.active, checkChar: " " },
+    { title: "Blocked", items: grouped.blocked, checkChar: " " },
+    { title: "Done", items: grouped.done, checkChar: "x" }
+  ];
+  if (includeCancelled) {
+    lanes.push({ title: "Cancelled", items: grouped.cancelled, checkChar: "x" });
+  }
+  const content = renderKanbanMarkdown(lanes);
+  const relOutputPath = options.outputPath ?? "ops/Workgraph Board.md";
+  const absOutputPath = resolvePathWithinWorkspace3(workspacePath, relOutputPath);
+  const parentDir = path6.dirname(absOutputPath);
+  if (!fs6.existsSync(parentDir)) fs6.mkdirSync(parentDir, { recursive: true });
+  fs6.writeFileSync(absOutputPath, content, "utf-8");
+  return {
+    outputPath: path6.relative(workspacePath, absOutputPath).replace(/\\/g, "/"),
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    counts: {
+      backlog: grouped.open.length,
+      inProgress: grouped.active.length,
+      blocked: grouped.blocked.length,
+      done: grouped.done.length,
+      cancelled: grouped.cancelled.length
+    },
+    content
+  };
+}
+function syncKanbanBoard(workspacePath, options = {}) {
+  return generateKanbanBoard(workspacePath, options);
+}
+function groupThreads(threads) {
+  const groups = {
+    open: [],
+    active: [],
+    blocked: [],
+    done: [],
+    cancelled: []
+  };
+  for (const thread of threads) {
+    const status = String(thread.fields.status ?? "open");
+    switch (status) {
+      case "active":
+        groups.active.push(thread);
+        break;
+      case "blocked":
+        groups.blocked.push(thread);
+        break;
+      case "done":
+        groups.done.push(thread);
+        break;
+      case "cancelled":
+        groups.cancelled.push(thread);
+        break;
+      case "open":
+      default:
+        groups.open.push(thread);
+        break;
+    }
+  }
+  const byPriority = (a, b) => {
+    const rank = (value) => {
+      switch (String(value ?? "medium")) {
+        case "urgent":
+          return 0;
+        case "high":
+          return 1;
+        case "medium":
+          return 2;
+        case "low":
+          return 3;
+        default:
+          return 4;
+      }
+    };
+    return rank(a.fields.priority) - rank(b.fields.priority) || String(a.fields.title).localeCompare(String(b.fields.title));
+  };
+  groups.open.sort(byPriority);
+  groups.active.sort(byPriority);
+  groups.blocked.sort(byPriority);
+  groups.done.sort(byPriority);
+  groups.cancelled.sort(byPriority);
+  return groups;
+}
+function renderKanbanMarkdown(lanes) {
+  const settings = {
+    "kanban-plugin": "board"
+  };
+  const lines = [
+    "---",
+    "kanban-plugin: board",
+    "---",
+    ""
+  ];
+  for (const lane of lanes) {
+    lines.push(`## ${lane.title}`);
+    lines.push("");
+    for (const thread of lane.items) {
+      const title = String(thread.fields.title ?? thread.path);
+      const priority = String(thread.fields.priority ?? "medium");
+      lines.push(`- [${lane.checkChar}] [[${thread.path}|${title}]] (#${priority})`);
+    }
+    lines.push("");
+    lines.push("");
+    lines.push("");
+  }
+  lines.push("%% kanban:settings");
+  lines.push("```");
+  lines.push(JSON.stringify(settings));
+  lines.push("```");
+  lines.push("%%");
+  lines.push("");
+  return lines.join("\n");
+}
+function resolvePathWithinWorkspace3(workspacePath, outputPath) {
+  const base = path6.resolve(workspacePath);
+  const resolved = path6.resolve(base, outputPath);
+  if (!resolved.startsWith(base + path6.sep) && resolved !== base) {
+    throw new Error(`Invalid board output path: ${outputPath}`);
+  }
+  return resolved;
+}
+
+// src/agent.ts
+var agent_exports = {};
+__export(agent_exports, {
+  getPresence: () => getPresence,
+  heartbeat: () => heartbeat,
+  list: () => list2
+});
+var PRESENCE_TYPE = "presence";
+var PRESENCE_STATUS_VALUES = /* @__PURE__ */ new Set(["online", "busy", "offline"]);
+function heartbeat(workspacePath, name, options = {}) {
+  const existing = getPresence(workspacePath, name);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const status = normalizeStatus(options.status ?? existing?.fields.status) ?? "online";
+  const capabilities = normalizeCapabilities(options.capabilities ?? existing?.fields.capabilities);
+  const actor = options.actor ?? name;
+  const currentTask = options.currentTask !== void 0 ? normalizeTask(options.currentTask) : normalizeTask(existing?.fields.current_task);
+  if (!existing) {
+    return create(
+      workspacePath,
+      PRESENCE_TYPE,
+      {
+        name,
+        status,
+        current_task: currentTask,
+        last_seen: now,
+        capabilities
+      },
+      renderPresenceBody(name, status, currentTask, capabilities, now),
+      actor
+    );
+  }
+  return update(
+    workspacePath,
+    existing.path,
+    {
+      name,
+      status,
+      current_task: currentTask,
+      last_seen: now,
+      capabilities
+    },
+    renderPresenceBody(name, status, currentTask, capabilities, now),
+    actor
+  );
+}
+function list2(workspacePath) {
+  return list(workspacePath, PRESENCE_TYPE).sort((a, b) => {
+    const aSeen = Date.parse(String(a.fields.last_seen ?? ""));
+    const bSeen = Date.parse(String(b.fields.last_seen ?? ""));
+    const safeA = Number.isFinite(aSeen) ? aSeen : 0;
+    const safeB = Number.isFinite(bSeen) ? bSeen : 0;
+    if (safeA !== safeB) return safeB - safeA;
+    return String(a.fields.name ?? "").localeCompare(String(b.fields.name ?? ""));
+  });
+}
+function getPresence(workspacePath, name) {
+  const target = normalizeName(name);
+  return list2(workspacePath).find((entry) => normalizeName(entry.fields.name) === target) ?? null;
+}
+function normalizeStatus(value) {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!PRESENCE_STATUS_VALUES.has(normalized)) return null;
+  return normalized;
+}
+function normalizeCapabilities(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((entry) => String(entry).trim()).filter(Boolean);
+}
+function normalizeTask(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized ? normalized : null;
+}
+function normalizeName(value) {
+  return String(value ?? "").trim().toLowerCase();
+}
+function renderPresenceBody(name, status, currentTask, capabilities, lastSeen) {
+  const lines = [
+    "## Presence",
+    "",
+    `- agent: ${name}`,
+    `- status: ${status}`,
+    `- last_seen: ${lastSeen}`,
+    `- current_task: ${currentTask ?? "none"}`,
+    "",
+    "## Capabilities",
+    "",
+    ...capabilities.length > 0 ? capabilities.map((capability) => `- ${capability}`) : ["- none"],
+    ""
+  ];
+  return lines.join("\n");
+}
+
+// src/onboard.ts
+var onboard_exports = {};
+__export(onboard_exports, {
+  onboardWorkspace: () => onboardWorkspace,
+  updateOnboardingStatus: () => updateOnboardingStatus
+});
+function onboardWorkspace(workspacePath, options) {
+  const spaces = options.spaces && options.spaces.length > 0 ? options.spaces : ["platform", "product", "operations"];
+  const spacesCreated = [];
+  for (const space of spaces) {
+    const title = titleCase2(space);
+    const created = create(
+      workspacePath,
+      "space",
+      {
+        title,
+        description: `${title} workspace lane`,
+        members: [options.actor],
+        tags: ["onboarded"]
+      },
+      `# ${title}
+
+Auto-created during onboarding.
+`,
+      options.actor
+    );
+    spacesCreated.push(created.path);
+  }
+  const threadsCreated = [];
+  if (options.createDemoThreads !== false) {
+    const templates = [
+      { title: "Review workspace policy gates", goal: "Validate sensitive transitions are governed.", space: spacesCreated[0] },
+      { title: "Configure board sync cadence", goal: "Set board update expectations for all agents.", space: spacesCreated[1] ?? spacesCreated[0] },
+      { title: "Establish daily checkpoint routine", goal: "Agents leave actionable hand-off notes.", space: spacesCreated[2] ?? spacesCreated[0] }
+    ];
+    for (const template of templates) {
+      const created = create(
+        workspacePath,
+        "thread",
+        {
+          title: template.title,
+          goal: template.goal,
+          status: "open",
+          priority: "medium",
+          space: template.space,
+          context_refs: [template.space],
+          tags: ["onboarding"]
+        },
+        `## Goal
+
+${template.goal}
+`,
+        options.actor
+      );
+      threadsCreated.push(created.path);
+    }
+  }
+  const boardResult = generateKanbanBoard(workspacePath, { outputPath: "ops/Onboarding Board.md" });
+  const commandCenterResult = generateCommandCenter(workspacePath, {
+    outputPath: "ops/Onboarding Command Center.md",
+    actor: options.actor
+  });
+  const checkpointResult = checkpoint(
+    workspacePath,
+    options.actor,
+    "Onboarding completed and workspace views initialized.",
+    {
+      next: ["Claim your next ready thread via `workgraph thread next --claim`"],
+      blocked: [],
+      tags: ["onboarding"]
+    }
+  );
+  const onboarding = create(
+    workspacePath,
+    "onboarding",
+    {
+      title: `Onboarding for ${options.actor}`,
+      actor: options.actor,
+      status: "active",
+      spaces: spacesCreated,
+      thread_refs: threadsCreated,
+      board: boardResult.outputPath,
+      command_center: commandCenterResult.outputPath,
+      tags: ["onboarding"]
+    },
+    [
+      "# Onboarding",
+      "",
+      `Actor: ${options.actor}`,
+      "",
+      "## Spaces",
+      "",
+      ...spacesCreated.map((space) => `- [[${space}]]`),
+      "",
+      "## Starter Threads",
+      "",
+      ...threadsCreated.map((threadRef) => `- [[${threadRef}]]`),
+      "",
+      `Board: [[${boardResult.outputPath}]]`,
+      `Command Center: [[${commandCenterResult.outputPath}]]`,
+      ""
+    ].join("\n"),
+    options.actor
+  );
+  return {
+    actor: options.actor,
+    spacesCreated,
+    threadsCreated,
+    boardPath: boardResult.outputPath,
+    commandCenterPath: commandCenterResult.outputPath,
+    checkpointPath: checkpointResult.path,
+    onboardingPath: onboarding.path
+  };
+}
+function updateOnboardingStatus(workspacePath, onboardingPath, status, actor) {
+  const onboarding = read(workspacePath, onboardingPath);
+  if (!onboarding) throw new Error(`Onboarding primitive not found: ${onboardingPath}`);
+  if (onboarding.type !== "onboarding") {
+    throw new Error(`Target is not an onboarding primitive: ${onboardingPath}`);
+  }
+  const current = String(onboarding.fields.status ?? "active");
+  const allowed = ONBOARDING_STATUS_TRANSITIONS[current] ?? [];
+  if (!allowed.includes(status)) {
+    throw new Error(`Invalid onboarding transition: ${current} -> ${status}. Allowed: ${allowed.join(", ") || "none"}`);
+  }
+  return update(
+    workspacePath,
+    onboardingPath,
+    { status },
+    void 0,
+    actor
+  );
+}
+var ONBOARDING_STATUS_TRANSITIONS = {
+  active: ["paused", "completed"],
+  paused: ["active", "completed"],
+  completed: []
+};
+function titleCase2(value) {
+  return value.split(/[-_\s]/g).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
+}
+
+// src/search-qmd-adapter.ts
+var search_qmd_adapter_exports = {};
+__export(search_qmd_adapter_exports, {
+  search: () => search
+});
+function search(workspacePath, text, options = {}) {
+  const requestedMode = options.mode ?? "auto";
+  const qmdEnabled = process.env.WORKGRAPH_QMD_ENDPOINT && process.env.WORKGRAPH_QMD_ENDPOINT.trim().length > 0;
+  if (requestedMode === "qmd" && !qmdEnabled) {
+    const results = keywordSearch(workspacePath, text, {
+      type: options.type,
+      limit: options.limit
+    });
+    return {
+      mode: "core",
+      query: text,
+      results,
+      fallbackReason: "QMD mode requested but WORKGRAPH_QMD_ENDPOINT is not configured."
+    };
+  }
+  if (requestedMode === "qmd" && qmdEnabled) {
+    const results = keywordSearch(workspacePath, text, {
+      type: options.type,
+      limit: options.limit
+    });
+    return {
+      mode: "qmd",
+      query: text,
+      results,
+      fallbackReason: "QMD endpoint configured; using core-compatible local ranking in MVP."
+    };
+  }
+  if (requestedMode === "auto" && qmdEnabled) {
+    const results = keywordSearch(workspacePath, text, {
+      type: options.type,
+      limit: options.limit
+    });
+    return {
+      mode: "qmd",
+      query: text,
+      results,
+      fallbackReason: "Auto mode selected; QMD endpoint detected; using core-compatible local ranking in MVP."
+    };
+  }
+  return {
+    mode: "core",
+    query: text,
+    results: keywordSearch(workspacePath, text, {
+      type: options.type,
+      limit: options.limit
+    })
+  };
+}
+
+// src/trigger.ts
+var trigger_exports = {};
+__export(trigger_exports, {
+  fireTrigger: () => fireTrigger
+});
+import { createHash } from "crypto";
+function fireTrigger(workspacePath, triggerPath, options) {
+  const trigger = read(workspacePath, triggerPath);
+  if (!trigger) throw new Error(`Trigger not found: ${triggerPath}`);
+  if (trigger.type !== "trigger") throw new Error(`Target is not a trigger primitive: ${triggerPath}`);
+  const triggerStatus = String(trigger.fields.status ?? "draft");
+  if (!["approved", "active"].includes(triggerStatus)) {
+    throw new Error(`Trigger must be approved/active to fire. Current status: ${triggerStatus}`);
+  }
+  const objective = options.objective ?? `Trigger ${String(trigger.fields.title ?? triggerPath)} fired action ${String(trigger.fields.action ?? "run")}`;
+  const eventSeed = options.eventKey ?? (/* @__PURE__ */ new Date()).toISOString();
+  const idempotencyKey = buildIdempotencyKey(triggerPath, eventSeed, objective);
+  const run = createRun(workspacePath, {
+    actor: options.actor,
+    objective,
+    context: {
+      trigger_path: triggerPath,
+      trigger_event: String(trigger.fields.event ?? ""),
+      ...options.context
+    },
+    idempotencyKey
+  });
+  append(workspacePath, options.actor, "create", triggerPath, "trigger", {
+    fired: true,
+    event_key: eventSeed,
+    run_id: run.id,
+    idempotency_key: idempotencyKey
+  });
+  return {
+    triggerPath,
+    run,
+    idempotencyKey
+  };
+}
+function buildIdempotencyKey(triggerPath, eventSeed, objective) {
+  return createHash("sha256").update(`${triggerPath}:${eventSeed}:${objective}`).digest("hex").slice(0, 32);
+}
+
+// src/clawdapus.ts
+var clawdapus_exports = {};
+__export(clawdapus_exports, {
+  CLAWDAPUS_INTEGRATION_PROVIDER: () => CLAWDAPUS_INTEGRATION_PROVIDER,
+  DEFAULT_CLAWDAPUS_SKILL_URL: () => DEFAULT_CLAWDAPUS_SKILL_URL,
+  fetchClawdapusSkillMarkdown: () => fetchClawdapusSkillMarkdown,
+  installClawdapusSkill: () => installClawdapusSkill
+});
+
+// src/integration-core.ts
+async function installSkillIntegration(workspacePath, provider, options) {
+  const actor = options.actor.trim();
+  if (!actor) {
+    throw new Error(`${provider.id} integration requires a non-empty actor.`);
+  }
+  const title = options.title?.trim() || provider.defaultTitle;
+  const sourceUrl = options.sourceUrl?.trim() || provider.defaultSourceUrl;
+  const existing = loadSkillIfExists(workspacePath, title);
+  if (existing && !options.force) {
+    throw new Error(
+      `Skill "${title}" already exists at ${existing.path}. Use --force to refresh it from source.`
+    );
+  }
+  const fetchSkillMarkdown = options.fetchSkillMarkdown ?? ((url) => fetchSkillMarkdownFromUrl(url, provider.userAgent));
+  const markdown = await fetchSkillMarkdown(sourceUrl);
+  if (!markdown.trim()) {
+    throw new Error(`Downloaded ${provider.id} skill from ${sourceUrl} is empty.`);
+  }
+  const skill = writeSkill(workspacePath, title, markdown, actor, {
+    owner: options.owner ?? actor,
+    status: options.status,
+    distribution: provider.distribution,
+    tags: mergeTags(provider.defaultTags, options.tags)
+  });
+  return {
+    provider: provider.id,
+    skill,
+    sourceUrl,
+    importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    replacedExisting: existing !== null
+  };
+}
+async function fetchSkillMarkdownFromUrl(sourceUrl, userAgent = "@versatly/workgraph optional-integration") {
+  let response;
+  try {
+    response = await fetch(sourceUrl, {
+      headers: {
+        "user-agent": userAgent
+      }
+    });
+  } catch (error) {
+    throw new Error(
+      `Failed to download skill from ${sourceUrl}: ${errorMessage(error)}`
+    );
+  }
+  if (!response.ok) {
+    throw new Error(
+      `Failed to download skill from ${sourceUrl}: HTTP ${response.status} ${response.statusText}`
+    );
+  }
+  return response.text();
+}
+function loadSkillIfExists(workspacePath, skillRef) {
+  try {
+    return loadSkill(workspacePath, skillRef);
+  } catch (error) {
+    const message = errorMessage(error);
+    if (message.startsWith("Skill not found:")) {
+      return null;
+    }
+    throw error;
+  }
+}
+function mergeTags(defaultTags, tags) {
+  const merged = /* @__PURE__ */ new Set(["optional-integration"]);
+  for (const tag of defaultTags) {
+    const normalized = tag.trim();
+    if (normalized) merged.add(normalized);
+  }
+  for (const tag of tags ?? []) {
+    const normalized = tag.trim();
+    if (normalized) merged.add(normalized);
+  }
+  return [...merged];
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/clawdapus.ts
+var DEFAULT_CLAWDAPUS_SKILL_URL = "https://raw.githubusercontent.com/mostlydev/clawdapus/master/skills/clawdapus/SKILL.md";
+var CLAWDAPUS_INTEGRATION_PROVIDER = {
+  id: "clawdapus",
+  defaultTitle: "clawdapus",
+  defaultSourceUrl: DEFAULT_CLAWDAPUS_SKILL_URL,
+  distribution: "clawdapus-optional-integration",
+  defaultTags: ["clawdapus"],
+  userAgent: "@versatly/workgraph clawdapus-optional-integration"
+};
+async function installClawdapusSkill(workspacePath, options) {
+  return installSkillIntegration(
+    workspacePath,
+    CLAWDAPUS_INTEGRATION_PROVIDER,
+    options
+  );
+}
+async function fetchClawdapusSkillMarkdown(sourceUrl) {
+  return fetchSkillMarkdownFromUrl(sourceUrl, CLAWDAPUS_INTEGRATION_PROVIDER.userAgent);
+}
+
+// src/integration.ts
+var integration_exports = {};
+__export(integration_exports, {
+  installIntegration: () => installIntegration,
+  listIntegrations: () => listIntegrations
+});
+var INTEGRATIONS = {
+  clawdapus: {
+    provider: CLAWDAPUS_INTEGRATION_PROVIDER,
+    description: "Infrastructure-layer governance skill import for AI agent containers.",
+    install: installClawdapusSkill
+  }
+};
+function listIntegrations() {
+  return Object.values(INTEGRATIONS).map((integration) => ({
+    id: integration.provider.id,
+    description: integration.description,
+    defaultTitle: integration.provider.defaultTitle,
+    defaultSourceUrl: integration.provider.defaultSourceUrl
+  }));
+}
+async function installIntegration(workspacePath, integrationId, options) {
+  const integration = INTEGRATIONS[integrationId.trim().toLowerCase()];
+  if (!integration) {
+    throw new Error(
+      `Unknown integration "${integrationId}". Supported integrations: ${supportedIntegrationList()}.`
+    );
+  }
+  return integration.install(workspacePath, options);
+}
+function supportedIntegrationList() {
+  return Object.keys(INTEGRATIONS).sort().join(", ");
+}
+
+// src/diagnostics/index.ts
+var diagnostics_exports = {};
+__export(diagnostics_exports, {
+  computeVaultStats: () => computeVaultStats,
+  diagnoseVaultHealth: () => diagnoseVaultHealth,
+  generateLedgerChangelog: () => generateLedgerChangelog,
+  renderChangelogText: () => renderChangelogText,
+  renderDoctorReport: () => renderDoctorReport,
+  renderReplayText: () => renderReplayText,
+  renderStatsReport: () => renderStatsReport,
+  replayLedger: () => replayLedger,
+  visualizeVaultGraph: () => visualizeVaultGraph
+});
+
+// src/diagnostics/doctor.ts
+import fs7 from "fs";
+import path8 from "path";
+import YAML2 from "yaml";
+
+// src/diagnostics/format.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m"
+};
+function supportsColor(enabledByOption) {
+  if (!enabledByOption) return false;
+  if (process.env.NO_COLOR) return false;
+  return process.stdout.isTTY === true;
+}
+function colorize(text, color, enabled) {
+  if (!enabled) return text;
+  if (!ANSI[color]) return text;
+  return `${ANSI[color]}${text}${ANSI.reset}`;
+}
+function dim(text, enabled) {
+  return colorize(text, "dim", enabled);
+}
+function parseDateToTimestamp(value, optionName) {
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Invalid ${optionName} value "${value}". Expected an ISO-8601 date/time.`);
+  }
+  return parsed;
+}
+function parsePositiveInt(rawValue, fallback, optionName) {
+  if (rawValue === void 0) return fallback;
+  const parsed = Number.parseInt(String(rawValue), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Invalid ${optionName} value "${rawValue}". Expected a positive integer.`);
+  }
+  return parsed;
+}
+function formatDurationHours(hours) {
+  if (!Number.isFinite(hours) || hours < 0) return "0h";
+  if (hours < 1) {
+    const minutes = Math.round(hours * 60);
+    return `${minutes}m`;
+  }
+  if (hours < 24) {
+    return `${hours.toFixed(2)}h`;
+  }
+  return `${(hours / 24).toFixed(2)}d`;
+}
+function inferPrimitiveTypeFromPath(targetPath) {
+  const normalized = String(targetPath).replace(/\\/g, "/");
+  const segment = normalized.split("/")[0]?.trim();
+  if (!segment) return null;
+  if (!normalized.endsWith(".md")) return null;
+  const singular = segment.endsWith("s") ? segment.slice(0, -1) : segment;
+  return singular || null;
+}
+
+// src/diagnostics/primitives.ts
+import path7 from "path";
+function loadPrimitiveInventory(workspacePath) {
+  const registry = loadRegistry(workspacePath);
+  const allPrimitives = queryPrimitives(workspacePath);
+  const byPath = /* @__PURE__ */ new Map();
+  const byType = /* @__PURE__ */ new Map();
+  const slugToPaths = /* @__PURE__ */ new Map();
+  const typeByDirectory = /* @__PURE__ */ new Map();
+  const typeDefs = /* @__PURE__ */ new Map();
+  for (const typeDef of Object.values(registry.types)) {
+    typeByDirectory.set(typeDef.directory, typeDef.name);
+    typeDefs.set(typeDef.name, typeDef);
+  }
+  const primitives = allPrimitives.map((instance) => {
+    const typeDef = typeDefs.get(instance.type);
+    const requiredFields = Object.entries(typeDef?.fields ?? {}).filter(([, fieldDef]) => fieldDef.required === true).map(([fieldName]) => fieldName);
+    const presentCount = requiredFields.filter((fieldName) => hasRequiredValue(instance.fields[fieldName])).length;
+    const frontmatterCompleteness = requiredFields.length === 0 ? 1 : presentCount / requiredFields.length;
+    const slug = path7.basename(instance.path, ".md");
+    return {
+      ...instance,
+      slug,
+      requiredFields,
+      frontmatterCompleteness
+    };
+  });
+  for (const primitive of primitives) {
+    byPath.set(primitive.path, primitive);
+    const existingByType = byType.get(primitive.type) ?? [];
+    existingByType.push(primitive);
+    byType.set(primitive.type, existingByType);
+    const existingBySlug = slugToPaths.get(primitive.slug) ?? [];
+    existingBySlug.push(primitive.path);
+    slugToPaths.set(primitive.slug, existingBySlug);
+  }
+  for (const list3 of byType.values()) {
+    list3.sort((a, b) => a.path.localeCompare(b.path));
+  }
+  for (const [slug, pathsForSlug] of slugToPaths.entries()) {
+    slugToPaths.set(slug, pathsForSlug.slice().sort((a, b) => a.localeCompare(b)));
+  }
+  return {
+    registry,
+    primitives: primitives.slice().sort((a, b) => a.path.localeCompare(b.path)),
+    byPath,
+    byType,
+    slugToPaths,
+    typeByDirectory,
+    typeDefs
+  };
+}
+function buildPrimitiveWikiGraph(workspacePath, inventoryInput) {
+  const inventory = inventoryInput ?? loadPrimitiveInventory(workspacePath);
+  const edgeSet = /* @__PURE__ */ new Set();
+  const outgoing = /* @__PURE__ */ new Map();
+  const incoming = /* @__PURE__ */ new Map();
+  const missingLinks = [];
+  const ambiguousLinks = [];
+  for (const primitive of inventory.primitives) {
+    if (!outgoing.has(primitive.path)) outgoing.set(primitive.path, /* @__PURE__ */ new Set());
+    if (!incoming.has(primitive.path)) incoming.set(primitive.path, /* @__PURE__ */ new Set());
+    for (const link of extractWikiLinks(primitive.body)) {
+      const resolved = resolvePrimitiveWikiTarget(link.rawTarget, inventory);
+      if (resolved.status === "resolved") {
+        const key = `${primitive.path}=>${resolved.path}`;
+        if (edgeSet.has(key)) continue;
+        edgeSet.add(key);
+        outgoing.get(primitive.path).add(resolved.path);
+        if (!incoming.has(resolved.path)) incoming.set(resolved.path, /* @__PURE__ */ new Set());
+        incoming.get(resolved.path).add(primitive.path);
+      } else if (resolved.status === "missing") {
+        missingLinks.push({
+          from: primitive.path,
+          token: link.token,
+          rawTarget: link.rawTarget,
+          normalizedTarget: resolved.normalizedTarget
+        });
+      } else if (resolved.status === "ambiguous") {
+        ambiguousLinks.push({
+          from: primitive.path,
+          token: link.token,
+          rawTarget: link.rawTarget,
+          normalizedTarget: resolved.normalizedTarget,
+          candidates: resolved.candidates
+        });
+      }
+    }
+  }
+  const edges = [...edgeSet].map((key) => {
+    const [from, to] = key.split("=>");
+    return { from, to };
+  }).sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+  const outgoingRecord = mapToSortedRecord(outgoing);
+  const incomingRecord = mapToSortedRecord(incoming);
+  const hubs = inventory.primitives.map((primitive) => ({
+    path: primitive.path,
+    degree: (outgoingRecord[primitive.path]?.length ?? 0) + (incomingRecord[primitive.path]?.length ?? 0)
+  })).filter((entry) => entry.degree > 0).sort((a, b) => b.degree - a.degree || a.path.localeCompare(b.path));
+  const orphanNodes = inventory.primitives.map((primitive) => primitive.path).filter((nodePath) => (outgoingRecord[nodePath]?.length ?? 0) === 0 && (incomingRecord[nodePath]?.length ?? 0) === 0).sort((a, b) => a.localeCompare(b));
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    nodes: inventory.primitives.map((primitive) => primitive.path),
+    edges,
+    outgoing: outgoingRecord,
+    incoming: incomingRecord,
+    hubs,
+    orphanNodes,
+    missingLinks: missingLinks.slice().sort((a, b) => a.from.localeCompare(b.from) || a.token.localeCompare(b.token)),
+    ambiguousLinks: ambiguousLinks.slice().sort((a, b) => a.from.localeCompare(b.from) || a.token.localeCompare(b.token))
+  };
+}
+function extractWikiLinks(markdown) {
+  const matches = markdown.matchAll(/\[\[([^[\]]+)\]\]/g);
+  const links = [];
+  for (const match of matches) {
+    const token = match[0];
+    const rawTarget = match[1]?.trim();
+    if (!token || !rawTarget) continue;
+    links.push({ token, rawTarget });
+  }
+  return links;
+}
+function resolvePrimitiveWikiTarget(rawTarget, inventory) {
+  const primary = rawTarget.split("|")[0]?.split("#")[0]?.trim() ?? "";
+  if (!primary) {
+    return { status: "non-primitive", normalizedTarget: "" };
+  }
+  if (/^https?:\/\//i.test(primary)) {
+    return { status: "external", normalizedTarget: primary };
+  }
+  const normalized = normalizeWikiTarget(primary);
+  if (normalized.includes("/")) {
+    if (inventory.byPath.has(normalized)) {
+      return { status: "resolved", normalizedTarget: normalized, path: normalized };
+    }
+    const directory = normalized.split("/")[0];
+    if (inventory.typeByDirectory.has(directory)) {
+      return { status: "missing", normalizedTarget: normalized };
+    }
+    return { status: "non-primitive", normalizedTarget: normalized };
+  }
+  const slug = normalized.replace(/\.md$/i, "");
+  const candidates = inventory.slugToPaths.get(slug) ?? [];
+  if (candidates.length === 1) {
+    return { status: "resolved", normalizedTarget: normalized, path: candidates[0] };
+  }
+  if (candidates.length > 1) {
+    return { status: "ambiguous", normalizedTarget: normalized, candidates };
+  }
+  return { status: "missing", normalizedTarget: normalized };
+}
+function normalizeWikiTarget(value) {
+  const normalized = value.replace(/\\/g, "/").replace(/^\.\//, "").trim();
+  if (!normalized) return normalized;
+  return normalized.endsWith(".md") ? normalized : `${normalized}.md`;
+}
+function hasRequiredValue(value) {
+  if (value === void 0 || value === null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  return true;
+}
+function mapToSortedRecord(source) {
+  const output = {};
+  const sortedKeys = [...source.keys()].sort((a, b) => a.localeCompare(b));
+  for (const key of sortedKeys) {
+    output[key] = [...source.get(key) ?? /* @__PURE__ */ new Set()].sort((a, b) => a.localeCompare(b));
+  }
+  return output;
+}
+
+// src/diagnostics/doctor.ts
+var DEFAULT_STALE_AFTER_MS = 60 * 60 * 1e3;
+var DOCTOR_ACTOR = "workgraph-doctor";
+function diagnoseVaultHealth(workspacePath, options = {}) {
+  const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
+  const fixEnabled = options.fix === true;
+  const fixActor = options.actor ?? DOCTOR_ACTOR;
+  const fixSummary = {
+    enabled: fixEnabled,
+    orphanLinksRemoved: 0,
+    staleClaimsReleased: 0,
+    staleRunsCancelled: 0,
+    filesUpdated: [],
+    errors: []
+  };
+  let findings = collectDoctorFindings(workspacePath, staleAfterMs);
+  if (fixEnabled) {
+    const orphanFix = removeOrphanLinks(workspacePath, findings.orphanLinks);
+    fixSummary.orphanLinksRemoved = orphanFix.removedLinks;
+    fixSummary.filesUpdated.push(...orphanFix.filesUpdated);
+    fixSummary.errors.push(...orphanFix.errors);
+    const staleClaimFix = releaseStaleClaims(workspacePath, findings.staleClaims);
+    fixSummary.staleClaimsReleased = staleClaimFix.released;
+    fixSummary.errors.push(...staleClaimFix.errors);
+    const staleRunFix = cancelStaleRuns(workspacePath, findings.staleRuns, fixActor);
+    fixSummary.staleRunsCancelled = staleRunFix.cancelled;
+    fixSummary.errors.push(...staleRunFix.errors);
+    if (fixSummary.orphanLinksRemoved > 0) {
+      refreshWikiLinkGraphIndex(workspacePath);
+    }
+    findings = collectDoctorFindings(workspacePath, staleAfterMs);
+  }
+  const warnings = findings.issues.filter((issue) => issue.severity === "warning").length;
+  const errors = findings.issues.filter((issue) => issue.severity === "error").length;
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspacePath,
+    ok: errors === 0,
+    summary: { errors, warnings },
+    checks: findings.checks,
+    issues: findings.issues,
+    fixes: {
+      ...fixSummary,
+      filesUpdated: fixSummary.filesUpdated.slice().sort((a, b) => a.localeCompare(b))
+    }
+  };
+}
+function collectDoctorFindings(workspacePath, staleAfterMs) {
+  const issues = [];
+  const now = Date.now();
+  let inventory = null;
+  try {
+    inventory = loadPrimitiveInventory(workspacePath);
+  } catch (error) {
+    issues.push({
+      code: "primitive-inventory-load-failed",
+      severity: "error",
+      message: `Failed to load primitive inventory: ${errorMessage2(error)}`
+    });
+  }
+  const primitiveGraph = inventory ? buildPrimitiveWikiGraph(workspacePath, inventory) : {
+    missingLinks: []
+  };
+  for (const orphan of primitiveGraph.missingLinks) {
+    issues.push({
+      code: "orphan-wiki-link",
+      severity: "warning",
+      message: `Orphan wiki-link in ${orphan.from}: ${orphan.token} -> ${orphan.normalizedTarget}`,
+      path: orphan.from,
+      details: {
+        token: orphan.token,
+        target: orphan.normalizedTarget
+      }
+    });
+  }
+  if (inventory) {
+    for (const primitive of inventory.primitives) {
+      for (const requiredField of primitive.requiredFields) {
+        if (isMissingRequiredValue(primitive.fields[requiredField])) {
+          issues.push({
+            code: "missing-required-field",
+            severity: "error",
+            message: `Missing required frontmatter field "${requiredField}" on ${primitive.path}`,
+            path: primitive.path,
+            details: {
+              field: requiredField,
+              type: primitive.type
+            }
+          });
+        }
+      }
+    }
+    for (const [slug, pathsForSlug] of inventory.slugToPaths.entries()) {
+      if (pathsForSlug.length <= 1) continue;
+      issues.push({
+        code: "duplicate-slug",
+        severity: "error",
+        message: `Duplicate slug "${slug}" is used by: ${pathsForSlug.join(", ")}`,
+        details: { slug, paths: pathsForSlug }
+      });
+    }
+  }
+  const staleClaims = collectStaleClaims(workspacePath, staleAfterMs, now);
+  for (const staleClaim of staleClaims) {
+    issues.push({
+      code: "stale-claim",
+      severity: "warning",
+      message: `Stale claim on ${staleClaim.target} by ${staleClaim.owner} (${formatDurationHours(staleClaim.ageMs / 36e5)} old)`,
+      path: staleClaim.target,
+      details: {
+        owner: staleClaim.owner,
+        claimedAt: staleClaim.claimedAt
+      }
+    });
+  }
+  const staleRuns = collectStaleRuns(workspacePath, staleAfterMs, now);
+  for (const staleRun of staleRuns) {
+    issues.push({
+      code: "stale-run",
+      severity: "warning",
+      message: `Run ${staleRun.id} is stuck in running for ${formatDurationHours(staleRun.ageMs / 36e5)}`,
+      details: {
+        runId: staleRun.id,
+        actor: staleRun.actor,
+        updatedAt: staleRun.updatedAt
+      }
+    });
+  }
+  const registryIssues = collectPrimitiveRegistryReferenceIssues(workspacePath, inventory);
+  issues.push(...registryIssues);
+  if (inventory) {
+    const emptyDirectoryIssues = collectEmptyPrimitiveDirectoryIssues(workspacePath, inventory);
+    issues.push(...emptyDirectoryIssues);
+  }
+  const checks = {
+    orphanWikiLinks: countIssues(issues, "orphan-wiki-link"),
+    staleClaims: countIssues(issues, "stale-claim"),
+    staleRuns: countIssues(issues, "stale-run"),
+    missingRequiredFields: countIssues(issues, "missing-required-field"),
+    brokenPrimitiveRegistryReferences: countIssues(issues, "broken-primitive-registry-reference"),
+    emptyPrimitiveDirectories: countIssues(issues, "empty-primitive-directory"),
+    duplicateSlugs: countIssues(issues, "duplicate-slug")
+  };
+  return {
+    issues: issues.sort((a, b) => severityRank(a.severity) - severityRank(b.severity) || a.code.localeCompare(b.code)),
+    checks,
+    orphanLinks: primitiveGraph.missingLinks,
+    staleClaims,
+    staleRuns
+  };
+}
+function collectStaleClaims(workspacePath, staleAfterMs, now) {
+  const staleClaims = [];
+  const claims = allClaims(workspacePath);
+  for (const [target, owner] of claims.entries()) {
+    const history = historyOf(workspacePath, target);
+    const lastClaim = history.slice().reverse().find((entry) => entry.op === "claim");
+    if (!lastClaim) continue;
+    const claimTs = Date.parse(lastClaim.ts);
+    if (!Number.isFinite(claimTs)) continue;
+    const ageMs = now - claimTs;
+    if (ageMs <= staleAfterMs) continue;
+    staleClaims.push({
+      target,
+      owner,
+      claimedAt: lastClaim.ts,
+      ageMs
+    });
+  }
+  return staleClaims.sort((a, b) => b.ageMs - a.ageMs || a.target.localeCompare(b.target));
+}
+function collectStaleRuns(workspacePath, staleAfterMs, now) {
+  const runs = readDispatchRunsSnapshot(workspacePath).filter((run) => run.status === "running");
+  const staleRuns = [];
+  for (const run of runs) {
+    const updatedTs = Date.parse(run.updatedAt);
+    if (!Number.isFinite(updatedTs)) continue;
+    const ageMs = now - updatedTs;
+    if (ageMs <= staleAfterMs) continue;
+    staleRuns.push({
+      id: run.id,
+      actor: run.actor,
+      updatedAt: run.updatedAt,
+      ageMs
+    });
+  }
+  return staleRuns.sort((a, b) => b.ageMs - a.ageMs || a.id.localeCompare(b.id));
+}
+function collectPrimitiveRegistryReferenceIssues(workspacePath, inventory) {
+  const issues = [];
+  const manifestPath = path8.join(workspacePath, ".workgraph", "primitive-registry.yaml");
+  if (!fs7.existsSync(manifestPath)) {
+    issues.push({
+      code: "broken-primitive-registry-reference",
+      severity: "error",
+      message: "Missing .workgraph/primitive-registry.yaml",
+      path: ".workgraph/primitive-registry.yaml"
+    });
+    return issues;
+  }
+  let parsed;
+  try {
+    parsed = YAML2.parse(fs7.readFileSync(manifestPath, "utf-8"));
+  } catch (error) {
+    issues.push({
+      code: "broken-primitive-registry-reference",
+      severity: "error",
+      message: `Unable to parse primitive-registry.yaml: ${errorMessage2(error)}`,
+      path: ".workgraph/primitive-registry.yaml"
+    });
+    return issues;
+  }
+  const primitives = parsed?.primitives;
+  if (!Array.isArray(primitives)) {
+    issues.push({
+      code: "broken-primitive-registry-reference",
+      severity: "error",
+      message: 'primitive-registry.yaml is missing a "primitives" array.',
+      path: ".workgraph/primitive-registry.yaml"
+    });
+    return issues;
+  }
+  const seenNames = /* @__PURE__ */ new Map();
+  for (const primitiveEntry of primitives) {
+    const name = String(primitiveEntry.name ?? "").trim();
+    const directory = String(primitiveEntry.directory ?? "").trim();
+    if (!name || !directory) {
+      issues.push({
+        code: "broken-primitive-registry-reference",
+        severity: "error",
+        message: "primitive-registry.yaml contains an entry with missing name or directory.",
+        path: ".workgraph/primitive-registry.yaml"
+      });
+      continue;
+    }
+    seenNames.set(name, (seenNames.get(name) ?? 0) + 1);
+    const registryType = inventory?.typeDefs.get(name);
+    if (!registryType) {
+      issues.push({
+        code: "broken-primitive-registry-reference",
+        severity: "error",
+        message: `primitive-registry.yaml references unknown primitive "${name}".`,
+        path: ".workgraph/primitive-registry.yaml"
+      });
+      continue;
+    }
+    if (registryType.directory !== directory) {
+      issues.push({
+        code: "broken-primitive-registry-reference",
+        severity: "error",
+        message: `primitive-registry.yaml directory mismatch for "${name}": expected "${registryType.directory}", got "${directory}".`,
+        path: ".workgraph/primitive-registry.yaml"
+      });
+    }
+    if (!fs7.existsSync(path8.join(workspacePath, directory))) {
+      issues.push({
+        code: "broken-primitive-registry-reference",
+        severity: "error",
+        message: `primitive-registry.yaml references missing directory "${directory}/".`,
+        path: ".workgraph/primitive-registry.yaml"
+      });
+    }
+  }
+  for (const [name, count] of seenNames.entries()) {
+    if (count <= 1) continue;
+    issues.push({
+      code: "broken-primitive-registry-reference",
+      severity: "error",
+      message: `primitive-registry.yaml has duplicate entries for primitive "${name}".`,
+      path: ".workgraph/primitive-registry.yaml"
+    });
+  }
+  if (inventory) {
+    const manifestNames = new Set(primitives.map((entry) => String(entry.name ?? "").trim()).filter(Boolean));
+    for (const typeName of inventory.typeDefs.keys()) {
+      if (manifestNames.has(typeName)) continue;
+      issues.push({
+        code: "broken-primitive-registry-reference",
+        severity: "warning",
+        message: `Registry type "${typeName}" is missing from primitive-registry.yaml.`,
+        path: ".workgraph/primitive-registry.yaml"
+      });
+    }
+  }
+  return issues;
+}
+function collectEmptyPrimitiveDirectoryIssues(workspacePath, inventory) {
+  const issues = [];
+  for (const typeDef of inventory.typeDefs.values()) {
+    const directoryPath = path8.join(workspacePath, typeDef.directory);
+    if (!fs7.existsSync(directoryPath)) continue;
+    const markdownCount = listMarkdownFilesRecursive(directoryPath).length;
+    if (markdownCount > 0) continue;
+    issues.push({
+      code: "empty-primitive-directory",
+      severity: "warning",
+      message: `Primitive directory "${typeDef.directory}/" is empty.`,
+      path: `${typeDef.directory}/`,
+      details: {
+        type: typeDef.name
+      }
+    });
+  }
+  return issues;
+}
+function removeOrphanLinks(workspacePath, orphanLinks) {
+  const errors = [];
+  const filesUpdated = [];
+  if (orphanLinks.length === 0) {
+    return { removedLinks: 0, filesUpdated, errors };
+  }
+  const tokensBySource = /* @__PURE__ */ new Map();
+  for (const orphan of orphanLinks) {
+    const tokenSet = tokensBySource.get(orphan.from) ?? /* @__PURE__ */ new Set();
+    tokenSet.add(orphan.token);
+    tokensBySource.set(orphan.from, tokenSet);
+  }
+  let removedLinks = 0;
+  for (const [sourcePath, tokenSet] of tokensBySource.entries()) {
+    const absPath = path8.join(workspacePath, sourcePath);
+    if (!fs7.existsSync(absPath)) continue;
+    try {
+      const raw = fs7.readFileSync(absPath, "utf-8");
+      let fileRemoved = 0;
+      const updated = raw.replace(/\[\[([^[\]]+)\]\]/g, (token) => {
+        if (!tokenSet.has(token)) return token;
+        fileRemoved += 1;
+        return "";
+      });
+      if (fileRemoved === 0) continue;
+      fs7.writeFileSync(absPath, updated, "utf-8");
+      removedLinks += fileRemoved;
+      filesUpdated.push(sourcePath);
+    } catch (error) {
+      errors.push(`Failed to remove orphan links from ${sourcePath}: ${errorMessage2(error)}`);
+    }
+  }
+  return {
+    removedLinks,
+    filesUpdated: filesUpdated.sort((a, b) => a.localeCompare(b)),
+    errors
+  };
+}
+function releaseStaleClaims(workspacePath, staleClaims) {
+  const errors = [];
+  let released = 0;
+  for (const staleClaim of staleClaims) {
+    try {
+      release(
+        workspacePath,
+        staleClaim.target,
+        staleClaim.owner,
+        "Auto-release stale claim by workgraph doctor"
+      );
+      released += 1;
+    } catch (error) {
+      const fallbackActor = staleClaim.owner || DOCTOR_ACTOR;
+      try {
+        append(workspacePath, fallbackActor, "release", staleClaim.target, "thread", {
+          reason: "Auto-release stale claim by workgraph doctor"
+        });
+        const existing = read(workspacePath, staleClaim.target);
+        if (existing) {
+          update(
+            workspacePath,
+            staleClaim.target,
+            { status: "open", owner: null },
+            void 0,
+            fallbackActor
+          );
+        }
+        released += 1;
+      } catch (fallbackError) {
+        errors.push(
+          `Failed to release stale claim ${staleClaim.target}: ${errorMessage2(error)} / fallback: ${errorMessage2(fallbackError)}`
+        );
+      }
+    }
+  }
+  return { released, errors };
+}
+function cancelStaleRuns(workspacePath, staleRuns, actor) {
+  const errors = [];
+  let cancelled = 0;
+  for (const staleRun of staleRuns) {
+    try {
+      stop(workspacePath, staleRun.id, actor);
+      cancelled += 1;
+    } catch (error) {
+      errors.push(`Failed to cancel stale run ${staleRun.id}: ${errorMessage2(error)}`);
+    }
+  }
+  return { cancelled, errors };
+}
+function readDispatchRunsSnapshot(workspacePath) {
+  const runsPath = path8.join(workspacePath, ".workgraph", "dispatch-runs.json");
+  if (!fs7.existsSync(runsPath)) return [];
+  try {
+    const parsed = JSON.parse(fs7.readFileSync(runsPath, "utf-8"));
+    return Array.isArray(parsed.runs) ? parsed.runs : [];
+  } catch {
+    return [];
+  }
+}
+function listMarkdownFilesRecursive(rootDirectory) {
+  const files = [];
+  const stack = [rootDirectory];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const entries = fs7.readdirSync(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const absPath = path8.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(absPath);
+        continue;
+      }
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        files.push(absPath);
+      }
+    }
+  }
+  return files;
+}
+function isMissingRequiredValue(value) {
+  if (value === void 0 || value === null) return true;
+  if (typeof value === "string") return value.trim().length === 0;
+  return false;
+}
+function countIssues(issues, code) {
+  return issues.filter((issue) => issue.code === code).length;
+}
+function severityRank(severity) {
+  return severity === "error" ? 0 : 1;
+}
+function errorMessage2(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+// src/diagnostics/replay.ts
+function replayLedger(workspacePath, options = {}) {
+  const sinceTs = options.since ? parseDateToTimestamp(options.since, "--since") : null;
+  const untilTs = options.until ? parseDateToTimestamp(options.until, "--until") : null;
+  if (options.type && !isReplayTypeFilter(options.type)) {
+    throw new Error(`Invalid --type "${options.type}". Expected create|update|transition.`);
+  }
+  const allEntries = readAll(workspacePath);
+  const ordered = allEntries.map((entry, index) => ({ entry, index })).sort((a, b) => {
+    const aTs = Date.parse(a.entry.ts);
+    const bTs = Date.parse(b.entry.ts);
+    const safeA = Number.isFinite(aTs) ? aTs : Number.MAX_SAFE_INTEGER;
+    const safeB = Number.isFinite(bTs) ? bTs : Number.MAX_SAFE_INTEGER;
+    return safeA - safeB || a.index - b.index;
+  }).map((item) => item.entry);
+  const events = ordered.filter((entry) => matchesReplayFilters(entry, options, sinceTs, untilTs)).map((entry) => mapReplayEvent(entry));
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspacePath,
+    filters: {
+      ...options.type ? { type: options.type } : {},
+      ...options.actor ? { actor: options.actor } : {},
+      ...options.primitive ? { primitive: options.primitive } : {},
+      ...options.since ? { since: options.since } : {},
+      ...options.until ? { until: options.until } : {}
+    },
+    totalEvents: allEntries.length,
+    events
+  };
+}
+function renderReplayText(report, options = {}) {
+  if (report.events.length === 0) {
+    return ["No ledger events matched the provided filters."];
+  }
+  const colorEnabled = supportsColor(options.color !== false);
+  const lines = [];
+  for (const event of report.events) {
+    const categoryColor = event.category === "create" ? "green" : event.category === "update" ? "yellow" : "cyan";
+    const categoryTag = colorize(event.category.toUpperCase().padEnd(10, " "), categoryColor, colorEnabled);
+    const ts = dim(event.ts, colorEnabled);
+    lines.push(`${ts} ${categoryTag} ${event.op.padEnd(8, " ")} ${event.actor} -> ${event.target}`);
+    if (event.diff) {
+      if (event.diff.changedFields.length > 0) {
+        lines.push(`  ${dim("\u0394 changed", colorEnabled)}: ${event.diff.changedFields.join(", ")}`);
+      }
+      if (event.diff.statusTransition) {
+        lines.push(
+          `  ${dim("\u0394 status", colorEnabled)}: ${String(event.diff.statusTransition.from)} -> ${String(event.diff.statusTransition.to)}`
+        );
+      }
+    }
+  }
+  return lines;
+}
+function mapReplayEvent(entry) {
+  const category = categoryForOp(entry.op);
+  const diff = entry.op === "update" ? summarizeUpdateDiff(entry) : void 0;
+  return {
+    ts: entry.ts,
+    actor: entry.actor,
+    op: entry.op,
+    target: entry.target,
+    primitiveType: entry.type,
+    category,
+    ...diff ? { diff } : {}
+  };
+}
+function summarizeUpdateDiff(entry) {
+  const changed = Array.isArray(entry.data?.changed) ? entry.data?.changed.map((field) => String(field)) : [];
+  const fromStatus = toNullableString(entry.data?.from_status);
+  const toStatus = toNullableString(entry.data?.to_status);
+  if (changed.length === 0 && fromStatus === void 0 && toStatus === void 0) {
+    return void 0;
+  }
+  return {
+    changedFields: changed,
+    ...fromStatus !== void 0 || toStatus !== void 0 ? {
+      statusTransition: {
+        from: fromStatus ?? null,
+        to: toStatus ?? null
+      }
+    } : {}
+  };
+}
+function matchesReplayFilters(entry, options, sinceTs, untilTs) {
+  if (options.type && categoryForOp(entry.op) !== options.type) return false;
+  if (options.actor && entry.actor !== options.actor) return false;
+  if (options.primitive) {
+    const primitiveFilter = options.primitive.toLowerCase();
+    const target = entry.target.toLowerCase();
+    const type = String(entry.type ?? "").toLowerCase();
+    if (!target.includes(primitiveFilter) && type !== primitiveFilter) return false;
+  }
+  if (sinceTs !== null || untilTs !== null) {
+    const eventTs = Date.parse(entry.ts);
+    if (!Number.isFinite(eventTs)) return false;
+    if (sinceTs !== null && eventTs < sinceTs) return false;
+    if (untilTs !== null && eventTs > untilTs) return false;
+  }
+  return true;
+}
+function categoryForOp(op) {
+  if (op === "create") return "create";
+  if (op === "update") return "update";
+  return "transition";
+}
+function isReplayTypeFilter(value) {
+  return value === "create" || value === "update" || value === "transition";
+}
+function toNullableString(value) {
+  if (value === void 0) return void 0;
+  if (value === null) return null;
+  return String(value);
+}
+
+// src/diagnostics/viz.ts
+import path9 from "path";
+var TYPE_COLORS = ["cyan", "magenta", "yellow", "green", "blue", "red"];
+function visualizeVaultGraph(workspacePath, options = {}) {
+  const inventory = loadPrimitiveInventory(workspacePath);
+  const primitiveGraph = buildPrimitiveWikiGraph(workspacePath, inventory);
+  const depth = normalizeDepth(options.depth);
+  const top = normalizeTop(options.top);
+  const colorEnabled = supportsColor(options.color !== false);
+  const typeColorMap = buildTypeColorMap(inventory);
+  const labelForNode = (nodePath) => {
+    const primitive = inventory.byPath.get(nodePath);
+    const typeName = primitive?.type ?? "unknown";
+    const base = `${nodePath} [${typeName}]`;
+    const typeColor = typeColorMap.get(typeName) ?? "gray";
+    return colorize(base, typeColor, colorEnabled);
+  };
+  let rendered = "";
+  let focusPath;
+  if (options.focus) {
+    focusPath = resolveFocusPath(options.focus, inventory);
+    rendered = renderFocusedGraph(focusPath, primitiveGraph, depth, labelForNode, colorEnabled);
+  } else {
+    rendered = renderTopHubGraph(primitiveGraph, depth, top, labelForNode, colorEnabled);
+  }
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspacePath,
+    nodeCount: primitiveGraph.nodes.length,
+    edgeCount: primitiveGraph.edges.length,
+    hubs: primitiveGraph.hubs,
+    ...focusPath ? { focus: focusPath } : {},
+    rendered
+  };
+}
+function renderFocusedGraph(focusPath, graph, depth, labelForNode, colorEnabled) {
+  const outgoing = graph.outgoing[focusPath] ?? [];
+  const incoming = graph.incoming[focusPath] ?? [];
+  const lines = [];
+  lines.push(labelForNode(focusPath));
+  const hasOutgoing = outgoing.length > 0;
+  const hasIncoming = incoming.length > 0;
+  if (!hasOutgoing && !hasIncoming) {
+    lines.push(`\u2514\u2500 ${dim("(no links)", colorEnabled)}`);
+    return lines.join("\n");
+  }
+  const sections = [];
+  if (outgoing.length > 0) {
+    sections.push({ title: "Outgoing", neighbors: outgoing, map: graph.outgoing, arrow: "\u25B6" });
+  }
+  if (incoming.length > 0) {
+    sections.push({ title: "Incoming", neighbors: incoming, map: graph.incoming, arrow: "\u25C0" });
+  }
+  sections.forEach((section, index) => {
+    const isLastSection = index === sections.length - 1;
+    lines.push(`${isLastSection ? "\u2514" : "\u251C"}\u2500 ${section.title}`);
+    renderNeighbors({
+      lines,
+      map: section.map,
+      neighbors: section.neighbors,
+      depthRemaining: depth,
+      prefix: isLastSection ? "   " : "\u2502  ",
+      arrow: section.arrow,
+      labelForNode,
+      colorEnabled,
+      ancestors: /* @__PURE__ */ new Set([focusPath])
+    });
+  });
+  return lines.join("\n");
+}
+function renderTopHubGraph(graph, depth, top, labelForNode, colorEnabled) {
+  const lines = [];
+  const hubs = graph.hubs.slice(0, top);
+  const roots = graph.nodes.length > top ? hubs.map((hub) => hub.path) : graph.nodes.slice().sort((a, b) => a.localeCompare(b));
+  const isTruncated = graph.nodes.length > top;
+  roots.forEach((root, rootIndex) => {
+    lines.push(labelForNode(root));
+    const neighbors = graph.outgoing[root] ?? [];
+    if (neighbors.length === 0) {
+      lines.push(`\u2514\u2500 ${dim("(no outgoing links)", colorEnabled)}`);
+    } else {
+      renderNeighbors({
+        lines,
+        map: graph.outgoing,
+        neighbors,
+        depthRemaining: depth,
+        prefix: "",
+        arrow: "\u25B6",
+        labelForNode,
+        colorEnabled,
+        ancestors: /* @__PURE__ */ new Set([root])
+      });
+    }
+    if (rootIndex !== roots.length - 1) {
+      lines.push("");
+    }
+  });
+  if (isTruncated) {
+    lines.push("");
+    lines.push(dim(`Showing top ${roots.length} most-connected nodes of ${graph.nodes.length}.`, colorEnabled));
+  }
+  return lines.join("\n");
+}
+function renderNeighbors(params) {
+  if (params.depthRemaining <= 0) return;
+  const sortedNeighbors = params.neighbors.slice().sort((a, b) => a.localeCompare(b));
+  sortedNeighbors.forEach((neighbor, index) => {
+    const isLast = index === sortedNeighbors.length - 1;
+    const branch = isLast ? "\u2514" : "\u251C";
+    const cycle = params.ancestors.has(neighbor);
+    const cycleTag = cycle ? ` ${dim("(cycle)", params.colorEnabled)}` : "";
+    params.lines.push(`${params.prefix}${branch}\u2500${params.arrow} ${params.labelForNode(neighbor)}${cycleTag}`);
+    if (cycle || params.depthRemaining <= 1) return;
+    const nextPrefix = `${params.prefix}${isLast ? "   " : "\u2502  "}`;
+    const nextAncestors = new Set(params.ancestors);
+    nextAncestors.add(neighbor);
+    renderNeighbors({
+      ...params,
+      neighbors: params.map[neighbor] ?? [],
+      depthRemaining: params.depthRemaining - 1,
+      prefix: nextPrefix,
+      ancestors: nextAncestors
+    });
+  });
+}
+function normalizeDepth(depth) {
+  if (depth === void 0) return 2;
+  return parsePositiveInt(String(depth), 2, "--depth");
+}
+function normalizeTop(top) {
+  if (top === void 0) return 10;
+  return parsePositiveInt(String(top), 10, "--top");
+}
+function resolveFocusPath(focusInput, inventory) {
+  const normalized = focusInput.replace(/\\/g, "/").trim();
+  if (!normalized) {
+    throw new Error("--focus value cannot be empty.");
+  }
+  const directCandidate = normalized.endsWith(".md") ? normalized : `${normalized}.md`;
+  if (inventory.byPath.has(normalized)) return normalized;
+  if (inventory.byPath.has(directCandidate)) return directCandidate;
+  const slug = path9.basename(normalized, ".md");
+  const candidates = inventory.slugToPaths.get(slug) ?? [];
+  if (candidates.length === 1) return candidates[0];
+  if (candidates.length > 1) {
+    throw new Error(`Focus slug "${focusInput}" is ambiguous: ${candidates.join(", ")}`);
+  }
+  throw new Error(`Focus node "${focusInput}" was not found.`);
+}
+function buildTypeColorMap(inventory) {
+  const map = /* @__PURE__ */ new Map();
+  const typeNames = [...inventory.typeDefs.keys()].sort((a, b) => a.localeCompare(b));
+  typeNames.forEach((typeName, index) => {
+    map.set(typeName, TYPE_COLORS[index % TYPE_COLORS.length]);
+  });
+  return map;
+}
+
+// src/diagnostics/stats.ts
+function computeVaultStats(workspacePath) {
+  const inventory = loadPrimitiveInventory(workspacePath);
+  const primitiveGraph = buildPrimitiveWikiGraph(workspacePath, inventory);
+  const byType = buildPrimitiveCountByType(inventory.primitives);
+  const frontmatter = computeFrontmatterStats(inventory.primitives);
+  const allEntries = readAll(workspacePath);
+  const eventRate = computeEventRatePerDay(allEntries);
+  const threadVelocity = computeThreadVelocity(workspacePath, inventory.byType.get("thread") ?? []);
+  const nodeCount = primitiveGraph.nodes.length;
+  const edgeCount = primitiveGraph.edges.length;
+  const possibleDirectedEdges = nodeCount > 1 ? nodeCount * (nodeCount - 1) : 0;
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspacePath,
+    primitives: {
+      total: inventory.primitives.length,
+      byType
+    },
+    links: {
+      total: edgeCount,
+      wikiLinkDensity: nodeCount > 0 ? edgeCount / nodeCount : 0,
+      graphDensityRatio: possibleDirectedEdges > 0 ? edgeCount / possibleDirectedEdges : 0,
+      orphanCount: primitiveGraph.missingLinks.length,
+      orphanNodeCount: primitiveGraph.orphanNodes.length,
+      mostConnectedNodes: primitiveGraph.hubs.slice(0, 10)
+    },
+    frontmatter,
+    ledger: {
+      totalEvents: allEntries.length,
+      eventRatePerDay: eventRate
+    },
+    threads: threadVelocity
+  };
+}
+function buildPrimitiveCountByType(primitives) {
+  const byType = primitives.reduce((acc, primitive) => {
+    acc[primitive.type] = (acc[primitive.type] ?? 0) + 1;
+    return acc;
+  }, {});
+  return Object.keys(byType).sort((a, b) => a.localeCompare(b)).reduce((acc, typeName) => {
+    acc[typeName] = byType[typeName];
+    return acc;
+  }, {});
+}
+function computeFrontmatterStats(primitives) {
+  if (primitives.length === 0) {
+    return {
+      averageCompleteness: 1,
+      byType: {}
+    };
+  }
+  const totalsByType = /* @__PURE__ */ new Map();
+  let sum = 0;
+  for (const primitive of primitives) {
+    sum += primitive.frontmatterCompleteness;
+    const current = totalsByType.get(primitive.type) ?? { sum: 0, count: 0 };
+    current.sum += primitive.frontmatterCompleteness;
+    current.count += 1;
+    totalsByType.set(primitive.type, current);
+  }
+  const byType = [...totalsByType.entries()].sort((a, b) => a[0].localeCompare(b[0])).reduce((acc, [typeName, stats]) => {
+    acc[typeName] = stats.count > 0 ? stats.sum / stats.count : 1;
+    return acc;
+  }, {});
+  return {
+    averageCompleteness: sum / primitives.length,
+    byType
+  };
+}
+function computeEventRatePerDay(entries) {
+  if (entries.length === 0) {
+    return {
+      average: 0,
+      byDay: []
+    };
+  }
+  const byDay = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const day = entry.ts.slice(0, 10);
+    if (!day) continue;
+    byDay.set(day, (byDay.get(day) ?? 0) + 1);
+  }
+  const dayCounts = [...byDay.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([day, count]) => ({ day, count }));
+  const totalCount = dayCounts.reduce((acc, item) => acc + item.count, 0);
+  return {
+    average: dayCounts.length > 0 ? totalCount / dayCounts.length : 0,
+    byDay: dayCounts
+  };
+}
+function computeThreadVelocity(workspacePath, threads) {
+  const durationsHours = [];
+  for (const thread of threads) {
+    const history = historyOf(workspacePath, thread.path);
+    const createEntry = history.find((entry) => entry.op === "create");
+    const completionEntry = history.find(
+      (entry) => entry.op === "done" || entry.op === "update" && String(entry.data?.to_status ?? "") === "done"
+    );
+    if (!createEntry || !completionEntry) continue;
+    const start = Date.parse(createEntry.ts);
+    const end = Date.parse(completionEntry.ts);
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end < start) continue;
+    durationsHours.push((end - start) / (1e3 * 60 * 60));
+  }
+  const sum = durationsHours.reduce((acc, value) => acc + value, 0);
+  return {
+    completedCount: durationsHours.length,
+    averageOpenToDoneHours: durationsHours.length > 0 ? sum / durationsHours.length : 0
+  };
+}
+
+// src/diagnostics/changelog.ts
+function generateLedgerChangelog(workspacePath, options) {
+  const sinceTs = parseDateToTimestamp(options.since, "--since");
+  const untilTs = options.until ? parseDateToTimestamp(options.until, "--until") : null;
+  const allEntries = readAll(workspacePath);
+  const grouped = /* @__PURE__ */ new Map();
+  let matchedEventCount = 0;
+  for (const entry of allEntries) {
+    const eventTs = Date.parse(entry.ts);
+    if (!Number.isFinite(eventTs)) continue;
+    if (eventTs < sinceTs) continue;
+    if (untilTs !== null && eventTs > untilTs) continue;
+    const action = categorizeEntry(entry);
+    if (!action) continue;
+    matchedEventCount += 1;
+    const day = entry.ts.slice(0, 10);
+    const primitiveType = entry.type ?? inferPrimitiveTypeFromPath(entry.target) ?? "unknown";
+    const dayGroup = grouped.get(day) ?? {
+      created: /* @__PURE__ */ new Map(),
+      updated: /* @__PURE__ */ new Map(),
+      completed: /* @__PURE__ */ new Map()
+    };
+    const byType = dayGroup[action];
+    const items = byType.get(primitiveType) ?? [];
+    items.push({
+      ts: entry.ts,
+      actor: entry.actor,
+      op: entry.op,
+      target: entry.target,
+      summary: buildEntrySummary(entry)
+    });
+    byType.set(primitiveType, items);
+    grouped.set(day, dayGroup);
+  }
+  const days = [...grouped.entries()].sort((a, b) => b[0].localeCompare(a[0])).map(([day, dayGroup]) => ({
+    day,
+    created: normalizeTypeGroups(dayGroup.created),
+    updated: normalizeTypeGroups(dayGroup.updated),
+    completed: normalizeTypeGroups(dayGroup.completed)
+  }));
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspacePath,
+    since: options.since,
+    ...options.until ? { until: options.until } : {},
+    totalEvents: matchedEventCount,
+    days
+  };
+}
+function renderChangelogText(report) {
+  if (report.days.length === 0) {
+    return [`No changelog activity found since ${report.since}.`];
+  }
+  const lines = [];
+  lines.push(`Changelog since ${report.since}${report.until ? ` until ${report.until}` : ""}`);
+  lines.push("");
+  for (const day of report.days) {
+    lines.push(`${day.day}`);
+    lines.push(...renderActionGroup("Created", day.created));
+    lines.push(...renderActionGroup("Updated", day.updated));
+    lines.push(...renderActionGroup("Completed", day.completed));
+    lines.push("");
+  }
+  return lines;
+}
+function renderActionGroup(title, groups) {
+  if (groups.length === 0) {
+    return [`  ${title}: none`];
+  }
+  const lines = [`  ${title}:`];
+  for (const group of groups) {
+    lines.push(`    - ${group.primitiveType}:`);
+    for (const item of group.items) {
+      const time = item.ts.slice(11, 19);
+      const summarySuffix = item.summary ? ` \u2014 ${item.summary}` : "";
+      lines.push(`      - [${time}] ${item.target} (${item.actor})${summarySuffix}`);
+    }
+  }
+  return lines;
+}
+function normalizeTypeGroups(byType) {
+  return [...byType.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([primitiveType, items]) => ({
+    primitiveType,
+    items: items.slice().sort((a, b) => a.ts.localeCompare(b.ts) || a.target.localeCompare(b.target))
+  }));
+}
+function categorizeEntry(entry) {
+  if (entry.op === "create") return "created";
+  if (entry.op === "done") return "completed";
+  if (entry.op === "update") {
+    const toStatus = String(entry.data?.to_status ?? "");
+    if (isCompletedStatus(toStatus)) return "completed";
+    return "updated";
+  }
+  return null;
+}
+function isCompletedStatus(status) {
+  const normalized = status.toLowerCase();
+  return normalized === "done" || normalized === "succeeded" || normalized === "completed" || normalized === "closed";
+}
+function buildEntrySummary(entry) {
+  if (entry.op === "create") {
+    return entry.data?.title ? `title: ${String(entry.data.title)}` : void 0;
+  }
+  if (entry.op === "update") {
+    const changed = Array.isArray(entry.data?.changed) ? entry.data?.changed.map((value) => String(value)) : [];
+    if (changed.length > 0) return `changed: ${changed.join(", ")}`;
+    if (entry.data?.to_status) return `status: ${String(entry.data?.to_status)}`;
+    return void 0;
+  }
+  if (entry.op === "done" && entry.data?.output) {
+    return `output: ${String(entry.data.output)}`;
+  }
+  return void 0;
+}
+
+// src/diagnostics/render.ts
+function renderDoctorReport(report) {
+  const lines = [];
+  lines.push(`Vault health: ${report.ok ? "OK" : "NOT OK"}`);
+  lines.push(`Errors: ${report.summary.errors}  Warnings: ${report.summary.warnings}`);
+  lines.push(
+    `Checks: orphan_links=${report.checks.orphanWikiLinks} stale_claims=${report.checks.staleClaims} stale_runs=${report.checks.staleRuns} missing_required=${report.checks.missingRequiredFields} broken_registry_refs=${report.checks.brokenPrimitiveRegistryReferences} empty_dirs=${report.checks.emptyPrimitiveDirectories} duplicate_slugs=${report.checks.duplicateSlugs}`
+  );
+  if (report.fixes.enabled) {
+    lines.push(
+      `Auto-fix: removed_orphan_links=${report.fixes.orphanLinksRemoved} released_stale_claims=${report.fixes.staleClaimsReleased} cancelled_stale_runs=${report.fixes.staleRunsCancelled}`
+    );
+    if (report.fixes.filesUpdated.length > 0) {
+      lines.push(`Updated files: ${report.fixes.filesUpdated.join(", ")}`);
+    }
+    if (report.fixes.errors.length > 0) {
+      lines.push(`Fix errors: ${report.fixes.errors.length}`);
+      for (const error of report.fixes.errors) {
+        lines.push(`  - ${error}`);
+      }
+    }
+  }
+  if (report.issues.length === 0) {
+    lines.push("No issues detected.");
+    return lines;
+  }
+  lines.push("Issues:");
+  for (const issue of report.issues) {
+    const pathSuffix = issue.path ? ` (${issue.path})` : "";
+    lines.push(`- [${issue.severity.toUpperCase()}] ${issue.code}${pathSuffix}: ${issue.message}`);
+  }
+  return lines;
+}
+function renderStatsReport(stats) {
+  const lines = [];
+  lines.push(`Primitives: total=${stats.primitives.total}`);
+  lines.push(
+    `By type: ${Object.entries(stats.primitives.byType).map(([type, count]) => `${type}=${count}`).join(", ") || "none"}`
+  );
+  lines.push(
+    `Links: total=${stats.links.total} density=${stats.links.wikiLinkDensity.toFixed(2)} orphan_links=${stats.links.orphanCount} orphan_nodes=${stats.links.orphanNodeCount}`
+  );
+  lines.push(
+    `Top hubs: ${stats.links.mostConnectedNodes.slice(0, 5).map((hub) => `${hub.path}(${hub.degree})`).join(", ") || "none"}`
+  );
+  lines.push(
+    `Frontmatter completeness: avg=${(stats.frontmatter.averageCompleteness * 100).toFixed(1)}%`
+  );
+  lines.push(
+    `Ledger event rate/day: avg=${stats.ledger.eventRatePerDay.average.toFixed(2)} over ${stats.ledger.eventRatePerDay.byDay.length} day(s)`
+  );
+  lines.push(
+    `Thread velocity: completed=${stats.threads.completedCount} avg_open_to_done=${formatDurationHours(stats.threads.averageOpenToDoneHours)}`
+  );
+  return lines;
+}
+
+// src/autonomy-daemon.ts
+var autonomy_daemon_exports = {};
+__export(autonomy_daemon_exports, {
+  readAutonomyDaemonStatus: () => readAutonomyDaemonStatus,
+  startAutonomyDaemon: () => startAutonomyDaemon,
+  stopAutonomyDaemon: () => stopAutonomyDaemon
+});
+import fs8 from "fs";
+import path10 from "path";
+import { spawn } from "child_process";
+var DAEMON_DIR = ".workgraph/daemon";
+var AUTONOMY_PID_FILE = "autonomy.pid";
+var AUTONOMY_HEARTBEAT_FILE = "autonomy-heartbeat.json";
+var AUTONOMY_LOG_FILE = "autonomy.log";
+var AUTONOMY_META_FILE = "autonomy-process.json";
+function startAutonomyDaemon(workspacePath, input) {
+  const daemonDir = ensureDaemonDir(workspacePath);
+  const pidPath = path10.join(daemonDir, AUTONOMY_PID_FILE);
+  const heartbeatPath = input.heartbeatPath ? resolvePathWithinWorkspace4(workspacePath, input.heartbeatPath) : path10.join(daemonDir, AUTONOMY_HEARTBEAT_FILE);
+  const logPath = input.logPath ? resolvePathWithinWorkspace4(workspacePath, input.logPath) : path10.join(daemonDir, AUTONOMY_LOG_FILE);
+  const metaPath = path10.join(daemonDir, AUTONOMY_META_FILE);
+  const existing = readAutonomyDaemonStatus(workspacePath, { cleanupStalePidFile: true });
+  if (existing.running) {
+    throw new Error(`Autonomy daemon already running (pid=${existing.pid}). Stop it before starting a new one.`);
+  }
+  const logFd = fs8.openSync(logPath, "a");
+  const args = buildAutonomyDaemonArgs(workspacePath, input, heartbeatPath);
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: process.env
+  });
+  fs8.closeSync(logFd);
+  child.unref();
+  if (!child.pid) {
+    throw new Error("Failed to start autonomy daemon: missing child process pid.");
+  }
+  fs8.writeFileSync(pidPath, `${child.pid}
+`, "utf-8");
+  fs8.writeFileSync(metaPath, JSON.stringify({
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pid: child.pid,
+    args,
+    actor: input.actor,
+    adapter: input.adapter ?? "cursor-cloud",
+    logPath,
+    heartbeatPath
+  }, null, 2) + "\n", "utf-8");
+  return readAutonomyDaemonStatus(workspacePath, { cleanupStalePidFile: true });
+}
+async function stopAutonomyDaemon(workspacePath, input = {}) {
+  const status = readAutonomyDaemonStatus(workspacePath, { cleanupStalePidFile: false });
+  if (!status.pid) {
+    return {
+      stopped: true,
+      previouslyRunning: false,
+      status: readAutonomyDaemonStatus(workspacePath, { cleanupStalePidFile: true })
+    };
+  }
+  const pid = status.pid;
+  const signal = input.signal ?? "SIGTERM";
+  const timeoutMs = clampInt(input.timeoutMs, 5e3, 250, 6e4);
+  const previouslyRunning = isProcessAlive(pid);
+  if (previouslyRunning) {
+    process.kill(pid, signal);
+  }
+  await waitForProcessExit(pid, timeoutMs);
+  let stopped = !isProcessAlive(pid);
+  if (!stopped && signal !== "SIGKILL") {
+    process.kill(pid, "SIGKILL");
+    await waitForProcessExit(pid, 1500);
+    stopped = !isProcessAlive(pid);
+  }
+  const pidPath = path10.join(ensureDaemonDir(workspacePath), AUTONOMY_PID_FILE);
+  if (stopped && fs8.existsSync(pidPath)) {
+    fs8.rmSync(pidPath, { force: true });
+  }
+  return {
+    stopped,
+    previouslyRunning,
+    pid,
+    status: readAutonomyDaemonStatus(workspacePath, { cleanupStalePidFile: true })
+  };
+}
+function readAutonomyDaemonStatus(workspacePath, options = {}) {
+  const daemonDir = ensureDaemonDir(workspacePath);
+  const pidPath = path10.join(daemonDir, AUTONOMY_PID_FILE);
+  const meta = readDaemonMeta(path10.join(daemonDir, AUTONOMY_META_FILE));
+  const logPath = meta?.logPath ? String(meta.logPath) : path10.join(daemonDir, AUTONOMY_LOG_FILE);
+  const heartbeatPath = meta?.heartbeatPath ? String(meta.heartbeatPath) : path10.join(daemonDir, AUTONOMY_HEARTBEAT_FILE);
+  const pid = readPid(pidPath);
+  const running = pid ? isProcessAlive(pid) : false;
+  if (!running && pid && options.cleanupStalePidFile !== false && fs8.existsSync(pidPath)) {
+    fs8.rmSync(pidPath, { force: true });
+  }
+  return {
+    running,
+    pid: running ? pid : void 0,
+    pidPath,
+    logPath,
+    heartbeatPath,
+    heartbeat: readHeartbeat(heartbeatPath)
+  };
+}
+function buildAutonomyDaemonArgs(workspacePath, input, heartbeatPath) {
+  const args = [
+    path10.resolve(input.cliEntrypointPath),
+    "autonomy",
+    "run",
+    "-w",
+    workspacePath,
+    "--actor",
+    input.actor,
+    "--adapter",
+    input.adapter ?? "cursor-cloud",
+    "--watch",
+    "--poll-ms",
+    String(clampInt(input.pollMs, 2e3, 100, 6e4)),
+    "--max-idle-cycles",
+    String(clampInt(input.maxIdleCycles, 2, 1, 1e4)),
+    "--max-steps",
+    String(clampInt(input.maxSteps, 200, 1, 5e3)),
+    "--step-delay-ms",
+    String(clampInt(input.stepDelayMs, 25, 0, 5e3)),
+    "--stale-claim-minutes",
+    String(clampInt(input.staleClaimMinutes, 30, 1, 24 * 60)),
+    "--heartbeat-file",
+    heartbeatPath,
+    "--json"
+  ];
+  if (typeof input.maxCycles === "number") {
+    args.push("--max-cycles", String(clampInt(input.maxCycles, 1, 1, Number.MAX_SAFE_INTEGER)));
+  }
+  if (input.agents && input.agents.length > 0) {
+    args.push("--agents", input.agents.join(","));
+  }
+  if (input.space) {
+    args.push("--space", input.space);
+  }
+  if (input.executeTriggers === false) {
+    args.push("--no-execute-triggers");
+  }
+  if (input.executeReadyThreads === false) {
+    args.push("--no-execute-ready-threads");
+  }
+  return args;
+}
+function waitForProcessExit(pid, timeoutMs) {
+  return new Promise((resolve) => {
+    const startedAt = Date.now();
+    const timer = setInterval(() => {
+      if (!isProcessAlive(pid)) {
+        clearInterval(timer);
+        resolve();
+        return;
+      }
+      if (Date.now() - startedAt >= timeoutMs) {
+        clearInterval(timer);
+        resolve();
+      }
+    }, 100);
+  });
+}
+function ensureDaemonDir(workspacePath) {
+  const daemonDir = path10.join(workspacePath, DAEMON_DIR);
+  if (!fs8.existsSync(daemonDir)) fs8.mkdirSync(daemonDir, { recursive: true });
+  return daemonDir;
+}
+function readPid(pidPath) {
+  if (!fs8.existsSync(pidPath)) return void 0;
+  const raw = fs8.readFileSync(pidPath, "utf-8").trim();
+  if (!raw) return void 0;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed <= 0) return void 0;
+  return parsed;
+}
+function readHeartbeat(heartbeatPath) {
+  if (!fs8.existsSync(heartbeatPath)) return void 0;
+  try {
+    const parsed = JSON.parse(fs8.readFileSync(heartbeatPath, "utf-8"));
+    if (!parsed || typeof parsed !== "object") return void 0;
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function readDaemonMeta(metaPath) {
+  if (!fs8.existsSync(metaPath)) return void 0;
+  try {
+    const parsed = JSON.parse(fs8.readFileSync(metaPath, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function isProcessAlive(pid) {
+  if (isZombieProcess(pid)) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isZombieProcess(pid) {
+  const statPath = `/proc/${pid}/stat`;
+  if (!fs8.existsSync(statPath)) return false;
+  try {
+    const stat = fs8.readFileSync(statPath, "utf-8");
+    const closingIdx = stat.indexOf(")");
+    if (closingIdx === -1 || closingIdx + 2 >= stat.length) return false;
+    const state = stat.slice(closingIdx + 2, closingIdx + 3);
+    return state === "Z";
+  } catch {
+    return false;
+  }
+}
+function resolvePathWithinWorkspace4(workspacePath, filePath) {
+  const base = path10.resolve(workspacePath);
+  const resolved = path10.resolve(base, filePath);
+  if (!resolved.startsWith(base + path10.sep) && resolved !== base) {
+    throw new Error(`Invalid path outside workspace: ${filePath}`);
+  }
+  return resolved;
+}
+function clampInt(value, fallback, min, max) {
+  const raw = typeof value === "number" && Number.isFinite(value) ? Math.trunc(value) : fallback;
+  return Math.min(max, Math.max(min, raw));
+}
+
+export {
+  bases_exports,
+  workspace_exports,
+  command_center_exports,
+  skill_exports,
+  lens_exports,
+  board_exports,
+  agent_exports,
+  onboard_exports,
+  search_qmd_adapter_exports,
+  trigger_exports,
+  installSkillIntegration,
+  fetchSkillMarkdownFromUrl,
+  clawdapus_exports,
+  integration_exports,
+  diagnostics_exports,
+  autonomy_daemon_exports
+};