@quantiya/codevibe-core 2.0.78 → 2.0.79

package/dist/orchestration-shell/cli.js

@@ -77487,6 +77487,7 @@ function validateOutboxLocation(value, generation, file) {
 }
 function definitiveRejectionCode(error) {
   if (!(error instanceof AppSyncGraphQLError)) return null;
+  if (error.errorType === "SYNC_QUOTA_EXHAUSTED") return "SYNC_QUOTA_EXHAUSTED";
   let values = [error.errorType, error.message.replace(/^GraphQL error: /, "")].filter(
     (value) => typeof value == "string"
   );
@@ -77549,14 +77550,14 @@ var WorkspaceTerminalCoordinator = class {
       throw new Error("WorkspaceTerminalCoordinator: record exceeds size limit");
     return bytes;
   }
-  async readJson(filePath) {
+  async readJson(filePath, missing = null) {
     try {
       let stat14 = await import_node_fs34.promises.lstat(filePath);
       if (!stat14.isFile() || stat14.isSymbolicLink() || stat14.size > MAX_RECORD_BYTES2)
         throw new Error("WorkspaceTerminalCoordinator: unsafe or oversized record");
       return JSON.parse(await import_node_fs34.promises.readFile(filePath, "utf8"));
     } catch (error) {
-      if (error.code === "ENOENT") return null;
+      if (error.code === "ENOENT") return missing;
       throw error;
     }
   }
@@ -77949,6 +77950,7 @@ var WorkspaceTerminalCoordinator = class {
     ]);
   }
   async flushTerminalIntent(intent) {
+    if (await this.settleQuarantined(intent.nonce, intent.sessionGenerationId)) return;
     intent.subjectKind === "task" ? (validateTerminal(intent), await this.prepareExactInput(intent, "outbox")) : (validateGroupTerminal(intent), await this.prepareExactInput(intent, "draft"), await this.promoteDraftToOutbox(intent));
     let row3 = await this.readJson(
       this.outboxPath(intent.nonce, intent.sessionGenerationId)
@@ -77956,25 +77958,64 @@ var WorkspaceTerminalCoordinator = class {
     if (!row3) throw new Error("WorkspaceTerminalCoordinator: exact outbox row is unavailable");
     await this.sendOutbox(validateOutboxForIntent(row3, intent));
   }
-  async acknowledge(nonce, generation = this.generation()) {
+  async syncSettlementDirectory(directory) {
+    let handle;
+    try {
+      handle = await import_node_fs34.promises.open(directory, import_node_fs34.constants.O_RDONLY | import_node_fs34.constants.O_DIRECTORY | import_node_fs34.constants.O_NOFOLLOW);
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    try {
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+  }
+  async persistSettlementMarker(file, record2) {
+    await atomicWriteFileSync2(file, this.serialize(record2), { requireDirectorySync: !0 });
+    for (let directory of [this.quarantineRoot(), path74.join(this.rootDir, "quarantine"), this.rootDir]) {
+      let handle = await import_node_fs34.promises.open(directory, import_node_fs34.constants.O_RDONLY | import_node_fs34.constants.O_DIRECTORY | import_node_fs34.constants.O_NOFOLLOW);
+      try {
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+    }
+  }
+  async acknowledge(nonce, generation = this.generation(), settlement = !1) {
+    let sync = (directory) => settlement ? this.syncSettlementDirectory(directory) : fsyncDir(directory);
     await import_node_fs34.promises.unlink(this.outboxPath(nonce, generation)).catch((error) => {
       if (error.code !== "ENOENT") throw error;
-    }), await fsyncDir(this.outboxDir(generation)), await import_node_fs34.promises.unlink(this.draftPath(nonce, generation)).catch((error) => {
+    }), await sync(this.outboxDir(generation)), await import_node_fs34.promises.unlink(this.draftPath(nonce, generation)).catch((error) => {
       if (error.code !== "ENOENT") throw error;
-    }), await fsyncDir(this.draftDir(generation)), await import_node_fs34.promises.unlink(this.intentPath(nonce, generation)).catch((error) => {
+    }), await sync(this.draftDir(generation)), await import_node_fs34.promises.unlink(this.intentPath(nonce, generation)).catch((error) => {
       if (error.code !== "ENOENT") throw error;
-    }), await fsyncDir(this.intentDir(generation));
+    }), await sync(this.intentDir(generation));
   }
   async quarantine(nonce, rejectionCode, generation = this.generation()) {
     let raw = await this.readJson(this.outboxPath(nonce, generation));
     if (!raw) return;
-    let row3 = validateOutbox(raw), directory = this.quarantineDir(generation), files = await this.listRecordsAcrossGenerations(this.quarantineRoot());
+    let row3 = validateOutbox(raw);
+    if (await this.settleQuarantined(nonce, generation, row3.inputHash)) return;
+    let directory = this.quarantineDir(generation), files = await this.listRecordsAcrossGenerations(this.quarantineRoot());
     if (files.length >= MAX_QUARANTINE_RECORDS) {
-      let oldest = (await Promise.all(files.map(async (record2) => ({
+      let pending2 = /* @__PURE__ */ new Set();
+      for (let root of [this.intentRoot(), this.outboxRoot(), this.draftRoot()])
+        for (let record2 of await this.listRecordsAcrossGenerations(root))
+          pending2.add(`${record2.generation}/${sha2563(path74.basename(record2.file, ".json"))}`);
+      let disposable = files.filter((record2) => !pending2.has(`${record2.generation}/${path74.basename(record2.file, ".json")}`)), oldest = (await Promise.all(disposable.map(async (record2) => ({
         ...record2,
         mtimeMs: (await import_node_fs34.promises.stat(record2.file)).mtimeMs
       })))).sort((left, right) => left.mtimeMs - right.mtimeMs || left.file.localeCompare(right.file))[0];
-      await import_node_fs34.promises.unlink(oldest.file), await fsyncDir(path74.dirname(oldest.file));
+      if (!oldest) throw new Error("WorkspaceTerminalCoordinator: pending settlement capacity is full");
+      for (let directory2 of [this.intentDir(oldest.generation), this.outboxDir(oldest.generation), this.draftDir(oldest.generation)]) {
+        await this.syncSettlementDirectory(directory2);
+        for (let file of await this.listRecords(directory2))
+          if (sha2563(path74.basename(file, ".json")) === path74.basename(oldest.file, ".json"))
+            throw new Error("WorkspaceTerminalCoordinator: settlement cleanup is still pending");
+      }
+      await import_node_fs34.promises.unlink(oldest.file), await this.syncSettlementDirectory(path74.dirname(oldest.file));
     }
     let diagnostic = {
       version: QUARANTINE_VERSION,
@@ -77983,10 +78024,37 @@ var WorkspaceTerminalCoordinator = class {
       rejectionCode,
       quarantinedAt: this.now().toISOString()
     };
-    await atomicWriteFileSync2(
+    await this.persistSettlementMarker(
       path74.join(directory, `${sha2563(nonce)}.json`),
-      this.serialize(diagnostic)
-    ), await this.acknowledge(nonce, generation), this.reportSyncIssue(`Workspace result could not be synchronized (${rejectionCode}).`);
+      diagnostic
+    ), await this.acknowledge(nonce, generation, !0), this.reportSyncIssue(`Workspace result could not be synchronized (${rejectionCode}).`);
+  }
+  async settleQuarantined(nonce, generation, inputHash) {
+    let markerPath = path74.join(this.quarantineDir(generation), `${sha2563(nonce)}.json`), missing = /* @__PURE__ */ Symbol("absent settlement record"), raw = await this.readJson(markerPath, missing);
+    if (raw === missing) return !1;
+    if (raw === null || typeof raw != "object" || Array.isArray(raw))
+      throw new Error("WorkspaceTerminalCoordinator: invalid settlement barrier");
+    let record2 = raw;
+    if (record2.version !== QUARANTINE_VERSION || record2.nonceHash !== sha2563(nonce) || typeof record2.inputHash != "string" || !SHA256_RE2.test(record2.inputHash) || inputHash !== void 0 && record2.inputHash !== inputHash || typeof record2.rejectionCode != "string" || ![
+      "SYNC_QUOTA_EXHAUSTED",
+      "OUTCOME_ADMISSION_EXPIRED",
+      "OUTCOME_ADMISSION_CONFLICT",
+      "GENERATION_MISMATCH",
+      "ACCOUNT_DELETING"
+    ].includes(record2.rejectionCode) || typeof record2.quarantinedAt != "string")
+      throw new Error("WorkspaceTerminalCoordinator: invalid settlement barrier");
+    let intentValue = await this.readJson(this.intentPath(nonce, generation), missing), intent = intentValue === missing ? void 0 : validateAnyIntent(intentValue);
+    if (intent && (intent.nonce !== nonce || intent.sessionId !== this.session.sessionId || intent.sessionGenerationId !== generation))
+      throw new Error("WorkspaceTerminalCoordinator: settlement intent identity changed");
+    for (let file of [this.outboxPath(nonce, generation), this.draftPath(nonce, generation)]) {
+      let saved = await this.readJson(file, missing);
+      if (saved === missing) continue;
+      let row3 = validateOutboxLocation(saved, generation, file);
+      if (row3.sessionId !== this.session.sessionId || row3.inputHash !== record2.inputHash)
+        throw new Error("WorkspaceTerminalCoordinator: settlement identity changed");
+      intent && validateOutboxForIntent(row3, intent);
+    }
+    return await this.persistSettlementMarker(markerPath, record2), await this.acknowledge(nonce, generation, !0), this.reportSyncIssue(`Workspace result could not be synchronized (${record2.rejectionCode}).`), !0;
   }
   reportSyncIssue(message2) {
     this.reportedSyncIssues.has(message2) || (this.reportedSyncIssues.add(message2), this.onSyncIssue?.(message2));
@@ -77994,6 +78062,7 @@ var WorkspaceTerminalCoordinator = class {
   async sendOutbox(row3) {
     for (let attempt = 1; attempt <= 2; attempt += 1)
       try {
+        if (await this.settleQuarantined(row3.nonce, row3.sessionGenerationId, row3.inputHash)) return;
         let target2 = this.outboxPath(row3.nonce, row3.sessionGenerationId), current = validateOutboxLocation(await this.readJson(target2), row3.sessionGenerationId, target2), { syncProtocol: priorProtocol, ...original } = row3, { syncProtocol: currentProtocol, ...persisted } = current;
         if (canonicalJson3(original) !== canonicalJson3(persisted) || priorProtocol === "SYNC_V2" && currentProtocol !== "SYNC_V2")
           throw new Error("WorkspaceTerminalCoordinator: outbox identity or protocol changed");

package/dist/orchestration-shell/workspace-terminal-coordinator.d.ts

@@ -107,8 +107,11 @@ export declare class WorkspaceTerminalCoordinator implements WorkspaceOutcomeSin
     private prepareExactInput;
     private promoteDraftToOutbox;
     private flushTerminalIntent;
+    private syncSettlementDirectory;
+    private persistSettlementMarker;
     private acknowledge;
     private quarantine;
+    private settleQuarantined;
     private reportSyncIssue;
     private sendOutbox;
     /** Reconcile terminal receipts first, then replay exact encrypted bytes. */

package/package.json

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