@quantiya/codevibe-core 2.0.84 → 2.0.85

package/dist/local-executor/shadow-recovery.d.ts

@@ -84,7 +84,7 @@ interface ShadowMarkerScan {
         detail: string;
     }>;
 }
-export declare function scanShadowMarkers(env?: ShadowEnv): Promise<ShadowMarkerScan>;
+export declare function scanShadowMarkers(env?: ShadowEnv, ownedTaskIds?: ReadonlySet<string>): Promise<ShadowMarkerScan>;
 export declare function reconcileExposureRetentions(retentions: ShadowMarkerScan['exposureRetentions'], recovered: readonly RecoveredShadow[], physicalCopyScope: string, env: ShadowEnv, retained: string[], snapshotIncarnations: SnapshotIncarnationIndex | null): Promise<void>;
 export declare function reclaimDisplacedShadow(record: DisplacedShadowMarkerRecord, env: ShadowEnv, physicalCopyScope: string, opts: {
     allowLiveOwner: boolean;
@@ -110,7 +110,7 @@ export declare function reconcileDisplacedSnapshots(records: readonly DisplacedS
  * self-consistent pair. A v2 root of a format this desktop does not know is list-only, so it is not offered for
  * recovery at all — recovery acts on what it is given.
  */
-export declare function listRecoverableShadows(env?: ShadowEnv): Promise<RecoveredShadow[]>;
+export declare function listRecoverableShadows(env?: ShadowEnv, ownedTaskIds?: ReadonlySet<string>): Promise<RecoveredShadow[]>;
 /** `env` pinned to one root pair, so every default inside a pass resolves to that pair and nothing else. */
 export declare function pairEnv(env: ShadowEnv, pass: {
     stateRootDir: string;

package/dist/orchestration-shell/cli.js

@@ -46359,7 +46359,24 @@ async function readAnchoredStateMarkerSnapshotForScan(stateRootAuthority, stateD
     }
   };
 }
-async function scanShadowMarkers(env = {}) {
+function pinShadowTaskScope(ownedTaskIds) {
+  let taskScope = ownedTaskIds === void 0 ? void 0 : new Set(ownedTaskIds);
+  if (taskScope)
+    for (let taskId of taskScope) {
+      if (taskId.length === 0) throw new Error("WorkspaceShadow: empty owned task id");
+      assertSafeStateComponent(taskId);
+    }
+  return taskScope;
+}
+async function scanShadowMarkers(env = {}, ownedTaskIds) {
+  let taskScope = pinShadowTaskScope(ownedTaskIds);
+  if (taskScope?.size === 0) return {
+    recovered: [],
+    exposureRetentions: [],
+    displacedSnapshots: [],
+    protectedDirNames: /* @__PURE__ */ new Set(),
+    unresolved: []
+  };
   let helperTimeout = env.helperTimeoutMs ?? env.workspaceAuthorityHelperTimeoutMs ?? (env.signal ? 2e3 : void 0), maxStateMarkerBytes = resolveStateMarkerByteLimit(env), requestedStateRoot = env.stateRootDir ?? defaultStateRoot(), requestedShadowRoot = (await resolveShadowRoots(env)).shadowRootDir;
   if (env.signal?.aborted) return { recovered: [], exposureRetentions: [], displacedSnapshots: [], protectedDirNames: /* @__PURE__ */ new Set(), unresolved: [] };
   let stateRootAuthority = await captureWorkspaceRootAuthority(requestedStateRoot, {
@@ -46413,7 +46430,9 @@ async function scanShadowMarkers(env = {}) {
   for (let taskEntry of entries) {
     if (env.signal?.aborted) break;
     if (isStateRootInfrastructureDirectory(taskEntry.name) || !taskEntry.isDirectory() || taskEntry.isSymbolicLink()) continue;
-    let taskId = taskEntry.name, stateDir = path54.join(stateRoot, taskId), stateDirAuthority;
+    let taskId = taskEntry.name;
+    if (taskScope && !taskScope.has(taskId)) continue;
+    let stateDir = path54.join(stateRoot, taskId), stateDirAuthority;
     try {
       stateDirAuthority = await captureWorkspaceRootAuthority(stateDir, {
         helperTimeoutMs: helperTimeout,
@@ -47075,7 +47094,9 @@ async function reconcileDisplacedSnapshots(records, keepTaskIds, ttlMs, now, phy
       });
     }
 }
-async function listRecoverableShadows(env = {}) {
+async function listRecoverableShadows(env = {}, ownedTaskIds) {
+  let taskScope = pinShadowTaskScope(ownedTaskIds);
+  if (taskScope?.size === 0) return [];
   let out = [];
   for (let pass of await shadowRootPasses(env)) {
     if (!await passIsActionable(pass)) {
@@ -47084,7 +47105,7 @@ async function listRecoverableShadows(env = {}) {
       });
       continue;
     }
-    let scan = await scanShadowMarkers(pairEnv(env, pass));
+    let scan = await scanShadowMarkers(pairEnv(env, pass), taskScope);
     for (let recovered of scan.recovered)
       out.push({ ...recovered, rootPair: { stateRootDir: pass.stateRootDir, shadowRootDir: pass.shadowRootDir } });
   }
@@ -47178,16 +47199,18 @@ async function reconcileShadowPublicationAuthorityInPair(taskIds, env) {
   );
 }
 async function listShadowCleanupResidue(taskIds, env = {}) {
+  let taskScope = pinShadowTaskScope(taskIds);
+  if (taskScope.size === 0) return [];
   let residue = [];
   for (let pass of await shadowRootPasses(env))
-    residue.push(...await listShadowCleanupResidueInPair(taskIds, pairEnv(env, pass)));
+    residue.push(...await listShadowCleanupResidueInPair(taskScope, pairEnv(env, pass)));
   return residue;
 }
 async function listShadowCleanupResidueInPair(taskIds, env) {
   if (taskIds.size === 0) return [];
   for (let taskId of taskIds)
     if (taskId.length === 0 || taskId === "." || taskId === ".." || taskId.includes("\0") || path54.basename(taskId) !== taskId) throw new Error("invalid owned task id for workspace cleanup audit");
-  let scan = await scanShadowMarkers(env), residue = [], add = (record2) => {
+  let scan = await scanShadowMarkers(env, taskIds), residue = [], add = (record2) => {
     taskIds.has(record2.taskId) && (residue.some(
       (item2) => item2.taskId === record2.taskId && item2.path === record2.path && item2.kind === record2.kind
     ) || residue.push(record2));
@@ -60849,7 +60872,7 @@ var LocalExecutorImpl = class {
     try {
       [canonicalRepo, recovered, owner] = await Promise.all([
         captureWorkspaceRootAuthority(repoRoot).then((value) => value.canonicalPath),
-        listRecoverableShadows(env),
+        listRecoverableShadows(env, this.integrationTaskIdsOwned),
         currentProcessIdentity()
       ]);
     } catch (err) {
@@ -74246,7 +74269,8 @@ ${section}`);
    * unresolved authority are preserved, but returned as explicit failures.
    */
   async cleanupOwnedTaskSnapshots(taskIds, context) {
-    let failures = [], attemptFailures = [], env = this.deps.shadowEnv ?? {};
+    if (taskIds.size === 0) return [];
+    let failures = [], attemptFailures = [], env = this.deps.shadowEnv ?? {}, cleanupStartedAt = Date.now();
     (await Promise.allSettled([...taskIds].map(
       (taskId) => this.runExclusiveShadowOp(taskId, async () => {
         let shadow = this.shadowsByTask.get(taskId);
@@ -74258,11 +74282,11 @@ ${section}`);
         `${context} mapped workspace ${[...taskIds][index]} disposal failed`
       ));
     });
-    let canonicalWorkingDir, recovered, currentOwner;
+    let mappedSettledAt = Date.now(), canonicalWorkingDir, recovered, currentOwner;
     try {
       [canonicalWorkingDir, recovered, currentOwner] = await Promise.all([
         captureWorkspaceRootAuthority(this.deps.workingDir).then((authority) => authority.canonicalPath),
-        (this.deps.shadowRecoveryOps?.listRecoverableShadows ?? listRecoverableShadows)(env),
+        (this.deps.shadowRecoveryOps?.listRecoverableShadows ?? listRecoverableShadows)(env, taskIds),
         currentProcessIdentity()
       ]);
     } catch (err) {
@@ -74271,10 +74295,10 @@ ${section}`);
         `${context} durable workspace enumeration failed`
       )), failures.push(...attemptFailures), failures;
     }
-    let ownedRecovered = recovered.filter(
+    let enumeratedAt = Date.now(), ownedRecovered = recovered.filter(
       (item2) => item2.workingDir === canonicalWorkingDir && taskIds.has(item2.taskId)
     );
-    if ((await Promise.allSettled(ownedRecovered.map(
+    (await Promise.allSettled(ownedRecovered.map(
       (item2) => this.runExclusiveShadowOp(item2.taskId, async () => {
         if (!(item2.ownerProcessIdentity.pid === currentOwner.pid && item2.ownerProcessIdentity.incarnationId === currentOwner.incarnationId) && await isProcessIdentityAlive(item2.ownerProcessIdentity))
           throw new Error(
@@ -74295,7 +74319,9 @@ ${section}`);
           `${context} durable workspace ${item2.taskId} (${item2.stateFile}) disposal failed`
         ));
       }
-    }), !this.deps.shadowRecoveryOps)
+    });
+    let recoveredSettledAt = Date.now();
+    if (!this.deps.shadowRecoveryOps)
       try {
         await reconcileShadowPublicationAuthority(taskIds, env);
       } catch (err) {
@@ -74306,7 +74332,7 @@ ${section}`);
       }
     try {
       let remaining;
-      this.deps.shadowRecoveryOps?.listShadowCleanupResidue ? remaining = await this.deps.shadowRecoveryOps.listShadowCleanupResidue(taskIds, env) : this.deps.shadowRecoveryOps?.listRecoverableShadows ? remaining = (await this.deps.shadowRecoveryOps.listRecoverableShadows(env)).filter(
+      this.deps.shadowRecoveryOps?.listShadowCleanupResidue ? remaining = await this.deps.shadowRecoveryOps.listShadowCleanupResidue(taskIds, env) : this.deps.shadowRecoveryOps?.listRecoverableShadows ? remaining = (await this.deps.shadowRecoveryOps.listRecoverableShadows(env, taskIds)).filter(
         (item2) => item2.workingDir === canonicalWorkingDir && taskIds.has(item2.taskId)
       ).map((item2) => ({
         taskId: item2.taskId,
@@ -74330,7 +74356,15 @@ ${section}`);
         `${context} final durable workspace enumeration failed`
       )), failures.push(...attemptFailures);
     }
