@versatly/workgraph 1.0.0 → 1.1.0

package/README.md

@@ -15,6 +15,7 @@ Agent-first workgraph workspace for multi-agent collaboration.
 - Native skill primitive lifecycle (`workgraph skill write/load/propose/promote`)
 - Primitive-registry manifest + auto-generated `.base` files
 - Orientation loop commands (`workgraph status/brief/checkpoint/intake`)
+- Deterministic context lenses (`workgraph lens list/show`) for real-time situational awareness
 - Multi-filter primitive query (`workgraph query ...`)
 - Core + QMD-compatible keyword search (`workgraph search ...`)
 - Obsidian Kanban board generation/sync (`workgraph board generate|sync`)
@@ -61,6 +62,8 @@ workgraph thread create "Ship command center" \
 workgraph thread next --claim --actor agent-worker --json
 workgraph status --json
 workgraph brief --actor agent-worker --json
+workgraph lens list --json
+workgraph lens show my-work --actor agent-worker --json
 workgraph query --type thread --status open --limit 10 --json
 workgraph search "auth" --mode auto --json
 workgraph checkpoint "Completed API layer" --next "implement tests" --actor agent-worker --json

package/dist/{chunk-R2MLGBHB.js → chunk-OTSECVE5.js}

@@ -6027,12 +6027,14 @@ export {
   CursorCloudAdapter,
   createRun,
   stop,
+  listRuns,
   dispatch_exports,
   parseCronExpression,
   matchesCronSchedule,
   nextCronMatch,
   trigger_engine_exports,
   createThread,
+  listReadyThreads,
   release,
   thread_exports,
   thread_audit_exports,

package/dist/{chunk-OJ6KOGB2.js → chunk-TOFSHG5S.js}

@@ -9,6 +9,8 @@ import {
   historyOf,
   keywordSearch,
   list,
+  listReadyThreads,
+  listRuns,
   listTypes,
   loadPolicyRegistry,
   loadRegistry,
@@ -21,7 +23,7 @@ import {
   saveRegistry,
   stop,
   update
-} from "./chunk-R2MLGBHB.js";
+} from "./chunk-OTSECVE5.js";
 
 // src/workspace.ts
 var workspace_exports = {};
@@ -532,14 +534,480 @@ function writeSkillManifest(workspacePath, slug, skill, actor) {
   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 fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 function generateKanbanBoard(workspacePath, options = {}) {
   const threads = list(workspacePath, "thread");
   const grouped = groupThreads(threads);
@@ -555,12 +1023,12 @@ function generateKanbanBoard(workspacePath, options = {}) {
   }
   const content = renderKanbanMarkdown(lanes);
   const relOutputPath = options.outputPath ?? "ops/Workgraph Board.md";
-  const absOutputPath = resolvePathWithinWorkspace2(workspacePath, relOutputPath);
-  const parentDir = path5.dirname(absOutputPath);
-  if (!fs5.existsSync(parentDir)) fs5.mkdirSync(parentDir, { recursive: true });
-  fs5.writeFileSync(absOutputPath, content, "utf-8");
+  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: path5.relative(workspacePath, absOutputPath).replace(/\\/g, "/"),
+    outputPath: path6.relative(workspacePath, absOutputPath).replace(/\\/g, "/"),
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     counts: {
       backlog: grouped.open.length,
@@ -658,10 +1126,10 @@ function renderKanbanMarkdown(lanes) {
   lines.push("");
   return lines.join("\n");
 }
-function resolvePathWithinWorkspace2(workspacePath, outputPath) {
-  const base = path5.resolve(workspacePath);
-  const resolved = path5.resolve(base, outputPath);
-  if (!resolved.startsWith(base + path5.sep) && resolved !== base) {
+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;
@@ -1157,8 +1625,8 @@ __export(diagnostics_exports, {
 });
 
 // src/diagnostics/doctor.ts
-import fs6 from "fs";
-import path7 from "path";
+import fs7 from "fs";
+import path8 from "path";
 import YAML2 from "yaml";
 
 // src/diagnostics/format.ts
@@ -1222,7 +1690,7 @@ function inferPrimitiveTypeFromPath(targetPath) {
 }
 
 // src/diagnostics/primitives.ts
-import path6 from "path";
+import path7 from "path";
 function loadPrimitiveInventory(workspacePath) {
   const registry = loadRegistry(workspacePath);
   const allPrimitives = queryPrimitives(workspacePath);
@@ -1240,7 +1708,7 @@ function loadPrimitiveInventory(workspacePath) {
     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 = path6.basename(instance.path, ".md");
+    const slug = path7.basename(instance.path, ".md");
     return {
       ...instance,
       slug,
@@ -1582,8 +2050,8 @@ function collectStaleRuns(workspacePath, staleAfterMs, now) {
 }
 function collectPrimitiveRegistryReferenceIssues(workspacePath, inventory) {
   const issues = [];
-  const manifestPath = path7.join(workspacePath, ".workgraph", "primitive-registry.yaml");
-  if (!fs6.existsSync(manifestPath)) {
+  const manifestPath = path8.join(workspacePath, ".workgraph", "primitive-registry.yaml");
+  if (!fs7.existsSync(manifestPath)) {
     issues.push({
       code: "broken-primitive-registry-reference",
       severity: "error",
@@ -1594,7 +2062,7 @@ function collectPrimitiveRegistryReferenceIssues(workspacePath, inventory) {
   }
   let parsed;
   try {
-    parsed = YAML2.parse(fs6.readFileSync(manifestPath, "utf-8"));
+    parsed = YAML2.parse(fs7.readFileSync(manifestPath, "utf-8"));
   } catch (error) {
     issues.push({
       code: "broken-primitive-registry-reference",
@@ -1646,7 +2114,7 @@ function collectPrimitiveRegistryReferenceIssues(workspacePath, inventory) {
         path: ".workgraph/primitive-registry.yaml"
       });
     }
-    if (!fs6.existsSync(path7.join(workspacePath, directory))) {
+    if (!fs7.existsSync(path8.join(workspacePath, directory))) {
       issues.push({
         code: "broken-primitive-registry-reference",
         severity: "error",
@@ -1681,8 +2149,8 @@ function collectPrimitiveRegistryReferenceIssues(workspacePath, inventory) {
 function collectEmptyPrimitiveDirectoryIssues(workspacePath, inventory) {
   const issues = [];
   for (const typeDef of inventory.typeDefs.values()) {
-    const directoryPath = path7.join(workspacePath, typeDef.directory);
-    if (!fs6.existsSync(directoryPath)) continue;
+    const directoryPath = path8.join(workspacePath, typeDef.directory);
+    if (!fs7.existsSync(directoryPath)) continue;
     const markdownCount = listMarkdownFilesRecursive(directoryPath).length;
     if (markdownCount > 0) continue;
     issues.push({
@@ -1711,10 +2179,10 @@ function removeOrphanLinks(workspacePath, orphanLinks) {
   }
   let removedLinks = 0;
   for (const [sourcePath, tokenSet] of tokensBySource.entries()) {
-    const absPath = path7.join(workspacePath, sourcePath);
-    if (!fs6.existsSync(absPath)) continue;
+    const absPath = path8.join(workspacePath, sourcePath);
+    if (!fs7.existsSync(absPath)) continue;
     try {
-      const raw = fs6.readFileSync(absPath, "utf-8");
+      const raw = fs7.readFileSync(absPath, "utf-8");
       let fileRemoved = 0;
       const updated = raw.replace(/\[\[([^[\]]+)\]\]/g, (token) => {
         if (!tokenSet.has(token)) return token;
@@ -1722,7 +2190,7 @@ function removeOrphanLinks(workspacePath, orphanLinks) {
         return "";
       });
       if (fileRemoved === 0) continue;
-      fs6.writeFileSync(absPath, updated, "utf-8");
+      fs7.writeFileSync(absPath, updated, "utf-8");
       removedLinks += fileRemoved;
       filesUpdated.push(sourcePath);
     } catch (error) {
@@ -1787,10 +2255,10 @@ function cancelStaleRuns(workspacePath, staleRuns, actor) {
   return { cancelled, errors };
 }
 function readDispatchRunsSnapshot(workspacePath) {
-  const runsPath = path7.join(workspacePath, ".workgraph", "dispatch-runs.json");
-  if (!fs6.existsSync(runsPath)) return [];
+  const runsPath = path8.join(workspacePath, ".workgraph", "dispatch-runs.json");
+  if (!fs7.existsSync(runsPath)) return [];
   try {
-    const parsed = JSON.parse(fs6.readFileSync(runsPath, "utf-8"));
+    const parsed = JSON.parse(fs7.readFileSync(runsPath, "utf-8"));
     return Array.isArray(parsed.runs) ? parsed.runs : [];
   } catch {
     return [];
@@ -1801,9 +2269,9 @@ function listMarkdownFilesRecursive(rootDirectory) {
   const stack = [rootDirectory];
   while (stack.length > 0) {
     const current = stack.pop();
-    const entries = fs6.readdirSync(current, { withFileTypes: true });
+    const entries = fs7.readdirSync(current, { withFileTypes: true });
     for (const entry of entries) {
-      const absPath = path7.join(current, entry.name);
+      const absPath = path8.join(current, entry.name);
       if (entry.isDirectory()) {
         stack.push(absPath);
         continue;
@@ -1947,7 +2415,7 @@ function toNullableString(value) {
 }
 
 // src/diagnostics/viz.ts
-import path8 from "path";
+import path9 from "path";
 var TYPE_COLORS = ["cyan", "magenta", "yellow", "green", "blue", "red"];
 function visualizeVaultGraph(workspacePath, options = {}) {
   const inventory = loadPrimitiveInventory(workspacePath);
@@ -2087,7 +2555,7 @@ function resolveFocusPath(focusInput, inventory) {
   const directCandidate = normalized.endsWith(".md") ? normalized : `${normalized}.md`;
   if (inventory.byPath.has(normalized)) return normalized;
   if (inventory.byPath.has(directCandidate)) return directCandidate;
-  const slug = path8.basename(normalized, ".md");
+  const slug = path9.basename(normalized, ".md");
   const candidates = inventory.slugToPaths.get(slug) ?? [];
   if (candidates.length === 1) return candidates[0];
   if (candidates.length > 1) {
@@ -2395,8 +2863,8 @@ __export(autonomy_daemon_exports, {
   startAutonomyDaemon: () => startAutonomyDaemon,
   stopAutonomyDaemon: () => stopAutonomyDaemon
 });
-import fs7 from "fs";
-import path9 from "path";
+import fs8 from "fs";
+import path10 from "path";
 import { spawn } from "child_process";
 var DAEMON_DIR = ".workgraph/daemon";
 var AUTONOMY_PID_FILE = "autonomy.pid";
@@ -2405,29 +2873,29 @@ var AUTONOMY_LOG_FILE = "autonomy.log";
 var AUTONOMY_META_FILE = "autonomy-process.json";
 function startAutonomyDaemon(workspacePath, input) {
   const daemonDir = ensureDaemonDir(workspacePath);
-  const pidPath = path9.join(daemonDir, AUTONOMY_PID_FILE);
-  const heartbeatPath = input.heartbeatPath ? resolvePathWithinWorkspace3(workspacePath, input.heartbeatPath) : path9.join(daemonDir, AUTONOMY_HEARTBEAT_FILE);
-  const logPath = input.logPath ? resolvePathWithinWorkspace3(workspacePath, input.logPath) : path9.join(daemonDir, AUTONOMY_LOG_FILE);
-  const metaPath = path9.join(daemonDir, AUTONOMY_META_FILE);
+  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 = fs7.openSync(logPath, "a");
+  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
   });
-  fs7.closeSync(logFd);
+  fs8.closeSync(logFd);
   child.unref();
   if (!child.pid) {
     throw new Error("Failed to start autonomy daemon: missing child process pid.");
   }
-  fs7.writeFileSync(pidPath, `${child.pid}
+  fs8.writeFileSync(pidPath, `${child.pid}
 `, "utf-8");
-  fs7.writeFileSync(metaPath, JSON.stringify({
+  fs8.writeFileSync(metaPath, JSON.stringify({
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     pid: child.pid,
     args,
@@ -2461,9 +2929,9 @@ async function stopAutonomyDaemon(workspacePath, input = {}) {
     await waitForProcessExit(pid, 1500);
     stopped = !isProcessAlive(pid);
   }
-  const pidPath = path9.join(ensureDaemonDir(workspacePath), AUTONOMY_PID_FILE);
-  if (stopped && fs7.existsSync(pidPath)) {
-    fs7.rmSync(pidPath, { force: true });
+  const pidPath = path10.join(ensureDaemonDir(workspacePath), AUTONOMY_PID_FILE);
+  if (stopped && fs8.existsSync(pidPath)) {
+    fs8.rmSync(pidPath, { force: true });
   }
   return {
     stopped,
@@ -2474,14 +2942,14 @@ async function stopAutonomyDaemon(workspacePath, input = {}) {
 }
 function readAutonomyDaemonStatus(workspacePath, options = {}) {
   const daemonDir = ensureDaemonDir(workspacePath);
-  const pidPath = path9.join(daemonDir, AUTONOMY_PID_FILE);
-  const meta = readDaemonMeta(path9.join(daemonDir, AUTONOMY_META_FILE));
-  const logPath = meta?.logPath ? String(meta.logPath) : path9.join(daemonDir, AUTONOMY_LOG_FILE);
-  const heartbeatPath = meta?.heartbeatPath ? String(meta.heartbeatPath) : path9.join(daemonDir, AUTONOMY_HEARTBEAT_FILE);
+  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 && fs7.existsSync(pidPath)) {
-    fs7.rmSync(pidPath, { force: true });
+  if (!running && pid && options.cleanupStalePidFile !== false && fs8.existsSync(pidPath)) {
+    fs8.rmSync(pidPath, { force: true });
   }
   return {
     running,
@@ -2494,7 +2962,7 @@ function readAutonomyDaemonStatus(workspacePath, options = {}) {
 }
 function buildAutonomyDaemonArgs(workspacePath, input, heartbeatPath) {
   const args = [
-    path9.resolve(input.cliEntrypointPath),
+    path10.resolve(input.cliEntrypointPath),
     "autonomy",
     "run",
     "-w",
@@ -2552,22 +3020,22 @@ function waitForProcessExit(pid, timeoutMs) {
   });
 }
 function ensureDaemonDir(workspacePath) {
-  const daemonDir = path9.join(workspacePath, DAEMON_DIR);
-  if (!fs7.existsSync(daemonDir)) fs7.mkdirSync(daemonDir, { recursive: true });
+  const daemonDir = path10.join(workspacePath, DAEMON_DIR);
+  if (!fs8.existsSync(daemonDir)) fs8.mkdirSync(daemonDir, { recursive: true });
   return daemonDir;
 }
 function readPid(pidPath) {
-  if (!fs7.existsSync(pidPath)) return void 0;
-  const raw = fs7.readFileSync(pidPath, "utf-8").trim();
+  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 (!fs7.existsSync(heartbeatPath)) return void 0;
+  if (!fs8.existsSync(heartbeatPath)) return void 0;
   try {
-    const parsed = JSON.parse(fs7.readFileSync(heartbeatPath, "utf-8"));
+    const parsed = JSON.parse(fs8.readFileSync(heartbeatPath, "utf-8"));
     if (!parsed || typeof parsed !== "object") return void 0;
     return parsed;
   } catch {
@@ -2575,9 +3043,9 @@ function readHeartbeat(heartbeatPath) {
   }
 }
 function readDaemonMeta(metaPath) {
-  if (!fs7.existsSync(metaPath)) return void 0;
+  if (!fs8.existsSync(metaPath)) return void 0;
   try {
-    const parsed = JSON.parse(fs7.readFileSync(metaPath, "utf-8"));
+    const parsed = JSON.parse(fs8.readFileSync(metaPath, "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
     return parsed;
   } catch {
@@ -2595,9 +3063,9 @@ function isProcessAlive(pid) {
 }
 function isZombieProcess(pid) {
   const statPath = `/proc/${pid}/stat`;
-  if (!fs7.existsSync(statPath)) return false;
+  if (!fs8.existsSync(statPath)) return false;
   try {
-    const stat = fs7.readFileSync(statPath, "utf-8");
+    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);
@@ -2606,10 +3074,10 @@ function isZombieProcess(pid) {
     return false;
   }
 }
-function resolvePathWithinWorkspace3(workspacePath, filePath) {
-  const base = path9.resolve(workspacePath);
-  const resolved = path9.resolve(base, filePath);
-  if (!resolved.startsWith(base + path9.sep) && resolved !== base) {
+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;
@@ -2624,6 +3092,7 @@ export {
   workspace_exports,
   command_center_exports,
   skill_exports,
+  lens_exports,
   board_exports,
   agent_exports,
   onboard_exports,

package/dist/cli.js

@@ -7,12 +7,13 @@ import {
   command_center_exports,
   diagnostics_exports,
   integration_exports,
+  lens_exports,
   onboard_exports,
   search_qmd_adapter_exports,
   skill_exports,
   trigger_exports,
   workspace_exports
-} from "./chunk-OJ6KOGB2.js";
+} from "./chunk-TOFSHG5S.js";
 import {
   autonomy_exports,
   dispatch_exports,
@@ -28,7 +29,7 @@ import {
   thread_audit_exports,
   thread_exports,
   trigger_engine_exports
-} from "./chunk-R2MLGBHB.js";
+} from "./chunk-OTSECVE5.js";
 
 // src/cli.ts
 import fs from "fs";
@@ -1053,6 +1054,57 @@ addWorkspaceOption(
     (result) => [`Captured intake: ${result.intake.path}`]
   )
 );
+var lensCmd = program.command("lens").description("Generate deterministic context lenses for situational awareness");
+addWorkspaceOption(
+  lensCmd.command("list").description("List built-in context lenses").option("--json", "Emit structured JSON output")
+).action(
+  (opts) => runCommand(
+    opts,
+    () => ({
+      lenses: lens_exports.listContextLenses()
+    }),
+    (result) => result.lenses.map((lens) => `lens://${lens.id} - ${lens.description}`)
+  )
+);
+addWorkspaceOption(
+  lensCmd.command("show <lensId>").description("Generate one context lens snapshot").option("-a, --actor <name>", "Actor identity for actor-scoped lenses", DEFAULT_ACTOR).option("--lookback-hours <hours>", "Lookback window in hours", "24").option("--stale-hours <hours>", "Stale threshold in hours", "24").option("--limit <n>", "Maximum items per section", "10").option("-o, --output <path>", "Write lens markdown to workspace-relative output path").option("--json", "Emit structured JSON output")
+).action(
+  (lensId, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      const lensOptions = {
+        actor: opts.actor,
+        lookbackHours: parsePositiveNumberOption(opts.lookbackHours, "lookback-hours"),
+        staleHours: parsePositiveNumberOption(opts.staleHours, "stale-hours"),
+        limit: parsePositiveIntegerOption(opts.limit, "limit")
+      };
+      if (opts.output) {
+        return lens_exports.materializeContextLens(workspacePath, lensId, {
+          ...lensOptions,
+          outputPath: opts.output
+        });
+      }
+      return lens_exports.generateContextLens(workspacePath, lensId, lensOptions);
+    },
+    (result) => {
+      const metricSummary = Object.entries(result.metrics).map(([metric, value]) => `${metric}=${value}`).join(" ");
+      const sectionSummary = result.sections.map((section) => `${section.id}:${section.items.length}`).join(" ");
+      const lines = [
+        `Lens: ${result.lens}`,
+        `Generated: ${result.generatedAt}`,
+        ...result.actor ? [`Actor: ${result.actor}`] : [],
+        `Metrics: ${metricSummary || "none"}`,
+        `Sections: ${sectionSummary || "none"}`
+      ];
+      if (isMaterializedLensResult(result)) {
+        lines.push(`Saved markdown: ${result.outputPath}`);
+        return lines;
+      }
+      return [...lines, "", ...result.markdown.split("\n")];
+    }
+  )
+);
 addWorkspaceOption(
   program.command("query").description("Query primitive instances with multi-field filters").option("--type <type>", "Primitive type").option("--status <status>", "Status value").option("--owner <owner>", "Owner/actor value").option("--tag <tag>", "Tag filter").option("--text <text>", "Full-text contains filter").option("--path-includes <text>", "Path substring filter").option("--updated-after <iso>", "Updated at or after").option("--updated-before <iso>", "Updated at or before").option("--created-after <iso>", "Created at or after").option("--created-before <iso>", "Created at or before").option("--limit <n>", "Result limit").option("--offset <n>", "Result offset").option("--json", "Emit structured JSON output")
 ).action(
@@ -1952,6 +2004,13 @@ function parsePositiveIntOption(value, name) {
   }
   return parsed;
 }
+function parsePositiveNumberOption(value, optionName) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Invalid --${optionName}. Expected a positive number.`);
+  }
+  return parsed;
+}
 function parseNonNegativeIntOption(value, name) {
   const parsed = Number.parseInt(String(value ?? ""), 10);
   if (!Number.isFinite(parsed) || parsed < 0) {
@@ -1959,6 +2018,16 @@ function parseNonNegativeIntOption(value, name) {
   }
   return parsed;
 }
+function parsePositiveIntegerOption(value, optionName) {
+  const parsed = Number.parseInt(String(value), 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`Invalid --${optionName}. Expected a positive integer.`);
+  }
+  return parsed;
+}
+function isMaterializedLensResult(value) {
+  return typeof value.outputPath === "string";
+}
 function normalizeRunStatus(status) {
   const normalized = String(status).toLowerCase();
   if (normalized === "running" || normalized === "succeeded" || normalized === "failed" || normalized === "cancelled") {

package/dist/index.d.ts

@@ -132,6 +132,51 @@ interface WorkgraphBrief {
     nextReadyThreads: PrimitiveInstance[];
     recentActivity: LedgerEntry[];
 }
+type WorkgraphLensId = 'my-work' | 'team-risk' | 'customer-health' | 'exec-brief';
+interface WorkgraphLensDescriptor {
+    id: WorkgraphLensId;
+    description: string;
+}
+interface WorkgraphLensOptions {
+    actor?: string;
+    lookbackHours?: number;
+    staleHours?: number;
+    limit?: number;
+}
+interface WorkgraphLensItem {
+    title: string;
+    path?: string;
+    status?: string;
+    priority?: string;
+    owner?: string;
+    detail?: string;
+    ageHours?: number;
+}
+interface WorkgraphLensSection {
+    id: string;
+    title: string;
+    items: WorkgraphLensItem[];
+}
+interface WorkgraphLensResult {
+    lens: WorkgraphLensId;
+    generatedAt: string;
+    actor?: string;
+    options: {
+        lookbackHours: number;
+        staleHours: number;
+        limit: number;
+    };
+    metrics: Record<string, number>;
+    sections: WorkgraphLensSection[];
+    markdown: string;
+}
+interface WorkgraphMaterializeLensOptions extends WorkgraphLensOptions {
+    outputPath: string;
+}
+interface WorkgraphMaterializedLensResult extends WorkgraphLensResult {
+    outputPath: string;
+    created: boolean;
+}
 interface PolicyParty {
     id: string;
     roles: string[];
@@ -655,6 +700,21 @@ declare namespace orientation {
   export { orientation_brief as brief, orientation_checkpoint as checkpoint, orientation_intake as intake, orientation_statusSnapshot as statusSnapshot };
 }
 
+/**
+ * Deterministic context lenses for fast, runtime-agnostic orientation.
+ */
+
+declare function listContextLenses(): WorkgraphLensDescriptor[];
+declare function generateContextLens(workspacePath: string, lensId: WorkgraphLensId | string, options?: WorkgraphLensOptions): WorkgraphLensResult;
+declare function materializeContextLens(workspacePath: string, lensId: WorkgraphLensId | string, options: WorkgraphMaterializeLensOptions): WorkgraphMaterializedLensResult;
+
+declare const lens_generateContextLens: typeof generateContextLens;
+declare const lens_listContextLenses: typeof listContextLenses;
+declare const lens_materializeContextLens: typeof materializeContextLens;
+declare namespace lens {
+  export { lens_generateContextLens as generateContextLens, lens_listContextLenses as listContextLenses, lens_materializeContextLens as materializeContextLens };
+}
+
 /**
  * Wiki-link graph indexing and graph-intelligence queries.
  */
@@ -1720,4 +1780,4 @@ declare class CursorCloudAdapter implements DispatchAdapter {
     execute(input: DispatchAdapterExecutionInput): Promise<DispatchAdapterExecutionResult>;
 }
 
-export { type CronField, type CronSchedule, CursorCloudAdapter, type DispatchAdapter, type DispatchAdapterCreateInput, type DispatchAdapterExecutionInput, type DispatchAdapterExecutionResult, type DispatchAdapterLogEntry, type DispatchAdapterRunStatus, type DispatchRun, type FieldDefinition, type InstallSkillIntegrationOptions, type InstallSkillIntegrationResult, type LedgerChainState, type LedgerEntry, type LedgerIndex, type LedgerOp, type PolicyParty, type PolicyRegistry, type PrimitiveInstance, type PrimitiveQueryFilters, type PrimitiveTypeDefinition, type Registry, type RunStatus, type SkillIntegrationProvider, THREAD_STATUS_TRANSITIONS, type ThreadStatus, type WorkgraphBrief, type WorkgraphStatusSnapshot, type WorkgraphWorkspaceConfig, agent, autonomy, autonomyDaemon, bases, board, claimLease, clawdapus, commandCenter, index as diagnostics, dispatch, fetchSkillMarkdownFromUrl, gate, graph, installSkillIntegration, integration, ledger, matchesCronSchedule, nextCronMatch, onboard, orientation, parseCronExpression, policy, query, registry, searchQmdAdapter, skill, store, thread, threadAudit, trigger, triggerEngine, workspace };
+export { type CronField, type CronSchedule, CursorCloudAdapter, type DispatchAdapter, type DispatchAdapterCreateInput, type DispatchAdapterExecutionInput, type DispatchAdapterExecutionResult, type DispatchAdapterLogEntry, type DispatchAdapterRunStatus, type DispatchRun, type FieldDefinition, type InstallSkillIntegrationOptions, type InstallSkillIntegrationResult, type LedgerChainState, type LedgerEntry, type LedgerIndex, type LedgerOp, type PolicyParty, type PolicyRegistry, type PrimitiveInstance, type PrimitiveQueryFilters, type PrimitiveTypeDefinition, type Registry, type RunStatus, type SkillIntegrationProvider, THREAD_STATUS_TRANSITIONS, type ThreadStatus, type WorkgraphBrief, type WorkgraphLensDescriptor, type WorkgraphLensId, type WorkgraphLensItem, type WorkgraphLensOptions, type WorkgraphLensResult, type WorkgraphLensSection, type WorkgraphMaterializeLensOptions, type WorkgraphMaterializedLensResult, type WorkgraphStatusSnapshot, type WorkgraphWorkspaceConfig, agent, autonomy, autonomyDaemon, bases, board, claimLease, clawdapus, commandCenter, index as diagnostics, dispatch, fetchSkillMarkdownFromUrl, gate, graph, installSkillIntegration, integration, ledger, lens, matchesCronSchedule, nextCronMatch, onboard, orientation, parseCronExpression, policy, query, registry, searchQmdAdapter, skill, store, thread, threadAudit, trigger, triggerEngine, workspace };

package/dist/index.js

@@ -9,12 +9,13 @@ import {
   fetchSkillMarkdownFromUrl,
   installSkillIntegration,
   integration_exports,
+  lens_exports,
   onboard_exports,
   search_qmd_adapter_exports,
   skill_exports,
   trigger_exports,
   workspace_exports
-} from "./chunk-OJ6KOGB2.js";
+} from "./chunk-TOFSHG5S.js";
 import {
   CursorCloudAdapter,
   THREAD_STATUS_TRANSITIONS,
@@ -36,7 +37,7 @@ import {
   thread_audit_exports,
   thread_exports,
   trigger_engine_exports
-} from "./chunk-R2MLGBHB.js";
+} from "./chunk-OTSECVE5.js";
 export {
   CursorCloudAdapter,
   THREAD_STATUS_TRANSITIONS,
@@ -56,6 +57,7 @@ export {
   installSkillIntegration,
   integration_exports as integration,
   ledger_exports as ledger,
+  lens_exports as lens,
   matchesCronSchedule,
   mcp_server_exports as mcpServer,
   nextCronMatch,

package/dist/mcp-server.js

@@ -1,7 +1,7 @@
 import {
   createWorkgraphMcpServer,
   startWorkgraphMcpServer
-} from "./chunk-R2MLGBHB.js";
+} from "./chunk-OTSECVE5.js";
 export {
   createWorkgraphMcpServer,
   startWorkgraphMcpServer

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@versatly/workgraph",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Agent-first workgraph workspace for multi-agent coordination with dynamic primitives, append-only ledger, and markdown-native storage.",
   "workspaces": [
     "packages/*"