@quantiya/codevibe-codex-plugin 2.0.113 → 2.0.114

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/advisory-fingerprint/git-runner.d.ts

@@ -6,10 +6,10 @@ export declare class ProcessRunError extends Error {
     readonly signal: NodeJS.Signals | null;
     readonly killed: boolean;
     readonly stderr: string;
-    /** the deadline ended the run (or no time was left to start it) */
+    /** the deadline ended the run, no time was left to start it, or the runner was aborted */
     readonly timedOut: boolean;
     constructor(message: string, code: number | string | null, signal: NodeJS.Signals | null, killed: boolean, stderr: string, 
-    /** the deadline ended the run (or no time was left to start it) */
+    /** the deadline ended the run, no time was left to start it, or the runner was aborted */
     timedOut: boolean);
 }
 export interface ProcessRunner {
@@ -18,6 +18,11 @@ export interface ProcessRunner {
         cwd: string;
         env: NodeJS.ProcessEnv;
     }): Promise<string>;
+    /**
+     * End all remaining work: SIGKILL the group of every spawned child that has not closed, release queued runs, and fail
+     * every later run. Idempotent. Returns the ids of the process groups it ended (empty when nothing was live).
+     */
+    abort(): readonly number[];
     /** Process-group ids this runner spawned (diagnostics and tests). */
     readonly spawnedGroups: readonly number[];
 }

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/advisory-fingerprint/panel-baseline.d.ts

@@ -0,0 +1,18 @@
+import type { AdvisoryWorkspaceFingerprintProbe } from './walk';
+/** Longest a cell waits for its siblings before the shared probe starts anyway. */
+export declare const PANEL_BASELINE_COALESCE_MS = 100;
+export interface PanelBaselineTake {
+    probe: AdvisoryWorkspaceFingerprintProbe;
+    /** `shared`: the panel's probe; `own`: this cell asked after it started and ran its own */
+    baseline: 'shared' | 'own';
+    /** time from this cell's request to the start of its probe (the coalescing wait; 0 for `own`) */
+    waitedMs: number;
+}
+export interface PanelBaseline {
+    take(): Promise<PanelBaselineTake>;
+}
+export declare function createPanelBaseline(opts: {
+    expectedCells: number;
+    probe: () => Promise<AdvisoryWorkspaceFingerprintProbe>;
+    coalesceMs?: number;
+}): PanelBaseline;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/cli.js

@@ -14682,12 +14682,17 @@ function endGroup(pgid) {
   } catch {
   }
 }