-    return failures;
+    return logger.debug("[QuorumLoop] owned workspace cleanup phase durations", {
+      context,
+      taskCount: taskIds.size,
+      recoveredCount: ownedRecovered.length,
+      mappedRetirementMs: mappedSettledAt - cleanupStartedAt,
+      durableEnumerationMs: enumeratedAt - mappedSettledAt,
+      recoveredRetirementMs: recoveredSettledAt - enumeratedAt,
+      publicationAndAuditMs: Date.now() - recoveredSettledAt
+    }), failures;
   }
   async disposeWorkspaces(opts = {}) {
     let strict = opts.strict ?? !0;

package/dist/orchestration-shell/quorum-loop.d.ts

@@ -518,7 +518,7 @@ export interface QuorumLoopDeps {
      * weakening any production timeout or filesystem check.
      */
     shadowRecoveryOps?: {
-        listRecoverableShadows?: (env: ShadowEnv) => Promise<RecoveredShadow[]>;
+        listRecoverableShadows?: (env: ShadowEnv, ownedTaskIds?: ReadonlySet<string>) => Promise<RecoveredShadow[]>;
         listShadowCleanupResidue?: (taskIds: ReadonlySet<string>, env: ShadowEnv) => Promise<ShadowCleanupResidue[]>;
         captureWorkspaceRootAuthority?: typeof captureWorkspaceRootAuthority;
         reopenShadow?: (recovered: RecoveredShadow, env: ShadowEnv) => Promise<WorkspaceShadow | null>;

package/package.json

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