@intentius/chant 0.49.0 → 0.51.0

package/src/cli/handlers/search.ts

@@ -8,7 +8,11 @@ import { discover } from "../../discovery/index";
 
 import { observeResources } from "../../lifecycle/observe";
 import { replaySnapshots, hasSnapshot } from "../../lifecycle/replay";
+import { diffLive, type LiveDiffResult } from "../../lifecycle/live-diff";
 import type { LiveObservation } from "../../graph-ir";
+import type { ResourceMetadata } from "../../lexicon";
+import type { ObservationDepth } from "../../lifecycle/types";
+import { formatUnobserved } from "../../observation";
 import { loadChantConfig, matchesDeclaredEnvironment } from "../../config";
 import { loadPlugins, resolveProjectLexicons } from "../plugins";
 import { formatError, formatWarning } from "../format";
@@ -56,6 +60,31 @@ export async function runSearch(ctx: CommandContext): Promise<number> {
   }
   const show = parseShow(args);
 
+  // Query-scoped drift (#1268): --check-live checks a snapshot answer against
+  // a live read, --check-snapshot checks a live answer against the recorded
+  // snapshot — the direction each needs is the source it does NOT already have.
+  if (args.checkLive && !args.at) {
+    console.error(formatError({
+      message: "chant search --check-live needs --at <ref>",
+      hint: "answer from a snapshot and check the matched rows against a live read: --at latest --check-live --env <name>",
+    }));
+    return 1;
+  }
+  if (args.checkSnapshot && !args.live) {
+    console.error(formatError({
+      message: "chant search --check-snapshot needs --live",
+      hint: "answer live and check the matched rows against the recorded snapshot: --live --check-snapshot --env <name>",
+    }));
+    return 1;
+  }
+  if (args.failOnDrift && !args.checkLive && !args.checkSnapshot) {
+    console.error(formatError({
+      message: "chant search --fail-on-drift needs --check-live or --check-snapshot",
+      hint: "it fails the check those flags run, so it is meaningless without one",
+    }));
+    return 1;
+  }
+
   const projectPath = resolve(".");
   const { config } = await loadChantConfig(projectPath);
 