+var abortedError = (code = null, signal = null, stderr = "") => new ProcessRunError("aborted", code, signal, !0, stderr, !0);
 function createProcessRunner(deadline, concurrency = 4) {
-  let spawnedGroups = [], active = 0, waiting = [], acquire = () => active < concurrency ? (active++, Promise.resolve()) : new Promise((resolve35) => waiting.push(() => (active++, resolve35()))), release = () => {
+  let spawnedGroups = [], live = /* @__PURE__ */ new Set(), runner = { state: "open" }, active = 0, waiting = [], acquire = () => active < concurrency || runner.state === "aborted" ? (active++, Promise.resolve()) : new Promise((resolve35) => waiting.push(() => (active++, resolve35()))), release = () => {
     active--;
     let next = waiting.shift();
     next && next();
   }, runOnce2 = (bin, args, opts) => new Promise((resolve35, reject) => {
+    if (runner.state === "aborted") {
+      reject(abortedError());
+      return;
+    }
     let remaining = deadline - Date.now();
     if (remaining < MIN_SPAWN_BUDGET_MS) {
       reject(new ProcessRunError("timeout", null, null, !1, "", !0));
@@ -14699,23 +14704,25 @@ function createProcessRunner(deadline, concurrency = 4) {
       detached: !0,
       // own process group: the whole group can be ended at the deadline
       stdio: ["ignore", "pipe", "pipe"]
-    });
-    typeof child.pid == "number" && spawnedGroups.push(child.pid);
+    }), pid = typeof child.pid == "number" ? child.pid : null;
+    pid !== null && (spawnedGroups.push(pid), live.add(pid));
     let out = [], outBytes = 0, err = "", timedOut = !1, overflow = !1, timer = setTimeout(() => {
-      timedOut = !0, typeof child.pid == "number" && endGroup(child.pid);
+      timedOut = !0, pid !== null && endGroup(pid);
     }, remaining);
     child.stdout?.on("data", (chunk) => {
       if (outBytes += chunk.length, outBytes > STDOUT_CAP_BYTES) {
-        overflow = !0, typeof child.pid == "number" && endGroup(child.pid);
+        overflow = !0, pid !== null && endGroup(pid);
         return;
       }
       out.push(chunk);
     }), child.stderr?.on("data", (chunk) => {
       err.length < STDERR_CAP_BYTES && (err += chunk.toString("utf8"));
     }), child.on("error", (spawnErr) => {
-      clearTimeout(timer), reject(new ProcessRunError(spawnErr.message, spawnErr.code ?? null, null, !1, err, !1));
+      if (clearTimeout(timer), pid !== null && live.delete(pid), runner.state === "aborted") return reject(abortedError(spawnErr.code ?? null, null, err));
+      reject(new ProcessRunError(spawnErr.message, spawnErr.code ?? null, null, !1, err, !1));
     }), child.on("close", (code, signal) => {
-      if (clearTimeout(timer), typeof child.pid == "number" && endGroup(child.pid), timedOut) return reject(new ProcessRunError("timeout", code, signal, !0, err, !0));
+      if (clearTimeout(timer), pid !== null && (live.delete(pid), endGroup(pid)), runner.state === "aborted") return reject(abortedError(code, signal, err));
+      if (timedOut) return reject(new ProcessRunError("timeout", code, signal, !0, err, !0));
       if (overflow) return reject(new ProcessRunError("output-too-large", code, signal, !0, err, !1));
       if (code === 0) return resolve35(Buffer.concat(out).toString("utf8"));
       reject(new ProcessRunError(`exit-${code ?? signal}`, code, signal, !1, err, !1));
@@ -14730,6 +14737,14 @@ function createProcessRunner(deadline, concurrency = 4) {
       } finally {
         release();
       }
+    },
+    abort() {
+      if (runner.state === "aborted") return [];
+      runner = { state: "aborted" };
+      let ended = [...live];
+      for (let pgid of ended) endGroup(pgid);
+      for (let next of waiting.splice(0)) next();
+      return ended;
     }
   };
 }
@@ -14812,13 +14827,19 @@ async function resolve3(runner, deps) {
   }
   return { kind: "available", bin };
 }
-var cached = null;
+var cached = null, cachedRunner = null;
 function handOffGit(runner, deps = defaultAvailabilityDeps) {
-  if (cached) return cached;
+  if (cached)
+    return cachedRunner === runner ? cached : cached.catch(() => handOffGit(runner, deps));
   let attempt = resolveHandOffGit(runner, deps);
-  return cached = attempt, attempt.catch(() => {
-    cached === attempt && (cached = null);
-  }), attempt;
+  return cached = attempt, cachedRunner = runner, attempt.then(
+    () => {
+      cached === attempt && (cachedRunner = null);
+    },
+    () => {
+      cached === attempt && (cached = null, cachedRunner = null);
+    }
+  ), attempt;
 }
 
 // src/orchestration-shell/advisory-fingerprint/repo-record.ts
