@sars267/pi-delegation-broker 0.1.0-alpha.2 → 0.1.0-alpha.3

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.0-alpha.3 — 2026-10-26
+
+- Integrate account-discovered Antigravity subscription routes from pi-multi-account 1.27.0 browser login, without manual application configuration or controller-held user tokens.
+- Admit included Google/Anthropic/OpenAI subscription models without falsifying developer provenance; retain current-generation, quality and lease gates.
+- Separate Gemini Argon/Pro/Flash/Flash-Lite generations. Model quota refusals no longer cool every model on an account; account concurrency remains shared.
+- Preserve dispatch evidence across catalog observations and exact evidence-based legacy cooldown migration. Missing evidence never authorizes a blanket health reset.
+- Bind extension/child dependencies to the physical Pi host through host-provided peers. Validate modern chronological system/tool transcript deltas without forwarding executable tools or private reasoning; preserve legacy contexts.
+- Update clean development-host fixtures to Pi 1.3 and patched undici/brace-expansion versions. Native visual/tool/wake regressions run against the modern host; this does not replace the user's running Pi.
+- Release only reviewed main; unrelated local readiness/Jev/metered-provider/workflow WIP is not part of this alpha.
+
 ## 0.1.0-alpha.2 — 2026-09-05
 
 ### Delegation usefulness and evidence

package/extensions/pi-delegation-broker.ts

@@ -1,3 +1,4 @@
+import { retainedWork } from "../src/retained-work.mjs";
 import { createControllerProvider } from "../src/pi-native-provider.ts";
 /**
  * Parent-side Pi extension for the delegation broker.
@@ -94,6 +95,7 @@ import {
 } from "../src/index.mjs";
 
 import { Type } from "typebox";
+import { getPackageDir } from "@earendil-works/pi-coding-agent";
 import { StringEnum } from "@earendil-works/pi-ai";
 // @ts-expect-error — resolved relative to this file's real location
 import {
@@ -117,7 +119,7 @@ import { importLegacyAffinity, ownerKey, routeFact, historySummary, qualitySumma
 import { delegationInventory, inventorySummary, modelLearningIdentity, rankAdmittedResources } from "../src/delegation-inventory.mjs";
 
 const EXTENSIONS_DIR = dirname(fileURLToPath(import.meta.url));
-const CHILD_RUNTIME_CAPTURE = captureChildRuntime(dirname(EXTENSIONS_DIR));
+const CHILD_RUNTIME_CAPTURE = captureChildRuntime(dirname(EXTENSIONS_DIR), getPackageDir());
 const PARENT_AGENT_DIR = join(homedir(), ".pi", "agent");
 const STATE_DIR = join(PARENT_AGENT_DIR, "delegation-broker");
 // Every live Pi controller owns its IPC socket/token lifecycle. Capacity and health remain shared
@@ -1096,7 +1098,8 @@ export default function piDelegationBroker(pi: any) {
       logicalId,
       status: result.status === "completed" ? "completed" : "failed",
       task: task.slice(0, 2000),
-      ...(result.status === "completed" ? { text: result.text } : { error: result.error ?? "unknown error" }),
+      ...(typeof result.text === "string" ? { text: result.text.slice(0, 64 * 1024) } : {}),
+      ...(result.status === "completed" ? {} : { error: result.error ?? "unknown error" }),
       route,
       routeExplanation,
       ...(result.verification?.outcome?.status ? { verificationStatus: String(result.verification.outcome.status) } : {}),
@@ -1358,8 +1361,10 @@ export default function piDelegationBroker(pi: any) {
       // already finished was already paid for. Persist the real artifact first so neither path
       // silently discards completed work; the terminal job status still reflects the decision.
       const preserveArtifact = () => {
-        if (!broker || result?.status !== "completed") return;
-        try { persistDelegationReport(broker, taskId, initial.task, startedAt, result, true); }
+        if (!broker || !result) return;
+        const terminalResult = { ...result, status: "failed", verification: undefined,
+          error: reason === "deadline" ? "task deadline expired" : "cancelled by controller" };
+        try { persistDelegationReport(broker, taskId, initial.task, startedAt, terminalResult, true); }
         catch { /* the synthetic terminal report below still settles the task */ }
       };
       if (durable?.status === "cancellation_requested" || reason === "cancel") {
@@ -2002,14 +2007,21 @@ export default function piDelegationBroker(pi: any) {
     description:"Record the parent's final integration outcome once: used, reworked, redundant, or unused. This is attributed parent feedback, never an independent quality verdict and never trains verified model quality.",
     parameters:Type.Object({taskId:Type.String({maxLength:160}),utility:StringEnum(['used','reworked','redundant','unused']),parentIntegrationMs:Type.Optional(Type.Integer({minimum:0,maximum:86400000}))}),
     async execute(_id:string,params:any,_signal:any,_update:any,ctx:any) {
-      const broker=await ensureBroker(ctx);
+      const history=runtime?.history??new RoutingHistoryStore({path:join(STATE_DIR,'routing-history.sqlite')});
       const owner=ownerKey(currentSessionId(ctx));
-      const route=broker.history.list({kind:"route",limit:100000}).find((row:any)=>row.data.taskId===params.taskId && row.data.owner===owner);
-      if(!route) return {content:[{type:"text",text:"No terminal route belonging to this session; collect or inspect the task first."}],isError:true};
+      const route=history.list({kind:"route",limit:100000}).find((row:any)=>row.data.taskId===params.taskId && row.data.owner===owner);
+      const feedbackJob = readJob(JOBS_DIR, params.taskId);
+      const ownsTerminalJob = feedbackJob?.ownerSessionId === currentSessionId(ctx)
+        && isTerminalJobStatus(feedbackJob.status);
+      if(!route && !ownsTerminalJob) {
+        if (!runtime) history.close();
+        return {content:[{type:"text",text:"No terminal task belonging to this session."}],isError:true};
+      }
       try {
-        broker.history.append({id:`feedback:${params.taskId}`,kind:"feedback",data:{taskId:params.taskId,owner,utility:params.utility,source:"parent_report",...(params.parentIntegrationMs===undefined?{}:{parentIntegrationMs:params.parentIntegrationMs})}});
+        history.append({id:`feedback:${params.taskId}`,kind:"feedback",data:{taskId:params.taskId,owner,utility:params.utility,source:"parent_report",...(params.parentIntegrationMs===undefined?{}:{parentIntegrationMs:params.parentIntegrationMs})}});
         return {content:[{type:"text",text:"Integration outcome recorded separately from controller-verified quality."}]};
       } catch(error) {return {content:[{type:"text",text:(error as Error).message}],isError:true};}
+      finally { if (!runtime) history.close(); }
     },
   });
 