@@ -73,6 +102,14 @@ export async function runSearch(ctx: CommandContext): Promise<number> {
   let ambientKinds: string[] = [];
   // Set only on a replay: whether the recording itself holds ambient resources.
   let replayAmbient: { recordedAmbient: boolean } | undefined;
+  // Query-scoped drift (#1268): the OTHER observation, read only when
+  // --check-live/--check-snapshot asked for one — the declared canvas to
+  // classify against, and whether the exit code should reflect what it found.
+  let checkObservations: LiveObservation[] | undefined;
+  let primaryObservations: LiveObservation[] | undefined;
+  let declaredForDrift: GraphIR | undefined;
+  let snapshotDepth: ObservationDepth | undefined;
+  let driftFailure = false;
   if (args.live || args.at) {
     const environment = args.env;
     if (!environment) {
@@ -126,6 +163,21 @@ export async function runSearch(ctx: CommandContext): Promise<number> {
         ),
       };
       source = { kind: "snapshot", commit: replay.commit, timestamp: replay.timestamp };
+      snapshotDepth = replay.depth;
+      if (args.checkLive) {
+        // A fresh live read, additional to the snapshot the answer itself came
+        // from — this is what the matched rows get checked against.
+        const liveCheck = await observeResources(environment, observing, buildResult, {
+          owned: true,
+          stacks,
+          ambient: args.ambient === true,
+        });
+        for (const e of liveCheck.errors) {
+          liveFailures.push(e);
+          console.error(formatError({ message: `live read failed — ${e}` }));
+        }
+        checkObservations = liveCheck.observations;
+      }
     } else {
       const observed = await observeResources(environment, observing, buildResult, {
         owned: true,
@@ -142,7 +194,22 @@ export async function runSearch(ctx: CommandContext): Promise<number> {
       observations = observed.observations;
       liveNotes = observed.notes ?? [];
       source = { kind: "live" };
+      if (args.checkSnapshot) {
+        // The reverse direction: answer live, check the matched rows against
+        // the most recently recorded snapshot. Missing entirely is not a
+        // failure of THIS command — the live answer already stands — so it is
+        // a note, not an error.
+        const scoped = new Set(stacks.filter((st) => st.src).map((st) => st.name));
+        const checkReplay = await replaySnapshots(environment, "latest", scoped);
+        if ("error" in checkReplay) {
+          console.error(formatWarning({ message: `--check-snapshot: ${checkReplay.error}` }));
+        } else {
+          checkObservations = checkReplay.observations;
+          snapshotDepth = checkReplay.depth;
+        }
+      }
     }
+    primaryObservations = observations;
     let live = buildLiveGraphIr(observations);
     // Containment edges, kept aside until after the overlay (see below).
     let containmentEdges: IREdge[] = [];
@@ -206,6 +273,7 @@ export async function runSearch(ctx: CommandContext): Promise<number> {
       stacks.length > 0
         ? await buildDeclaredPerStack(stacks, projectPath)
         : buildGraphIr((await discover(resolve(args.src ?? config.sourceDir ?? "."))).entities, projectPath);
+    declaredForDrift = declared;
     // Carry the NOT-OBSERVED half of the tri-state (#1089) onto the rows, so a
     // declared entity nobody could read is painted `_unobserved` and a row can
     // say so instead of printing blank where a physical id would go (#1263).
@@ -279,6 +347,29 @@ export async function runSearch(ctx: CommandContext): Promise<number> {
   // Qualifies the provenance line, so it sits with it: one line per distinct
   // note for the whole run, not one per stack, and after the rows (#1265).
   for (const n of liveNotes) console.error(formatWarning({ message: n }));
+  // Query-scoped drift (#1268): the matched rows, and only the matched rows,
+  // checked against the observation the primary answer did NOT use. Scoping
+  // both sides of diffLive() to the matched ids is what keeps a query-scoped-
+  // out resource from reading as `missing` or `unobserved` — it was never
+  // asked about, which is a third thing from both.
+  if (checkObservations && declaredForDrift && primaryObservations) {
+    const declaredIds = new Set(declaredForDrift.nodes.map((n) => n.id));
+    const matchedIds = new Set(matches.map((n) => n.id));
+    const nowObservations = args.checkLive ? checkObservations : primaryObservations;
+    const thenObservations = args.checkLive ? primaryObservations : checkObservations;
+    const driftCount = renderDrift(
+      diffLive({
+        declared: new Set([...matchedIds].filter((id) => declaredIds.has(id))),
+        observedNow: pickResources(mergeResources(nowObservations), matchedIds),
+        observedThen: pickResources(mergeResources(thenObservations), matchedIds),
+        unobserved: pickResources(collectUnobserved(nowObservations), matchedIds),
+      }),
+      matches.length,
+      args.checkLive ? "live" : "snapshot",
+      snapshotDepth,
+    );
+    if (args.failOnDrift && driftCount > 0) driftFailure = true;
+  }
   ambientHint(matches, ambientKinds, args.ambient === true, replayAmbient);
   showMiss(matches, show);
   regionSpread(terms, matches, show);
@@ -297,6 +388,7 @@ export async function runSearch(ctx: CommandContext): Promise<number> {
     }));
     return 1;
   }
+  if (driftFailure) return 1;
   return 0;
 }
 
@@ -463,6 +555,63 @@ function provenance(matches: IRNode[], source: AnswerSource, recorded?: string,
   console.log(`— observed from snapshot${at}${taken} · bound ${bound}/${matches.length}`);
 }
 
+/** Union `LiveObservation.resources` across lexicons into one name-keyed map. */
+function mergeResources(observations: LiveObservation[]): Record<string, ResourceMetadata> {
+  const out: Record<string, ResourceMetadata> = {};
+  for (const o of observations) Object.assign(out, o.resources);
+  return out;
+}
+
+/** Restrict a name-keyed map to the matched ids — the whole of "query-scoped". */
+function pickResources<T>(map: Record<string, T>, ids: Set<string>): Record<string, T> {
+  const out: Record<string, T> = {};
+  for (const id of ids) if (id in map) out[id] = map[id];
+  return out;
+}
+
+/**
+ * Render the query-scoped drift check (#1268) — one line per matched resource
+ * whose {@link diffLive} verdict is not `unchanged`, then a summary.
+ *
+ * Reuses `diffLive` unmodified, so every category means exactly what it means
+ * in `lifecycle diff --live`: `missing`/`orphan`/`disappeared`/`drifted` count
+ * as drift, the same set `lifecycle diff` totals; `newlyObserved` and runtime
+ * children are reported but do not, and `unobserved` — a read that could not
+ * look — stays distinct from both, the same #1089 tri-state everywhere else.
+ */
+function renderDrift(
+  diff: LiveDiffResult,
+  checked: number,
+  direction: "live" | "snapshot",
+  depth?: ObservationDepth,
+): number {
+  for (const name of diff.missing) console.log(`⚠ ${name} — missing (declared, not found by this check)`);
+  for (const name of diff.orphan) console.log(`⚠ ${name} — orphan (observed, not declared)`);
+  for (const name of diff.disappeared) console.log(`⚠ ${name} — disappeared since the recorded snapshot`);
+  for (const drift of diff.driftedSinceSnapshot) {
+    for (const change of drift.changes) {
+      console.log(`⚠ ${drift.name}  ${change.path}: ${formatValue(change.oldValue)} → ${formatValue(change.newValue)} — drifted`);
+    }
+  }
+  for (const name of diff.newlyObserved) console.log(`  · ${name} — newly observed since the recorded snapshot`);
+  for (const r of diff.runtimeChildren) console.log(`  · ${r.name} (${r.type}) — runtime, owned by ${r.owner}`);
+  for (const u of diff.unobserved) console.log(`  ? ${formatUnobserved(u.name, u)}`);
+  const driftCount = diff.missing.length + diff.orphan.length + diff.disappeared.length + diff.driftedSinceSnapshot.length;
+  const label = direction === "live" ? "a live read" : "the recorded snapshot";
+  const depthNote = depth === "deep" ? " · snapshot recorded at deep depth, compared here at identity" : "";
+  console.log(
+    `— checked against ${label} · ${driftCount > 0 ? `${driftCount} of ${checked} matched drifted` : `no drift across ${checked} matched`}${depthNote}`,
+  );
+  return driftCount;
+}
+
+function formatValue(v: unknown): string {
+  if (v === undefined) return "<unset>";
+  if (typeof v === "string") return v.length > 60 ? v.slice(0, 57) + "..." : v;
+  const json = JSON.stringify(v);
+  return json.length > 60 ? json.slice(0, 57) + "..." : json;
+}
+
 /**
  * Name the facts chant computed for the kinds in this result that the query did not use.
  *
@@ -815,4 +964,4 @@ function formatRow(n: IRNode, show: string[]): string {
 }
 
 /** Internals exposed for unit tests. */
-export const __searchInternals = { parseQuery, matchTerm, formatRow, explain, describeTerm, derivedSurface, availableAttrs, ambientHint, regionSpread, showMiss, provenance };
+export const __searchInternals = { parseQuery, matchTerm, formatRow, explain, describeTerm, derivedSurface, availableAttrs, ambientHint, regionSpread, showMiss, provenance, renderDrift, mergeResources, pickResources };

package/src/cli/main.test.ts

@@ -383,6 +383,29 @@ describe("parseArgs", () => {
     expect(() => parseArgs(["run", "myop", "--json=1"])).toThrow(/--json is a boolean flag/);
   });
 
+  test("--fold-rank has the same context-sensitive bare-vs-path behavior as --report (#1083)", () => {
+    // Bare --fold-rank is the boolean (print the ranked report); --fold-rank
+    // <path> is the collapsed-format export destination.
+    const bare = parseArgs(["build", "src", "--fold", "--fold-rank"]);
+    expect(bare.foldRank).toBe(true);
+    expect(bare.foldRankCollapsedFile).toBeUndefined();
+
+    const withPath = parseArgs(["build", "src", "--fold", "--fold-rank", "out.collapsed"]);
+    expect(withPath.foldRankCollapsedFile).toBe("out.collapsed");
+    expect(withPath.foldRank).toBeUndefined();
+
+    // A following flag (not a path) keeps the bare-boolean reading.
+    const beforeFlag = parseArgs(["build", "src", "--fold-rank", "--verbose"]);
+    expect(beforeFlag.foldRank).toBe(true);
+    expect(beforeFlag.verbose).toBe(true);
+  });
+
+  test("--fold-rank=<path> (joined form) resolves the same as the space-separated one", () => {
+    const result = parseArgs(["build", "src", "--fold-rank=out.collapsed"]);
+    expect(result.foldRankCollapsedFile).toBe("out.collapsed");
+    expect(result.foldRank).toBeUndefined();
+  });
+
   test("--report keeps its context-sensitive bare-vs-value behavior when joined", () => {
     // --report is deliberately not in the boolean-reject set: bare --report is
     // a boolean (`run`), but --report <path> is a SARIF destination (migrate).

package/src/cli/main.ts

@@ -24,11 +24,13 @@ import { runCarveEmit } from "./handlers/carve-emit";
 import { runCarveBridge } from "./handlers/carve-bridge";
 import { runCarveApply } from "./handlers/carve-apply";
 import { runLifecycleSnapshot, runLifecycleShow, runLifecycleDiff, runLifecycleRollback, runLifecyclePlan, runLifecycleAffected, runLifecycleLog, runLifecycleTeardown, runLifecycleUnknown } from "./handlers/lifecycle";
-import { runComponentsStatus, runComponentsReleaseRecord, runComponentsUnknown } from "./handlers/components";
+import { runComponentsStatus, runComponentsReleaseRecord, runComponentsExport, runComponentsUnknown } from "./handlers/components";
+import { runScenarioCheck, runScenarioUnknown } from "./handlers/scenario";
 import { runGraph } from "./handlers/graph";
 import { runExplain } from "./handlers/explain";
 import { runSearch } from "./handlers/search";
 import { runOp, runOpList, runOpStatus, runOpSignal, runOpCancel, runOpLog } from "./handlers/run";
+import { runOperator, runOperatorStatus, runApprove } from "./handlers/operator";
 import { runEmulator } from "./handlers/emulator";
 import { splitJoinedFlags, dispatchCommandGroup, collectCommandGroups, formatCommandGroupsHelp, type CommandGroup } from "./command-group";
 import type { LexiconPlugin } from "../lexicon";
@@ -80,6 +82,10 @@ const BOOLEAN_FLAGS = new Set([
   "--sandbox",
   "--yes",
   "--confirm-prod",
+  "--once",
+  "--check-live",
+  "--check-snapshot",
+  "--fail-on-drift",
 ]);
 
 /**
@@ -302,6 +308,12 @@ export function parseArgs(args: string[]): ParsedArgs {
       result.at = args[++i];
     } else if (arg === "--ambient") {
       result.ambient = true;
+    } else if (arg === "--check-live") {
+      result.checkLive = true;
+    } else if (arg === "--check-snapshot") {
+      result.checkSnapshot = true;
+    } else if (arg === "--fail-on-drift") {
+      result.failOnDrift = true;
     } else if (arg === "--run-examples") {
       result.runExamples = true;
     } else if (arg === "--pinned-digest") {
@@ -334,6 +346,17 @@ export function parseArgs(args: string[]): ParsedArgs {
       result.fold = false;
     } else if (arg === "--sandbox") {
       result.sandbox = true;
+    } else if (arg === "--fold-rank") {
+      // chant #1083 — same context-sensitive shape as --report above:
+      // `--fold-rank` alone prints the ranked-blocker report; `--fold-rank
+      // <path>` ALSO writes the Brendan Gregg collapsed-format export there.
+      const next = args[i + 1];
+      if (next && !next.startsWith("-")) {
+        result.foldRankCollapsedFile = next;
+        i++;
+      } else {
+        result.foldRank = true;
+      }
     } else if (arg === "--param") {
       // chant #1118/#1127 — `--param name=value` (space-separated) and
       // `--param=name=value` (joined, split above at its first `=` into flag
@@ -347,6 +370,14 @@ export function parseArgs(args: string[]): ParsedArgs {
       result.paramsFile = args[++i];
     } else if (arg === "--projection") {
       result.projection = args[++i];
+    } else if (arg === "--interval") {
+      result.interval = args[++i];
+    } else if (arg === "--lease-ttl") {
+      result.leaseTtl = args[++i];
+    } else if (arg === "--once") {
+      result.once = true;
+    } else if (arg === "--note") {
+      result.note = args[++i];
     } else if (arg.startsWith("--")) {
       // chant #1127 — every recognized flag is matched above; anything left
       // starting with `--` is unrecognized, whether it arrived bare
@@ -462,6 +493,24 @@ Ops:
                         consumer to render live wave/component/phase/step
                         progress instead of tailing raw logs (additive; run
                         semantics/exit code unchanged)
+  operator               Run scheduled ticks for discovered ConvergeOps
+                        locally, no Temporal (#1485): acquire/renew a per-op
+                        lease (git ref CAS), tick on --interval, record every
+                        result as a ledger fact. --env <env> scopes to one
+                        environment; --interval <dur> (default 60s) and
+                        --lease-ttl <dur> (default 5m) tune cadence; --once
+                        runs a single round and exits (cron/systemd-timer/
+                        CronJob invokers use this instead of the daemon)
+  operator status        Last tick, outcomes, and pending gates per
+                        ConvergeOp, read from the chant/lifecycle orphan
+                        branch alone — no daemon needs to be running
+                        (--env <env>, --json)
+  approve <op> <gate>    Record a gate's out-of-band resolution fact
+                        (--actor <name>, --note <text>) — the durable
+                        counterpart to a converge tick's gate-as-fact
+                        outcome; see the pending-gates list in operator
+                        status. Does not itself unblock the gated op's local
+                        dispatch (re-run --temporal, or merge its PR)
 
   graph                 Show Op dependency graph (--stacks for cross-stack order,
                         --format ir|mermaid|dot|layout for the lint-gated graph IR,
@@ -496,6 +545,12 @@ Lifecycle (alias: lc):
                             --confirm-prod, or an interactive confirmation)
   lifecycle log [env]       History of lifecycle snapshots
 
+Plan scenarios (#1292):
+  scenario check            Evaluate every declared Scenario's expect clause
+                            offline, against its given fixture (no cloud, no
+                            credentials); --json: emit verdicts as JSON.
+                            Nonzero exit on any failing scenario.
+
 Component release ledger + status:
   components status [env]  What's built vs what's deployed where, joined by
                             digest (--live: reconcile against live+ownership;
@@ -505,6 +560,11 @@ Component release ledger + status:
   components release <env> Append one immutable release record
                             (--component <name> --digest <sha256:...>
                              [--git-sha <sha>] [--run-id <id>] [--actor <name>])
+  components export <env>  Materialize a persisted build archive manifest to
+                            a portable directory (--component <name>
+                            [--digest <manifestDigest>] -o <dir> [--json]);
+                            copies every image/template/asset/sbom entry
+                            byte-for-byte plus a self-describing manifest.json
 
 Lexicon development:
   dev generate          Generate lexicon artifacts (+ validate + coverage)
@@ -590,6 +650,14 @@ Options:
   --no-fold             (build) Opt out of folding for this invocation: every
                         source module is imported and run, the pre-#1134
                         behavior. Beats chant.config.ts's build.fold.
+  --fold-rank [<path>]  (build, with --fold) Rank run-mode files by dominator
+                        retained-count over the forward import-failure graph
+                        (#1083) — fixing the top blocker unblocks the most
+                        files. Files held back only by the reverse rule
+                        (#1044) are reported separately, never folded into
+                        the ranking. With a path argument, also writes a
+                        Brendan Gregg collapsed-format export (weighted by
+                        retained count) there, for any flame/icicle viewer.
   --sandbox             (build) Run run-fallback source files (or every
                         file, without --fold) together, isolated, in one
                         sandboxed child process instead of in-process
@@ -620,6 +688,7 @@ Examples:
   chant build ./infra/ --components --generate gitlab --output .gitlab-ci.yml
   chant run --components search-service --env staging
   chant run --components all --env production
+  chant components export prod --component search-service -o ./dist/search-service
   chant import template.json --output ./infra/
   chant import --from prod --name my-bucket --output src/
   chant lint ./infra/
@@ -780,6 +849,10 @@ const registry: CommandDef[] = [
   { name: "run log", handler: runOpLog },
   { name: "run", handler: runOp },
 
+  { name: "operator status", handler: runOperatorStatus },
+  { name: "operator", handler: runOperator },
+  { name: "approve", handler: runApprove },
+
   { name: "graph", handler: runGraph },
   { name: "vendor", handler: runVendor },
 
@@ -793,9 +866,15 @@ const registry: CommandDef[] = [
   { name: "lifecycle teardown", requiresPlugins: true, handler: runLifecycleTeardown },
   { name: "lifecycle log", handler: runLifecycleLog },
 
+  // Plan scenarios (#1292) — fully offline, no plugin network calls, but
+  // requiresPlugins:true so the build step has serializers to partition
+  // against, same as every other build-then-something verb.
+  { name: "scenario check", requiresPlugins: true, handler: runScenarioCheck },
+
   // Component release ledger + status surface (#568, epic #551)
   { name: "components status", requiresPlugins: true, handler: runComponentsStatus },
   { name: "components release", handler: runComponentsReleaseRecord },
+  { name: "components export", handler: runComponentsExport },
 
   // Local emulators of configured lexicons (#920). Compound so the action word
   // lands in args.path (not consumed as a project dir) and projectPath is forced ".".
@@ -811,6 +890,7 @@ const registry: CommandDef[] = [
   { name: "carve", handler: runCarveUnknown },
   { name: "emulator", requiresPlugins: true, handler: runEmulator },
   { name: "lifecycle", handler: runLifecycleUnknown },
+  { name: "scenario", handler: runScenarioUnknown },
   { name: "dev", handler: runDevUnknown },
   { name: "serve", handler: runServeUnknown },
   { name: "components", handler: runComponentsUnknown },

package/src/cli/mcp/op-tools.ts

@@ -1,8 +1,9 @@
 import { resolve } from "node:path";
 import { discoverOps } from "../../op/discover";
 import { makeTemporalClient } from "../handlers/run";
-import { resolveWorkflowId } from "../handlers/run-client";
+import { resolveWorkflowId, fetchNormalizedHistory } from "../handlers/run-client";
 import { generateReport } from "../handlers/run-report";
+import { extractStepRecords, countActivities, queryGateState } from "../handlers/op-progress";
 import type { ToolRegistration } from "./lifecycle-tools";
 
 function workflowFnName(opName: string): string {
@@ -117,14 +118,22 @@ export function createOpStatusTool(): ToolRegistration {
       const name = params.name as string;
       const profile = params.profile as string | undefined;
 
+      const { ops } = await discoverOps();
+      const config = ops.get(name)?.config;
+
       const { client } = await makeTemporalClient(profile, resolve("."));
       const handle = client.workflow.getHandle(resolveWorkflowId(name));
       const desc = await handle.describe();
-      const history = await handle.fetchHistory();
+      const history = await fetchNormalizedHistory(handle);
 
-      const events = history.events ?? [];
-      const activitiesCompleted = events.filter((e) => e.eventType === "ActivityTaskCompleted").length;
-      const activitiesScheduled = events.filter((e) => e.eventType === "ActivityTaskScheduled").length;
+      const { completed: activitiesCompleted, scheduled: activitiesScheduled } = countActivities(history);
+      // Per-phase progress (#1676) — the same StepRecord shape `chant run
+      // <name> --json` uses locally, so a consumer renders one way
+      // regardless of executor. Only buildable when the Op's config was
+      // discoverable (a *.op.ts file on disk); absent otherwise rather than
+      // guessed at.
+      const progress = config ? extractStepRecords(config, history, { final: Boolean(desc.closeTime) }) : undefined;
+      const gate = await queryGateState(handle);
 
       return {
         workflowId: desc.workflowId,
@@ -135,6 +144,8 @@ export function createOpStatusTool(): ToolRegistration {
         taskQueue: desc.taskQueue,
         activitiesCompleted,
         activitiesScheduled,
+        ...(progress ? { progress } : {}),
+        gate: gate ?? null,
       };
     },
   };
@@ -196,7 +207,7 @@ export function createOpReportTool(): ToolRegistration {
       const { client } = await makeTemporalClient(profile, resolve("."));
       const handle = client.workflow.getHandle(resolveWorkflowId(name));
       const desc = await handle.describe();
-      const history = await handle.fetchHistory();
+      const history = await fetchNormalizedHistory(handle);
 
       return generateReport(name, config, desc, history);
     },

package/src/cli/mcp/resource-handlers.ts

@@ -5,7 +5,8 @@ import { getContext } from "./resources/context";
 import { readSnapshot, readEnvironmentSnapshots } from "../../lifecycle/git";
 import { discoverOps } from "../../op/discover";
 import { makeTemporalClient } from "../handlers/run";
-import { resolveWorkflowId } from "../handlers/run-client";
+import { resolveWorkflowId, fetchNormalizedHistory } from "../handlers/run-client";
+import { extractStepRecords, countActivities, queryGateState } from "../handlers/op-progress";
 import { loadOkfBundle } from "../../okf-read";
 import { loadChantConfigUpward, resolveKnowledgeDir } from "../../config";
 
@@ -177,11 +178,16 @@ export async function handleResourcesRead(
   if (uri.startsWith("chant://ops/") && uri.endsWith("/runs/latest")) {
     const name = uri.replace("chant://ops/", "").replace("/runs/latest", "");
     try {
+      const { ops } = await discoverOps();
+      const config = ops.get(name)?.config;
+
       const { client } = await makeTemporalClient(undefined, resolve("."));
       const handle = client.workflow.getHandle(resolveWorkflowId(name));
       const desc = await handle.describe();
-      const history = await handle.fetchHistory();
-      const events = history.events ?? [];
+      const history = await fetchNormalizedHistory(handle);
+      const { completed: activitiesCompleted, scheduled: activitiesScheduled } = countActivities(history);
+      const progress = config ? extractStepRecords(config, history, { final: Boolean(desc.closeTime) }) : undefined;
+      const gate = await queryGateState(handle);
       const result = {
         workflowId: desc.workflowId,
         runId: desc.runId,
@@ -189,8 +195,10 @@ export async function handleResourcesRead(
         startTime: desc.startTime,
         closeTime: desc.closeTime ?? null,
         taskQueue: desc.taskQueue,
-        activitiesCompleted: events.filter((e) => e.eventType === "ActivityTaskCompleted").length,
-        activitiesScheduled: events.filter((e) => e.eventType === "ActivityTaskScheduled").length,
+        activitiesCompleted,
+        activitiesScheduled,
+        ...(progress ? { progress } : {}),
+        gate: gate ?? null,
       };
       return {
         contents: [{ uri, mimeType: "application/json", text: JSON.stringify(result, null, 2) }],