arkgate 4.8.4 → 4.8.6

package/bin/lib/ark-order-invariants.mjs

@@ -9,9 +9,17 @@
  */
 
 import { ArkOrderError } from './ark-order-error.mjs';
-import { DEFAULT_MAX_XI_KEYS } from './ark-order-types.mjs';
+import { CAPACITY_OPS, DEFAULT_MAX_XI_KEYS } from './ark-order-types.mjs';
 import { deterministicHash, stableSerialize } from './stableHash';
 export { DEFAULT_MAX_XI_KEYS };
+/** D7: consumer still owns handlers — this only names the travel verb. */
+export function ingestTravelAction(residual) {
+    if (residual.kind === 'absorb')
+        return 'send';
+    if (residual.kind === 'escalate_up' && residual.target === 'human')
+        return 'raises';
+    return 'none';
+}
 const FORBIDDEN_PLANE_METHODS = ['update', 'patch', 'set', 'mutate'];
 export function isForbiddenPlaneMethod(name) {
     return FORBIDDEN_PLANE_METHODS.includes(name);
@@ -70,42 +78,197 @@ export function assertXiSchema(xi, schema) {
         }
     }
 }
-export function hashReleasePayload(xi, sigma) {
+function catalogDigestFor(xi, catalogDigest) {
+    if (typeof catalogDigest !== 'string')
+        return undefined;
+    if (!Object.prototype.hasOwnProperty.call(xi, 'catalogReleaseId'))
+        return undefined;
+    return catalogDigest;
+}
+export function hashReleasePayload(xi, sigma, catalogDigest) {
+    const digest = catalogDigestFor(xi, catalogDigest);
+    if (digest !== undefined)
+        return deterministicHash(stableSerialize({ xi, sigma, catalogDigest: digest }));
     return deterministicHash(stableSerialize({ xi, sigma }));
 }
+export function hashXiIdentity(xi, catalogDigest) {
+    const digest = catalogDigestFor(xi, catalogDigest);
+    if (digest !== undefined)
+        return deterministicHash(stableSerialize({ xi, catalogDigest: digest }));
+    return deterministicHash(stableSerialize({ xi }));
+}
+export function hashSigmaIdentity(sigma) {
+    return deterministicHash(stableSerialize({ sigma }));
+}
+export function xiRecordsEqual(left, right) {
+    return stableSerialize(left) === stableSerialize(right);
+}
+/** D1: after the first freeze, a later release() may not change ξ. */
+export function assertUnvalvedRelease(current, nextXi) {
+    if (!current)
+        return;
+    if (xiRecordsEqual(current.xi, nextXi))
+        return;
+    throw new ArkOrderError('ARKORDER_UNVALVED_RELEASE', 'ξ is frozen; change the pattern with proposeRelease then apply(ProposeResult)');
+}
 export function createFrozenRelease(input) {
     assertXiKeyCap(input.xi, input.maxXiKeys);
     const xi = freezeRecord(input.xi, 'ξ');
+    assertXiHasNoTtl(xi);
     assertXiSchema(xi, input.xiSchema);
     const sigma = freezeRecord(input.sigma ?? {}, 'σ');
     const release = Object.freeze({
         version: input.version,
-        hash: hashReleasePayload(xi, sigma),
+        hash: hashReleasePayload(xi, sigma, input.catalogDigest),
+        xiHash: hashXiIdentity(xi, input.catalogDigest),
+        sigmaHash: hashSigmaIdentity(sigma),
         xi,
         sigma,
         releasedAt: input.now,
     });
     return release;
 }
-export function classifyIngest(projection, event, packs = []) {
+/** D2: refresh σ without minting a pattern. xiHash must not change. */
+export function refreshSigmaRecord(input) {
+    const sigma = freezeRecord(input.sigma, 'σ');
+    return Object.freeze({
+        version: input.current.version,
+        hash: hashReleasePayload(input.current.xi, sigma, input.catalogDigest),
+        xiHash: input.current.xiHash,
+        sigmaHash: hashSigmaIdentity(sigma),
+        xi: input.current.xi,
+        sigma,
+        releasedAt: input.now,
+    });
+}
+const XI_TTL_KEY_RE = /^(ttl|freshUntil|fresh_until|maxAge|max_age)$/i;
+export function assertXiHasNoTtl(xi) {
+    for (const key of Object.keys(xi)) {
+        if (XI_TTL_KEY_RE.test(key)) {
+            throw new ArkOrderError('ARKORDER_XI_TTL', `ξ key ${JSON.stringify(key)} is a freshness field; TTL belongs on σ, never on ξ`);
+        }
+    }
+}
+export function assertInformationBudget(projection, budget) {
+    if (!budget || budget.cannotObserve.length === 0)
+        return;
+    const denied = new Set(budget.cannotObserve);
+    for (const kind of projection.allowedKinds) {
+        if (denied.has(kind)) {
+            throw new ArkOrderError('ARKORDER_INFORMATION_BUDGET', `projection allows ${JSON.stringify(kind)}; informationBudget.cannotObserve forbids it`);
+        }
+    }
+}
+export function assertSigmaFresh(input) {
+    if (input.maxAgeMs === undefined)
+        return;
+    const until = input.sigma.freshUntil;
+    if (typeof until === 'number') {
+        if (input.now > until) {
+            throw new ArkOrderError('ARKORDER_STALE_SIGMA', 'σ freshUntil has elapsed; ξ does not TTL');
+        }
+        return;
+    }
+    const origin = typeof input.sigma.releasedAt === 'number' ? input.sigma.releasedAt : input.releasedAt;
+    if (typeof origin === 'number' && input.now - origin > input.maxAgeMs) {
+        throw new ArkOrderError('ARKORDER_STALE_SIGMA', 'σ is older than sigmaMaxAgeMs; ξ does not TTL');
+    }
+}
+export function fieldEventIdentity(event) {
+    return deterministicHash(stableSerialize({ kind: event.kind, payload: event.payload ?? null }));
+}
+function bindResidual(event, xiHash) {
+    return { event, xiHash, eventId: fieldEventIdentity(event) };
+}
+const CAPACITY_OP_SET = new Set(CAPACITY_OPS);
+function isCapacityOp(value) {
+    return typeof value === 'string' && CAPACITY_OP_SET.has(value);
+}
+function numericLeaf(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function compareCapacity(left, op, right) {
+    if (op === 'lte')
+        return left <= right;
+    if (op === 'lt')
+        return left < right;
+    if (op === 'gte')
+        return left >= right;
+    return left > right;
+}
+function packHasFunction(value) {
+    if (typeof value === 'function')
+        return true;
+    if (value === null || typeof value !== 'object')
+        return false;
+    if (Array.isArray(value))
+        return value.some(packHasFunction);
+    return Object.values(value).some(packHasFunction);
+}
+function evaluateCapacity(event, sigma, pack) {
+    const rows = pack.capacity ?? [];
+    for (const row of rows) {
+        if (packHasFunction(row) || !isCapacityOp(row.op))
+            return 'pack';
+        if (row.kind !== event.kind)
+            continue;
+        const payload = event.payload && typeof event.payload === 'object' && !Array.isArray(event.payload)
+            ? numericLeaf(event.payload[row.payloadKey])
+            : undefined;
+        const limit = numericLeaf(sigma[row.sigmaKey]);
+        if (payload === undefined || limit === undefined)
+            return 'pack';
+        if (!compareCapacity(payload, row.op, limit))
+            return 'capacity';
+    }
+    return 'ok';
+}
+export function classifyIngest(projection, event, packs = [], xiHash = '', sigma = Object.freeze({})) {
     const kind = event.kind;
+    const bound = bindResidual(event, xiHash);
     for (const pack of packs) {
+        if (packHasFunction(pack.capacity) || packHasFunction(pack.escalateKinds)) {
+            return {
+                ...bound,
+                kind: 'hold',
+                reasonCode: 'pack',
+                reason: `pack ${pack.id} is not data-only; user predicates are forbidden`,
+            };
+        }
         if (pack.escalateKinds?.includes(kind)) {
+            const target = pack.escalateTarget ?? 'human';
             return {
-                kind: 'escalate',
-                event,
+                ...bound,
+                kind: 'escalate_up',
+                reasonCode: 'pack',
                 reason: `pack ${pack.id} slaves kind ${JSON.stringify(kind)} to a pattern change`,
+                target,
             };
         }
     }
-    if (projection.allowedKinds.includes(kind)) {
-        return { kind: 'absorb', event };
+    if (!projection.allowedKinds.includes(kind)) {
+        return {
+            ...bound,
+            kind: 'escalate_up',
+            reasonCode: 'not-in-pattern',
+            reason: `kind ${JSON.stringify(kind)} is not allowed by h(ξ); field cannot rewrite the pattern`,
+            target: 'human',
+        };
     }
-    return {
-        kind: 'escalate',
-        event,
-        reason: `kind ${JSON.stringify(kind)} is not allowed by h(ξ); field cannot rewrite the pattern`,
-    };
+    for (const pack of packs) {
+        const cap = evaluateCapacity(event, sigma, pack);
+        if (cap === 'ok')
+            continue;
+        return {
+            ...bound,
+            kind: 'hold',
+            reasonCode: cap,
+            reason: cap === 'capacity'
+                ? `pack ${pack.id} capacity ${JSON.stringify(event.kind)} does not hold`
+                : `pack ${pack.id} capacity is not numeric data`,
+        };
+    }
+    return { ...bound, kind: 'absorb' };
 }
 export function blastRadiusOf(previous, next) {
     const prev = new Set(previous.allowedKinds);
@@ -142,6 +305,7 @@ export function proposePatternChange(input) {
         now: input.now,
         maxXiKeys: input.maxXiKeys,
         xiSchema: input.xiSchema,
+        catalogDigest: input.catalogDigest,
     });
     if (candidate.hash === input.current.hash) {
         throw new ArkOrderError('ARKORDER_EMPTY_BLAST', 'delta does not change ξ; that is not a pattern change');
@@ -158,3 +322,25 @@ export function proposePatternChange(input) {
         invalidations,
     };
 }
+/** D1 valve: freeze ProposeResult.nextXi. Empty blast still fails. */
+export function applyProposedRelease(input) {
+    const candidate = createFrozenRelease({
+        xi: { ...input.proposal.nextXi },
+        sigma: { ...input.current.sigma },
+        version: input.current.version + 1,
+        now: input.now,
+        maxXiKeys: input.maxXiKeys,
+        xiSchema: input.xiSchema,
+        catalogDigest: input.catalogDigest,
+    });
+    if (xiRecordsEqual(candidate.xi, input.current.xi)) {
+        throw new ArkOrderError('ARKORDER_EMPTY_BLAST', 'delta does not change ξ; that is not a pattern change');
+    }
+    const previous = input.projector(input.current, input.current.sigma);
+    const next = input.projector(candidate, candidate.sigma);
+    const { blastRadius } = blastRadiusOf(previous, next);
+    if (blastRadius.length === 0) {
+        throw new ArkOrderError('ARKORDER_EMPTY_BLAST', 'pattern change has empty blast radius; that key is not an order parameter');
+    }
+    return candidate;
+}

package/bin/lib/ark-order-sensors.mjs

@@ -18,6 +18,8 @@ export const ARKORDER_TIER1_SENSOR_IDS = [
     'arkorder-too-many-params',
     'arkorder-ingest-writes-xi',
     'arkorder-xi-field-write',
+    'arkorder-information-budget',
+    'arkorder-xi-ttl',
 ];
 export const ARKORDER_RULE_IDS = {
     'arkorder-missing-plane': 'ARKORDER_MISSING_PLANE',
@@ -26,6 +28,8 @@ export const ARKORDER_RULE_IDS = {
     'arkorder-too-many-params': 'ARKORDER_TOO_MANY_PARAMS',
     'arkorder-ingest-writes-xi': 'ARKORDER_INGEST_WRITES_XI',
     'arkorder-xi-field-write': 'ARKORDER_XI_FIELD_WRITE',
+    'arkorder-information-budget': 'ARKORDER_INFORMATION_BUDGET',
+    'arkorder-xi-ttl': 'ARKORDER_XI_TTL',
 };
 function isDomainRoleLayer(layer, intentPrefixes = []) {
     const name = layer.trim();

package/bin/lib/ark-order-types.mjs

@@ -9,3 +9,6 @@
  */
 
 export const DEFAULT_MAX_XI_KEYS = 7;
+export const INGEST_RESIDUAL_KINDS = ['absorb', 'escalate_up', 'hold'];
+export const INGEST_REASON_CODES = ['not-in-pattern', 'stale-sigma', 'pack', 'capacity'];
+export const CAPACITY_OPS = ['lte', 'lt', 'gte', 'gt'];

package/bin/lib/check-args.mjs

@@ -149,11 +149,13 @@ export function parseArgs(argv) {
     else if (arg === '--prune-home-duplicates') args.pruneHomeDuplicates = true;
     else if (arg === '--claude-home') args.claudeHome = true;
     else if (arg === '--grok-home') args.grokHome = true;
+    else if (arg === '--antigravity-home') args.antigravityHome = true;
     else if (arg === '--agent-homes') {
       args.agentHomes = true;
       args.codexHome = true;
       args.claudeHome = true;
       args.grokHome = true;
+      args.antigravityHome = true;
     }
     else if (arg === '--migrate-commands') args.migrateCommands = true;
     else if (arg === '--no-cache') args.noCache = true;

package/bin/lib/diagnostic-catalog.mjs

@@ -67,10 +67,14 @@ export const DIAGNOSTIC_CATALOG = Object.freeze([
     entry('ARKRUN_TRANSPORT_BYPASS', 'arkrun', 'Homemade broker or emitter import', 'A managed layer imports a closed broker/queue/emitter specifier (EventEmitter, queue clients, …) instead of the ArkRun kernel transport.', 'Send through the ArkRun kernel transport instead of importing that broker or emitter, then preflight again. Never mechanical-safe — homemade buses stay judgment.'),
     entry('ARKORDER_MISSING_PLANE', 'arkorder', 'No createOrderPlane in plane roots', 'The ArkOrder extra is on but no createOrderPlane factory was found in arkOrder.planeRoots, so agents can skip the pattern plane while the write gate stays green.', 'Import createOrderPlane from arkgate/order and call it in a plane root listed in arkOrder.planeRoots, then preflight again. Never mechanical-safe — factory placement is a design decision.'),
     entry('ARKORDER_KERNEL_IN_DOMAIN', 'arkorder', 'Domain-role layer imports the order plane', 'A Domain-role layer imports arkgate/order. Domain stays plane-free; planeRoots own the factory.', 'Move the arkgate/order import out of the Domain-role layer into a plane root or adapter, then preflight again. Never mechanical-safe.'),
-    entry('ARKORDER_GENERIC_UPDATE', 'arkorder', 'Generic update of ξ', 'A call to update/patch/set on the order plane rewrites the slow pattern. Haken slaving forbids generic ξ mutation.', 'Use release() to freeze ξ or proposeRelease() for a pattern change with blast radius, then preflight again. Never mechanical-safe.'),
+    entry('ARKORDER_GENERIC_UPDATE', 'arkorder', 'Generic update of ξ', 'A call to update/patch/set on the order plane rewrites the slow pattern. Haken slaving forbids generic ξ mutation.', 'Use release() for the first freeze of ξ. Later pattern change is proposeRelease then apply(ProposeResult). Never update/patch/set. Never mechanical-safe.'),
     entry('ARKORDER_TOO_MANY_PARAMS', 'arkorder', 'Too many slow keys', 'ξ has more keys than arkOrder.maxXiKeys. Haken requires a few slow modes, not a dump of microstate.', 'Cut ξ to the slow keys that actually slave the rest, then preflight again. Never mechanical-safe.'),
-    entry('ARKORDER_INGEST_WRITES_XI', 'arkorder', 'ingest assigned into ξ', 'An ingest() result is written into a Release or ξ store. ingest may absorb or escalate; it never mints a pattern.', 'Keep ingest results as absorb/escalate only. Change ξ with proposeRelease + release. Never mechanical-safe.'),
-    entry('ARKORDER_XI_FIELD_WRITE', 'arkorder', 'Slow key written around the order plane', 'A managed-layer file imports a persistence driver and writes a declared arkOrder.xiKeys name. Field events absorb or escalate; they do not PATCH the slow pattern.', 'Keep invoices, seats, hours, and logs on ingest. Change the slow key with proposeRelease + release, then preflight again. Never mechanical-safe.'),
+    entry('ARKORDER_INGEST_WRITES_XI', 'arkorder', 'ingest assigned into ξ', 'An ingest() result is written into a Release or ξ store. ingest may absorb, escalate_up, or hold; it never mints a pattern.', 'Keep ingest results as absorb/escalate_up/hold only. Change ξ with proposeRelease then apply(ProposeResult). Never mechanical-safe.'),
+    entry('ARKORDER_XI_FIELD_WRITE', 'arkorder', 'Slow key written around the order plane', 'A managed-layer file imports a persistence driver and writes a declared arkOrder.xiKeys name. Field events absorb or escalate; they do not PATCH the slow pattern.', 'Keep invoices, seats, hours, and logs on ingest. Change the slow key with proposeRelease then apply(ProposeResult), then preflight again. Never mechanical-safe.'),
+    entry('ARKORDER_INFORMATION_BUDGET', 'arkorder', 'Projection observes a forbidden kind', 'h(ξ) allowedKinds includes a kind listed in informationBudget.cannotObserve. A scale may not look at what it was told not to see.', 'Cut that kind from the projector or from cannotObserve, then preflight again. Never mechanical-safe.'),
+    entry('ARKORDER_XI_TTL', 'arkorder', 'Slow key carries a freshness field', 'ξ named ttl/freshUntil/maxAge. Freshness belongs on σ. A slow parameter that expires per transaction is not slow.', 'Move freshness onto σ (freshUntil) and keep ξ stable, then preflight again. Never mechanical-safe.'),
+    entry('ARKORDER_STALE_SIGMA', 'arkorder', 'σ is stale', 'ingest ran after σ.freshUntil (or sigmaMaxAgeMs). ξ does not TTL.', 'Call refreshSigma and ingest again, or proposeRelease then apply(ProposeResult) if the pattern changed. Never mechanical-safe.'),
+    entry('ARKORDER_UNVALVED_RELEASE', 'arkorder', 'Unvalved second freeze of ξ', 'release() ran after a pattern was already frozen and the new ξ differs. First freeze is release(); later pattern change is proposeRelease then apply.', 'Change ξ with proposeRelease then apply(ProposeResult). release() is only the first freeze. Never mechanical-safe.'),
     // ── atomic preflight / change set ────────────────────────────────────────
     entry('INVALID_CHANGE_PATH', 'preflight', 'Unsafe change path', 'A change set entry is not a safe, non-empty project-relative path (absolute, escape, empty, or NUL).', 'Use canonical project-relative paths only in the atomic change set, then preflight again.'),
     entry('DUPLICATE_CHANGE_PATH', 'preflight', 'Duplicate path in change set', 'The atomic change set lists more than one operation for the same path.', 'Collapse to one create/update/delete per path, then preflight again.'),

package/bin/lib/first-run-help.mjs

@@ -82,7 +82,7 @@ Options:
                Valid ids: crud-product, api-backend, frontend-surface, library-sdk, cli-utility,
                worker-pipeline, event-coordinator, integration-bridge, multi-app-workspace, prototype-spike,
                vertical-slice-product, ddd-bounded-contexts.
-  --tools      One active agent host for start (claude,cursor,codex,grok,windsurf,cline,copilot,kiro,roo,continue,gemini).
+  --tools      One active agent host for start (claude,cursor,codex,grok,antigravity,windsurf,cline,copilot,kiro,roo,continue,gemini).
                Omit to use the active host; an unknown host creates only the shared compact router.
   --remove-host <host>
                Preview or apply removal of that compact host integration; re-add it with --tools <host>.
@@ -142,7 +142,7 @@ export function checkUsageAll() {
     '           Best-effort open in browser (local TTY). No-op if open fails. --no-open / ARK_NO_OPEN_REPORT=1 to skip; --open forces open.',
     '       ark-check --init [--preset hexagonal|layered|feature-sliced|monorepo|ui-surface|vertical-slice|ddd-bounded-contexts|vite-vercel-spa|clean-architecture|onion-architecture] [--force] [--follow-config-root]',
     '       --follow-config-root  On writes (init/install-agent-gates/migrate --write/…), adopt walked-up monorepo config root (default: keep explicit --root)',
-    '       ark-check --install-agent-gates [--tools claude,cursor,codex,grok] [--require-write-hook <host>] [--skills-only] [--codex-home] [--claude-home] [--grok-home] [--agent-homes] [--force]',
+    '       ark-check --install-agent-gates [--tools claude,cursor,codex,grok,antigravity] [--require-write-hook <host>] [--skills-only] [--codex-home] [--claude-home] [--grok-home] [--antigravity-home] [--agent-homes] [--force]',
     '       ark-check --update-baseline [file]     freeze current violations (default .ark-baseline.json)',
     '       ark-check --print-config eleven-layer',
     '',
@@ -208,7 +208,7 @@ export function checkUsageAll() {
     'Included but unclassified source files therefore stay red instead of false-green.',
     '',
     '--install-agent-gates writes AGENTS.md, .mcp.json, and the CI workflow for every',
-    'project, plus tool-specific templates. Known tools: claude, cursor, codex, grok',
+    'project, plus tool-specific templates. Known tools: claude, cursor, codex, grok, antigravity',
     '(Claude/Grok/Antigravity/Cursor hard-write hooks when covered; Codex hard local apply_patch;',
     'shared CI check for all) and',
     'windsurf, cline, copilot, kiro, roo, continue, gemini',
@@ -225,7 +225,7 @@ export function checkUsageAll() {
     'Pass --tools to pick which tool configs to write; otherwise they are auto-detected',
     'from their config directories (.claude/, .cursor/, .codex/, .grok/, .windsurf/,',
     '.clinerules/, .kiro/, .roo/, .continue/, .gemini/; copilot is explicit-only).',
-    'claude+cursor+codex+grok are written when nothing is detected.',
+    'claude+cursor+codex+grok+antigravity are written when nothing is detected.',
     '',
     'Generate a starter 11-layer config:',
     '  ark-check --print-config eleven-layer > ark.config.json',

package/bin/lib/remediation.mjs

@@ -107,6 +107,7 @@ const ARKORDER_JUDGMENT_RULE_IDS = new Set([
     'ARKORDER_TOO_MANY_PARAMS',
     'ARKORDER_INGEST_WRITES_XI',
     'ARKORDER_XI_FIELD_WRITE',
+    'ARKORDER_UNVALVED_RELEASE',
 ]);
 function arkRunCallSiteName(violation) {
     return typeof violation.target === 'string' && violation.target.trim().length > 0
@@ -238,15 +239,17 @@ export function deterministicNextAction(violation) {
         case 'ARKORDER_KERNEL_IN_DOMAIN':
             return 'Move the arkgate/order import out of the Domain-role layer into a plane root or adapter, then preflight again. Never mechanical-safe.';
         case 'ARKORDER_GENERIC_UPDATE':
-            return 'Use release() to freeze ξ or proposeRelease() for a pattern change with blast radius, then preflight again. Never mechanical-safe.';
+            return 'Use release() for the first freeze of ξ. Later pattern change is proposeRelease then apply(ProposeResult). Never update/patch/set. Never mechanical-safe.';
         case 'ARKORDER_TOO_MANY_PARAMS':
             return 'Cut ξ to the slow keys that actually slave the rest, then preflight again. Never mechanical-safe.';
         case 'ARKORDER_INGEST_WRITES_XI':
-            return 'Keep ingest results as absorb/escalate only. Change ξ with proposeRelease + release. Never mechanical-safe.';
+            return 'Keep ingest results as absorb/escalate_up/hold only. Change ξ with proposeRelease then apply(ProposeResult). Never mechanical-safe.';
         case 'ARKORDER_XI_FIELD_WRITE':
             return typeof violation.target === 'string' && violation.target.length > 0
-                ? `Do not persist slow key ${violation.target} from a use-case. Absorb the field with ingest() or change the pattern with proposeRelease(), then preflight again.`
-                : 'Do not persist a declared slow key from a use-case. Absorb the field with ingest() or change the pattern with proposeRelease(), then preflight again. Never mechanical-safe.';
+                ? `Do not persist slow key ${violation.target} from a use-case. Absorb the field with ingest() or change the pattern with proposeRelease then apply, then preflight again.`
+                : 'Do not persist a declared slow key from a use-case. Absorb the field with ingest() or change the pattern with proposeRelease then apply, then preflight again. Never mechanical-safe.';
+        case 'ARKORDER_UNVALVED_RELEASE':
+            return 'Change ξ with proposeRelease then apply(ProposeResult). release() is only the first freeze. Never mechanical-safe.';
         default:
             if (typeof violation.ruleId === 'string' && violation.ruleId.startsWith('ARKRULE_')) {
                 return `Fix the ArkRule ${typeof violation.arkruleId === 'string' ? violation.arkruleId : violation.ruleId}, then preflight again.`;
@@ -517,6 +520,10 @@ export function enrichViolationWithFixClass(violation) {
         case 'ARKORDER_TOO_MANY_PARAMS':
         case 'ARKORDER_INGEST_WRITES_XI':
         case 'ARKORDER_XI_FIELD_WRITE':
+        case 'ARKORDER_INFORMATION_BUDGET':
+        case 'ARKORDER_XI_TTL':
+        case 'ARKORDER_STALE_SIGMA':
+        case 'ARKORDER_UNVALVED_RELEASE':
             enriched.fixClass = 'arkorder-usage';
             enriched.effort = 'medium';
             enriched.enthusiastHint =
@@ -530,7 +537,15 @@ export function enrichViolationWithFixClass(violation) {
                                 ? 'ingest can absorb or escalate. It never writes a new house.'
                                 : violation.ruleId === 'ARKORDER_XI_FIELD_WRITE'
                                     ? 'Name the slow keys in arkOrder.xiKeys. Invoices and seats still flow; changing the plan is a new release, not prisma.update.'
-                                    : 'Call createOrderPlane from arkgate/order in a listed plane root so the app actually freezes a pattern.';
+                                    : violation.ruleId === 'ARKORDER_INFORMATION_BUDGET'
+                                        ? 'A scale may not observe a denied kind. Cut it from the projector or from cannotObserve.'
+                                        : violation.ruleId === 'ARKORDER_XI_TTL'
+                                            ? 'TTL is σ, never ξ. A slow key that expires is not an order parameter.'
+                                            : violation.ruleId === 'ARKORDER_STALE_SIGMA'
+                                                ? 'Refresh σ. ξ does not expire.'
+                                                : violation.ruleId === 'ARKORDER_UNVALVED_RELEASE'
+                                                    ? 'The pattern is frozen. proposeRelease then apply — do not call release() again with a different ξ.'
+                                                    : 'Call createOrderPlane from arkgate/order in a listed plane root so the app actually freezes a pattern.';
             break;
         default:
             enriched.fixClass = 'review-contract';

package/bin/lib/skill-catalog-apply.mjs

@@ -99,7 +99,12 @@ export function applySkillCatalogFollowup({
   }
 
   const catalogReady = projectCatalogReady(root, skillNames);
-  if ((args.claudeHome || args.grokHome || args.agentHomes) && catalogReady) {
+  const wantAntigravityHome = Boolean(args.antigravityHome || args.agentHomes);
+  const wantClaudeGrokHome = Boolean(args.claudeHome || args.grokHome || args.agentHomes);
+  // Claude/Grok home copies override or duplicate the project catalog in the
+  // same session. Antigravity's official global catalog (~/.gemini/config/skills)
+  // is the machine floor for every workspace — still write it when asked.
+  if (wantClaudeGrokHome && catalogReady) {
     if (!args.json) {
       console.log('');
       console.log(
@@ -109,6 +114,17 @@ export function applySkillCatalogFollowup({
         `  Remove leftover home copies: ${arkCommand(root, 'ark-check', '--install-agent-gates --skills-only --prune-home-duplicates')}`
       );
     }
+    installRequestedAgentHomes({
+      root,
+      skills,
+      version,
+      force: args.force,
+      claudeHome: false,
+      grokHome: false,
+      antigravityHome: wantAntigravityHome,
+      agentHomes: false,
+      json: args.json,
+    });
   } else {
     installRequestedAgentHomes({
       root,
@@ -117,6 +133,7 @@ export function applySkillCatalogFollowup({
       force: args.force,
       claudeHome: args.claudeHome,
       grokHome: args.grokHome,
+      antigravityHome: args.antigravityHome,
       agentHomes: args.agentHomes,
       json: args.json,
     });

package/bin/lib/skill-install.mjs

@@ -182,10 +182,11 @@ export function resolveTools(args) {
   ) {
     detected.add('antigravity');
   }
-  // No signal at all: fall back to a complete starter set including Grok (field
-  // log: default claude+cursor+codex silently omitted Grok skills for Grok hosts).
+  // No signal at all: fall back to a complete starter set including Grok and
+  // Antigravity (field log: default claude+cursor+codex silently omitted Grok;
+  // the same hole left Antigravity without `.agents/skills`).
   if (detected.size === 0) {
-    return { tools: new Set(['claude', 'cursor', 'codex', 'grok']), source: 'default' };
+    return { tools: new Set(['claude', 'cursor', 'codex', 'grok', 'antigravity']), source: 'default' };
   }
   return { tools: detected, source: 'detected' };
 }

package/bin/lib/upgrade-whats-new.mjs

@@ -61,7 +61,7 @@ export function buildUpgradeWhatsNewSuggestions() {
         id: 'shared-agent-homes',
         title: 'Shared agent skills (home)',
         try: 'npx arkgate-check --install-agent-gates --skills-only --agent-homes --force',
-        inspect: 'doctor.agentHomeGaps (Claude/Grok ~/.*/skills when those catalogs exist)',
+        inspect: 'doctor.agentHomeGaps (Claude/Grok ~/.*/skills and Antigravity ~/.gemini/config/skills when those catalogs exist)',
         why:
           'Project skills follow this pin. Shared homes stay on the newest ArkGate on the machine (additive; never downgrade). Orphan 2.x global skills stop coaching the wrong version.',
       },

package/dist/{diagnosticCatalog-DgTs0abp.d.ts → diagnosticCatalog-D_DI7qrZ.d.ts}

@@ -409,7 +409,7 @@ declare const ARK_ANALYSIS_RESULT_SCHEMA: {
 };
 
 /** ArkGate library version — single source of truth. */
-declare const version = "4.8.4";
+declare const version = "4.8.6";
 
 /**
  * AI Code Gate (basic).