@quantiya/codevibe-claude-plugin 2.0.10 → 2.0.11

package/node_modules/@quantiya/codevibe-core/dist/local-executor/workspace-shadow.d.ts

@@ -223,6 +223,13 @@ export declare class WorkspaceShadow {
     private constructor();
     /** @internal — test introspection of the tracked set. */
     get trackedSetForTests(): ReadonlySet<string>;
+    /**
+     * Number of paths this shadow tracks. 2026-08-22 — exposed for the reviewer
+     * timeout diagnostics: workspace SIZE is what separates "the diff was large"
+     * from "the workspace was large" when a reviewer blows its wall clock, and
+     * that distinction picks the fix. A count only; never the paths.
+     */
+    get trackedCount(): number;
     /** Exact user-root instance authenticated into reviewed team bundles. */
     rootAuthorityForBundle(): WorkspaceRootAuthority;
     /** Exact disposable-root incarnation required by every task-scoped consumer. */

package/node_modules/@quantiya/codevibe-core/dist/local-model/manager.d.ts

@@ -4,7 +4,7 @@ import { type LocalModelState, type LocalModelStateStore } from './state';
 import { type OllamaPullProgressListener } from './ollama';
 import type { LocalGemmaPlannerRunner } from '../planner/local-gemma';
 export type LocalModelCommand = 'install' | 'status' | 'remove' | 'enable' | 'warm' | 'health-check';
-export type LocalModelEntitlementSource = 'backend' | 'environment' | 'unauthenticated' | 'unavailable';
+export type LocalModelEntitlementSource = 'backend' | 'unauthenticated' | 'unavailable';
 export interface LocalModelEntitlement {
     tier: Tier | 'UNKNOWN';
     source: LocalModelEntitlementSource;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/audit-runner.d.ts

@@ -17,9 +17,8 @@ export interface RunAuditBrowserDeps {
     /** The session the task belongs to (the `queryAudit` 2-arg shape needs it). */
     sessionId: string;
     /**
-     * The effective tier. When provided (the CLI passes the `CODEVIBE_TIER` env
-     * value inline), it is authoritative (honors `CODEVIBE_TIER`). When omitted,
-     * the runner reads `getSubscriptionStatus().tier` from the backend.
+     * The effective tier from an already-authenticated caller. Production CLI
+     * omits this and lets the runner read `getSubscriptionStatus().tier`.
      */
     tier?: Tier;
     /** Test seam — defaults to `cryptoService.decryptContent`. */

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

@@ -84,8 +84,8 @@ export declare function resolveLaunchMode(args: Pick<ParsedCliArgs, 'agent'>, ti
  * Authentication, encryption, and backend admission are hard prerequisites.
  * Failures propagate to `main`, which exits before opening the shell.
  *
- * The tier is resolved here too (§3.C.19): a `CODEVIBE_TIER` env override wins
- * (the dev/dogfood lever), otherwise `getSubscriptionStatus` must succeed.
+ * The tier is resolved here too (§3.C.19): `getSubscriptionStatus` must
+ * succeed unless a test passes the explicit `deps.tier` seam.
  */
 export declare function resumeOrCreateSession(appsyncClient: AppSyncClient, deps?: {
     resolveSessionIdFn?: (client: AppSyncClient) => Promise<string | null>;

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

@@ -6832,6 +6832,8 @@ function formatTokens(n) {
 }
 function renderProgressLine(event) {
   switch (event.phase) {
+    case "preparing_workspace":
+      return "Preparing an isolated workspace copy \u2014 this can take a while on a large folder";
     case "shadow_created":
       return "Workspace copy ready \u2014 starting implementor";
     case "implementor_running": {
@@ -7063,6 +7065,10 @@ var REFRESH_ONLY_PHASES = /* @__PURE__ */ new Set([
   "not_applied",
   "progress_cleared"
 ]), IMPLEMENT_REVIEW_PHASES = /* @__PURE__ */ new Set([
+  // 2026-08-22 (Stage-1 MED-6) — the preparing window belongs to the same
+  // IMPLEMENT family as `shadow_created`; omitting it would silently DROP any
+  // REFRESH-ONLY event that arrives while it is open.
+  "preparing_workspace",
   "shadow_created",
   "implementor_running",
   "diff_captured",
@@ -23120,7 +23126,31 @@ var LocalGemmaPlannerAdapter = class {
 };
 
 // src/orchestration-shell/quorum-loop.ts
-var import_node_fs19 = require("node:fs"), path54 = __toESM(require("node:path")), os29 = __toESM(require("node:os")), import_uuid8 = require("uuid"), import_ulid4 = require("ulid");
+var import_node_fs19 = require("node:fs");
+
+// src/reduced-trust-notice.ts
+var surfacedRationales = /* @__PURE__ */ new Set();
+function noticeKey(sessionId, tier, reason) {
+  return `${sessionId}\0${tier}\0${reason}`;
+}
+function shouldSurfaceFullReducedTrustRationale(sessionId, tier, reason) {
+  let key = noticeKey(sessionId, tier, reason);
+  if (surfacedRationales.has(key)) return !1;
+  if (surfacedRationales.size >= 512) {
+    let oldest = surfacedRationales.values().next();
+    oldest.done || surfacedRationales.delete(oldest.value);
+  }
+  return surfacedRationales.add(key), !0;
+}
+function releaseReducedTrustRationaleClaim(sessionId, tier, reason) {
+  surfacedRationales.delete(noticeKey(sessionId, tier, reason));
+}
+function collapsedReducedTrustLine(actor) {
+  return `${actor} is running with reduced trust (same posture as above).`;
+}
+
+// src/orchestration-shell/quorum-loop.ts
+var path54 = __toESM(require("node:path")), os29 = __toESM(require("node:os")), import_uuid8 = require("uuid"), import_ulid4 = require("ulid");
 
 // src/local-executor/authority.ts
 var import_node_fs6 = require("node:fs"), path26 = __toESM(require("node:path")), AuthorityError = class extends Error {
@@ -26483,6 +26513,15 @@ var WorkspaceShadow = class _WorkspaceShadow {
   get trackedSetForTests() {
     return this.trackedSet;
   }
+  /**
+   * Number of paths this shadow tracks. 2026-08-22 — exposed for the reviewer
+   * timeout diagnostics: workspace SIZE is what separates "the diff was large"
+   * from "the workspace was large" when a reviewer blows its wall clock, and
+   * that distinction picks the fix. A count only; never the paths.
+   */
+  get trackedCount() {
+    return this.trackedSet.size;
+  }
   /** Exact user-root instance authenticated into reviewed team bundles. */
   rootAuthorityForBundle() {
     return { ...this.workspaceRootAuthority };
@@ -39174,7 +39213,7 @@ var LocalExecutorImpl = class {
       `[LocalExecutorImpl] \u26A0\uFE0F CP-7 REDUCED-TRUST (tier=${tier}) \u2014 the trusted-execution moat is ${tier === "none" ? "OFF" : "WEAKENED"} for this implementor session: ${reason}`,
       { sessionId: this.sessionId, agentKind, tier, reducedTrust: !0 }
     );
-    let content = `\u26A0\uFE0F Reduced-trust mode: ${reason} The implementor's ambient credentials may be reachable; the trusted-execution moat is ${tier === "none" ? "OFF" : "weakened"} for this session.`, metadata = {
+    let content = tier === "none" || shouldSurfaceFullReducedTrustRationale(this.sessionId, tier, reason) ? `\u26A0\uFE0F Reduced-trust mode: ${reason} The implementor's ambient credentials may be reachable; the trusted-execution moat is ${tier === "none" ? "OFF" : "weakened"} for this session.` : collapsedReducedTrustLine("The implementor"), metadata = {
       source: "cp7_reduced_trust",
       reducedTrust: !0,
       tier,
@@ -47115,7 +47154,7 @@ var CONTINUATION_EXPIRES_TTL_MS = 1440 * 60 * 1e3, ACTIVE_AGENT_KINDS = ["CLAUDE
 function isActiveAgentKind2(agent) {
   return agent === "CLAUDE" || agent === "CODEX" || agent === "ANTIGRAVITY";
 }
-var IMPLEMENTOR_TICK_MS = 1e4, TICK_SCAN_MAX_TRACKED = 5e3, TICK_SCAN_TIMEOUT_MS = 1e3, REVIEWER_ERROR_LOG_RAW_OUTPUT_CAP = 4e3;
+var IMPLEMENTOR_TICK_MS = 1e4, TICK_SCAN_MAX_TRACKED = 5e3, TICK_SCAN_TIMEOUT_MS = 1e3, BACKGROUND_RECOVERY_ABORTED = /* @__PURE__ */ Symbol("background-recovery-aborted"), REVIEWER_ERROR_LOG_RAW_OUTPUT_CAP = 4e3;
 function describeReviewerErrorDetail(detail) {
   switch (detail.kind) {
     case "timeout":
@@ -47898,6 +47937,8 @@ var QuorumLoop = class _QuorumLoop {
      * never call each other), so it cannot self-deadlock.
      */
     this.shadowOpsByTask = /* @__PURE__ */ new Map();
+    /** Abort only the read-only waits owned by non-draining startup recovery. */
+    this.backgroundRecoveryAbortControllers = /* @__PURE__ */ new Set();
     /** Once set, no new implementor workspace may be created for this session. */
     this.shuttingDown = !1;
     /**
@@ -48057,6 +48098,17 @@ var QuorumLoop = class _QuorumLoop {
         this.releaseRecoveryRelaunchPermit();
       }
   }
+  awaitBackgroundRecoveryStep(work, signal) {
+    return signal ? signal.aborted ? Promise.reject(BACKGROUND_RECOVERY_ABORTED) : new Promise((resolve18, reject) => {
+      let settled = !1, finish = (complete) => {
+        settled || (settled = !0, signal.removeEventListener("abort", onAbort), complete());
+      }, onAbort = () => finish(() => reject(BACKGROUND_RECOVERY_ABORTED));
+      signal.addEventListener("abort", onAbort, { once: !0 }), work.then(
+        (value) => finish(() => resolve18(value)),
+        (err) => finish(() => reject(err))
+      );
+    }) : work;
+  }
   /**
    * Serialize one shadow lifecycle op for `taskId` behind any in-flight op for
    * the same task. The op's result/rejection is returned to ITS caller; a
@@ -49047,6 +49099,10 @@ var QuorumLoop = class _QuorumLoop {
       roundActive = !1, tickTimer && (clearInterval(tickTimer), tickTimer = null);
     }, roundBriefForSpawn = args.brief, copiedForSpawn = [];
     try {
+      this.emitProgressForTask(args.taskId, originEpoch, {
+        phase: "preparing_workspace",
+        round: args.roundNumber
+      });
       let shadow = await this.ensureShadow(args.taskId);
       if (this.teamRunIsHalted(args.teamAuthority)) return;
       let snapshotAuthority = shadow.snapshotAuthorityForDispatch();
@@ -50611,7 +50667,9 @@ var QuorumLoop = class _QuorumLoop {
             role: args.role,
             agentKind: args.agentKind,
             guardMs: SEAT_EVALUATE_TIMEOUT_MS,
-            audit: "synthesized ESCALATE (#C1F-8): reviewer_error:timeout (seat-guard)"
+            audit: "synthesized ESCALATE (#C1F-8): reviewer_error:timeout (seat-guard)",
+            // 2026-08-22 — same timeout diagnostics as the inner path (below).
+            ...this.describeReviewShapeForDiagnostics(args.gateId)
           }), verdict = this.synthesizeEscalate(args, cleanReasoning);
         } else if (err instanceof ReviewerErrorClass) {
           let failureReason = failureReasonFromDetail(err.detail), cleanReasoning = failureReasonTemplate(args.agentKind, failureReason);
@@ -50625,7 +50683,21 @@ var QuorumLoop = class _QuorumLoop {
             // Audit prefix kept in LOGS only (#C1F-8) — never on the wire.
             audit: `synthesized ESCALATE (#C1F-8): reviewer_error:${err.detail.kind}`,
             ...describeReviewerErrorDetail(err.detail),
-            message: err.message
+            message: err.message,
+            // 2026-08-22 (dogfood) — TIMEOUT DIAGNOSTICS, local log only.
+            //
+            // A live 5-minute reviewer timeout on a ONE-FILE deletion diff was
+            // not root-causable from this record: it says the wall expired but
+            // nothing about what the reviewer was up against. Without the
+            // review's shape you cannot separate "the diff was genuinely large"
+            // from "the reviewer wandered the workspace" from "the host was
+            // saturated" — the three have different fixes, and guessing between
+            // them is how a one-off gets mistaken for a systemic defect.
+            //
+            // Emitted for EVERY reviewer error (cheap, and a spawn_failed
+            // benefits from the same shape context). All values are counts and
+            // labels — no diff content, no agent output, nothing on the wire.
+            ...this.describeReviewShapeForDiagnostics(args.gateId)
           }), verdict = this.synthesizeEscalate(args, cleanReasoning);
         } else
           throw err;
@@ -50767,17 +50839,58 @@ var QuorumLoop = class _QuorumLoop {
       agentKind: args.agentKind,
       reason
     });
+    let claimedFullRationale = !1;
     try {
-      this.surfaceHalt(
-        `Reviewer (${seatLabel(args.agentKind, args.seatId)}) is running with reduced trust: ${reason}`
+      let actor = `Reviewer (${seatLabel(args.agentKind, args.seatId)})`, sessionId = this.deps.session.sessionId;
+      claimedFullRationale = shouldSurfaceFullReducedTrustRationale(
+        sessionId,
+        "reviewer",
+        reason
+      ), this.surfaceHalt(
+        claimedFullRationale ? `${actor} is running with reduced trust: ${reason}` : collapsedReducedTrustLine(actor)
       );
     } catch (e) {
-      logger.warn("[QuorumLoop] reduced-trust badge surfaceHalt threw (badge is best-effort) \u2014 continuing", {
+      claimedFullRationale && releaseReducedTrustRationaleClaim(
+        this.deps.session.sessionId,
+        "reviewer",
+        reason
+      ), logger.warn("[QuorumLoop] reduced-trust badge surfaceHalt threw (badge is best-effort) \u2014 continuing", {
         seatId: args.seatId,
         err: e.message
       });
     }
   }
+  /**
+   * Local-only shape summary of the review a failing seat was working on.
+   *
+   * 2026-08-22 (dogfood): a reviewer wall-clock expiry told us WHEN it gave up
+   * and nothing about WHAT it faced, so a single load-induced timeout on a
+   * one-file diff looked indistinguishable from a systemic defect. These counts
+   * separate the three candidate causes (big diff / big workspace / saturated
+   * host) on the next occurrence.
+   *
+   * Counts and labels ONLY — never diff content, paths, or agent output. This
+   * feeds a `logger.warn` that stays on the desktop; nothing here reaches the
+   * wire. Fail-soft: diagnostics must never throw inside an error handler.
+   */
+  describeReviewShapeForDiagnostics(gateId) {
+    try {
+      let taskId = this.taskByGateId.get(gateId), reviewed = taskId ? this.reviewedSnapshotByTask.get(taskId) : void 0, shadow = taskId ? this.shadowForTask(taskId) : void 0;
+      return {
+        diagReviewFiles: reviewed?.length ?? null,
+        // Stage-2 R1 LOW-3: `.length` counts UTF-16 code units, not bytes, so a
+        // diff of multi-byte source under-reported against a byte-named field.
+        // `Buffer.byteLength` is the idiom already used in this file (~:774).
+        diagReviewBytes: reviewed?.reduce(
+          (sum, f) => sum + (f.content ? Buffer.byteLength(f.content, "utf8") : 0),
+          0
+        ) ?? null,
+        diagWorkspaceTracked: shadow?.trackedCount ?? null
+      };
+    } catch {
+      return { diagReviewFiles: null, diagUnavailable: !0 };
+    }
+  }
   // ─── CP-14 Wave B — confined class-2 resolver + final-tip Tier-2 dispatch ────
   /**
    * Wave B §2.1 confinement TRI-STATE for a merge-gate model/reviewer invocation
@@ -51240,17 +51353,25 @@ var QuorumLoop = class _QuorumLoop {
    * while `pending` and un-expired), so the approved code is never lost; a
    * re-delivered packet (or the next live edge) promotes it.
    */
-  recoverShadows() {
-    return this.startSessionWork((admission) => this.recoverShadowsOwned(admission));
+  recoverShadows(opts = {}) {
+    if (opts.drainOnShutdown ?? !0)
+      return this.startSessionWork((admission2) => this.recoverShadowsOwned(admission2));
+    if (this.shuttingDown) return Promise.resolve();
+    let admission = /* @__PURE__ */ Symbol("quorum-background-recovery"), controller = new AbortController();
+    this.backgroundRecoveryAbortControllers.add(controller);
+    let recovery = this.recoverShadowsOwned(admission, controller.signal), release = () => {
+      this.backgroundRecoveryAbortControllers.delete(controller);
+    };
+    return recovery.then(release, release), recovery;
   }
-  async recoverShadowsOwned(admission) {
+  async recoverShadowsOwned(admission, signal) {
     if (this.admittedSessionWorkMayContinue(admission))
       try {
-        let env = this.deps.shadowEnv ?? {}, [recoverable, canonicalWorkingDir, currentOwner] = await Promise.all([
+        let env = this.deps.shadowEnv ?? {}, [recoverable, canonicalWorkingDir, currentOwner] = await this.awaitBackgroundRecoveryStep(Promise.all([
           (this.deps.shadowRecoveryOps?.listRecoverableShadows ?? listRecoverableShadows)(env),
           (this.deps.shadowRecoveryOps?.captureWorkspaceRootAuthority ?? captureWorkspaceRootAuthority)(this.deps.workingDir).then((authority) => authority.canonicalPath),
           currentProcessIdentity()
-        ]);
+        ]), signal);
         if (!this.admittedSessionWorkMayContinue(admission)) return;
         let now = Date.now(), ttlMs = env.ttlMs ?? DEFAULT_SHADOW_TTL_MS, keep = /* @__PURE__ */ new Set();
         this.activeTaskId && keep.add(this.activeTaskId);
@@ -51273,9 +51394,15 @@ var QuorumLoop = class _QuorumLoop {
           try {
             await this.runExclusiveShadowOp(recovered.taskId, async () => {
               if (!this.admittedSessionWorkMayContinue(admission) || this.shadowsByTask.get(recovered.taskId)?.matchesRecoveredInstance(recovered)) return;
-              if (!(recovered.ownerProcessIdentity.pid === currentOwner.pid && recovered.ownerProcessIdentity.incarnationId === currentOwner.incarnationId) && await isProcessIdentityAlive(recovered.ownerProcessIdentity))
+              if (!(recovered.ownerProcessIdentity.pid === currentOwner.pid && recovered.ownerProcessIdentity.incarnationId === currentOwner.incarnationId) && await this.awaitBackgroundRecoveryStep(
+                isProcessIdentityAlive(recovered.ownerProcessIdentity),
+                signal
+              ))
                 throw new Error("recoverable workspace belongs to another live process");
-              let shadow = await (this.deps.shadowRecoveryOps?.reopenShadow ?? reopenShadow)(recovered, env);
+              let shadow = await this.awaitBackgroundRecoveryStep(
+                (this.deps.shadowRecoveryOps?.reopenShadow ?? reopenShadow)(recovered, env),
+                signal
+              );
               if (!this.admittedSessionWorkMayContinue(admission) || !shadow) return;
               if (!shadow.matchesRecoveredInstance(recovered))
                 throw new Error("reopened recovery snapshot changed exact authority");
@@ -51294,6 +51421,7 @@ var QuorumLoop = class _QuorumLoop {
               ));
             });
           } catch (err) {
+            if (err === BACKGROUND_RECOVERY_ABORTED) return;
             failures.push(this.rememberWorkspaceLifecycleFailure(
               err,
               `workspace ${recovered.taskId} recovery reconciliation failed`
@@ -51311,6 +51439,7 @@ var QuorumLoop = class _QuorumLoop {
             causes: failures
           });
       } catch (err) {
+        if (err === BACKGROUND_RECOVERY_ABORTED || !this.admittedSessionWorkMayContinue(admission)) return;
         let failure = this.rememberWorkspaceLifecycleFailure(
           err,
           "workspace recovery/GC sweep failed"
@@ -51446,7 +51575,10 @@ var QuorumLoop = class _QuorumLoop {
   }
   async disposeWorkspaces(opts = {}) {
     let strict = opts.strict ?? !0;
-    this.shuttingDown = !0, this.cancelRecoveryRelaunchWaiters(), this.pendingB1TaskGroupId = null, this.subscriptionReady = !1, this.bufferedTeamPackets.length = 0, this.pendingGateDispatches.length = 0;
+    this.shuttingDown = !0;
+    for (let controller of this.backgroundRecoveryAbortControllers)
+      controller.abort();
+    this.cancelRecoveryRelaunchWaiters(), this.pendingB1TaskGroupId = null, this.subscriptionReady = !1, this.bufferedTeamPackets.length = 0, this.pendingGateDispatches.length = 0;
     let failures = [], pendingImplementors = [...this.pendingImplementorByGate.values()];
     for (let pending of pendingImplementors)
       try {
@@ -53997,7 +54129,7 @@ async function runOrchestrationShell(args) {
         { error: err.message }
       );
     }
-    args.quorumLoop && args.quorumLoop.recoverShadows().catch((err) => {
+    args.quorumLoop && args.quorumLoop.recoverShadows({ drainOnShutdown: !1 }).catch((err) => {
       logger.warn("[orchestration-shell] startup workspace recovery failed", {
         error: err.message
       });
@@ -58973,6 +59105,7 @@ async function findPendingForIntent(intent, logger2) {
 var DEFINITIVE_CREATE_REJECTIONS = /* @__PURE__ */ new Set([
   "AccountDeletionInProgress",
   "CreationRequestConflict",
+  "InvalidSessionStatus",
   "RateLimited",
   "SessionIdReserved",
   "SessionIdRetired",
@@ -58982,6 +59115,7 @@ var DEFINITIVE_CREATE_REJECTIONS = /* @__PURE__ */ new Set([
   "UnauthorizedException"
 ]), DEFINITIVE_CREATE_REJECTION_CODES = /* @__PURE__ */ new Set([
   "RATE_LIMITED",
+  "INVALID_SESSION_STATUS",
   "SESSION_ID_RESERVED",
   "SESSION_LIMIT_EXCEEDED",
   "UNAUTHORIZED"
@@ -62742,9 +62876,6 @@ async function resumeOrCreateSession2(appsyncClient, deps) {
   }
 }
 async function resolveCliTier(appsyncClient) {
-  let envTier = process.env.CODEVIBE_TIER;
-  if (envTier === "FREE" || envTier === "PRO" || envTier === "MAX")
-    return envTier;
   try {
     return (await appsyncClient.getSubscriptionStatus()).tier;
   } catch (err) {
@@ -63031,15 +63162,17 @@ async function runAuditCli(parsed, deps) {
       `Usage: codevibe audit show <task-id> [--json] [--session <session-id>]
 `
     ), 2;
-  let appsyncClient = deps?.appsyncClient ?? new AppSyncClient();
+  let appsyncClient = deps?.appsyncClient ?? new AppSyncClient(), authenticated;
   try {
-    await appsyncClient.authenticateWithStoredTokens();
+    authenticated = await appsyncClient.authenticateWithStoredTokens();
   } catch (e) {
     return err(
       `Not signed in \u2014 run \`codevibe login\` first (${e?.message ?? "auth unavailable"}).
 `
     ), 2;
   }
+  if (!authenticated)
+    return err("Not signed in \u2014 run `codevibe login` first.\n"), 2;
   let sessionId = parsed.sessionId ?? null;
   if (!sessionId) {
     let resolveSessionId = deps?.resolveSessionIdFn ?? resolveActiveSessionId;
@@ -63059,10 +63192,7 @@ async function runAuditCli(parsed, deps) {
   let result = await runAuditBrowser({
     appsyncClient,
     taskId: parsed.taskId,
-    sessionId,
-    // Honor CODEVIBE_TIER for the Max gate (same override the rest of the CLI
-    // uses); when FREE/PRO/unset the runner falls back to getSubscriptionStatus.
-    tier: process.env.CODEVIBE_TIER === "MAX" || process.env.CODEVIBE_TIER === "PRO" || process.env.CODEVIBE_TIER === "FREE" ? process.env.CODEVIBE_TIER : void 0
+    sessionId
   });
   return parsed.json ? (out(`${JSON.stringify(result, null, 2)}
 `), 0) : (out(`${renderAuditResultText(result)}
@@ -63127,9 +63257,9 @@ Run codevibe --help for usage.
       error: err?.message
     });
   });
-  let localModelState = await readLocalModelState(), envTier = process.env.CODEVIBE_TIER, localModelEntitlement = {
+  let localModelState = await readLocalModelState(), localModelEntitlement = {
     tier,
-    source: envTier === "FREE" || envTier === "PRO" || envTier === "MAX" ? "environment" : "backend"
+    source: "backend"
   }, localModelBoot = resolveLocalModelBoot({
     requestedMode: mode,
     entitlement: localModelEntitlement,

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/quorum-loop.d.ts

@@ -369,8 +369,8 @@ export interface QuorumLoopDeps {
      */
     detectedAgents?: string[];
     /**
-     * #585 auto-continuation (Max) — the resolved subscription tier (from
-     * `resumeOrCreateSession`: env override → getSubscriptionStatus → FREE).
+     * #585 auto-continuation (Max) — the resolved authenticated subscription tier
+     * threaded from CLI startup/resume.
      * MAX → a quota-exhausted continuation handoff AUTO-ACCEPTS on the strongest
      * available agent (no prompt). Pro/Free/unresolved/absent → the existing
      * `continuation_offer_handoff` prompt (fail-closed). Auto-continuation only
@@ -1095,8 +1095,11 @@ export declare class QuorumLoop {
      * never call each other), so it cannot self-deadlock.
      */
     private readonly shadowOpsByTask;
+    /** Abort only the read-only waits owned by non-draining startup recovery. */
+    private readonly backgroundRecoveryAbortControllers;
     /** Once set, no new implementor workspace may be created for this session. */
     private shuttingDown;
+    private awaitBackgroundRecoveryStep;
     /**
      * Serialize one shadow lifecycle op for `taskId` behind any in-flight op for
      * the same task. The op's result/rejection is returned to ITS caller; a
@@ -1818,6 +1821,20 @@ export declare class QuorumLoop {
      * RUNS (it always runs; the badge only informs the user).
      */
     private surfaceReviewerReducedTrust;
+    /**
+     * Local-only shape summary of the review a failing seat was working on.
+     *
+     * 2026-08-22 (dogfood): a reviewer wall-clock expiry told us WHEN it gave up
+     * and nothing about WHAT it faced, so a single load-induced timeout on a
+     * one-file diff looked indistinguishable from a systemic defect. These counts
+     * separate the three candidate causes (big diff / big workspace / saturated
+     * host) on the next occurrence.
+     *
+     * Counts and labels ONLY — never diff content, paths, or agent output. This
+     * feeds a `logger.warn` that stays on the desktop; nothing here reaches the
+     * wire. Fail-soft: diagnostics must never throw inside an error handler.
+     */
+    private describeReviewShapeForDiagnostics;
     /**
      * Wave B §2.1 confinement TRI-STATE for a merge-gate model/reviewer invocation
      * (LOCK #C14-MOAT). Path A: the CP-7 substrate/broker (not opted out + a Trusted
@@ -1985,7 +2002,9 @@ export declare class QuorumLoop {
      * while `pending` and un-expired), so the approved code is never lost; a
      * re-delivered packet (or the next live edge) promotes it.
      */
-    recoverShadows(): Promise<void>;
+    recoverShadows(opts?: {
+        drainOnShutdown?: boolean;
+    }): Promise<void>;
     private recoverShadowsOwned;
     /**
      * Session-exit ownership boundary. Stop future creates, wait behind every

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/task-progress.d.ts

@@ -5,6 +5,9 @@
  * (controlled operational notice text; see the header + the entry's carve-out).
  */
 export type TaskProgressEvent = ({
+    phase: 'preparing_workspace';
+    round: number;
+} | {
     phase: 'shadow_created';
     round: number;
 } | {

package/node_modules/@quantiya/codevibe-core/dist/reduced-trust-notice.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Per-session de-duplication for the CP-7 reduced-trust rationale.
+ *
+ * WHY (2026-08-22, dogfood): the reduced-trust rationale is ~600 characters and
+ * was surfaced in FULL once per agent — implementor, reviewer seat 0, reviewer
+ * seat 1 — so a single one-file task printed roughly 1.8 KB of identical
+ * boilerplate that buried the actual progress milestones. In the live transcript
+ * the banner outweighed every `●` line combined.
+ *
+ * The rationale is genuinely important the FIRST time: it tells the operator the
+ * trusted-execution moat is weakened for this session and why. It carries no new
+ * information on the second and third repetition within the same session, where
+ * the tier and reason are identical.
+ *
+ * So: surface the full rationale ONCE per (session, tier, reason), and collapse
+ * every later occurrence to a one-line reminder that still names the actor. The
+ * WARN log is unaffected — the durable forensic record keeps every occurrence in
+ * full; only the user-facing surface is de-duplicated.
+ *
+ * Keyed on (sessionId, tier, reason) rather than sessionId alone so a session
+ * that DEGRADES (e.g. `sandbox_exec` → `none`, or a different reason) surfaces
+ * the new rationale in full rather than silently collapsing a more severe
+ * posture into a one-liner.
+ */
+/**
+ * True the FIRST time this exact (session, tier, reason) rationale is surfaced;
+ * false for every later call. Call once per user-facing surfacing decision.
+ */
+export declare function shouldSurfaceFullReducedTrustRationale(sessionId: string, tier: string, reason: string): boolean;
+/**
+ * Undo a claim (Stage-1 LOW-15). The caller test-and-sets BEFORE surfacing, so
+ * a surfacing that then THROWS would otherwise burn the "first" slot: every
+ * later actor collapses to "(same posture as above)" pointing at a rationale
+ * the operator never saw. Callers that surface fallibly must release on failure.
+ */
+export declare function releaseReducedTrustRationaleClaim(sessionId: string, tier: string, reason: string): void;
+/**
+ * The collapsed one-line form for a repeat occurrence. Names the actor so the
+ * operator can still see WHICH agent is reduced-trust, and points at the full
+ * rationale already in scrollback.
+ */
+export declare function collapsedReducedTrustLine(actor: string): string;
+/** Test-only reset — the Set is module-global and would leak across cases. */
+export declare function __resetReducedTrustNoticesForTest(): void;

package/node_modules/@quantiya/codevibe-core/dist/tool-activity/consolidator.d.ts

@@ -48,6 +48,13 @@ export interface ToolActivityTransport {
  * undecryptable generation forever (a liveness/G2 failure on key rotation).
  */
 export declare function isSessionKeyStaleError(err: unknown): boolean;
+/**
+ * True only when the backend has proved that this session generation can never
+ * accept another event. These errors settle the durable window terminally;
+ * key rotation, contention, throttling, networking, and unknown failures remain
+ * retryable so recoverable tool activity is never discarded.
+ */
+export declare function isTerminalSessionError(err: unknown): boolean;
 export interface ToolActivityConsolidatorOptions {
     agent: string;
     /** The backend session id bound into each window's envelope (X2a routing). */