@mstar-harness/dsh 3.7.3 → 3.8.0

package/dist/index.js

@@ -1122,8 +1122,8 @@ var require_lib2 = __commonJS(function(exports, module) {
 });
 
 // src/index.ts
-import { existsSync as existsSync22, readFileSync as readFileSync18, readdirSync as readdirSync14 } from "node:fs";
-import { join as join24 } from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync19, readdirSync as readdirSync14 } from "node:fs";
+import { join as join25 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import {
   apply as applySkillLocal,
@@ -4353,6 +4353,11 @@ function sessionCwdOf(agent) {
   const cwd = session?.header?.cwd;
   return typeof cwd === "string" && cwd.trim() !== "" ? cwd : undefined;
 }
+function sessionHeaderIdOf(agent) {
+  const session = agent?.session;
+  const id = session?.header?.id;
+  return typeof id === "string" && id.trim() !== "" ? id : undefined;
+}
 function actorAgentOf(actor) {
   return actor?.agent;
 }
@@ -4377,8 +4382,8 @@ function skillLocalConfig(config) {
 }
 
 // src/gates/catalog.ts
-import { existsSync as existsSync14, readFileSync as readFileSync8, readdirSync as readdirSync4 } from "node:fs";
-import { join as join8 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync11, readdirSync as readdirSync4 } from "node:fs";
+import { join as join12 } from "node:path";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 
 // src/gates/agent-flow.ts
@@ -4655,9 +4660,15 @@ function assignmentHeaderValue(headerRegion, label) {
   const line = headerRegion.match(bold)?.[1] ?? headerRegion.match(plain)?.[1];
   if (line === undefined)
     return;
-  const value = line.trim();
+  const value = stripWrappingCodeSpan(line.trim());
   return value === "" ? undefined : value;
 }
+function stripWrappingCodeSpan(value) {
+  if (value.length < 2 || !value.startsWith("`") || !value.endsWith("`"))
+    return value;
+  const inner = value.slice(1, -1);
+  return inner.includes("`") ? value : inner.trim();
+}
 function firstToken(value) {
   const token = value.split(/\s+/)[0];
   return token === "" ? undefined : token;
@@ -5639,6 +5650,228 @@ function recordTaskSettle(snapshot, pairing) {
   }
 }
 
+// src/engine-status-store.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync8, renameSync as renameSync3, rmSync, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname9, join as join8 } from "node:path";
+var ENGINE_STATUS_SNAPSHOT_VERSION = 1;
+var ENGINE_STATUS_SNAPSHOT_ENTRY_VERSION = 1;
+var ENGINE_STATUS_SNAPSHOT_MAX_PER_SESSION = 50;
+var ENGINE_STATUS_SNAPSHOT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+var ENGINE_STATUS_SNAPSHOT_MAX_BYTES = 16 * 1024 * 1024;
+var ENGINE_STATUS_SNAPSHOT_LOCK_TIMEOUT_MS = 250;
+var ENGINE_STATUS_SNAPSHOT_RELATIVE_PATH = "snapshots/engine-status.json";
+function engineStatusSnapshotPath(harnessDir) {
+  return join8(harnessDir, ENGINE_STATUS_SNAPSHOT_RELATIVE_PATH);
+}
+function engineStatusUnavailable(reason) {
+  return { kind: "unavailable", reason };
+}
+function isPlainObject6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value !== "" ? value : undefined;
+}
+function asEntry(value) {
+  if (!isPlainObject6(value))
+    return;
+  if (value.rv !== ENGINE_STATUS_SNAPSHOT_ENTRY_VERSION)
+    return;
+  const cwd = nonEmptyString(value.cwd);
+  const at = nonEmptyString(value.at);
+  if (cwd === undefined || at === undefined)
+    return;
+  if (typeof value.turn !== "number" || !Number.isFinite(value.turn))
+    return;
+  if (!isPlainObject6(value.payload))
+    return;
+  return { rv: value.rv, cwd, at, turn: value.turn, payload: value.payload };
+}
+function entryAge(at, nowMs) {
+  const parsed = Date.parse(at);
+  if (!Number.isFinite(parsed))
+    return;
+  return nowMs - parsed;
+}
+function readEngineStatusSnapshot(harnessDir, sessionId) {
+  if (harnessDir === null || harnessDir === "")
+    return engineStatusUnavailable("no-harness-dir");
+  if (sessionId === "")
+    return engineStatusUnavailable("no-session-entry");
+  let raw;
+  try {
+    raw = readFileSync8(engineStatusSnapshotPath(harnessDir), "utf8");
+  } catch (error) {
+    const code = error.code;
+    return engineStatusUnavailable(code === "ENOENT" ? "absent" : "unreadable");
+  }
+  let doc;
+  try {
+    doc = JSON.parse(raw);
+  } catch {
+    return engineStatusUnavailable("invalid-json");
+  }
+  if (!isPlainObject6(doc) || doc.sv !== ENGINE_STATUS_SNAPSHOT_VERSION) {
+    return engineStatusUnavailable("envelope-schema");
+  }
+  const entries = doc.entries;
+  if (!isPlainObject6(entries))
+    return engineStatusUnavailable("envelope-schema");
+  if (!Object.hasOwn(entries, sessionId))
+    return engineStatusUnavailable("no-session-entry");
+  const bucket = entries[sessionId];
+  if (!Array.isArray(bucket) || bucket.length === 0)
+    return engineStatusUnavailable("no-session-entry");
+  const entry = asEntry(bucket[bucket.length - 1]);
+  if (entry === undefined)
+    return engineStatusUnavailable("entry-schema");
+  return { kind: "ok", entry };
+}
+function sessionMap() {
+  return Object.create(null);
+}
+function loadForWrite(harnessDir) {
+  let raw;
+  try {
+    raw = readFileSync8(engineStatusSnapshotPath(harnessDir), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { kind: "ok", doc: { sv: ENGINE_STATUS_SNAPSHOT_VERSION, entries: sessionMap() } };
+    }
+    return { kind: "refused", reason: "store-unreadable" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { kind: "refused", reason: "store-invalid-json" };
+  }
+  if (!isPlainObject6(parsed) || parsed.sv !== ENGINE_STATUS_SNAPSHOT_VERSION || !isPlainObject6(parsed.entries)) {
+    return { kind: "refused", reason: "store-envelope-schema" };
+  }
+  const entries = sessionMap();
+  for (const [key, value] of Object.entries(parsed.entries)) {
+    if (!Array.isArray(value))
+      return { kind: "refused", reason: "store-entry-schema" };
+    const kept = [];
+    for (const candidate of value) {
+      const entry = asEntry(candidate);
+      if (entry === undefined)
+        return { kind: "refused", reason: "store-entry-schema" };
+      kept.push(entry);
+    }
+    if (kept.length > 0)
+      entries[key] = kept;
+  }
+  return { kind: "ok", doc: { sv: ENGINE_STATUS_SNAPSHOT_VERSION, entries } };
+}
+function pruneBucket(bucket, nowMs) {
+  const fresh = [];
+  for (const entry of bucket) {
+    const age = entryAge(entry.at, nowMs);
+    if (age === undefined || age > ENGINE_STATUS_SNAPSHOT_MAX_AGE_MS)
+      continue;
+    fresh.push(entry);
+  }
+  if (fresh.length <= ENGINE_STATUS_SNAPSHOT_MAX_PER_SESSION)
+    return fresh;
+  return fresh.slice(fresh.length - ENGINE_STATUS_SNAPSHOT_MAX_PER_SESSION);
+}
+function bucketRecency(bucket) {
+  let newest = 0;
+  for (const entry of bucket) {
+    const parsed = Date.parse(entry.at);
+    if (Number.isFinite(parsed) && parsed > newest)
+      newest = parsed;
+  }
+  return newest;
+}
+function enforceGlobalBound(pruned, keep, maxBytes, sizeOf) {
+  if (sizeOf(pruned) <= maxBytes)
+    return 0;
+  const candidates = Object.keys(pruned).filter((key) => key !== keep).map((key) => ({ key, recency: bucketRecency(pruned[key]) })).sort((left, right) => left.recency - right.recency);
+  let evicted = 0;
+  for (const candidate of candidates) {
+    if (sizeOf(pruned) <= maxBytes)
+      break;
+    delete pruned[candidate.key];
+    evicted += 1;
+  }
+  return evicted;
+}
+var oversizeWarned = new Set;
+function writeEngineStatusSnapshot(harnessDir, input) {
+  if (harnessDir === null || harnessDir === "")
+    return { kind: "degraded", reason: "no-harness-dir" };
+  if (input.sessionId === "")
+    return { kind: "degraded", reason: "no-session-id" };
+  if (input.cwd === "")
+    return { kind: "degraded", reason: "no-session-cwd" };
+  if (!Number.isFinite(input.turn))
+    return { kind: "degraded", reason: "invalid-turn" };
+  if (!isPlainObject6(input.payload))
+    return { kind: "degraded", reason: "payload-not-object" };
+  const at = (input.now ?? new Date).toISOString();
+  if (!Number.isFinite(Date.parse(at)))
+    return { kind: "degraded", reason: "invalid-timestamp" };
+  const dir = dirname9(engineStatusSnapshotPath(harnessDir));
+  const file = engineStatusSnapshotPath(harnessDir);
+  const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2, 10)}.tmp`;
+  try {
+    mkdirSync3(dir, { recursive: true });
+    return withWorkflowDirLock(dir, () => {
+      const loaded = loadForWrite(harnessDir);
+      if (loaded.kind === "refused")
+        return { kind: "degraded", reason: loaded.reason };
+      const doc = loaded.doc;
+      const nowMs = Date.parse(at);
+      const bucket = pruneBucket(doc.entries[input.sessionId] ?? [], nowMs);
+      bucket.push({
+        rv: ENGINE_STATUS_SNAPSHOT_ENTRY_VERSION,
+        cwd: input.cwd,
+        at,
+        turn: input.turn,
+        payload: input.payload
+      });
+      doc.entries[input.sessionId] = pruneBucket(bucket, nowMs);
+      const pruned = sessionMap();
+      for (const [key, value] of Object.entries(doc.entries)) {
+        const kept = pruneBucket(value, nowMs);
+        if (kept.length === 0)
+          continue;
+        pruned[key] = kept;
+      }
+      const maxBytes = input.maxBytes ?? ENGINE_STATUS_SNAPSHOT_MAX_BYTES;
+      const serialized = (entries) => JSON.stringify({ sv: ENGINE_STATUS_SNAPSHOT_VERSION, entries });
+      const evicted = enforceGlobalBound(pruned, input.sessionId, maxBytes, (entries) => Buffer.byteLength(serialized(entries), "utf8"));
+      const payload = serialized(pruned);
+      const oversized = Buffer.byteLength(payload, "utf8") > maxBytes;
+      let total = 0;
+      for (const kept of Object.values(pruned))
+        total += kept.length;
+      writeFileSync5(tmp, payload);
+      renameSync3(tmp, file);
+      let warn;
+      if (oversized && !oversizeWarned.has(file)) {
+        oversizeWarned.add(file);
+        warn = `engine-status snapshot store ${file} is above its ${maxBytes}-byte ceiling ` + `(kept ${total} entries, shed ${evicted} oldest session bucket(s) this write); ` + "recovery: delete the file — it is prunable plugin-owned state and readers answer unavailable for it";
+      }
+      return {
+        kind: "written",
+        path: file,
+        entries: total,
+        evicted,
+        ...warn === undefined ? {} : { warn }
+      };
+    }, { timeoutMs: ENGINE_STATUS_SNAPSHOT_LOCK_TIMEOUT_MS });
+  } catch (error) {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {}
+    return { kind: "degraded", reason: error?.message ?? "write-failed" };
+  }
+}
+
 // src/gates/catalog.ts
 var CATALOG_LOGGER = "mstar/engine-status-catalog";
 var DEFAULT_CATALOG_TTL_MS = 60000;
@@ -5655,18 +5888,19 @@ function residualSeverityIndex(severity) {
 function pluginVersion() {
   for (const rel of ["../package.json", "../../package.json"]) {
     try {
-      const pkg = JSON.parse(readFileSync8(new URL(rel, import.meta.url), "utf8"));
+      const pkg = JSON.parse(readFileSync11(new URL(rel, import.meta.url), "utf8"));
       if (typeof pkg.version === "string" && pkg.version !== "")
         return pkg.version;
     } catch {}
   }
   return "0.0.0";
 }
-function engineStatusSource(harnessDir) {
+function engineStatusSource() {
+  return { kind: "plugin", plugin: "mstar-engine-status", form: "catalog" };
+}
+function engineStatusPayload(harnessDir) {
   const iteration = harnessDir !== null ? iterationGateSource(harnessDir) : undefined;
   return {
-    kind: "mstar-engine-status",
-    form: "catalog",
     version: pluginVersion(),
     harnessDir,
     enforcement: harnessDir !== null ? resolveRepoEnforcement(harnessDir) : { hard: false, source: "none" },
@@ -5690,23 +5924,23 @@ function createCatalogInvalidation(cache) {
     }
   };
 }
-function buildCatalogSources(ctx, harnessDir) {
-  const source = engineStatusSource(harnessDir);
-  if (source.version === "0.0.0") {
+function buildCatalogPayload(ctx, harnessDir) {
+  const payload = engineStatusPayload(harnessDir);
+  if (payload.version === "0.0.0") {
     ctx.logger(CATALOG_LOGGER).warn("plugin manifest version unavailable — falling back to 0.0.0 for the engine-status catalog watermark");
   }
-  return source;
+  return payload;
 }
-function catalogSourcesFor(ctx, cache, register, key, harnessDir, ttlMs) {
+function catalogPayloadFor(ctx, cache, register, key, harnessDir, ttlMs) {
   const entry = cache.get(key);
   if (entry !== undefined && Date.now() - entry.builtAt < ttlMs) {
     register(harnessDir, key);
-    return entry.sources;
+    return entry.payload;
   }
-  const sources = buildCatalogSources(ctx, harnessDir);
-  cache.set(key, { sources, builtAt: Date.now() });
+  const payload = buildCatalogPayload(ctx, harnessDir);
+  cache.set(key, { payload, builtAt: Date.now() });
   register(harnessDir, key);
-  return sources;
+  return payload;
 }
 function renderEngineStatusCatalog(source) {
   const enforcement = `${source.enforcement.hard ? "hard" : "soft"}${source.enforcement.source === "none" ? "" : ` (${source.enforcement.source})`}`;
@@ -5784,7 +6018,7 @@ function hhmm(ts) {
 function harnessStateSource(harnessDir) {
   if (harnessDir === null)
     return null;
-  const statusPath = join8(harnessDir, STATUS_FILE);
+  const statusPath = join12(harnessDir, STATUS_FILE);
   if (!existsSync14(statusPath))
     return null;
   try {
@@ -5804,7 +6038,7 @@ function harnessStateSource(harnessDir) {
     if (selection.kind === "error") {
       return selectionErrorState(selection, rollup, harnessDir, compass);
     }
-    const snapshotPath = join8(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
+    const snapshotPath = join12(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
     let snapshot;
     if (!existsSync14(snapshotPath)) {
       return selectionErrorState({
@@ -5868,7 +6102,7 @@ function harnessStateSource(harnessDir) {
       leases,
       knowledge: knowledgeDigest(harnessDir),
       direction: compass !== undefined ? compassDirection(compass.compassPath) : null,
-      agentFlow: readAgentFlow(join8(harnessDir, selection.dir), 50)
+      agentFlow: readAgentFlow(join12(harnessDir, selection.dir), 50)
     };
   } catch {
     return null;
@@ -5908,11 +6142,11 @@ function projectRollupSource(harnessDir, residuals) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const roadmapPath = join8(projectsDir, entry.name, PROJECT_ROADMAP_FILE);
+      const roadmapPath = join12(projectsDir, entry.name, PROJECT_ROADMAP_FILE);
       if (!existsSync14(roadmapPath))
         continue;
       try {
-        const doc = parseCompassFrontmatterText(readFileSync8(roadmapPath, "utf8"), roadmapPath);
+        const doc = parseCompassFrontmatterText(readFileSync11(roadmapPath, "utf8"), roadmapPath);
         if (Array.isArray(doc.milestones)) {
           for (const milestone of doc.milestones) {
             if (typeof milestone === "string" && milestone.trim() !== "")
@@ -5986,7 +6220,7 @@ function projectRegisters(harnessDir) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const registerPath = join8(projectsDir, entry.name, PROJECT_REGISTER_FILE);
+    const registerPath = join12(projectsDir, entry.name, PROJECT_REGISTER_FILE);
     if (!existsSync14(registerPath))
       continue;
     try {
@@ -5998,13 +6232,13 @@ function projectRegisters(harnessDir) {
   return registers;
 }
 function knowledgeDigest(harnessDir) {
-  const indexPath = join8(harnessDir, "knowledge", "README.md");
+  const indexPath = join12(harnessDir, "knowledge", "README.md");
   if (!existsSync14(indexPath))
     return null;
   try {
     const categories = new Set;
     let docCount = 0;
-    for (const line of readFileSync8(indexPath, "utf8").split(/\r?\n/)) {
+    for (const line of readFileSync11(indexPath, "utf8").split(/\r?\n/)) {
       const row = line.trim().match(/^\|(.+)\|$/);
       if (row === null)
         continue;
@@ -6027,7 +6261,7 @@ function knowledgeDigest(harnessDir) {
 }
 function compassDirection(compassPath) {
   try {
-    const content = readFileSync8(compassPath, "utf8");
+    const content = readFileSync11(compassPath, "utf8");
     const section = content.match(/^## Direction lock[^\n]*\n+([\s\S]*?)(?=\n## |$)/m);
     if (section === null)
       return null;
@@ -6055,12 +6289,12 @@ function steeringCompassPath(harnessDir) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const compassPath = join8(iterationsDir, entry.name, "delivery-compass.md");
+    const compassPath = join12(iterationsDir, entry.name, "delivery-compass.md");
     if (!existsSync14(compassPath))
       continue;
     let content;
     try {
-      content = readFileSync8(compassPath, "utf8");
+      content = readFileSync11(compassPath, "utf8");
     } catch {
       continue;
     }
@@ -6074,7 +6308,7 @@ function steeringCompassPath(harnessDir) {
 function iterationGateSource(harnessDir) {
   if (harnessDir === null)
     return;
-  const statusPath = join8(harnessDir, STATUS_FILE);
+  const statusPath = join12(harnessDir, STATUS_FILE);
   if (!existsSync14(statusPath))
     return;
   const compass = steeringCompassPath(harnessDir);
@@ -6083,7 +6317,7 @@ function iterationGateSource(harnessDir) {
   const selection = resolveReadWorkflow(harnessDir);
   if (selection.kind === "error")
     return;
-  const snapshotPath = join8(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
+  const snapshotPath = join12(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
   try {
     const snapshotDoc = readJson(snapshotPath);
     const compassDoc = parseCompassFrontmatter(compass.compassPath);
@@ -6116,13 +6350,14 @@ async function preStepCatalogListener(ctx, resolver, explicitKey, cache, ttlMs,
     const cwd = sessionCwdOf(payload.agent);
     const harnessDir = resolver.forWorkspace(cwd);
     const key = explicitKey ?? cwd ?? "";
-    const sources = catalogSourcesFor(ctx, cache, register, key, harnessDir, ttlMs);
+    const catalogPayload = catalogPayloadFor(ctx, cache, register, key, harnessDir, ttlMs);
     const messages = [...decision.messages];
-    const text = renderEngineStatusCatalog(sources);
+    const text = renderEngineStatusCatalog(catalogPayload);
     const digestKey = agentDigestKey(payload.agent, cwd);
     const prior = digests.get(digestKey);
     if (prior === undefined || prior.turn !== payload.turn || prior.text !== text) {
-      messages.push(createUserMessage({ source: sources, content: [{ type: "text", text }] }));
+      messages.push(createUserMessage({ source: engineStatusSource(), content: [{ type: "text", text }] }));
+      persistEngineStatusSnapshot(ctx, harnessDir, cwd, payload.turn, catalogPayload, payload.agent);
     }
     digests.set(digestKey, { turn: payload.turn, text });
     return { kind: "enter", messages };
@@ -6135,10 +6370,208 @@ function agentDigestKey(agent, cwd) {
   const id = agent?.id;
   return `${typeof id === "string" ? id : "<unknown>"}\x00${cwd ?? ""}`;
 }
+function persistEngineStatusSnapshot(ctx, harnessDir, cwd, turn, catalogPayload, agent) {
+  const sessionId = sessionHeaderIdOf(agent);
+  if (sessionId === undefined || cwd === undefined)
+    return;
+  if (harnessDir === null)
+    return;
+  const result = writeEngineStatusSnapshot(harnessDir, {
+    sessionId,
+    cwd,
+    turn,
+    payload: catalogPayload
+  });
+  if (result.kind === "degraded") {
+    ctx.logger(CATALOG_LOGGER).warn(`engine-status snapshot not persisted for ${sessionId} (readers answer unavailable): ${result.reason}`);
+    return;
+  }
+  if (result.warn !== undefined)
+    ctx.logger(CATALOG_LOGGER).warn(result.warn);
+}
+
+// src/engine-status-endpoint.ts
+import { isAbsolute as isAbsolute3 } from "node:path";
+
+// ../../node_modules/.bun/@deepseek-ai+dsh-typert-protocol@0.1.5-rc.1+1e4e7adc57ac8890/node_modules/@deepseek-ai/dsh-typert-protocol/lib/index.js
+import { Service as Service2 } from "@deepseek-ai/cordis";
+var TYPERT_REMOTE_SEGMENT_PATTERN = /^[A-Za-z0-9_$.-]+$/;
+function isTypertRemoteSegment(value) {
+  return value !== "." && value !== ".." && TYPERT_REMOTE_SEGMENT_PATTERN.test(value);
+}
+function bindTypertRemote(service, serviceKey, options = {}) {
+  validateName("service key", serviceKey);
+  const namespace = options.namespace ?? serviceKey;
+  validateName("namespace", namespace);
+  return Object.freeze({
+    service,
+    serviceKey,
+    namespace
+  });
+}
+var TypertRemoteService = class extends Service2 {
+  typertRemote;
+  constructor(ctx, serviceKey, options = {}) {
+    super(ctx, serviceKey);
+    this.typertRemote = bindTypertRemote(this, this.name, options);
+  }
+};
+function validateName(subject, value) {
+  if (!isTypertRemoteSegment(value))
+    throw new TypeError(`typert-protocol: ${subject} must contain only RPC endpoint segment characters`);
+}
+
+// src/engine-status-wire.ts
+var MSTAR_ENGINE_STATUS_NAMESPACE = "mstar";
+var MSTAR_ENGINE_STATUS_METHOD = "engineStatus";
+
+// src/engine-status-endpoint.ts
+var CONTRIBUTING_PACKAGE = "@mstar-harness/dsh";
+var ENDPOINT_LOGGER = "mstar-engine-status-endpoint";
+function unavailable(reason) {
+  return { status: "unavailable", reason };
+}
+function nonEmptyString2(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function headerCwdOf(value) {
+  const header = value?.header;
+  return nonEmptyString2(header?.cwd);
+}
+function isRefusedPath(cwd) {
+  if (cwd.includes("\x00"))
+    return true;
+  if (!isAbsolute3(cwd))
+    return true;
+  return cwd.split(/[\\/]+/).includes("..");
+}
+
+class MstarEngineStatusGateway extends TypertRemoteService {
+  resolver;
+  bootHarnessDir;
+  constructor(ctx, options) {
+    super(ctx, MSTAR_ENGINE_STATUS_NAMESPACE);
+    this.resolver = options.resolver;
+    this.bootHarnessDir = options.bootHarnessDir;
+  }
+  async engineStatus(sessionId, cwd) {
+    try {
+      return await this.serve(sessionId, cwd);
+    } catch (error) {
+      this.ctx.logger(ENDPOINT_LOGGER).warn(`engineStatus failed for ${String(sessionId)} (answering unavailable): ${error?.message ?? error}`);
+      return unavailable("internal-error");
+    }
+  }
+  async serve(sessionId, cwd) {
+    const sid = nonEmptyString2(sessionId);
+    if (sid === undefined)
+      return unavailable("invalid-session-id");
+    const claimed = nonEmptyString2(cwd);
+    if (claimed === undefined)
+      return unavailable("invalid-cwd");
+    if (isRefusedPath(claimed))
+      return unavailable("cwd-refused");
+    const session = await this.resolveSessionCwd(sid);
+    if (session.kind !== "ok")
+      return unavailable(session.reason);
+    const harnessDir = this.bootHarnessDir ?? this.resolver.forWorkspace(session.cwd);
+    if (harnessDir === null || harnessDir === "")
+      return unavailable("no-harness-dir");
+    const read = readEngineStatusSnapshot(harnessDir, sid);
+    if (read.kind !== "ok")
+      return unavailable(`store-${read.reason}`);
+    const entry = read.entry;
+    if (entry.cwd !== claimed)
+      return unavailable("cwd-mismatch");
+    if (entry.cwd !== session.cwd)
+      return unavailable("session-cwd-mismatch");
+    return {
+      status: "ok",
+      sessionId: sid,
+      cwd: entry.cwd,
+      at: entry.at,
+      turn: entry.turn,
+      payload: entry.payload
+    };
+  }
+  async resolveSessionCwd(sessionId) {
+    const sessions = this.ctx.get("sessions");
+    const live = typeof sessions?.get === "function" ? sessions.get(sessionId) : undefined;
+    const liveCwd = headerCwdOf(live);
+    if (liveCwd !== undefined)
+      return { kind: "ok", cwd: liveCwd, source: "live" };
+    const controller = this.ctx.get("sessionController");
+    if (typeof controller?.inspect !== "function") {
+      return { kind: "unavailable", reason: live === undefined ? "session-absent" : "session-cwd-absent" };
+    }
+    let inspection;
+    try {
+      inspection = await controller.inspect(sessionId);
+    } catch {
+      return { kind: "unavailable", reason: "session-inspect-failed" };
+    }
+    const persistedCwd = headerCwdOf(inspection);
+    if (persistedCwd === undefined)
+      return { kind: "unavailable", reason: "session-cwd-absent" };
+    return { kind: "ok", cwd: persistedCwd, source: "persisted" };
+  }
+}
+function mstarEngineStatusContribution() {
+  return {
+    package: CONTRIBUTING_PACKAGE,
+    face: "host",
+    schemas: [],
+    model: { services: [], events: [], objects: [] },
+    invocations: [
+      {
+        id: `${CONTRIBUTING_PACKAGE}#${MSTAR_ENGINE_STATUS_NAMESPACE}/${MSTAR_ENGINE_STATUS_METHOD}`,
+        service: MSTAR_ENGINE_STATUS_NAMESPACE,
+        namespace: MSTAR_ENGINE_STATUS_NAMESPACE,
+        method: MSTAR_ENGINE_STATUS_METHOD,
+        invocation: { kind: "direct" },
+        parameters: [
+          { name: "sessionId", wire: "sessionId", source: "json", codec: { mode: "src-json" } },
+          { name: "cwd", wire: "cwd", source: "json", codec: { mode: "src-json" } }
+        ],
+        result: { mode: "src-json" }
+      }
+    ]
+  };
+}
+function engineStatusServicePresent(ctx) {
+  try {
+    return ctx.get(MSTAR_ENGINE_STATUS_NAMESPACE) !== undefined;
+  } catch {
+    return false;
+  }
+}
+function installEngineStatusEndpoint(ctx, options) {
+  if (engineStatusServicePresent(ctx)) {
+    ctx.logger(ENDPOINT_LOGGER).debug("mstar engine-status gateway already registered — kept as-is (multi-fiber dedupe)");
+  } else {
+    try {
+      new MstarEngineStatusGateway(ctx, options);
+    } catch (error) {
+      if (!(error instanceof Error) || !error.message.includes("has been registered"))
+        throw error;
+      ctx.logger(ENDPOINT_LOGGER).debug("mstar engine-status gateway registered concurrently — kept the first (multi-fiber dedupe)");
+    }
+  }
+  ctx.inject(["typert"], (tctx) => {
+    try {
+      return tctx.typert.register(mstarEngineStatusContribution());
+    } catch (error) {
+      if (!(error instanceof Error) || !error.message.includes("already registered"))
+        throw error;
+      tctx.logger(ENDPOINT_LOGGER).debug("mstar engine-status endpoints registered concurrently — none on this fiber (multi-fiber dedupe)");
+      return () => {};
+    }
+  });
+}
 
 // src/gates/status.ts
 import { existsSync as existsSync15, readdirSync as readdirSync7 } from "node:fs";