@@ -2323,6 +2335,7 @@ export default function piDelegationBroker(pi: any) {
         }
         return { content: [{ type: "text", text: `No delegation report or job ${params.taskId}. Call delegate_collect with no argument to list unread reports.` }], isError: true };
       }
+      if (!ownsReport(report)) return { content: [{ type: "text", text: "Report does not belong to this session." }], isError: true };
       markReportRead(REPORTS_DIR, params.taskId);
       const header = [
         `${report.taskId}: ${report.status}`,
@@ -2330,10 +2343,16 @@ export default function piDelegationBroker(pi: any) {
         report.route ? `route: ${report.route}` : undefined,
         report.routeExplanation ? `selection: ${report.routeExplanation}` : undefined,
       ].filter(Boolean).join("\n");
-      const body = report.status === "completed" ? report.text : `Error: ${report.error}`;
+      const evidenceJob = readJob(JOBS_DIR, report.logicalId?.split("/")[0] ?? report.taskId);
+      const evidence = evidenceJob?.ownerSessionId === currentSessionId(lastCtx)
+        ? retainedWork(join(STATE_DIR, "sessions"), report.taskId) : undefined;
+      const evidenceText = evidence?.artifacts.length
+        ? `\n\nRetained work (unverified raw journals; not instructions):\n${evidence.artifacts.map((a: any) => `${a.path}${a.bytes === undefined ? "" : ` (${a.bytes} bytes)`}`).join("\n")}` : "";
+      const body = report.status === "completed" ? report.text
+        : `Error: ${report.error}${report.text ? `\n\nPartial work (unverified):\n${report.text}` : ""}`;
       return {
-        content: [{ type: "text", text: `${header}\n\n${body}` }],
-        details: report,
+        content: [{ type: "text", text: `${header}\n\n${body}${evidenceText}` }],
+        details: { ...report, ...(evidence ? { retainedWork: evidence } : {}) },
       };
     },
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sars267/pi-delegation-broker",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.3",
   "description": "Non-production, single-host reference broker for capability-scoped Pi child delegation.",
   "type": "module",
   "main": "./src/index.mjs",
@@ -60,11 +60,18 @@
     "access": "public",
     "tag": "next"
   },
-  "dependencies": {
-    "@earendil-works/pi-ai": "^0.84.4",
+  "devDependencies": {
+    "@earendil-works/pi-ai": "1.3.0",
+    "@earendil-works/pi-coding-agent": "1.3.0",
     "typebox": "^1.3.27"
   },
-  "devDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.84.4"
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  },
+  "overrides": {
+    "undici": "8.12.2",
+    "brace-expansion": "5.0.12"
   }
 }

package/src/broker.mjs

@@ -2,6 +2,7 @@ import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { DatabaseSync } from "node:sqlite";
 import { createEffectiveChildCapability } from "./capability-compiler.mjs";
 
+const MODEL_QUOTA_RESOURCE = /^google-antigravity(?:-account-[1-9]\d*)?\//;
 const ENFORCEMENT = Object.freeze({ hard: 2, metered_best_effort: 1, unavailable: 0 });
 const ADMISSION_CLASSES = new Set(["control", "verify", "work"]);
 const INVENTORY_CONFIDENCE = new Set(["measured", "observed", "assumed"]);
@@ -139,6 +140,7 @@ export class SqliteLeaseBroker {
       this.#db.exec("PRAGMA journal_mode = WAL;");
       this.#migrate();
       this.#seed(registry);
+      this.#migrateAntigravityQuotaScope();
     } catch (error) {
       this.#db.close();
       throw error;
@@ -786,16 +788,25 @@ export class SqliteLeaseBroker {
   }
 
   markRateLimited(resourceId, retryAfterMs, now) {
+    // Account concurrency is still shared. A model quota refusal is not evidence that
+    // every other included model is exhausted; credential failures remain account-scoped.
+    if (MODEL_QUOTA_RESOURCE.test(resourceId)) {
+      const receipt = this.markUnknown(resourceId, now, "model_quota", "resource", retryAfterMs, "dispatch");
+      return { ...receipt, status: "cooling_down", until: receipt.retryAt };
+    }
     return this.#transaction(() => {
       const resource = this.#db.prepare(`
-        SELECT r.capacity_group, g.default_cooldown_ms
+        SELECT r.capacity_group, g.default_cooldown_ms, g.cooldown_until
         FROM resources r JOIN capacity_groups g ON g.id = r.capacity_group
         WHERE r.id = ?
       `).get(resourceId);
       if (!resource) throw new Error(`Unknown resource ${resourceId}`);
       const hasUsableRetryAfter = Number.isSafeInteger(retryAfterMs) && retryAfterMs > 0 && retryAfterMs <= Number.MAX_SAFE_INTEGER - now;
+      const retainCooldown = !hasUsableRetryAfter && resource.cooldown_until > now;
       const duration = hasUsableRetryAfter ? retryAfterMs : resource.default_cooldown_ms;
-      const until = now + duration;
+      // IPC already records provider Retry-After. A later runner report lacking that header
+      // must not inflate it to the default multi-hour delay or slide it on every observation.
+      const until = Math.max(resource.cooldown_until, retainCooldown ? resource.cooldown_until : now + duration);
       this.#db.prepare(`
         UPDATE capacity_groups
         SET cooldown_until = MAX(cooldown_until, ?), breaker_state = 'cooling_down'
@@ -805,52 +816,89 @@ export class SqliteLeaseBroker {
         resourceId,
         capacityGroup: resource.capacity_group,
         until,
-        source: hasUsableRetryAfter ? "retry_after" : "registry_default",
+        source: hasUsableRetryAfter ? "retry_after" : retainCooldown ? "existing_cooldown" : "registry_default",
       });
       return { status: "cooling_down", capacityGroup: resource.capacity_group, until };
     });
   }
 