@@ -15017,20 +15038,27 @@ async function probeAdvisoryWorkspaceFingerprintImpl(workspaceRoot, options = {}
     timer = setTimeout(() => {
       state.expired = !0, resolve35({ kind: "probe-failed", method: state.method, reason: "timeout", durationMs: Date.now() - started });
     }, Math.max(0, timeoutMs));
-  });
+  }), runner = createProcessRunner(started + timeoutMs, options.gitConcurrency ?? ADVISORY_GIT_CONCURRENCY), result;
   try {
-    return await Promise.race([body(workspaceRoot, started, started + timeoutMs, options, state), deadlineHit]);
+    return result = await Promise.race([body(workspaceRoot, started, started + timeoutMs, options, state, runner), deadlineHit]), result;
   } finally {
     clearTimeout(timer);
+    let ended = runner.abort();
+    ended.length > 0 && logger.warn("[orchestration-shell] advisory fingerprint: ended git process group(s) after the probe stopped", {
+      groups: ended.length,
+      pgids: ended,
+      reason: result?.kind === "probe-failed" ? result.reason : result?.kind ?? "unknown"
+    });
   }
 }
-async function body(workspaceRoot, started, deadline, options, state) {
+async function body(workspaceRoot, started, deadline, options, state, runner) {
+  let resolvedRoot;
   try {
-    await fs13.realpath(workspaceRoot);
+    resolvedRoot = await fs13.realpath(workspaceRoot);
   } catch (err) {
     return { kind: "probe-failed", method: "walk", reason: `root-unreadable:${errnoCode(err)}`, durationMs: Date.now() - started };
   }
-  let runner = createProcessRunner(deadline, options.gitConcurrency ?? ADVISORY_GIT_CONCURRENCY), marker = gitEnvSelectsRepository() ? "present" : await gitMarkerState(workspaceRoot);
+  let marker = gitEnvSelectsRepository() ? "present" : await gitMarkerState(workspaceRoot);
   if (marker === "unknown")
     return { kind: "probe-failed", method: "marker", reason: "git-marker-unknown", durationMs: Date.now() - started };
   if (marker === "present") {
@@ -15040,14 +15068,15 @@ async function body(workspaceRoot, started, deadline, options, state) {
     if (repo === "error")
       return { kind: "probe-failed", method: "git", reason: "git-rev-parse-failed", durationMs: Date.now() - started };
     if (repo === "repository") {
-      let failedGit = { kind: "probe-failed", method: "git", reason: "git-probe-failed" };
+      let failedGit = { kind: "probe-failed", method: "git", reason: "git-probe-failed" }, top = null;
       try {
-        let env = launchGitEnv(), top = (await runner.run("git", [...ADVISORY_GIT_PREFIX, "rev-parse", "--show-toplevel"], { cwd: workspaceRoot, env })).trim();
-        if (!top) return { ...failedGit, durationMs: Date.now() - started };
+        let env = launchGitEnv();
+        if (top = (await runner.run("git", [...ADVISORY_GIT_PREFIX, "rev-parse", "--show-toplevel"], { cwd: workspaceRoot, env })).trim() || null, !top) return { ...failedGit, durationMs: Date.now() - started };
         let value = `git:${await launchRecord(top, { runner, git: "git", env, before: null, controlSets: {}, repositories: 0 }, repositoryScrubbedEnv())}`;
         return state.expired || Date.now() > deadline ? { kind: "probe-failed", method: "git", reason: "timeout", durationMs: Date.now() - started } : { kind: "fingerprint", method: "git", value, entries: 1, durationMs: Date.now() - started };
       } catch (err) {
-        return err instanceof ProbeFailure ? logRepositoryFailure(workspaceRoot, err) : logRepositoryFailure(workspaceRoot, new ProbeFailure("git-probe-failed", workspaceRoot, failureCategory(err))), { ...failedGit, durationMs: Date.now() - started };
+        let logBase = top ?? resolvedRoot;
+        return err instanceof ProbeFailure ? logRepositoryFailure(logBase, err) : logRepositoryFailure(logBase, new ProbeFailure("git-probe-failed", logBase, failureCategory(err))), { ...failedGit, durationMs: Date.now() - started };
       }
     }
   }
@@ -15066,6 +15095,7 @@ async function walkFolder(workspaceRoot, started, deadline, options, state, runn
       return null;
     }
     if (shared.failure) throw shared.failure;
+    if (expired()) throw new ProbeFailure("timeout", abs, "timeout");
     try {
       let git2 = await handOff();
       if (!git2) return null;
@@ -15108,7 +15138,12 @@ async function walkFolder(workspaceRoot, started, deadline, options, state, runn
               if (st.isDirectory()) {
                 let repo = await repoOf(abs);
                 if (repo !== null) {
-                  let line = repo.record.then((value2) => JSON.stringify([rel, "repo", String(st.mode), value2]));
+                  let line = repo.record.then(
+                    (value2) => JSON.stringify([rel, "repo", String(st.mode), value2]),
+                    (err) => {
+                      throw err instanceof ProbeFailure ? err : new ProbeFailure("repo-probe-failed", abs, "record-other");
+                    }
+                  );
                   return line.catch(() => {
                   }), deferred.push(line), null;
                 }
@@ -33549,7 +33584,7 @@ function requestOllamaGenerateStream(config, promptText, opts) {
           reject(err instanceof Error ? err : new Error(String(err)));
         }
       }
-    }, guarded = (fn) => {
+    }, guarded2 = (fn) => {
       try {
         fn();
       } catch (err) {
@@ -33617,7 +33652,7 @@ function requestOllamaGenerateStream(config, promptText, opts) {
           res.resume(), finish(() => reject(new Error(`Ollama request failed with HTTP ${status}`)));
           return;
         }
-        activeRes = res, ndjson = /x-ndjson/i.test(String(res.headers["content-type"] ?? "")), res.on("error", (err) => finish(() => reject(err))), res.on("data", (chunk) => guarded(() => {
+        activeRes = res, ndjson = /x-ndjson/i.test(String(res.headers["content-type"] ?? "")), res.on("error", (err) => finish(() => reject(err))), res.on("data", (chunk) => guarded2(() => {
           if (settled) return;
           if (responseBytes += chunk.byteLength, responseBytes > MAX_RESPONSE_BYTES) {
             finish(() => reject(new Error("Ollama response exceeded the size limit"))), res.destroy();
@@ -33631,7 +33666,7 @@ function requestOllamaGenerateStream(config, promptText, opts) {
             buffer = buffer.slice(nl + 1), handleLine(line, res), nl = buffer.indexOf(`
 `);
           }
-        })), res.on("end", () => guarded(() => {
+        })), res.on("end", () => guarded2(() => {
           if (!settled && (buffer += decoder.end(), handleLine(buffer, res), buffer = "", !settled)) {
             if (!sawDone && (ndjson || chunks !== 1 || lastDone === !1)) {
               finish(
@@ -33732,14 +33767,14 @@ function requestOllamaPull(config, onProgress = () => {
           return;
         }
         res.on("error", (err) => finish(() => reject(err)));
-        let guarded = (fn) => {
+        let guarded2 = (fn) => {
           try {
             fn();
           } catch (err) {
             finish(() => reject(err instanceof Error ? err : new Error(String(err))));
           }
         };
-        res.on("data", (chunk) => guarded(() => {
+        res.on("data", (chunk) => guarded2(() => {
           if (settled) return;
           resetStall(), buffer += pullDecoder.write(chunk);
           let newlineIndex = buffer.indexOf(`
@@ -33751,7 +33786,7 @@ function requestOllamaPull(config, onProgress = () => {
 `);
           }
           buffer.length > MAX_PULL_LINE_BYTES && (finish(() => reject(new Error("Ollama pull response line exceeded the size limit"))), res.destroy());
-        })), res.on("end", () => guarded(() => {
+        })), res.on("end", () => guarded2(() => {
           settled || (buffer += pullDecoder.end(), handleLine(buffer), buffer = "", finish(() => resolve35()));
         }));
       }
@@ -94786,6 +94821,68 @@ function composeBrainstormPanelBrief(input) {
 `));
 }
 
+// src/orchestration-shell/structural-summary-notices.ts
+var STRUCTURAL_SUMMARY_TRUNCATED_NOTICE = "This folder is too large to summarize in full \u2014 agents see a partial overview. Start CodeVibe in a smaller folder for a complete one.", STRUCTURAL_SUMMARY_SLOW_NOTICE = "The workspace overview took longer than usual to build.";
+function structuralSummarySlowEvent(sessionId, elapsedMs) {
+  return {
+    sessionId,
+    type: "NOTIFICATION",
+    source: "DESKTOP",
+    isEncrypted: !0,
+    content: STRUCTURAL_SUMMARY_SLOW_NOTICE,
+    metadata: { event: "structural_summary_slow", elapsedMs: Math.round(elapsedMs) }
+  };
+}
+function structuralSummaryTruncatedEvent(sessionId, reason) {
+  return {
+    sessionId,
+    type: "NOTIFICATION",
+    source: "DESKTOP",
+    isEncrypted: !0,
+    content: STRUCTURAL_SUMMARY_TRUNCATED_NOTICE,
+    metadata: { event: "structural_summary_truncated", reason }
+  };
+}
+
+// src/orchestration-shell/advisory-fingerprint/panel-baseline.ts
+init_logger2();
+var PANEL_BASELINE_COALESCE_MS = 100;
+function guarded(probe) {
+  let started = Date.now();
+  return Promise.resolve().then(probe).catch(
+    () => ({
+      kind: "probe-failed",
+      method: "marker",
+      reason: "panel-baseline-error",
+      durationMs: Date.now() - started
+    })
+  );
+}
+function createPanelBaseline(opts) {
+  let coalesceMs = opts.coalesceMs ?? PANEL_BASELINE_COALESCE_MS, state = { phase: "collecting", arrived: 0, waiters: [], timer: null }, start = () => {
+    if (state.phase !== "collecting") return;
+    let { waiters, timer, arrived } = state;
+    timer && clearTimeout(timer);
+    let startedAt = Date.now(), result = guarded(opts.probe);
+    state = { phase: "started", result }, logger.info("[orchestration-shell] advisory fingerprint: panel baseline started", {
+      cells: opts.expectedCells,
+      arrived
+    });
+    for (let w of waiters)
+      result.then((probe) => w.resolve({ probe, baseline: "shared", waitedMs: Math.max(0, startedAt - w.askedAt) }));
+  };
+  return {
+    take() {
+      if (state.phase === "started")
+        return guarded(opts.probe).then((probe) => ({ probe, baseline: "own", waitedMs: 0 }));
+      let collecting = state;
+      return new Promise((resolve35) => {
+        collecting.waiters.push({ askedAt: Date.now(), resolve: resolve35 }), collecting.arrived += 1, collecting.arrived >= opts.expectedCells ? start() : collecting.timer === null && (collecting.timer = setTimeout(start, coalesceMs));
+      });
+    }
+  };
+}
+
 // src/orchestration-shell/index.ts
 init_process_markers();
 
@@ -99070,10 +99167,12 @@ async function runReadOnlyAgentAdvisoryResult(args) {
       throw new Error("advisory process retirement has no durable authority");
     let authority = processAuthority;
     await attachmentJournal.retireProcess(authority, owner), processAuthority = null;
-  } : void 0, advisoryTaskId = syntheticReadOnlyAdvisoryTaskId(), treeBefore = await probeAdvisoryWorkspaceFingerprint(args.workingDir);
+  } : void 0, advisoryTaskId = syntheticReadOnlyAdvisoryTaskId(), before = args.beforeProbe ? await args.beforeProbe() : { probe: await probeAdvisoryWorkspaceFingerprint(args.workingDir), baseline: "own", waitedMs: 0 }, treeBefore = before.probe;
   if (treeBefore.kind !== "fingerprint")
     return logger.error("[orchestration-shell] workspace fingerprint unavailable before read-only advisory turn \u2014 failing closed", {
       agent: args.agent,
+      baseline: before.baseline,
+      baselineWaitMs: before.waitedMs,
       workingDir: args.workingDir,
       method: treeBefore.method,
       reason: treeBefore.reason,
@@ -99128,7 +99227,9 @@ async function runReadOnlyAgentAdvisoryResult(args) {
     method: treeAfter.method,
     entries: treeAfter.entries,
     beforeMs: treeBefore.durationMs,
-    afterMs: treeAfter.durationMs
+    afterMs: treeAfter.durationMs,
+    baseline: before.baseline,
+    baselineWaitMs: before.waitedMs
   });
   let output = await readPlanModeOutput({
     agent: args.agent,
@@ -99310,7 +99411,7 @@ async function routeReadOnlyAgentMention(args) {
   });
   let newlyWalled = /* @__PURE__ */ new Set(), isPanelFanout = isBroadcast || agents.length > 1;
   try {
-    let completedCount = 0, cells = await Promise.all(agents.map(async (agent) => {
+    let completedCount = 0, panelBaseline = createPanelBaseline({ expectedCells: agents.length, probe: () => probeAdvisoryWorkspaceFingerprint(workingDir) }), cells = await Promise.all(agents.map(async (agent) => {
       let cellIntent = isBroadcast && args.intent.target !== "ALL" ? { ...args.intent, target: "ALL", rawMention: "@all" } : perAgentFraming && agent !== args.intent.target ? { ...args.intent, target: agent, rawMention: normalizedMentionForTarget(agent) } : args.intent, framingPrefix = perAgentFraming ? `You are being addressed as ${normalizedMentionForTarget(agent)}. Respond to the part(s) of the request directed at you; treat the rest as context.
 
 ` : "", attachmentTail = panelCopied.length > 0 ? `${renderAttachmentsForAgent(agent, panelCopied, workingDir)}
@@ -99328,6 +99429,7 @@ ${READ_ONLY_ADVISORY_ATTACHMENT_SCOPE_LINE}` : "", cellBrief = `${framingPrefix}
           // cell (the old 120s interactive cap killed whole-repo advisories mid-run
           // and left every advisor on the bounded failure label).
           timeoutMs: BRAINSTORM_PANEL_ADVISORY_TIMEOUT_MS,
+          beforeProbe: panelBaseline.take,
           ...panelPrepared?.advisoryCleanupAuthority ? { attachmentBatch: panelPrepared.advisoryCleanupAuthority.batch } : {}
         });
         if (!result.ok) {
@@ -100326,8 +100428,8 @@ async function routeDocumentInspectionAdvisory(deps) {
         text: output
       }), !0;
     } else {
-      let failureMessage = "A read-capable model is required to inspect and summarize documents in this workspace. No task was started and no files were modified.";
-      return result.usage.unavailableReason === "workspace_mutation_detected" ? failureMessage = "A workspace mutation was detected during document inspection. Please inspect the workspace." : result.usage.unavailableReason === "workspace_verification_unavailable" ? failureMessage = "Workspace integrity could not be verified following document inspection." : result.timedOut && (failureMessage = "Document inspection timed out. No task was started and no files were modified."), store.dispatch({
+      let failureMessage = "A read-capable model is required to inspect and summarize documents in this workspace. No task was started and no files were modified.", verificationText = workspaceVerificationMessage(result.usage.unavailableReason);
+      return verificationText ? failureMessage = verificationText : result.timedOut && (failureMessage = "Document inspection timed out. No task was started and no files were modified."), store.dispatch({
         type: "SHELL_ADVISORY",
         source: "shell",
         text: failureMessage
@@ -103342,24 +103444,12 @@ async function refreshStructuralSummaryIntoStore(deps) {
       "[orchestration-shell] emit STRUCTURAL_SUMMARY_GENERATED failed (non-fatal)",
       { error: err.message }
     );
-  }), result.recomputed && (elapsedMs > 2e3 && (emitShellEventBound({
-    sessionId: args.session.sessionId,
-    type: "NOTIFICATION",
-    source: "DESKTOP",
-    isEncrypted: !0,
-    metadata: { event: "structural_summary_slow", elapsedMs: Math.round(elapsedMs) }
-  }).catch(() => {
+  }), result.recomputed && (elapsedMs > 2e3 && (emitShellEventBound(structuralSummarySlowEvent(args.session.sessionId, elapsedMs)).catch(() => {
   }), logger.warn("[orchestration-shell] structural summary slow", {
     elapsedMs: Math.round(elapsedMs)
   })), summary.privacyEnvelope.budgetExceeded)) {
     let reason = summary.privacyEnvelope.budgetReason ?? "fileCount";
-    emitShellEventBound({
-      sessionId: args.session.sessionId,
-      type: "NOTIFICATION",
-      source: "DESKTOP",
-      isEncrypted: !0,
-      metadata: { event: "structural_summary_truncated", reason }
-    }).catch(() => {
+    emitShellEventBound(structuralSummaryTruncatedEvent(args.session.sessionId, reason)).catch(() => {
     }), logger.warn("[orchestration-shell] structural summary truncated", { reason });
   }
   return result;
@@ -103394,30 +103484,12 @@ async function runStructuralSummarySessionStart(deps) {
         "[orchestration-shell] emit STRUCTURAL_SUMMARY_GENERATED failed (non-fatal)",
         { error: err.message }
       );
-    }), elapsedMs > 2e3 && (emitShellEventBound({
-      sessionId: args.session.sessionId,
-      type: "NOTIFICATION",
-      source: "DESKTOP",
-      isEncrypted: !0,
-      metadata: {
-        event: "structural_summary_slow",
-        elapsedMs: Math.round(elapsedMs)
-      }
-    }).catch(() => {
+    }), elapsedMs > 2e3 && (emitShellEventBound(structuralSummarySlowEvent(args.session.sessionId, elapsedMs)).catch(() => {
     }), logger.warn("[orchestration-shell] structural summary slow", {
       elapsedMs: Math.round(elapsedMs)
     })), summary.privacyEnvelope.budgetExceeded) {
       let reason = summary.privacyEnvelope.budgetReason ?? "fileCount";
-      emitShellEventBound({
-        sessionId: args.session.sessionId,
-        type: "NOTIFICATION",
-        source: "DESKTOP",
-        isEncrypted: !0,
-        metadata: {
-          event: "structural_summary_truncated",
-          reason
-        }
-      }).catch(() => {
+      emitShellEventBound(structuralSummaryTruncatedEvent(args.session.sessionId, reason)).catch(() => {
       }), logger.warn("[orchestration-shell] structural summary truncated", {
         reason
       });

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/structural-summary-notices.d.ts

@@ -0,0 +1,7 @@
+import type { ShellEventEmit } from './emit-shell-event';
+export declare const STRUCTURAL_SUMMARY_TRUNCATED_NOTICE = "This folder is too large to summarize in full \u2014 agents see a partial overview. Start CodeVibe in a smaller folder for a complete one.";
+export declare const STRUCTURAL_SUMMARY_SLOW_NOTICE = "The workspace overview took longer than usual to build.";
+/** §4.7 slow-path audit: the summary walk took longer than its threshold. */
+export declare function structuralSummarySlowEvent(sessionId: string, elapsedMs: number): ShellEventEmit;
+/** The summary hit its privacy budget; `reason` is the dominant cause (file count before body bytes). */
+export declare function structuralSummaryTruncatedEvent(sessionId: string, reason: string): ShellEventEmit;

package/node_modules/@quantiya/codevibe-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-core",
-  "version": "2.0.97",
+  "version": "2.0.98",
   "description": "Core library for CodeVibe plugins - shared keychain, crypto, AppSync, and auth functionality",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-codex-plugin",
-  "version": "2.0.113",
+  "version": "2.0.114",
   "description": "Control OpenAI Codex CLI from your iPhone and Android — real-time sync, approve file edits, send prompts by voice. Part of CodeVibe.",
   "main": "dist/server.js",
   "codevibe": {
@@ -47,7 +47,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@quantiya/codevibe-core": "^2.0.97",
+    "@quantiya/codevibe-core": "^2.0.98",
     "@quantiya/quorum-core": "^1.0.1",
     "chokidar": "^4.0.0",
     "dotenv": "^16.6.1",