-import { basename as basename5, join as join12, relative as relative7, resolve as resolve10 } from "node:path";
+import { basename as basename5, join as join14, relative as relative7, resolve as resolve10 } from "node:path";
 var LOGGER_NAME = "mstar/status-gate";
 function harnessDocKindOfTarget(harnessDir, targetPath) {
   const resolved = resolve10(targetPath);
@@ -6154,8 +6587,8 @@ function harnessDocKindOfTarget(harnessDir, targetPath) {
     workflowDir = resolveWorkflowDir(harnessDir, { harnessDir });
     projectDir = resolveProjectDir(harnessDir, { harnessDir });
   } catch {
-    workflowDir = join12(harnessDir, "workflows");
-    projectDir = join12(harnessDir, "projects");
+    workflowDir = join14(harnessDir, "workflows");
+    projectDir = join14(harnessDir, "projects");
   }
   if (name === WORKFLOW_SNAPSHOT_FILE && /^[^/]+\/snapshot\.json$/.test(relative7(workflowDir, resolved)))
     return "snapshot";
@@ -6219,7 +6652,7 @@ function projectRegisterDocs(harnessDir) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const registerPath = join12(projectsDir, entry.name, PROJECT_REGISTER_FILE);
+    const registerPath = join14(projectsDir, entry.name, PROJECT_REGISTER_FILE);
     if (!existsSync15(registerPath))
       continue;
     try {
@@ -6293,8 +6726,8 @@ async function editIntentListener(ctx, resolver, config, adapter, target, actor,
 }
 
 // src/gates/skill-lint.ts
-import { existsSync as existsSync16, readFileSync as readFileSync11 } from "node:fs";
-import { basename as basename8, dirname as dirname9, resolve as resolve12, sep as sep2 } from "node:path";
+import { existsSync as existsSync16, readFileSync as readFileSync13 } from "node:fs";
+import { basename as basename8, dirname as dirname10, resolve as resolve12, sep as sep2 } from "node:path";
 var SKILL_LINT_LOGGER = "mstar/skill-lint";
 
 class SkillLintVetoError extends Error {
@@ -6335,7 +6768,7 @@ function lintSkillDoc(doc, options = {}) {
   return violations.length === 0 ? { ok: true, violations } : { ok: false, violations };
 }
 function lintSkillWrite(doc, options) {
-  const skillId = basename8(dirname9(resolve12(options.target)));
+  const skillId = basename8(dirname10(resolve12(options.target)));
   const result = lintSkillDoc(doc, { skillId });
   if (options.hard && !result.ok) {
     throw new SkillLintVetoError(options.target, result.violations);
@@ -6354,7 +6787,7 @@ function isSkillTarget(roots, target) {
   return roots.some((root) => resolvedPath.startsWith(resolve12(root) + sep2));
 }
 function skillNameOf(target) {
-  return basename8(dirname9(target.displayPath));
+  return basename8(dirname10(target.displayPath));
 }
 function skillCanonicalForm(target) {
   return resolveSkillRoot("dsh", { skill: skillNameOf(target), rel: "SKILL.md" });
@@ -6371,7 +6804,7 @@ function gateSkillIntent(ctx, harnessDir, config, target) {
       return;
     let doc;
     try {
-      doc = readFileSync11(skillPath, "utf8");
+      doc = readFileSync13(skillPath, "utf8");
     } catch (error) {
       ctx.logger(SKILL_LINT_LOGGER).error(`skill lint degraded to allow (cannot read ${skillPath}): ${error.message}`);
       ctx.emit("mstar/skill-lint", {
@@ -6384,7 +6817,7 @@ function gateSkillIntent(ctx, harnessDir, config, target) {
       });
       return;
     }
-    const result = lintSkillDoc(doc, { skillId: basename8(dirname9(skillPath)) });
+    const result = lintSkillDoc(doc, { skillId: basename8(dirname10(skillPath)) });
     if (result.ok)
       return;
     const hard = resolveSeamHard(harnessDir, config);
@@ -6418,8 +6851,8 @@ async function skillWriteIntentListener(ctx, resolver, config, target, actor, ne
 }
 
 // src/gates/seams.ts
-import { existsSync as existsSync17, readFileSync as readFileSync13, readdirSync as readdirSync10 } from "node:fs";
-import { basename as basename10, dirname as dirname10, join as join14, resolve as resolve14, sep as sep3 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync14, readdirSync as readdirSync10 } from "node:fs";
+import { basename as basename10, dirname as dirname11, join as join17, resolve as resolve14, sep as sep3 } from "node:path";
 
 // ../engine/dist/audit.js
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
@@ -6651,8 +7084,8 @@ function rolesDirOf(path) {
   const segments = resolve14(path).split(sep3);
   const idx = segments.indexOf("mstar-roles");
   if (idx === -1)
-    return dirname10(path);
-  return idx === 0 ? sep3 : join14(sep3, ...segments.slice(1, idx + 1));
+    return dirname11(path);
+  return idx === 0 ? sep3 : join17(sep3, ...segments.slice(1, idx + 1));
 }
 function isSeamTarget(seam, harnessDir, target) {
   const path = resolve14(target.displayPath);
@@ -6666,7 +7099,7 @@ function isSeamTarget(seam, harnessDir, target) {
     case "compound": {
       if (harnessDir === null)
         return false;
-      return path.startsWith(resolve14(join14(harnessDir, "knowledge")) + sep3) && isMarkdownDoc(path);
+      return path.startsWith(resolve14(join17(harnessDir, "knowledge")) + sep3) && isMarkdownDoc(path);
     }
     case "roles":
       return isRolesTarget(path);
@@ -6684,10 +7117,10 @@ function auditSecretsViolations(findings, file) {
 function validateDesignDoc(doc, path) {
   const violations = [...validateDesignTokenFrontmatter(doc).violations];
   const isDark = basename10(path) === "DESIGN.dark.md";
-  const sibling = join14(dirname10(path), isDark ? "DESIGN.md" : "DESIGN.dark.md");
+  const sibling = join17(dirname11(path), isDark ? "DESIGN.md" : "DESIGN.dark.md");
   if (existsSync17(sibling)) {
-    const light = isDark ? readFileSync13(sibling, "utf8") : doc;
-    const dark = isDark ? doc : readFileSync13(sibling, "utf8");
+    const light = isDark ? readFileSync14(sibling, "utf8") : doc;
+    const dark = isDark ? doc : readFileSync14(sibling, "utf8");
     violations.push(...assertLightDarkParity(light, dark).violations);
   }
   return violations.length === 0 ? { ok: true, violations } : { ok: false, violations };
@@ -6701,21 +7134,21 @@ function validateAuditDoc(doc, path) {
 function validateCompoundDoc(doc, _path, harnessDir) {
   const violations = [...validateSchemaYaml(doc).violations];
   if (harnessDir !== null) {
-    violations.push(...referenceExists(dirname10(harnessDir), doc).violations);
+    violations.push(...referenceExists(dirname11(harnessDir), doc).violations);
   }
   return violations.length === 0 ? { ok: true, violations } : { ok: false, violations };
 }
-function validateRolesState(rolesDir, skillsRoot = dirname10(rolesDir)) {
+function validateRolesState(rolesDir, skillsRoot = dirname11(rolesDir)) {
   const violations = [...validateRoleMapping(rolesDir).violations];
   const skillTexts = {};
   for (const entry of readdirSync10(skillsRoot, { withFileTypes: true })) {
     if (!entry.isDirectory() || !entry.name.startsWith("mstar-"))
       continue;
-    const skillFile = join14(skillsRoot, entry.name, "SKILL.md");
+    const skillFile = join17(skillsRoot, entry.name, "SKILL.md");
     if (!existsSync17(skillFile))
       continue;
     try {
-      skillTexts[entry.name] = readFileSync13(skillFile, "utf8");
+      skillTexts[entry.name] = readFileSync14(skillFile, "utf8");
     } catch {}
   }
   violations.push(...lintLoadOrder(skillTexts).violations);
@@ -6750,7 +7183,7 @@ function gateSeamIntent(ctx, harnessDir, config, seam, target) {
       return;
     let doc;
     try {
-      doc = readFileSync13(path, "utf8");
+      doc = readFileSync14(path, "utf8");
     } catch (error) {
       logger.error(`seam lint degraded to allow (cannot read ${path}): ${error.message}`);
       emitSeamAdvisory(ctx, seam, target.displayPath, { ok: true, violations: [] }, false, { degraded: true });
@@ -6816,8 +7249,8 @@ function lintRolesWrite(doc, options) {
 }
 
 // src/gates/tools.ts
-import { existsSync as existsSync18, readFileSync as readFileSync14 } from "node:fs";
-import { join as join17, resolve as resolve16 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync15 } from "node:fs";
+import { join as join19, resolve as resolve16 } from "node:path";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 var ITERATION_VIOLATION_SCHEMA = {
   type: "object",
@@ -7038,10 +7471,10 @@ function registerSeamTools(ctx, resolver) {
       isConcurrencySafe: () => false,
       async execute(args) {
         const abs = resolve16(args.dir);
-        const lightPath = join17(abs, "DESIGN.md");
+        const lightPath = join19(abs, "DESIGN.md");
         if (!existsSync18(lightPath))
           throw new Error(`design file not found: ${lightPath}`);
-        const light = readFileSync14(lightPath, "utf8");
+        const light = readFileSync15(lightPath, "utf8");
         const result = validateDesignDoc(light, lightPath);
         const level = completenessLevel(light);
         return {
@@ -7094,7 +7527,7 @@ function registerSeamTools(ctx, resolver) {
         const abs = resolve16(args.plan_path);
         if (!existsSync18(abs))
           throw new Error(`plan file not found: ${abs}`);
-        const text = readFileSync14(abs, "utf8");
+        const text = readFileSync15(abs, "utf8");
         const result = validateAuditDoc(text, abs);
         return { ok: result.ok, violations: result.violations.map(iterationViolationView), secrets: result.findings };
       }
@@ -7134,7 +7567,7 @@ function registerSeamTools(ctx, resolver) {
         const abs = resolve16(args.doc_path);
         if (!existsSync18(abs))
           throw new Error(`knowledge doc not found: ${abs}`);
-        const text = readFileSync14(abs, "utf8");
+        const text = readFileSync15(abs, "utf8");
         const base = validateCompoundDoc(text, abs, args.repo_root !== undefined ? null : resolver.forAgent(exec.agent));
         const violations = [...base.violations];
         if (args.repo_root !== undefined) {
@@ -7177,7 +7610,7 @@ function registerSeamTools(ctx, resolver) {
       isConcurrencySafe: () => false,
       async execute(args) {
         const rolesDir = resolve16(args.roles_dir);
-        if (!existsSync18(join17(rolesDir, "SKILL.md")))
+        if (!existsSync18(join19(rolesDir, "SKILL.md")))
           throw new Error(`roles dir not found: ${rolesDir}`);
         const result = validateRolesState(rolesDir, args.skills_root !== undefined ? resolve16(args.skills_root) : undefined);
         return { ok: result.ok, violations: result.violations.map(iterationViolationView) };
@@ -7188,8 +7621,8 @@ function registerSeamTools(ctx, resolver) {
 
 // src/gates/adapter.ts
 import { existsSync as existsSync19 } from "node:fs";
-import { join as join19 } from "node:path";
-import { Service as Service2 } from "@deepseek-ai/cordis";
+import { join as join20 } from "node:path";
+import { Service as Service3 } from "@deepseek-ai/cordis";
 var HOST_LOGGER = "mstar/host-adapter";
 function mergeLeasesMatch(left, right) {
   const a = left ?? {};
@@ -7197,7 +7630,7 @@ function mergeLeasesMatch(left, right) {
   return ["holder", "claimed_at", "plan_id", "source_branch", "target_branch"].every((key) => a[key] === b[key]);
 }
 
-class DshHostAdapter extends Service2 {
+class DshHostAdapter extends Service3 {
   host = "dsh";
   resolver;
   config;
@@ -7279,7 +7712,7 @@ class DshHostAdapter extends Service2 {
     if (harnessDir !== null) {
       const selection = resolveActiveWorkflow(harnessDir);
       if (selection.kind === "active") {
-        const snapshotPath = join19(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
+        const snapshotPath = join20(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
         try {
           const snapshot = readJson(snapshotPath);
           const stored = snapshot?.integration_merge_lease;
@@ -7305,8 +7738,8 @@ class DshHostAdapter extends Service2 {
 }
 
 // src/gates/agent-personas.ts
-import { readFileSync as readFileSync15, readdirSync as readdirSync12, statSync as statSync7 } from "node:fs";
-import { join as join20, resolve as resolve17, sep as sep5 } from "node:path";
+import { readFileSync as readFileSync16, readdirSync as readdirSync12, statSync as statSync7 } from "node:fs";
+import { join as join21, resolve as resolve17, sep as sep5 } from "node:path";
 var ROLE_ID_PATTERN = /^[a-z0-9-]{1,32}$/;
 var defaultCache = new Map;
 function personaFor(roleId, lookup, warn) {
@@ -7334,7 +7767,7 @@ function subagentRoleIds(agentsDir) {
     const roleId = name.slice(0, -3);
     let content;
     try {
-      content = readFileSync15(join20(agentsDir, name), "utf8");
+      content = readFileSync16(join21(agentsDir, name), "utf8");
     } catch {
       continue;
     }
@@ -7364,7 +7797,7 @@ function defaultFromMirror(agentsDir, roleId, warn) {
     return hit.text;
   let content;
   try {
-    content = readFileSync15(file, "utf8");
+    content = readFileSync16(file, "utf8");
   } catch {
     return;
   }
@@ -7595,8 +8028,8 @@ function log2(level, message) {
 }
 
 // src/gates/workflow-ledger.ts
-import { readFileSync as readFileSync16, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join21 } from "node:path";
+import { readFileSync as readFileSync17, renameSync as renameSync4, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join22 } from "node:path";
 var WORKFLOW_LEDGER_LOGGER = "mstar/workflow-ledger";
 var TOOL_WORKFLOW_RUN_START = "tool-workflow/run-start";
 var TOOL_WORKFLOW_AGENT_START = "tool-workflow/agent-start";
@@ -7640,7 +8073,7 @@ function loadWatermark(workflowDir, fresh = false) {
     return cached;
   const watermark = new Map;
   try {
-    const raw = readFileSync16(join21(workflowDir, WORKFLOW_LEDGER_WATERMARK_FILE), "utf8");
+    const raw = readFileSync17(join22(workflowDir, WORKFLOW_LEDGER_WATERMARK_FILE), "utf8");
     const record = asRecord(JSON.parse(raw));
     const cursors = asRecord(record?.cursors);
     if (cursors !== undefined) {
@@ -7663,10 +8096,10 @@ function loadWatermark(workflowDir, fresh = false) {
 }
 function saveWatermark(workflowDir, watermark) {
   try {
-    const file = join21(workflowDir, WORKFLOW_LEDGER_WATERMARK_FILE);
+    const file = join22(workflowDir, WORKFLOW_LEDGER_WATERMARK_FILE);
     const tmp = `${file}.tmp`;
-    writeFileSync5(tmp, JSON.stringify({ v: 1, cursors: Object.fromEntries(watermark) }));
-    renameSync3(tmp, file);
+    writeFileSync7(tmp, JSON.stringify({ v: 1, cursors: Object.fromEntries(watermark) }));
+    renameSync4(tmp, file);
   } catch (error) {
     log3("warn", `workflow-ledger watermark write failed for ${workflowDir} — in-memory only (restart re-records): ${errorMessage3(error)}`);
   }
@@ -7879,8 +8312,8 @@ function registerWorkflowLedger(ctx, resolver, workflowAskCache) {
 }
 
 // src/gates/goal-bridge.ts
-import { existsSync as existsSync20, readFileSync as readFileSync17, readdirSync as readdirSync13 } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync18, readdirSync as readdirSync13 } from "node:fs";
+import { join as join23 } from "node:path";
 var GOAL_BRIDGE_LOGGER = "mstar/goal-bridge";
 var DEFAULT_MAX_GOAL_ROUNDS = 256;
 var FLOW_SEQUENCE = "iteration-start → per-plan cycles → iteration-close → PR delivery → merge-ready";
@@ -7907,12 +8340,12 @@ function projectRegisterPointer(harnessDir) {
     for (const entry of readdirSync13(projectsDir, { withFileTypes: true })) {
       if (!entry.isDirectory())
         continue;
-      const registerPath = join22(projectsDir, entry.name, PROJECT_REGISTER_FILE);
+      const registerPath = join23(projectsDir, entry.name, PROJECT_REGISTER_FILE);
       if (existsSync20(registerPath))
         return registerPath;
     }
   } catch {}
-  return join22(projectsDir, _DEFAULT_PROJECT, PROJECT_REGISTER_FILE);
+  return join23(projectsDir, _DEFAULT_PROJECT, PROJECT_REGISTER_FILE);
 }
 function isRootLikeAgent(agent) {
   const header = agent?.session?.header;
@@ -7934,12 +8367,12 @@ function steeringCompass(harnessDir) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const compassPath = join22(iterationsDir, entry.name, "delivery-compass.md");
+    const compassPath = join23(iterationsDir, entry.name, "delivery-compass.md");
     if (!existsSync20(compassPath))
       continue;
     let content;
     try {
-      content = readFileSync17(compassPath, "utf8");
+      content = readFileSync18(compassPath, "utf8");
     } catch {
       continue;
     }
@@ -8116,7 +8549,7 @@ function registerGoalBridge(ctx, resolver, config) {
 
 // src/gates/plan-mode-bridge.ts
 import { existsSync as existsSync21 } from "node:fs";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 var PLAN_MODE_BRIDGE_LOGGER = "mstar/plan-mode-bridge";
 var PLAN_STATUS_TODO = "Todo";
 var planModeBridgeLogSink = () => {};
@@ -8132,13 +8565,13 @@ function errorMessage5(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function hasPrepareWindow(harnessDir) {
-  const statusPath = join23(harnessDir, STATUS_FILE);
+  const statusPath = join24(harnessDir, STATUS_FILE);
   if (!existsSync21(statusPath))
     return false;
   const selection = resolveReadWorkflow(harnessDir);
   if (selection.kind === "error")
     return false;
-  const snapshotPath = join23(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
+  const snapshotPath = join24(harnessDir, selection.dir, WORKFLOW_SNAPSHOT_FILE);
   let doc;
   try {
     doc = readJson(snapshotPath);
@@ -8584,16 +9017,16 @@ function engineStatusProvider(ctx, resolver, bootHarnessDir) {
     const now = Date.now();
     let entry = memo.get(harnessDir);
     if (entry === undefined || now - entry.builtAt >= DEFAULT_CATALOG_TTL_MS) {
-      entry = { source: buildCatalogSources(ctx, harnessDir), builtAt: now };
+      entry = { payload: buildCatalogPayload(ctx, harnessDir), builtAt: now };
       memo.set(harnessDir, entry);
     }
-    return engineStatusSummary(entry.source);
+    return engineStatusSummary(entry.payload);
   };
 }
 var DIGEST_PLAN_CAP = 8;
-function engineStatusSummary(source) {
-  const lines = [`mstar engine status: v${source.version}`];
-  const state = source.state;
+function engineStatusSummary(payload) {
+  const lines = [`mstar engine status: v${payload.version}`];
+  const state = payload.state;
   if (state !== null) {
     const selection = state.selection;
     if (selection.kind === "active") {
@@ -8678,7 +9111,7 @@ function registerMstarCommands(ctx) {
     for (const file of readdirSync14(dir).sort()) {
       if (!file.endsWith(".md"))
         continue;
-      const parsed = parseCommandMarkdown(readFileSync18(join24(dir, file), "utf8"));
+      const parsed = parseCommandMarkdown(readFileSync19(join25(dir, file), "utf8"));
       if (parsed === undefined)
         continue;
       commandsCtx.commands.register({
@@ -8871,7 +9304,7 @@ function apply(ctx, config) {
   const explicitKey = bootHarnessDir !== null ? EXPLICIT_CACHE_KEY : undefined;
   const catalogCache = new Map;
   if (explicitKey !== undefined) {
-    catalogCache.set(explicitKey, { sources: buildCatalogSources(ctx, bootHarnessDir), builtAt: Date.now() });
+    catalogCache.set(explicitKey, { payload: buildCatalogPayload(ctx, bootHarnessDir), builtAt: Date.now() });
   }
   const catalogInvalidation = createCatalogInvalidation(catalogCache);
   if (explicitKey !== undefined)
@@ -8879,6 +9312,7 @@ function apply(ctx, config) {
   setAgentFlowInvalidator(catalogInvalidation.invalidate);
   const catalogDigests = new Map;
   ctx.on("agent/pre-step", (payload, next) => preStepCatalogListener(ctx, resolver, explicitKey, catalogCache, ttlMs, catalogInvalidation.register, catalogDigests, payload, next));
+  installEngineStatusEndpoint(ctx, { resolver, bootHarnessDir });
   registerSddIterationTools(ctx, resolver);
   registerSeamTools(ctx, resolver);
 }