owlrunkit 0.16.0 → 0.16.1

package/scripts/runkit-contract/project-cli-resolver.mjs

@@ -18,6 +18,9 @@ const OFFICIAL_CLI_ENTRYPOINT =
 const EXACT_VERSION = /^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?$/;
 const SHA256_REF = /^sha256:[a-f0-9]{64}$/;
 const TRUSTED_PRIOR_CORE_IDENTITIES = new Map([
+  ["0.16.0", new Set([
+    "sha256:320fb1d97b4459d1a14b0b67807dcf2bc6b03970492cb9fb2c6245b17912c81e",
+  ])],
   ["0.15.1", new Set([
     "sha256:e8ca57522a8e473da356ceb3768bb650267894638d450d5e49463ab6f51c752b",
   ])],

package/scripts/runkit-contract/project-control-parser.mjs

@@ -140,7 +140,40 @@ function allowedKeys(value, expected) {
   return Object.keys(value).every(key => expected.includes(key));
 }
 
-function inspectLeases(root, executionRoot, runId, contract) {
+function validateHistoricalLeaseOwnedPaths(paths, contract) {
+  try {
+    return contract.validateLeaseOwnedPaths(paths);
+  } catch {
+    if (!Array.isArray(paths) || paths.length === 0) throw new Error("invalid");
+    const normalized = [...new Set(paths.map(value => {
+      if (
+        typeof value !== "string"
+        || value.length === 0
+        || path.isAbsolute(value)
+        || path.win32.isAbsolute(value)
+        || value.includes("\\")
+      ) throw new Error("invalid");
+      const segments = value.split("/");
+      if (segments.some(segment => (
+        segment.length === 0 || segment === "." || segment === ".."
+      ))) throw new Error("invalid");
+      if (
+        value.startsWith(`${contract.runtimeRoot}/`)
+        && value !== `${contract.runtimeRoot}/profiles.json`
+      ) throw new Error("invalid");
+      return value;
+    }))].sort(compareCodeUnits);
+    return normalized;
+  }
+}
+
+function inspectLeases(
+  root,
+  executionRoot,
+  runId,
+  contract,
+  { historicalAccepted = false, expectedReleasedLeaseIds = null } = {},
+) {
   const leasesRoot = path.join(executionRoot, "leases");
   if (!hasFilesystemEntry(leasesRoot)) {
     return {
@@ -200,7 +233,9 @@ function inspectLeases(root, executionRoot, runId, contract) {
       issues.push(`Lease attempt is invalid: ${runId}/${entry.name}`);
     }
     try {
-      const ownedPaths = contract.validateLeaseOwnedPaths(lease.ownedPaths);
+      const ownedPaths = historicalAccepted
+        ? validateHistoricalLeaseOwnedPaths(lease.ownedPaths, contract)
+        : contract.validateLeaseOwnedPaths(lease.ownedPaths);
       if (ownedPaths.some(ownedPath => (
         ownedPath.includes("*")
         && (!ownedPath.endsWith("/**") || ownedPath.slice(0, -3).includes("*"))
@@ -232,6 +267,14 @@ function inspectLeases(root, executionRoot, runId, contract) {
     .map(lease => lease.workItemId)
     .filter(workItemId => typeof workItemId === "string")
     .sort(compareCodeUnits);
+  if (
+    historicalAccepted
+    && Array.isArray(expectedReleasedLeaseIds)
+    && JSON.stringify(releasedWorkItemIds)
+      !== JSON.stringify([...expectedReleasedLeaseIds].sort(compareCodeUnits))
+  ) {
+    issues.push(`Historical accepted released lease binding mismatch: ${runId}`);
+  }
   return {
     status: issues.length > 0
       ? "invalid"
@@ -337,6 +380,11 @@ function inspectCloseout(root, executionRoot, runId, pin, contract) {
       }
       : {}),
     core: issues.length === 0 ? closeout.artifact.core : null,
+    releasedLeaseIds: issues.length === 0
+      && payload.decision === "accepted"
+      && Array.isArray(payload.verification?.releasedLeaseIds)
+      ? [...payload.verification.releasedLeaseIds]
+      : null,
     issues,
   };
 }
@@ -746,7 +794,18 @@ export function parseProjectControlState({
       && contract.validateExecutionPin({ expected: pin, actual: currentCore }).status !== "valid";
     const preserveHistoricalLeases = lifecycle === "closed"
       && new Set(["blocked", "rejected"]).has(closeout.decision);
-    const inspectedLease = inspectLeases(root, executionRoot, runId, contract);
+    const inspectedLease = inspectLeases(
+      root,
+      executionRoot,
+      runId,
+      contract,
+      {
+        historicalAccepted: historical
+          && lifecycle === "closed"
+          && closeout.decision === "accepted",
+        expectedReleasedLeaseIds: closeout.releasedLeaseIds,
+      },
+    );
     const lease = preserveHistoricalLeases && inspectedLease.status !== "invalid"
       ? {
           ...inspectedLease,

package/scripts/runkit-contract/runkit-cli.mjs

@@ -93,7 +93,10 @@ import {
 } from "./profile-onboarding.mjs";
 import {
   discoverFleet,
+  inspectFleetRegistry,
   registerFleetCoverageRoot,
+  replaceFleetRegistry,
+  rollbackFleetRegistry,
 } from "./fleet-discovery.mjs";
 import { routeRunKitAssuranceV1 } from "./assurance-router.mjs";
 import { deriveHumanStatusFromInspectV1 } from "./human-status.mjs";
@@ -162,9 +165,10 @@ Two-stage deployment
   owlrunkit deployment execute --workspace . [--resume] --prepare <receipt> --owner-decision <decision-v1.json> --owner-authority <signed-v2.json> --manifest <remote.json>
 
 Fleet and status
-  owlrunkit fleet register-root --fleet-root <directory>
-  owlrunkit fleet discover
-  owlrunkit status --workspace .
+  owlrunkit fleet <register-root|inspect-registry> [options]
+  owlrunkit fleet replace-registry --request <file> --receipt <file> [--dry-run]
+  owlrunkit fleet rollback-registry --receipt <file> --rollback-receipt <file>
+  owlrunkit fleet discover; owlrunkit status --workspace .
 
 Core successor
   owlrunkit core-successor <plan|apply|resume> --workspace . [...]
@@ -193,12 +197,33 @@ Required:
 `,
   fleet: `Usage:
   owlrunkit fleet register-root --fleet-root <directory>
+  owlrunkit fleet inspect-registry [--registry <file>]
+  owlrunkit fleet replace-registry --request <file> --receipt <file> [--registry <file>] [--dry-run]
+  owlrunkit fleet rollback-registry --receipt <file> --rollback-receipt <file> [--registry <file>]
   owlrunkit fleet discover [--fleet-root <directory>] [--fleet-manifest <file>]
 `,
   "fleet register-root": `Usage:
   owlrunkit fleet register-root --fleet-root <directory>
 
 Registers one durable fleet coverage root for later no-argument discovery.
+`,
+  "fleet inspect-registry": `Usage:
+  owlrunkit fleet inspect-registry [--registry <file>]
+
+Reads the exact registry bytes, hashes, roots, and membership without mutation.
+`,
+  "fleet replace-registry": `Usage:
+  owlrunkit fleet replace-registry --request <file> --receipt <file>
+    [--registry <file>] [--dry-run]
+
+Atomically replaces a registry from an exact preimage and evidence-bound fleet
+membership. Coverage reduction requires explicit exclusion evidence.
+`,
+  "fleet rollback-registry": `Usage:
+  owlrunkit fleet rollback-registry --receipt <replacement-receipt.json>
+    --rollback-receipt <file> [--registry <file>]
+
+Restores the exact preimage recorded by a replacement receipt.
 `,
   "fleet discover": `Usage:
   owlrunkit fleet discover [--fleet-root <directory>] [--fleet-manifest <file>]
@@ -1602,6 +1627,8 @@ export async function runCli(argv = process.argv.slice(2), runtimeHooks = {}) {
             ? ["json"]
         : command === "profiles"
             ? ["json", "dry-run", "apply"]
+        : command === "fleet" && action === "replace-registry"
+          ? ["dry-run"]
         : command === "candidate"
           ? ["delivery-v1"]
         : command === "core-successor" && action === "resume"
@@ -1651,19 +1678,50 @@ export async function runCli(argv = process.argv.slice(2), runtimeHooks = {}) {
       if (action === "register-root") {
         const registered = await registerFleetCoverageRoot({
           fleetRoot: requireOption(options, "fleet-root"),
+          fleetRegistryPath: options.registry,
         });
         return {
           ...registered,
           exitCode: 0,
         };
       }
+      if (action === "inspect-registry") {
+        return {
+          ...await inspectFleetRegistry({
+            fleetRegistryPath: options.registry,
+          }),
+          exitCode: 0,
+        };
+      }
+      if (action === "replace-registry") {
+        return {
+          ...await replaceFleetRegistry({
+            replacementRequestPath: requireOption(options, "request"),
+            receiptPath: options.receipt,
+            dryRun: options["dry-run"] === true,
+            fleetRegistryPath: options.registry,
+          }),
+          exitCode: 0,
+        };
+      }
+      if (action === "rollback-registry") {
+        return {
+          ...await rollbackFleetRegistry({
+            replacementReceiptPath: requireOption(options, "receipt"),
+            rollbackReceiptPath: requireOption(options, "rollback-receipt"),
+            fleetRegistryPath: options.registry,
+          }),
+          exitCode: 0,
+        };
+      }
       if (action !== "discover") {
-        throw new Error("Usage: owlrunkit fleet <register-root|discover> [--fleet-root <directory> | --fleet-manifest <file> | --workspace-root <directory>]");
+        throw new Error("Usage: owlrunkit fleet <register-root|inspect-registry|replace-registry|rollback-registry|discover>");
       }
       const discovered = await discoverFleet({
         fleetRoots: options["fleet-root"] ?? null,
         fleetManifestPath: options["fleet-manifest"] ?? null,
         workspaceRoots: options["workspace-root"] ?? null,
+        fleetRegistryPath: options.registry ?? null,
       });
       return {
         ...discovered,

package/scripts/runkit-contract/schemas/core-successor-plan-v1.schema.json

@@ -97,7 +97,7 @@
     "discovery": {
       "type": "object",
       "additionalProperties": false,
-      "required": ["schemaVersion", "source", "coverageRoots", "unreachableRoots", "workspaceRoots", "complete", "frozenManifestSha256", "authorizationGranted"],
+      "required": ["schemaVersion", "source", "coverageRoots", "unreachableRoots", "workspaceRoots", "classifications", "issues", "complete", "frozenManifestSha256", "authorizationGranted"],
       "properties": {
         "schemaVersion": { "const": "OwlCodaRunKitFleetDiscoveryV1" },
         "source": { "type": "string", "minLength": 1 },
@@ -105,6 +105,18 @@
         "coverageRoots": { "type": "array", "items": { "type": "string" } },
         "unreachableRoots": { "type": "array", "items": { "type": "string" } },
         "workspaceRoots": { "type": "array", "minItems": 1, "items": { "type": "string", "minLength": 1 } },
+        "classifications": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["active", "retired", "excluded", "invalid"],
+          "properties": {
+            "active": { "type": "array", "items": { "type": "string", "minLength": 1 } },
+            "retired": { "type": "array", "items": { "type": "string", "minLength": 1 } },
+            "excluded": { "type": "array", "items": { "type": "string", "minLength": 1 } },
+            "invalid": { "type": "array", "items": { "type": "string", "minLength": 1 } }
+          }
+        },
+        "issues": { "type": "array", "maxItems": 0 },
         "complete": { "const": true },
         "frozenManifestSha256": { "$ref": "#/$defs/hash" },
         "authorizationGranted": { "const": false }
@@ -146,7 +158,7 @@
       "materializationProof": { "candidateSha256": "sha256:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", "payloadSha256": "sha256:3333333333333333333333333333333333333333333333333333333333333333", "materializedCore": { "contractVersion": "0.2", "coreVersion": "0.16.0", "coreManifestSha256": "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "coreSourceRef": "artifact:sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" }, "matchesToCore": true }
     },
     "fleetDiscoveryRequest": { "fleetRoots": ["/fleet"] },
-    "fleetDiscovery": { "schemaVersion": "OwlCodaRunKitFleetDiscoveryV1", "source": "fleet_roots", "coverageRoots": ["/fleet"], "unreachableRoots": [], "workspaceRoots": ["/fleet/project"], "complete": true, "frozenManifestSha256": "sha256:eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", "authorizationGranted": false },
+    "fleetDiscovery": { "schemaVersion": "OwlCodaRunKitFleetDiscoveryV1", "source": "fleet_roots", "coverageRoots": ["/fleet"], "unreachableRoots": [], "workspaceRoots": ["/fleet/project"], "classifications": { "active": ["/fleet/project"], "retired": [], "excluded": [], "invalid": [] }, "issues": [], "complete": true, "frozenManifestSha256": "sha256:eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", "authorizationGranted": false },
     "migrationContract": { "completeFleetRequired": true, "globalPreflightBeforeWrites": true, "ownerMigrationAuthorityRequired": true, "migrationScope": "project_runkit_config_and_local_migration_receipt_only", "projectOrder": "canonical_workspace_root" },
     "repositoryActions": { "stage": false, "commit": false, "push": false, "publish": false, "deploy": false },
     "authorizationGranted": false,

package/scripts/runkit-contract/schemas/fleet-discovery-v1.schema.json

@@ -4,16 +4,40 @@
   "title": "OwlCoda RunKit Fleet Discovery V1",
   "type": "object",
   "additionalProperties": false,
-  "required": ["schemaVersion", "source", "coverageRoots", "unreachableRoots", "workspaceRoots", "complete", "frozenManifestSha256", "authorizationGranted"],
+  "required": ["schemaVersion", "source", "coverageRoots", "unreachableRoots", "workspaceRoots", "classifications", "issues", "complete", "frozenManifestSha256", "authorizationGranted"],
   "properties": {
     "schemaVersion": { "const": "OwlCodaRunKitFleetDiscoveryV1" },
-    "source": { "enum": ["fleet_registry", "fleet_roots", "fleet_manifest", "explicit_workspaces"] },
+    "source": { "enum": ["fleet_registry", "fleet_registry_membership", "fleet_roots", "fleet_manifest", "explicit_workspaces"] },
     "manifestPath": { "type": "string", "minLength": 1 },
     "registryPath": { "type": "string", "minLength": 1 },
     "registrySha256": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
     "coverageRoots": { "type": "array", "uniqueItems": true, "items": { "type": "string", "minLength": 1 } },
     "unreachableRoots": { "type": "array", "uniqueItems": true, "items": { "type": "string", "minLength": 1 } },
     "workspaceRoots": { "type": "array", "maxItems": 256, "uniqueItems": true, "items": { "type": "string", "minLength": 1 } },
+    "classifications": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["active", "retired", "excluded", "invalid"],
+      "properties": {
+        "active": { "type": "array", "maxItems": 256, "uniqueItems": true, "items": { "type": "string", "minLength": 1 } },
+        "retired": { "type": "array", "maxItems": 256, "uniqueItems": true, "items": { "type": "string", "minLength": 1 } },
+        "excluded": { "type": "array", "maxItems": 256, "uniqueItems": true, "items": { "type": "string", "minLength": 1 } },
+        "invalid": { "type": "array", "maxItems": 256, "uniqueItems": true, "items": { "type": "string", "minLength": 1 } }
+      }
+    },
+    "issues": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["code", "path", "coverageRoot"],
+        "properties": {
+          "code": { "type": "string", "minLength": 1 },
+          "path": { "type": "string", "minLength": 1 },
+          "coverageRoot": { "type": "string", "minLength": 1 }
+        }
+      }
+    },
     "complete": { "type": "boolean" },
     "frozenManifestSha256": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
     "authorizationGranted": { "const": false }
@@ -24,6 +48,13 @@
     "coverageRoots": ["/absolute/path/to/fleet"],
     "unreachableRoots": [],
     "workspaceRoots": ["/absolute/path/to/fleet/project"],
+    "classifications": {
+      "active": ["/absolute/path/to/fleet/project"],
+      "retired": [],
+      "excluded": [],
+      "invalid": []
+    },
+    "issues": [],
     "complete": true,
     "frozenManifestSha256": "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
     "authorizationGranted": false

package/scripts/runkit-contract/sync-core016-release-identity.mjs

@@ -19,8 +19,13 @@ const RELEASE_FILES = Object.freeze({
     "integrations/codex/skills/owlcoda-runkit/assets/templates/config.json",
 });
 
+const RELEASE_VERSION = "0.16.1";
 const ATTEST_RUNTIME_CORE016 =
-  /(coreVersion:\s*"0\.16\.0",\s*coreManifestSha256:\s*")sha256:[a-f0-9]{64}("\s*,?)/gu;
+  new RegExp(
+    `(coreVersion:\\s*"${RELEASE_VERSION.replaceAll(".", "\\.")}",`
+      + `\\s*coreManifestSha256:\\s*")sha256:[a-f0-9]{64}("\\s*,?)`,
+    "gu",
+  );
 
 function readJson(ref) {
   return JSON.parse(readFileSync(ref, "utf8"));
@@ -54,7 +59,7 @@ export function synchronizeCore016ReleaseIdentityV1({
   const root = path.resolve(repositoryRoot);
   if (
     core?.contractVersion !== "0.2"
-    || core?.coreVersion !== "0.16.0"
+    || core?.coreVersion !== RELEASE_VERSION
     || !/^sha256:[a-f0-9]{64}$/u.test(
       core?.coreManifestSha256 ?? "",
     )
@@ -66,12 +71,12 @@ export function synchronizeCore016ReleaseIdentityV1({
   const packageManifest = readJson(refs.packageManifest);
   if (
     packageManifest.name !== "owlrunkit"
-    || packageManifest.version !== "0.16.0"
+    || packageManifest.version !== RELEASE_VERSION
   ) throw new Error("core016_release_package_invalid");
   const attestManifest = readJson(refs.attestManifest);
   const candidateIndexes = attestManifest.supportedProducerCoreIdentities
     ?.map((identity, index) => ({ identity, index }))
-    .filter(({ identity }) => identity?.coreVersion === "0.16.0") ?? [];
+    .filter(({ identity }) => identity?.coreVersion === RELEASE_VERSION) ?? [];
   if (candidateIndexes.length !== 1) {
     throw new Error("core016_release_attest_candidate_ambiguous");
   }