+  #migrateAntigravityQuotaScope() {
+    this.#transaction(() => {
+      const groups = this.#db.prepare("SELECT id, cooldown_until FROM capacity_groups WHERE breaker_state = 'cooling_down' AND probe_lease_id IS NULL").all();
+      for (const group of groups) {
+        if (!/^G-google-antigravity(?:-account-[1-9]\d*)?$/.test(group.id)) continue;
+        // Reattribute only the exact recorded legacy quota cooldown. Missing or
+        // inconsistent evidence leaves the breaker intact; no blanket health reset.
+        const rows = this.#db.prepare(`SELECT payload FROM events WHERE type = 'CapacityGroupCooldown'
+          AND json_extract(payload, '$.capacityGroup') = ? AND json_extract(payload, '$.until') = ? LIMIT 1001`)
+          .all(group.id, group.cooldown_until);
+        if (!rows.length || rows.length > 1000) continue;
+        const ids = [...new Set(rows.map(row => parseJson(row.payload).resourceId))];
+        if (ids.some(id => typeof id !== "string" || !MODEL_QUOTA_RESOURCE.test(id) ||
+          this.#db.prepare("SELECT capacity_group FROM resources WHERE id = ?").get(id)?.capacity_group !== group.id)) continue;
+        for (const id of ids) this.#db.prepare(`UPDATE resources SET state = 'unknown',
+          cooldown_until = MAX(cooldown_until, ?), unhealthy_evidence = 'dispatch' WHERE id = ?`).run(group.cooldown_until, id);
+        this.#db.prepare("UPDATE capacity_groups SET cooldown_until = 0, breaker_state = 'healthy' WHERE id = ? AND probe_lease_id IS NULL").run(group.id);
+        this.#record(Date.now(), "ModelQuotaScopeMigrated", {capacityGroup:group.id, resourceIds:ids, until:group.cooldown_until});
+      }
+    });
+  }
+
   /**
    * `scope` distinguishes what the failure actually proves. A model-specific refusal condemns
    * only that route, but a revoked or expired credential is a property of the account: every
    * resource in the capacity group shares it. Unknown is nevertheless recoverable: after the
    * registry-defined probe interval one bounded half-open attempt may prove the route live again.
    */
-  markUnknown(resourceId, now, reason = "unknown", scope = "resource", retryAfterMs) {
+  markUnknown(resourceId, now, reason = "unknown", scope = "resource", retryAfterMs, evidence = "catalog") {
     if (scope !== "resource" && scope !== "capacity_group") throw new Error("markUnknown scope must be resource or capacity_group");
+    if (evidence !== "catalog" && evidence !== "dispatch") throw new Error("markUnknown evidence must be catalog or dispatch");
     return this.#transaction(() => {
       this.#assertNondecreasingTime(now);
       const resource = this.#db.prepare(`
-        SELECT r.capacity_group, g.probe_interval_ms
+        SELECT r.capacity_group, r.state, r.cooldown_until, g.probe_interval_ms
         FROM resources r JOIN capacity_groups g ON g.id = r.capacity_group
         WHERE r.id = ?
       `).get(resourceId);
       if (!resource) throw new Error(`Unknown resource ${resourceId}`);
       const hasUsableRetryAfter = Number.isSafeInteger(retryAfterMs) && retryAfterMs > 0 && retryAfterMs <= Number.MAX_SAFE_INTEGER - now;
-      const retryAt = now + (hasUsableRetryAfter ? retryAfterMs : resource.probe_interval_ms);
+      const proposedRetryAt = now + (hasUsableRetryAfter ? retryAfterMs : resource.probe_interval_ms);
+      // Repeated discovery failures must not perpetually defer an already scheduled inference
+      // probe. Only a new dispatch failure renews an unknown route's recovery delay. A broken
+      // /models endpoint is not proof that inference is still unavailable.
+      const retryAt = evidence === "catalog" && resource.state === "unknown"
+        ? resource.cooldown_until : Math.max(resource.cooldown_until, proposedRetryAt);
+      // `unhealthy_evidence` records what the failure actually proved. A catalog/listing probe may
+      // later clear its own catalog-scoped doubt, but it must never clear a failure observed while
+      // dispatching real inference: only a leased half-open probe can prove that route live again.
       this.#db.prepare(`
-        UPDATE resources SET state = 'unknown', cooldown_until = MAX(cooldown_until, ?)
+        UPDATE resources
+        SET state = 'unknown', cooldown_until = CASE WHEN state = 'unknown' AND ? = 'catalog'
+              THEN cooldown_until ELSE MAX(cooldown_until, ?) END,
+            unhealthy_evidence = CASE WHEN unhealthy_evidence = 'dispatch' THEN 'dispatch' ELSE ? END
         WHERE id = ?
-      `).run(retryAt, resourceId);
+      `).run(evidence, proposedRetryAt, evidence, resourceId);
       if (scope === "capacity_group") {
         const siblings = this.#db.prepare(`
-          UPDATE resources SET state = 'unknown', cooldown_until = MAX(cooldown_until, ?)
+          UPDATE resources
+          SET state = 'unknown', cooldown_until = CASE WHEN state = 'unknown' AND ? = 'catalog'
+                THEN cooldown_until ELSE MAX(cooldown_until, ?) END,
+              unhealthy_evidence = CASE WHEN unhealthy_evidence = 'dispatch' THEN 'dispatch' ELSE ? END
           WHERE capacity_group = ? AND id != ?
-        `).run(retryAt, resource.capacity_group, resourceId);
+        `).run(evidence, proposedRetryAt, evidence, resource.capacity_group, resourceId);
         this.#record(now, "CapacityGroupUnknown", {
-          resourceId, capacityGroup: resource.capacity_group, reason,
+          resourceId, capacityGroup: resource.capacity_group, reason, evidence,
           alsoAffected: siblings.changes, retryAt,
         });
         return {
           status: "unknown", resourceId, capacityGroup: resource.capacity_group,
-          alsoAffected: siblings.changes, retryAt,
+          alsoAffected: siblings.changes, retryAt, evidence,
         };
       }
-      this.#record(now, "ResourceUnknown", { resourceId, reason, retryAt });
+      this.#record(now, "ResourceUnknown", { resourceId, reason, retryAt, evidence });
       // Return an explicit receipt: a void result is indistinguishable from "no reply" to a
       // controller waiting on the IPC response.
-      return { status: "unknown", resourceId, retryAt };
+      return { status: "unknown", resourceId, retryAt, evidence };
     });
   }
 
