@quantiya/codevibe-claude-plugin 2.0.19 → 2.0.20

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

@@ -294,6 +294,8 @@ export interface ShadowEnv {
     afterQuotaReferenceMarkerEntry?: (filePath: string) => Promise<void> | void;
     /** @internal deterministic replacement seam after a quota-reference marker is opened. */
     afterQuotaReferenceMarkerStat?: (filePath: string) => Promise<void> | void;
+    /** @internal deterministic replacement seam after the final target lifecycle scan. */
+    afterQuotaRetirementTargetProof?: (shadowRoot: string) => Promise<void> | void;
     /** @internal fail initial/retry shadow-root durability before acknowledgement. */
     failShadowRootDirectorySyncStage?: 'target-child' | 'target-parent';
     /** @internal fail initial/retry state-root durability before acknowledgement. */

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

@@ -255,7 +255,17 @@ interface RegisteredShadowRoot extends AnchoredFsIdentity {
  * physical shadow root before copying, so the aggregate scan cannot be split by
  * different temp-root configuration.
  */
-export declare function registerAndListQuotaShadowRoots(stateRoot: string, stateRootIdentity: WorkspaceRootAuthority, currentShadowRoot: string, currentShadowRootIdentity: WorkspaceRootAuthority, publicationOwnerKey: string, maxStateMarkerBytes: number, afterQuotaReferenceTaskEntry?: (stateDir: string) => Promise<void> | void, afterQuotaReferenceMarkerEntry?: (filePath: string) => Promise<void> | void, afterQuotaReferenceMarkerStat?: (filePath: string) => Promise<void> | void, failDirectorySync?: boolean): Promise<RegisteredShadowRoot[]>;
+export declare function registerAndListQuotaShadowRoots(stateRoot: string, stateRootIdentity: WorkspaceRootAuthority, currentShadowRoot: string, currentShadowRootIdentity: WorkspaceRootAuthority, publicationOwnerKey: string, maxStateMarkerBytes: number, afterQuotaReferenceTaskEntry?: (stateDir: string) => Promise<void> | void, afterQuotaReferenceMarkerEntry?: (filePath: string) => Promise<void> | void, afterQuotaReferenceMarkerStat?: (filePath: string) => Promise<void> | void, failDirectorySync?: boolean, mode?: 'register-current' | 'retire-current-if-unused', afterQuotaRetirementTargetProof?: (shadowRoot: string) => Promise<void> | void): Promise<RegisteredShadowRoot[]>;
+/**
+ * Retire the exact current shadow-root authority after terminal cleanup.
+ *
+ * Registration and retirement share the same cross-process quota fence. The
+ * current root is removed only when the exact registered directory still
+ * exists, contains no generated snapshot/staging/tombstone, and is not named
+ * by any durable state or exposure marker. A missing, replaced, renamed, or
+ * referenced authority remains fail-closed in `registerAndListQuotaShadowRoots`.
+ */
+export declare function retireQuotaShadowRootIfUnused(stateRoot: string, stateRootIdentity: WorkspaceRootAuthority, currentShadowRoot: string, currentShadowRootIdentity: WorkspaceRootAuthority, publicationOwnerKey: string, maxStateMarkerBytes: number, afterQuotaReferenceTaskEntry?: (stateDir: string) => Promise<void> | void, afterQuotaReferenceMarkerEntry?: (filePath: string) => Promise<void> | void, afterQuotaReferenceMarkerStat?: (filePath: string) => Promise<void> | void, failDirectorySync?: boolean, afterQuotaRetirementTargetProof?: (shadowRoot: string) => Promise<void> | void): Promise<boolean>;
 interface CleanupBlockAnchorRead {
     present: boolean;
     cleanupOwners: ProcessCleanupOwner[];

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

@@ -229,6 +229,7 @@ export declare class WorkspaceShadow {
          */
         applyingAuthorityRetired?: boolean;
     }): Promise<void>;
+    private retirePhysicalCopyRootIfUnused;
     private retainExposureWriteAuthority;
     private runOwnedStateFileWrite;
     private acceptExposureSnapshot;

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

@@ -33076,8 +33076,13 @@ function isSameRegisteredRootAuthority(prior, current) {
 function isSameRootAfterDeviceReincarnation(prior, current) {
   return prior.dev !== current.dev && prior.ino === current.ino && prior.version === current.version && prior.canonicalPath === current.canonicalPath && prior.birthtimeNs === current.birthtimeNs;
 }
-async function collectDurablyReferencedShadowRoots(stateRoot, stateRootAuthority, maxStateMarkerBytes, registeredShadowRoots, afterTaskEntry, afterMarkerEntry, afterMarkerStat) {
-  let referenced = /* @__PURE__ */ new Set(), budget = createPathBudget(), taskEntries = await readDirectoryBounded(
+async function collectDurablyReferencedShadowRoots(stateRoot, stateRootAuthority, maxStateMarkerBytes, registeredShadowRoots, afterTaskEntry, afterMarkerEntry, afterMarkerStat, allowUnrecognizedRegularFiles = !1, allowUnregisteredReferences = !1, allowConcurrentSiblingTeardown = !1) {
+  let retryConcurrentSiblingTeardown = (error, target) => {
+    let code = error?.code, message = error instanceof Error ? error.message : String(error), isSiblingChurn = code === "ENOENT" || message.includes("workspace root changed while opening") || message.includes("workspace root cwd identity mismatch") || message.includes("workspace root changed during authority capture") || message.includes("bounded-directory target identity mismatch") || message.includes("bounded-directory parent changed while opening") || message.includes("bounded-directory parent changed while descending") || message.includes("anchored read root authority unavailable") || message.includes("anchored read root identity mismatch") || message.includes("anchored read root incarnation mismatch") || message.includes("anchored read directory chain changed") || message.includes("anchored read directory changed while descending") || message.includes("anchored read cwd identity mismatch") || message.includes("anchored read file identity mismatch") || message.includes("anchored read file changed during read") || message.includes("anchored read file path changed") || message.includes("anchored read file changed after read");
+    throw allowConcurrentSiblingTeardown && isSiblingChurn ? new Error(
+      `bounded-directory target changed during enumeration: ${target}; ${message}`
+    ) : error;
+  }, referenced = /* @__PURE__ */ new Set(), budget = createPathBudget(), taskEntries = await readDirectoryBounded(
     stateRoot,
     budget,
     "physical-copy root reference enumeration",
@@ -33090,15 +33095,24 @@ async function collectDurablyReferencedShadowRoots(stateRoot, stateRootAuthority
   );
   for (let taskEntry of taskEntries) {
     if (isStateRootInfrastructureDirectory(taskEntry.name) || taskEntry.name === SHADOW_ROOT_REGISTRY_FILE) continue;
-    if (!taskEntry.isDirectory() || taskEntry.isSymbolicLink())
+    if (!taskEntry.isDirectory() || taskEntry.isSymbolicLink()) {
+      if (allowUnrecognizedRegularFiles && taskEntry.isFile() && !taskEntry.isSymbolicLink()) continue;
       throw new Error("physical-copy root reference state entry changed type");
+    }
     let taskId = taskEntry.name, stateDir = path38.join(stateRoot, taskId), enumeratedStateDir = boundedDirectoryStat(taskEntry);
     if (!enumeratedStateDir)
       throw new Error("physical-copy root reference state entry lacks authority");
     await afterTaskEntry?.(stateDir);
-    let stateDirAuthority = await captureWorkspaceRootAuthority(stateDir);
+    let stateDirAuthority = await captureWorkspaceRootAuthority(stateDir).catch(
+      (error) => retryConcurrentSiblingTeardown(
+        error,
+        `sibling state directory ${taskId}`
+      )
+    );
     if (stateDirAuthority.dev !== enumeratedStateDir.dev || stateDirAuthority.ino !== enumeratedStateDir.ino || stateDirAuthority.birthtimeNs !== enumeratedStateDir.birthtimeNs || stateDirAuthority.canonicalPath !== enumeratedStateDir.canonicalPath || path38.dirname(stateDirAuthority.canonicalPath) !== stateRoot || path38.basename(stateDirAuthority.canonicalPath) !== taskId)
-      throw new Error("physical-copy root reference state directory changed after enumeration");
+      throw allowConcurrentSiblingTeardown ? new Error(
+        `bounded-directory target changed during enumeration: sibling state directory ${taskId}`
+      ) : new Error("physical-copy root reference state directory changed after enumeration");
     let markerEntries = await readDirectoryBounded(
       stateDir,
       budget,
@@ -33110,7 +33124,10 @@ async function collectDurablyReferencedShadowRoots(stateRoot, stateRootAuthority
         rootAuthority: stateRootAuthority,
         relativeDirectory: taskId
       }
-    );
+    ).catch((error) => retryConcurrentSiblingTeardown(
+      error,
+      `sibling state contents ${taskId}`
+    ));
     for (let markerEntry of markerEntries) {
       let isStateMarker = SHADOW_STATE_FILE_RE.test(markerEntry.name), isExposureRetention = SHADOW_EXPOSURE_RETENTION_FILE_RE.test(markerEntry.name);
       if (!isStateMarker && !isExposureRetention) continue;
@@ -33120,38 +33137,55 @@ async function collectDurablyReferencedShadowRoots(stateRoot, stateRootAuthority
       if (!enumeratedMarker)
         throw new Error("physical-copy root reference marker lacks authority");
       await afterMarkerEntry?.(stateFile);
-      let read = await anchoredReadFileWithinRoot(stateDir, markerEntry.name, {
-        maxBytes: maxStateMarkerBytes,
-        expectedRoot: stateDirAuthority,
-        expectedFile: enumeratedMarker,
-        requireSingleLink: !0,
-        afterStat: () => afterMarkerStat?.(stateFile)
-      });
-      if (!read) throw new Error("physical-copy root reference marker disappeared");
+      let read;
+      try {
+        read = await anchoredReadFileWithinRoot(stateDir, markerEntry.name, {
+          maxBytes: maxStateMarkerBytes,
+          expectedRoot: stateDirAuthority,
+          expectedFile: enumeratedMarker,
+          requireSingleLink: !0,
+          afterStat: () => afterMarkerStat?.(stateFile)
+        });
+      } catch (error) {
+        retryConcurrentSiblingTeardown(
+          error,
+          `sibling marker ${taskId}/${markerEntry.name}`
+        );
+      }
+      if (!read)
+        throw allowConcurrentSiblingTeardown ? new Error(
+          `bounded-directory target changed during enumeration: sibling marker ${taskId}/${markerEntry.name}`
+        ) : new Error("physical-copy root reference marker disappeared");
       let decoded = read.bytes.toString("utf8");
       if (!Buffer.from(decoded, "utf8").equals(read.bytes))
         throw new Error("physical-copy root reference marker is not strict UTF-8");
       let value = JSON.parse(decoded);
       if (isStateMarker) {
         let marker = validateMarkerShape(value, taskId), markerRoot2 = path38.dirname(marker.shadowDir);
-        if (!registeredShadowRoots.has(markerRoot2))
+        if (validateStateMarkerPlacement(marker, stateFile, stateDir, markerRoot2, stateRoot), !registeredShadowRoots.has(markerRoot2)) {
+          if (allowUnregisteredReferences) continue;
           throw new Error("physical-copy root reference marker names an unregistered root");
-        validateStateMarkerPlacement(marker, stateFile, stateDir, markerRoot2, stateRoot), referenced.add(markerRoot2);
+        }
+        referenced.add(markerRoot2);
         continue;
       }
       let preliminary = value;
       if (typeof preliminary.finalShadowDir != "string")
         throw new Error("physical-copy root exposure marker lacks a shadow path");
       let markerRoot = path38.dirname(preliminary.finalShadowDir);
-      if (!registeredShadowRoots.has(markerRoot))
+      if (assertExposureRetentionMarker(value, taskId, stateFile, markerRoot, stateRoot), !registeredShadowRoots.has(markerRoot)) {
+        if (allowUnregisteredReferences) continue;
         throw new Error("physical-copy root exposure marker names an unregistered root");
-      assertExposureRetentionMarker(value, taskId, stateFile, markerRoot, stateRoot), referenced.add(markerRoot);
+      }
+      referenced.add(markerRoot);
     }
   }
   return referenced;
 }
-async function registerAndListQuotaShadowRoots(stateRoot, stateRootIdentity, currentShadowRoot, currentShadowRootIdentity, publicationOwnerKey, maxStateMarkerBytes, afterQuotaReferenceTaskEntry, afterQuotaReferenceMarkerEntry, afterQuotaReferenceMarkerStat, failDirectorySync = !1) {
-  let registryPath = path38.join(stateRoot, SHADOW_ROOT_REGISTRY_FILE), expected = await captureAnchoredWritePrecondition(registryPath, 1024 * 1024), roots = [];
+async function registerAndListQuotaShadowRoots(stateRoot, stateRootIdentity, currentShadowRoot, currentShadowRootIdentity, publicationOwnerKey, maxStateMarkerBytes, afterQuotaReferenceTaskEntry, afterQuotaReferenceMarkerEntry, afterQuotaReferenceMarkerStat, failDirectorySync = !1, mode = "register-current", afterQuotaRetirementTargetProof) {
+  let registryPath = path38.join(stateRoot, SHADOW_ROOT_REGISTRY_FILE), expected = await captureAnchoredWritePrecondition(registryPath, 1024 * 1024);
+  if (mode === "retire-current-if-unused" && expected.kind === "absent") return [];
+  let roots = [];
   if (expected.kind === "existing") {
     let read = await anchoredReadFileWithinRoot(stateRoot, SHADOW_ROOT_REGISTRY_FILE, {
       maxBytes: 1048576
@@ -33171,13 +33205,16 @@ async function registerAndListQuotaShadowRoots(stateRoot, stateRootIdentity, cur
     if (consumeMetadataPath(registryBudget, root.path, "physical-copy root registry"), byPath.has(root.path)) throw new Error("physical-copy root registry contains duplicates");
     byPath.set(root.path, root);
   }
-  let priorCurrent = byPath.get(currentShadowRoot), reincarnatedDevice = null;
+  let priorCurrent = byPath.get(currentShadowRoot);
+  if (mode === "retire-current-if-unused" && !priorCurrent)
+    return roots;
+  let reincarnatedDevice = null;
   if (priorCurrent && !isSameRegisteredRootAuthority(priorCurrent, currentShadowRootIdentity))
     if (isSameRootAfterDeviceReincarnation(priorCurrent, currentShadowRootIdentity))
       reincarnatedDevice = priorCurrent.dev;
     else
       throw new Error("physical-copy root changed identity while quota authority is retained");
-  if (priorCurrent || consumeMetadataPath(registryBudget, currentShadowRoot, "physical-copy root registry"), byPath.set(currentShadowRoot, { path: currentShadowRoot, ...currentShadowRootIdentity }), byPath.size > 256) throw new Error("physical-copy root registry exceeds 256 roots");
+  if (!priorCurrent && mode === "register-current" && consumeMetadataPath(registryBudget, currentShadowRoot, "physical-copy root registry"), mode === "register-current" && byPath.set(currentShadowRoot, { path: currentShadowRoot, ...currentShadowRootIdentity }), byPath.size > 256) throw new Error("physical-copy root registry exceeds 256 roots");
   let retained = [], scanBudget = createPathBudget(), referencedShadowRoots = null, hasPhysicalCopyEntry = async (candidate) => {
     let liveRoot;
     try {
@@ -33192,7 +33229,7 @@ async function registerAndListQuotaShadowRoots(stateRoot, stateRootIdentity, cur
       "physical-copy root retirement enumeration",
       candidate.path,
       { rootAuthority: liveRoot, relativeDirectory: "" }
-    )).some((entry) => entry.isDirectory() && !entry.isSymbolicLink() && (SHADOW_DIR_RE.test(entry.name) || SHADOW_STAGING_DIR_RE.test(entry.name) || SHADOW_TREE_TOMBSTONE_RE.test(entry.name)));
+    )).some((entry) => SHADOW_DIR_RE.test(entry.name) || SHADOW_STAGING_DIR_RE.test(entry.name) || SHADOW_TREE_TOMBSTONE_RE.test(entry.name));
     return await assertWorkspaceRootAuthority(
       liveRoot.canonicalPath,
       liveRoot,
@@ -33207,6 +33244,42 @@ async function registerAndListQuotaShadowRoots(stateRoot, stateRootIdentity, cur
     afterQuotaReferenceMarkerEntry,
     afterQuotaReferenceMarkerStat
   ), !referencedShadowRoots.has(candidate.path));
+  if (mode === "retire-current-if-unused") {
+    let candidate = priorCurrent;
+    if (await assertWorkspaceRootAuthority(
+      currentShadowRoot,
+      currentShadowRootIdentity,
+      "physical-copy current-root retirement preflight"
+    ), await hasPhysicalCopyEntry(candidate) || (referencedShadowRoots = await collectDurablyReferencedShadowRoots(
+      stateRoot,
+      stateRootIdentity,
+      maxStateMarkerBytes,
+      new Set(byPath.keys()),
+      afterQuotaReferenceTaskEntry,
+      afterQuotaReferenceMarkerEntry,
+      afterQuotaReferenceMarkerStat,
+      !0,
+      !0,
+      !0
+    ), referencedShadowRoots.has(candidate.path))) return roots;
+    let retirementPostimage = roots.filter((root) => root.path !== currentShadowRoot);
+    return await hasPhysicalCopyEntry(candidate) ? roots : (await afterQuotaRetirementTargetProof?.(currentShadowRoot), await assertWorkspaceRootAuthority(
+      currentShadowRoot,
+      currentShadowRootIdentity,
+      "physical-copy current-root retirement commit"
+    ), await anchoredAtomicWrite(
+      registryPath,
+      JSON.stringify({ version: 2, roots: retirementPostimage }),
+      {
+        expected,
+        expectedParent: stateRootIdentity,
+        mode: 384,
+        maxTargetBytes: 1024 * 1024,
+        failDirectorySync,
+        publicationOwnerKey
+      }
+    ), retirementPostimage);
+  }
   for (let candidate of byPath.values()) {
     if (candidate.path === currentShadowRoot) {
       retained.push(candidate);
@@ -33254,6 +33327,41 @@ async function registerAndListQuotaShadowRoots(stateRoot, stateRootIdentity, cur
     }
   ), retained;
 }
+async function retireQuotaShadowRootIfUnused(stateRoot, stateRootIdentity, currentShadowRoot, currentShadowRootIdentity, publicationOwnerKey, maxStateMarkerBytes, afterQuotaReferenceTaskEntry, afterQuotaReferenceMarkerEntry, afterQuotaReferenceMarkerStat, failDirectorySync = !1, afterQuotaRetirementTargetProof) {
+  await assertWorkspaceRootAuthority(
+    stateRoot,
+    stateRootIdentity,
+    "physical-copy root retirement state root"
+  ), await assertWorkspaceRootAuthority(
+    currentShadowRoot,
+    currentShadowRootIdentity,
+    "physical-copy root retirement current root"
+  );
+  let quotaLockDir = path38.join(stateRoot, SHADOW_QUOTA_LOCK_DIR), quotaLockRootAuthority = await captureWorkspaceRootAuthority(quotaLockDir);
+  if (path38.dirname(quotaLockRootAuthority.canonicalPath) !== stateRootIdentity.canonicalPath || path38.basename(quotaLockRootAuthority.canonicalPath) !== SHADOW_QUOTA_LOCK_DIR)
+    throw new Error("physical-copy quota-lock directory escaped its state-root authority");
+  return withAnchoredExclusiveLock(
+    path38.join(quotaLockRootAuthority.canonicalPath, SHADOW_QUOTA_LOCK_FILE),
+    async () => !(await withTransientDirectoryEnumerationRetry(() => registerAndListQuotaShadowRoots(
+      stateRoot,
+      stateRootIdentity,
+      currentShadowRoot,
+      currentShadowRootIdentity,
+      publicationOwnerKey,
+      maxStateMarkerBytes,
+      afterQuotaReferenceTaskEntry,
+      afterQuotaReferenceMarkerEntry,
+      afterQuotaReferenceMarkerStat,
+      failDirectorySync,
+      "retire-current-if-unused",
+      afterQuotaRetirementTargetProof
+    ), {
+      maxAttempts: 8,
+      retryDelaysMs: [10, 25, 50, 100, 200, 400, 800]
+    })).some((candidate) => candidate.path === currentShadowRoot),
+    { expectedParent: quotaLockRootAuthority }
+  );
+}
 async function readCleanupBlockAnchor(shadowDir, expected) {
   try {
     if (shadowDir !== expected.snapshotRootAuthority.canonicalPath)
@@ -33792,6 +33900,24 @@ var WorkspaceShadow = class _WorkspaceShadow {
             stateRootAuthority,
             resolveStateMarkerByteLimit(env)
           ).catch(() => {
+          }), await registerAndListQuotaShadowRoots(
+            stateRoot,
+            stateRootIdentity,
+            shadowRoot,
+            shadowRootIdentity,
+            publicationOwnerKey,
+            resolveStateMarkerByteLimit(env),
+            env.afterQuotaReferenceTaskEntry,
+            env.afterQuotaReferenceMarkerEntry,
+            env.afterQuotaReferenceMarkerStat,
+            env.failQuotaRegistryDirectorySync === !0,
+            "retire-current-if-unused"
+          ).catch((retirementErr) => {
+            logger.warn("[WorkspaceShadow] failed-create root retirement deferred", {
+              taskId,
+              shadowRoot,
+              err: retirementErr instanceof Error ? retirementErr.message : String(retirementErr)
+            });
           }), err;
         }
       },
@@ -34300,12 +34426,15 @@ var WorkspaceShadow = class _WorkspaceShadow {
         this.snapshotRootAuthority
       );
       if (displaced && displaced.canonicalPath !== this.shadowDir) {
-        await this.discardDisplacedSnapshot(opts);
+        await this.discardDisplacedSnapshot(opts), await this.retirePhysicalCopyRootIfUnused();
         return;
       }
       if (snapshotPathError.code === "ENOENT") {
-        if (await this.exactStateResourcesAreRetired()) return;
-        await this.discardDisplacedSnapshot(opts);
+        if (await this.exactStateResourcesAreRetired()) {
+          await this.retirePhysicalCopyRootIfUnused();
+          return;
+        }
+        await this.discardDisplacedSnapshot(opts), await this.retirePhysicalCopyRootIfUnused();
         return;
       }
       if (snapshotPathError.code !== "ENOENT")
@@ -34341,7 +34470,10 @@ var WorkspaceShadow = class _WorkspaceShadow {
       opts.applyingAuthorityRetired === !0,
       snapshotAuthority
     );
-    if (!disposalSnapshot) return;
+    if (!disposalSnapshot) {
+      await this.retirePhysicalCopyRootIfUnused();
+      return;
+    }
     let stateFileIdentity = disposalSnapshot.stateFileIdentity, exposureFile = path39.join(
       this.stateDir,
       exposureRetentionFileNameForShadow(this.shadowDir)
@@ -34453,6 +34585,35 @@ var WorkspaceShadow = class _WorkspaceShadow {
       expectedParent: disposalSnapshot.stateRootAuthority
     }).catch(() => {
     })), treeRemoved && releasePhysicalCopyBytes(this.physicalCopyScope, this.shadowDir), removeError) throw removeError;
+    await this.retirePhysicalCopyRootIfUnused();
+  }
+  async retirePhysicalCopyRootIfUnused() {
+    let shadowRoot = path39.dirname(this.shadowDir);
+    try {
+      let shadowRootAuthority = await captureWorkspaceRootAuthority(shadowRoot);
+      await retireQuotaShadowRootIfUnused(
+        this.stateRootAuthority.canonicalPath,
+        this.stateRootAuthority,
+        shadowRootAuthority.canonicalPath,
+        shadowRootAuthority,
+        workspacePublicationAuthorityOwnerKey(
+          this.stateRootAuthority.canonicalPath,
+          this.taskId
+        ),
+        this.maxStateMarkerBytes,
+        this.env.afterQuotaReferenceTaskEntry,
+        this.env.afterQuotaReferenceMarkerEntry,
+        this.env.afterQuotaReferenceMarkerStat,
+        this.env.failQuotaRegistryDirectorySync === !0,
+        this.env.afterQuotaRetirementTargetProof
+      );
+    } catch (err) {
+      logger.warn("[WorkspaceShadow] physical-copy root retirement deferred", {
+        taskId: this.taskId,
+        shadowRoot,
+        err: err instanceof Error ? err.message : String(err)
+      });
+    }
   }
   retainExposureWriteAuthority(fileAuthority, stateDirAuthority) {
     if (!sameWorkspaceRootAuthority(stateDirAuthority, this.stateDirAuthority))

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

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-core",
-  "version": "2.0.16",
+  "version": "2.0.17",
   "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-claude-plugin",
-  "version": "2.0.19",
+  "version": "2.0.20",
   "description": "Control Claude Code 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.16",
+    "@quantiya/codevibe-core": "2.0.17",
     "@quantiya/quorum-core": "^1.0.1",
     "dotenv": "^16.6.1",
     "express": "^5.1.0",