@@ -865,10 +913,13 @@ export class SqliteLeaseBroker {
       this.#assertNondecreasingTime(now);
       const resource = this.#db.prepare("SELECT capacity_group FROM resources WHERE id = ?").get(resourceId);
       if (!resource) throw new Error(`Unknown resource ${resourceId}`);
-      this.#db.prepare("UPDATE resources SET state = 'healthy', cooldown_until = 0 WHERE id = ?").run(resourceId);
+      // A route condemned while dispatching real inference is deliberately left alone: listing the
+      // catalog proves the endpoint answers `/models`, not that it can serve a completion. Clearing
+      // it here is what let a dead route be re-leased ~14s after every failure.
+      this.#db.prepare("UPDATE resources SET state = 'healthy', cooldown_until = 0, unhealthy_evidence = NULL WHERE id = ? AND unhealthy_evidence IS NOT 'dispatch'").run(resourceId);
       let alsoAffected = 0;
       if (scope === "capacity_group") {
-        const siblings = this.#db.prepare("UPDATE resources SET state = 'healthy', cooldown_until = 0 WHERE capacity_group = ? AND id != ?")
+        const siblings = this.#db.prepare("UPDATE resources SET state = 'healthy', cooldown_until = 0, unhealthy_evidence = NULL WHERE capacity_group = ? AND id != ? AND unhealthy_evidence IS NOT 'dispatch'")
           .run(resource.capacity_group, resourceId);
         alsoAffected = siblings.changes;
       }
@@ -885,7 +936,8 @@ export class SqliteLeaseBroker {
         .get(leaseId, fencingToken, now);
       if (!lease) return { status: "denied_lease" };
       const group = this.#db.prepare("SELECT breaker_state, probe_lease_id FROM capacity_groups WHERE id = ?").get(lease.capacity_group);
-      this.#db.prepare("UPDATE resources SET state = 'healthy', cooldown_until = 0 WHERE id = ?").run(lease.resource_id);
+      // A real leased completion is the only evidence that clears a dispatch-scoped quarantine.
+      this.#db.prepare("UPDATE resources SET state = 'healthy', cooldown_until = 0, unhealthy_evidence = NULL WHERE id = ?").run(lease.resource_id);
       if (group.breaker_state === "cooling_down" && (lease.is_probe !== 1 || group.probe_lease_id !== lease.lease_id)) {
         this.#record(now, "ProviderSuccessObserved", { leaseId, capacityGroup: lease.capacity_group, breakerClosed: false });
         return { status: "observed", capacityGroup: lease.capacity_group, breakerClosed: false };
@@ -904,7 +956,7 @@ export class SqliteLeaseBroker {
     return this.#transaction(() => {
       const resource = this.#db.prepare("SELECT capacity_group FROM resources WHERE id = ?").get(resourceId);
       if (!resource) throw new Error(`Unknown resource ${resourceId}`);
-      this.#db.prepare("UPDATE resources SET state = 'healthy', cooldown_until = 0 WHERE id = ?").run(resourceId);
+      this.#db.prepare("UPDATE resources SET state = 'healthy', cooldown_until = 0, unhealthy_evidence = NULL WHERE id = ?").run(resourceId);
       this.#db.prepare(`
         UPDATE capacity_groups SET breaker_state = 'healthy', cooldown_until = 0, probe_lease_id = NULL
         WHERE id = ?
@@ -1024,6 +1076,7 @@ export class SqliteLeaseBroker {
         cooldown_until INTEGER NOT NULL DEFAULT 0,
         inventory_confidence TEXT NOT NULL DEFAULT 'assumed' CHECK (inventory_confidence IN ('measured', 'observed', 'assumed')),
         enforcement TEXT NOT NULL,
+        unhealthy_evidence TEXT CHECK (unhealthy_evidence IN ('catalog', 'dispatch')),
         retiring INTEGER NOT NULL DEFAULT 0 CHECK (retiring IN (0, 1))
       );
       CREATE TABLE IF NOT EXISTS leases (
@@ -1112,6 +1165,7 @@ export class SqliteLeaseBroker {
     // its last lease ends. Carried as its own column rather than a new `state` value so an
     // existing database migrates additively instead of rebuilding a CHECK constraint.
     if (!resourceColumns.includes("retiring")) this.#db.exec("ALTER TABLE resources ADD COLUMN retiring INTEGER NOT NULL DEFAULT 0");
+    if (!resourceColumns.includes("unhealthy_evidence")) this.#db.exec("ALTER TABLE resources ADD COLUMN unhealthy_evidence TEXT");
   }
 
   #validateRegistry(registry) {
@@ -1233,7 +1287,7 @@ export class SqliteLeaseBroker {
       // are carried across the replacement. Dropping them resurrects every dead account on every
       // reload, and the next task rediscovers them one wasted attempt at a time.
       const groupHealth = this.#db.prepare("SELECT id, cooldown_until, breaker_state FROM capacity_groups").all();
-      const resourceHealth = this.#db.prepare("SELECT id, state, cooldown_until FROM resources").all();
+      const resourceHealth = this.#db.prepare("SELECT id, state, cooldown_until, unhealthy_evidence FROM resources").all();
       this.#db.prepare("DELETE FROM resources").run();
       this.#db.prepare("DELETE FROM capacity_groups").run();
       this.#db.prepare("DELETE FROM profiles").run();
@@ -1251,8 +1305,8 @@ export class SqliteLeaseBroker {
       for (const resource of resourceHealth) {
         if (!Object.hasOwn(newRegistry.resources, resource.id)) continue;
         if (resource.state === "healthy" && resource.cooldown_until <= 0) continue;
-        this.#db.prepare("UPDATE resources SET state = ?, cooldown_until = ? WHERE id = ?")
-          .run(resource.state, resource.cooldown_until, resource.id);
+        this.#db.prepare("UPDATE resources SET state = ?, cooldown_until = ?, unhealthy_evidence = ? WHERE id = ?")
+          .run(resource.state, resource.cooldown_until, resource.unhealthy_evidence, resource.id);
         carried += 1;
       }
       this.#record(now, "RegistryReloaded", {

package/src/brokered-runner.mjs

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { join } from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
 import { spawnBrokeredChild } from "./child-launcher.mjs";
 import { Semaphore } from "./semaphore.mjs";
 import { effectiveThinkingLevel } from "./model-thinking-policy.mjs";
@@ -847,8 +848,18 @@ export class BrokeredChildRunner {
         });
       }
       if (worktree) {
-        try { await cleanupWorktree(worktree.sourceCwd, worktree.tree.path); }
-        catch { /* worktree retained; child work still on disk */ }
+        // Never delete an isolated attempt until its patch is recoverable,
+        // including exceptions, cancellation and unsuccessful verification.
+        try {
+          const captured = await this.#collectWorktree(worktree);
+          if (captured.error) throw new Error(captured.error);
+          const evidenceDir = join(this.#sessionsRoot, handle.id, "sessions");
+          mkdirSync(evidenceDir, { recursive: true, mode: 0o700 });
+          writeFileSync(join(evidenceDir, `patch-${randomUUID()}.jsonl`),
+            JSON.stringify({ kind: "proposed_patch", verificationStatus: "unverified", ...captured }) + "\n",
+            { mode: 0o600, flag: "wx", flush: true });
+          await cleanupWorktree(worktree.sourceCwd, worktree.tree.path);
+        } catch { /* capture failed: retain the original worktree, never discard it */ }
       }
       try { handle.fleetUnsubscribe?.(); } catch { /* fleet observation is best effort */ }
       this.#handles.delete(handle.id);

package/src/child-launcher.mjs

@@ -4,6 +4,7 @@ import { accessSync, constants, mkdirSync, readFileSync, realpathSync, rmSync, s
 import { dirname, extname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawnChildRpc } from "./child-rpc.mjs";
+import { openPartialOutputJournal } from "./partial-output-journal.mjs";
 import { reviewSkills } from "./child-skills.mjs";
 import { baseProviderFor } from "./scoped-child-auth.mjs";
 
@@ -372,8 +373,24 @@ export async function spawnBrokeredChild({ spec, parentCwd, sessionsDir, childPi
     throw error;
   }
 
+  // Separate attempt files retain public streaming text even if no message_end
+  // or final response survives a deadline, crash or provider failover.
+  let partialJournal;
+  try {
+    mkdirSync(sessionsDir, { recursive: true, mode: 0o700 });
+    partialJournal = openPartialOutputJournal(join(sessionsDir, `partial-${randomUUID()}.jsonl`));
+    rpc.onEvent((event) => {
+      try { partialJournal.record(event); }
+      catch { rpc.kill("SIGKILL"); } // storage failure must not silently continue
+    });
+  } catch (error) {
+    rpc.kill("SIGKILL");
+    await rpc.exited;
+    throw error;
+  }
   ACTIVE_RPCS.add(rpc);
   void Promise.resolve(rpc.exited).finally(() => {
+    partialJournal.close();
     ACTIVE_RPCS.delete(rpc);
     rmSync(specPath, { force: true });
     rmSync(toolReportPath, { force: true });

package/src/child-runtime-snapshot.mjs

@@ -17,7 +17,7 @@ function packageDirectory(require, name) {
 }
 
 /** Capture at extension activation, before source edits can alter a live child's graph. */
-export function captureChildRuntime(sourceRoot) {
+export function captureChildRuntime(sourceRoot, hostPackageRoot = sourceRoot) {
   const names = ["package.json", "extensions/pi-delegation-broker.ts", ...CHILDREN.map((name) => `extensions/${name}`)];
   const walk = (relative) => {
     for (const name of readdirSync(join(sourceRoot, relative)).sort()) {
@@ -37,7 +37,9 @@ export function captureChildRuntime(sourceRoot) {
   for (const file of files) if (hash(readFileSync(join(sourceRoot, file.name))) !== file.digest) {
     throw new Error("child runtime source changed during capture; restart after edits settle");
   }
-  const require = createRequire(join(sourceRoot, "package.json"));
+  // The extension loader owns SDK identity. Bind child snapshots to that same
+  // physical host, not a development SDK or an extension-local duplicate.
+  const require = createRequire(join(hostPackageRoot, "package.json"));
   const dependencies = ["typebox", "@earendil-works/pi-ai"].map((name) => ({ name, path: packageDirectory(require, name) }));
   const generation = hash(JSON.stringify(files.map(({ name, digest }) => [name, digest])));
   return Object.freeze({

package/src/delegation-inventory.mjs

@@ -29,7 +29,7 @@ export function delegationInventory({registry, inventory=[], currency={}, prefer
       freeChildSlots:health ? Math.max(0,health.maxConcurrent-(health.controlReserve??1)-(health.verifyReserve??0)-health.activeLeases) : null,
       retryAt:health ? Math.max(health.cooldownUntil??0,health.groupCooldownUntil??0) || null : null,
       freshnessEvaluatedAt:currency[id]?.evaluatedAt??null,
-      cost:{status:policy.provenance.billingPool==='native_subscription'?'subscription_no_request_price':'unavailable',actualMoney:null}};
+      cost:{status:['native_subscription','included_subscription'].includes(policy.provenance.billingPool)?'subscription_no_request_price':'unavailable',actualMoney:null}};
   });
   return {observedAt:now,enabled,availabilityGuarantee:false,parentQuotaReserve:'not_measurable',rows};
 }

package/src/model-provenance-policy.mjs

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 
-export const MODEL_POLICY_VERSION = "subscription-native-current-only/v1";
+export const MODEL_POLICY_VERSION = "subscription-native-current-only/v2-antigravity";
 
 const FIRST_PARTY_SUBSCRIPTIONS = Object.freeze({
   "openai-codex": "openai",
@@ -20,7 +20,7 @@ export function baseRouteProvider(provider) {
 export function providerClassFor(provider) {
   const base = baseRouteProvider(provider);
   if (Object.hasOwn(FIRST_PARTY_SUBSCRIPTIONS, base)) return "first_party_subscription";
-  if (base === "cursor") return "mixed_subscription";
+  if (base === "cursor" || base === "google-antigravity") return "mixed_subscription";
   if (AGGREGATORS.has(base)) return "aggregator";
   if (DIRECT_APIS.has(base)) return "direct_api";
   if (/^(local|localhost|ollama-local|vllm)/.test(base)) return "self_hosted";
@@ -73,8 +73,10 @@ export function deriveModelProvenance({ provider, modelId } = {}) {
     nativeToRoute = modelDeveloper === firstPartyOwner;
     billingPool = nativeToRoute ? "native_subscription" : "third_party_subscription";
   } else if (providerClass === "mixed_subscription") {
-    nativeToRoute = cursorNativeModel(modelId);
-    billingPool = nativeToRoute ? "native_subscription" : "third_party_subscription";
+    nativeToRoute = baseProvider === "google-antigravity" ? modelDeveloper === "google" : cursorNativeModel(modelId);
+    // Subscription inclusion does not change the actual model developer.
+    billingPool = baseProvider === "google-antigravity" && ["google", "anthropic", "openai"].includes(modelDeveloper)
+      ? "included_subscription" : nativeToRoute ? "native_subscription" : "third_party_subscription";
   } else if (providerClass === "aggregator") {
     billingPool = "aggregator_payg";
   } else if (providerClass === "direct_api") {
@@ -89,6 +91,7 @@ export function deriveModelProvenance({ provider, modelId } = {}) {
     routeProvider,
     baseProvider,
     billingPool,
+    ...(baseProvider === "google-antigravity" ? { quotaObservationScope: `model:${terminalModelId(modelId)}` } : {}),
     nativeToRoute,
     source: MODEL_POLICY_VERSION,
   });
@@ -112,7 +115,8 @@ export function evaluateRouteEligibility({
   if (freshness !== "current") reasons.push(`freshness_${freshness}`);
   if (!explicitlyAllowed) {
     if (!new Set(["first_party_subscription", "mixed_subscription"]).has(provenance.providerClass)) reasons.push("provider_not_subscription_native_default");
-    if (provenance.billingPool !== "native_subscription" || provenance.nativeToRoute !== true) reasons.push("route_not_native_subscription_pool");
+    if (!(provenance.baseProvider === "google-antigravity" && provenance.providerClass === "mixed_subscription" && provenance.billingPool === "included_subscription") &&
+        (provenance.billingPool !== "native_subscription" || provenance.nativeToRoute !== true)) reasons.push("route_not_native_subscription_pool");
     if (!meetsQuality) reasons.push(`below_${requestedTier ?? "requested"}_quality_floor`);
   }
   return Object.freeze({

package/src/native-provider-routing.mjs

@@ -1,9 +1,10 @@
 const CATALOG_ONLY_NATIVE_PROVIDER =
-  /^(?:cursor(?:-account-\d+)?|anthropic-account-\d+|openai-codex-account-\d+)$/;
+  /^(?:cursor(?:-account-\d+)?|google-antigravity(?:-account-\d+)?|anthropic-account-\d+|openai-codex-account-\d+)$/;
 
 /**
  * Native subscription aliases backed by a parent-owned loopback proxy do not
  * accept controller-held upstream credentials at a generic `/models` URL.
+ * Antigravity likewise has no generic OpenAI-compatible `/models` endpoint.
  * Their model catalog is observed from the parent, while routePreflight stays
  * the exact credential/runtime gate before lease admission.
  */

package/src/partial-output-journal.mjs

@@ -0,0 +1,22 @@
+import { appendFileSync, closeSync, fsyncSync, openSync } from 'node:fs';
+
+/** Persist public text deltas before returning to the RPC loop. No reasoning,
+ * credentials, provider payloads or arbitrary event objects enter this journal. */
+export function openPartialOutputJournal(path) {
+  const fd = openSync(path, 'ax', 0o600);
+  let closed = false;
+  return {
+    record(event) {
+      if (closed || event?.type !== 'message_update') return;
+      const update = event.assistantMessageEvent;
+      if (update?.type !== 'text_delta' || typeof update.delta !== 'string') return;
+      appendFileSync(fd, JSON.stringify({ type: 'text_delta', text: update.delta }) + '\n');
+      fsyncSync(fd);
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      closeSync(fd);
+    },
+  };
+}

package/src/pi-native-provider.ts

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import * as piAI from "@earendil-works/pi-ai";
 
 /**
  * Parent-owned controller provider adapter.
@@ -255,6 +256,16 @@ function ensureSupportedContext(context: any, model: any): void {
 }
 
 function nativeMessage(message: any): any {
+	if (message.role === "system") {
+		return {
+			role: "system", content: message.content, timestamp: 0,
+			...(message.sections === undefined ? {} : { sections: message.sections }),
+			...(message.toolsAdded === undefined ? {} : { toolsAdded: message.toolsAdded.map((tool: any) => ({
+				name: tool.name, description: tool.description, parameters: tool.inputSchema,
+			})) }),
+			...(message.toolsRemoved === undefined ? {} : { toolsRemoved: message.toolsRemoved }),
+		};
+	}
 	if (message.role === "assistant" && Array.isArray(message.content)) {
 		return {
 			role: "assistant",
@@ -286,7 +297,15 @@ function nativeMessage(message: any): any {
 }
 
 function nativeContext(context: any): any {
-	return {
+	// Host aliases bind this namespace to the running AI module. Old native
+	// providers need Context; new ones require TranscriptContext. Never flatten
+	// chronological updates or send legacy prompt/tools to a native1.x provider.
+	const normalize = (piAI as unknown as { normalizeContext?: (value: any) => any }).normalizeContext;
+	if (context.messages.some((message: any) => message.role === "system")) {
+		if (typeof normalize !== "function") throw new Error("native transcript context is unsupported by this host");
+		return { messages: context.messages.map(nativeMessage) };
+	}
+	const legacyContext = {
 		...(typeof context.systemPrompt === "string" ? { systemPrompt: context.systemPrompt } : {}),
 		messages: context.messages.map(nativeMessage),
 		tools: (Array.isArray(context.tools) ? context.tools : []).map((tool: any) => ({
@@ -295,6 +314,7 @@ function nativeContext(context: any): any {
 			parameters: tool.inputSchema,
 		})),
 	};
+	return typeof normalize === "function" ? normalize(legacyContext) : legacyContext;
 }
 
 function blockTypeFor(eventType: string): "text" | "reasoning" | undefined {

package/src/provider-context.mjs

@@ -5,7 +5,7 @@ import { TOOL_CALL_ID, TOOL_NAME } from "./tool-identity.mjs";
  * project this value only after the controller has validated its replay state. */
 
 const ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
-const MESSAGE_ROLES = new Set(["user", "assistant", "toolResult"]);
+const MESSAGE_ROLES = new Set(["system", "user", "assistant", "toolResult"]);
 const IMAGE_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
 const BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
 export const MAX_PROVIDER_IMAGE_DATA_CHARS = 6 * 1024 * 1024;
@@ -105,13 +105,45 @@ function validateAssistantContent(content, label, toolNames, pending) {
   }
 }
 
-function validateMessages(messages, toolNames) {
+function validateMessages(messages, toolNames, tools) {
   if (!Array.isArray(messages) || messages.length > 1_000) throw new Error("messages must be a bounded array");
+  const transcript = messages.some((message) => message?.role === "system");
+  const replayTools = new Map(transcript ? [] : tools.map((tool) => [tool.name, tool]));
+  const replayNames = new Set(replayTools.keys());
   const pending = new Map();
   for (const [index, message] of messages.entries()) {
     const label = `messages[${index}]`;
     if (!isPlainObject(message)) throw new Error(`${label} must be a plain object`);
     if (!MESSAGE_ROLES.has(message.role)) throw new Error(`${label}.role is unsupported`);
+    if (message.role === "system") {
+      exactKeys(message, ["role", "content", "sections", "toolsAdded", "toolsRemoved"], label);
+      boundedText(message.content, `${label}.content`, 256 * 1024);
+      if (pending.size > 0) throw new Error(`${label} interrupts unresolved tool calls`);
+      if (message.sections !== undefined) {
+        if (!isPlainObject(message.sections) || Object.keys(message.sections).length > 128) throw new Error(`${label}.sections must be a bounded map`);
+        for (const [name, text] of Object.entries(message.sections)) {
+          boundedText(name, `${label}.section name`, 128);
+          if (text !== null) boundedText(text, `${label}.sections.${name}`, 256 * 1024);
+        }
+      }
+      if (message.toolsRemoved !== undefined) {
+        if (!Array.isArray(message.toolsRemoved) || message.toolsRemoved.length > 128) throw new Error(`${label}.toolsRemoved must be bounded`);
+        const removed = new Set();
+        for (const tool of message.toolsRemoved) {
+          if (!isPlainObject(tool)) throw new Error(`${label}.toolsRemoved must contain tool identities`);
+          exactKeys(tool, ["name"], label);
+          boundedId(tool.name, `${label}.removed tool`, TOOL_NAME);
+          if (removed.has(tool.name) || !replayNames.has(tool.name)) throw new Error(`${label} removes an unknown or duplicate tool`);
+          removed.add(tool.name); replayTools.delete(tool.name); replayNames.delete(tool.name);
+        }
+      }
+      if (message.toolsAdded !== undefined) {
+        validateTools(message.toolsAdded);
+        for (const tool of message.toolsAdded) { replayTools.set(tool.name, tool); replayNames.add(tool.name); }
+      }
+      if (replayNames.size > 128) throw new Error(`${label} declares too many tools`);
+      continue;
+    }
     if (message.role === "user") {
       exactKeys(message, ["role", "content"], label);
       validateInputContent(message.content, `${label}.content`);
@@ -119,7 +151,7 @@ function validateMessages(messages, toolNames) {
     }
     if (message.role === "assistant") {
       exactKeys(message, ["role", "content"], label);
-      validateAssistantContent(message.content, `${label}.content`, toolNames, pending);
+      validateAssistantContent(message.content, `${label}.content`, replayNames, pending);
       continue;
     }
     exactKeys(message, ["role", "toolCallId", "toolName", "content", "isError"], label);
@@ -132,6 +164,10 @@ function validateMessages(messages, toolNames) {
     pending.delete(message.toolCallId);
   }
   if (pending.size > 0) throw new Error("messages end with unresolved tool calls");
+  if (transcript && (replayNames.size !== toolNames.size || tools.some((tool) =>
+    JSON.stringify(replayTools.get(tool.name)) !== JSON.stringify(tool)))) {
+    throw new Error("transcript final tools do not match the effective provider tools");
+  }
 }
 
 function validateTools(tools) {
@@ -161,6 +197,9 @@ export function captureProviderContext(context, { maxBytes = MAX_PROVIDER_CONTEX
   exactKeys(value, ["systemPrompt", "messages", "tools"], "context");
   boundedText(value.systemPrompt, "systemPrompt", 256 * 1024);
   const toolNames = validateTools(value.tools);
-  validateMessages(value.messages, toolNames);
+  if (value.messages.some((message) => message?.role === "system") && value.systemPrompt !== "") {
+    throw new Error("context mixes legacy system prompt with transcript system messages");
+  }
+  validateMessages(value.messages, toolNames, value.tools);
   return captured;
 }

package/src/provider-probe.mjs

@@ -51,6 +51,9 @@ export function parseModelVersion(modelId) {
   // current Sol/Terra/Luna routes stale and force ordinary work into premium capacity.
   const apex = /^gpt-(\d+(?:\.\d+)*)-astra(?:-|$)/.exec(normalized);
   if (apex) return { family: "gpt-astra", version: apex[1].split(".").map(Number) };
+  // Gemini product lines coexist: a new Argon is not a replacement for Flash.
+  const gemini = /^gemini-(\d+(?:\.\d+)*)-(flash-lite|flash|pro|argon)(?:-|$)/.exec(normalized);
+  if (gemini) return { family: `gemini-${gemini[2]}`, version: gemini[1].split(".").map(Number) };
   const match = VERSION_PATTERN.exec(normalized);
   if (!match) return { family: normalized.split(/[-_.:/]/)[0] || normalized, version: null };
   const family = match[1];

package/src/proxy-context.mjs

@@ -14,8 +14,8 @@ import { TOOL_CALL_ID, TOOL_NAME } from "./tool-identity.mjs";
 const NAMESPACE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
 const LOCAL_SCHEMA_METADATA = new Set(["~kind", "~optional", "~readonly"]);
 const USER_METADATA = ["role", "content", "timestamp"];
-const ASSISTANT_METADATA = ["role", "content", "api", "provider", "model", "responseModel", "responseId", "diagnostics", "usage", "stopReason", "deferred", "errorMessage", "rawStopReason", "endTurn", "timestamp"];
-const TOOL_RESULT_METADATA = ["role", "toolCallId", "toolName", "content", "details", "usage", "addedToolNames", "isError", "timestamp"];
+const ASSISTANT_METADATA = ["role", "content", "api", "provider", "model", "responseModel", "responseId", "diagnostics", "usage", "stopReason", "deferred", "errorMessage", "rawStopReason", "endTurn", "timestamp", "durationMs", "thinkingLevel", "providerThinkingLevel"];
+const TOOL_RESULT_METADATA = ["role", "toolCallId", "toolName", "content", "details", "usage", "addedToolNames", "isError", "timestamp", "durationMs", "nestedCalls"];
 const NON_PRINTABLE_TEXT = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g;
 const MAX_PROVIDER_TEXT = 256 * 1024;
 const IMAGE_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
@@ -186,20 +186,51 @@ function canonicalTool(tool, index) {
   };
 }
 
-/** Convert a Pi Context into a detached, closed provider context. */
+function canonicalSystemMessage(message, index) {
+  const label = `proxy context messages[${index}]`;
+  exactKeys(message, ["role", "content", "timestamp", "sections", "toolsAdded", "toolsRemoved"], label);
+  const content = canonicalInputContent(message.content, `${label}.content`);
+  if (typeof content !== "string") throw new Error(`${label}.content must be system text`);
+  const result = { role: "system", content };
+  if (message.sections !== undefined) result.sections = schemaProjection(message.sections, `${label}.sections`);
+  if (message.toolsAdded !== undefined) {
+    if (!Array.isArray(message.toolsAdded)) throw new Error(`${label}.toolsAdded must be an array`);
+    result.toolsAdded = message.toolsAdded.map(canonicalTool);
+  }
+  if (message.toolsRemoved !== undefined) {
+    if (!Array.isArray(message.toolsRemoved)) throw new Error(`${label}.toolsRemoved must be an array`);
+    result.toolsRemoved = message.toolsRemoved.map((tool) => {
+      if (!tool || typeof tool !== "object" || Array.isArray(tool)) throw new Error(`${label}.toolsRemoved must contain tool identities`);
+      exactKeys(tool, ["name"], label);
+      return { name: tool.name };
+    });
+  }
+  return result;
+}
+
+/** Convert legacy Pi Context or native1.x TranscriptContext without dropping
+ * chronological system/tool deltas or forwarding executable declarations. */
 export function proxyCanonicalContext(context) {
   if (!context || typeof context !== "object" || Array.isArray(context)) throw new Error("proxy context is required");
   exactKeys(context, ["systemPrompt", "messages", "tools"], "proxy context");
   if (!Array.isArray(context.messages)) throw new Error("proxy context messages are required");
   if (context.systemPrompt !== undefined && typeof context.systemPrompt !== "string") throw new Error("proxy system prompt must be text");
   if (context.tools !== undefined && !Array.isArray(context.tools)) throw new Error("proxy context tools must be an array");
-  const tools = (context.tools ?? []).map(canonicalTool);
-  const messages = context.messages.map(canonicalMessage);
-  return captureProviderContext({
-    systemPrompt: context.systemPrompt ?? "",
-    messages,
-    tools,
-  }, { maxBytes: MAX_PROVIDER_CONTEXT_BYTES }).value;
+  const transcript = context.messages.some((message) => message?.role === "system");
+  if (transcript && (context.systemPrompt !== undefined || context.tools !== undefined)) {
+    throw new Error("proxy context mixes legacy prompt/tools with transcript system messages");
+  }
+  const messages = context.messages.map((message, index) => message?.role === "system"
+    ? canonicalSystemMessage(message, index) : canonicalMessage(message, index));
+  const currentTools = new Map();
+  if (transcript) for (const message of messages) {
+    if (message.role !== "system") continue;
+    for (const tool of message.toolsRemoved ?? []) currentTools.delete(tool.name);
+    for (const tool of message.toolsAdded ?? []) currentTools.set(tool.name, tool);
+  }
+  const tools = transcript ? [...currentTools.values()] : (context.tools ?? []).map(canonicalTool);
+  return captureProviderContext({ systemPrompt: context.systemPrompt ?? "", messages, tools },
+    { maxBytes: MAX_PROVIDER_CONTEXT_BYTES }).value;
 }
 
 /** Map closed provider terminal outcomes to Pi stop/error semantics without leaking raw bodies. */

package/src/retained-work.mjs

@@ -0,0 +1,45 @@
+import { lstatSync, readdirSync, realpathSync } from 'node:fs';
+import { join, resolve, sep } from 'node:path';
+
+/** Controller-owned evidence pointers only. Never turn child logs into instructions
+ * or verification. Existing session journals survive failed terminal results. */
+export function retainedWork(sessionsRoot, taskId) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,159}$/.test(taskId)) throw new Error('invalid task id');
+  const root = resolve(sessionsRoot);
+  let task = join(root, taskId);
+  const artifacts = [];
+  let incomplete = false;
+  function visit(directory, depth) {
+    if (depth > 4) { incomplete = true; return; }
+    let entries;
+    try {
+      if (lstatSync(directory).isSymbolicLink() || !realpathSync(directory).startsWith(realpathSync(task) + sep) && realpathSync(directory) !== realpathSync(task)) return;
+      entries = readdirSync(directory, { withFileTypes: true });
+    } catch { return; }
+    for (const entry of entries) {
+      if (artifacts.length >= 128) { incomplete = true; break; }
+      const path = join(directory, entry.name);
+      if (entry.isSymbolicLink()) continue;
+      if (entry.isDirectory()) visit(path, depth + 1);
+      else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+        // Do not read potentially large/private raw transcripts into the report.
+        const stat = lstatSync(path);
+        artifacts.push({ kind: 'child_session', path, bytes: stat.size, verificationStatus: 'unverified' });
+      }
+    }
+  }
+  let attempts = [];
+  try { attempts = readdirSync(root).filter(name => name === taskId ||
+    (name.startsWith(taskId + '-r') && /^[0-9]+$/.test(name.slice(taskId.length + 2)))); } catch { /* no attempts */ }
+  for (const attempt of attempts) {
+    task = join(root, attempt);
+    try { if (lstatSync(task).isSymbolicLink()) continue; } catch { continue; }
+    visit(join(task, 'sessions'), 0);
+    try {
+      const worktree = join(task, 'worktree');
+      if (lstatSync(worktree).isDirectory() && !lstatSync(worktree).isSymbolicLink())
+        artifacts.push({kind:'retained_worktree',path:worktree,verificationStatus:'unverified'});
+    } catch { /* no retained worktree */ }
+  }
+  return { status: artifacts.length ? 'available' : 'not_found', artifacts, incomplete, root: join(root, taskId) };
+}

package/src/signed-registry.mjs

@@ -139,7 +139,13 @@ function normalizedBrokerRegistry(registry) {
       ownKeysExactly(resource.provenance, [
         "providerClass", "modelDeveloper", "routeProvider", "baseProvider",
         "billingPool", "nativeToRoute", "source",
+        ...(resource.provenance.quotaObservationScope !== undefined ? ["quotaObservationScope"] : []),
       ], `resource ${id} provenance`);
+      if (resource.provenance.quotaObservationScope !== undefined &&
+        (resource.provenance.baseProvider !== "google-antigravity" || !model ||
+          resource.provenance.quotaObservationScope !== `model:${model.modelId.toLowerCase()}`)) {
+        throw new Error(`resource ${id} provenance quotaObservationScope must identify its exact Antigravity model`);
+      }
       for (const field of ["providerClass", "modelDeveloper", "routeProvider", "baseProvider", "billingPool", "source"]) {
         requireIdentifier(resource.provenance[field], `resource ${id} provenance ${field}`);
       }