owlrunkit 0.17.1 → 0.18.0

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

@@ -14,7 +14,7 @@ import { fileURLToPath } from "node:url";
 import { parseProjectControlState } from "./project-control-parser.mjs";
 
 export const CONTRACT_VERSION = "0.2";
-export const CORE_VERSION = "0.17.1";
+export const CORE_VERSION = "0.18.0";
 export const RUNTIME_ROOT = ".owlcoda/runkit";
 
 const CORE_FILES = [
@@ -66,6 +66,7 @@ const CORE_FILES = [
   "source-candidate.mjs",
   "source-fingerprint.mjs",
   "sync-release-identity.mjs",
+  "team-project-successor.mjs",
   "team-project.mjs",
   "verification-envelope.mjs",
   "verification-envelope-check.mjs",
@@ -122,6 +123,7 @@ const CORE_FILES = [
   "schemas/verification-context-v1.schema.json",
   "schemas/team-project-definition-v1.schema.json",
   "schemas/team-project-event-v1.schema.json",
+  "schemas/team-project-successor-receipt-v1.schema.json",
   "schemas/team-project-status-v1.schema.json",
   "schemas/verification-envelope-v1.schema.json",
   "schemas/verification-finalize-attempt-v1.schema.json",

package/scripts/runkit-contract/human-status.mjs

@@ -58,6 +58,20 @@ function sameStringSet(left, right) {
     && sortedLeft.every((value, index) => value === sortedRight[index]);
 }
 
+function decisionCounts(closed) {
+  const counts = { accepted: 0, blocked: 0, rejected: 0 };
+  for (const execution of closed) counts[closedDecision(execution)] += 1;
+  return counts;
+}
+
+function sameDecisionCounts(left, right) {
+  return isRecord(left)
+    && isRecord(right)
+    && ["accepted", "blocked", "rejected"].every(
+      (decision) => left[decision] === right[decision],
+    );
+}
+
 export function selectClosedHistoryFocusV1(inspected) {
   const closed = Array.isArray(inspected?.executions)
     ? inspected.executions.filter(execution => execution.lifecycle === "closed")
@@ -98,6 +112,22 @@ export function selectClosedHistoryFocusV1(inspected) {
       };
     }
   }
+  if (
+    historyBound
+    && history.status === "multiple_independent_closed_histories"
+    && history.lineageVerified === false
+    && history.headRunId === null
+    && history.blocking === false
+    && Array.isArray(history.issues)
+    && history.issues.length === 0
+    && sameDecisionCounts(history.decisionCounts, decisionCounts(closed))
+  ) {
+    return {
+      status: "multiple_independent_closed_histories",
+      selectedExecution: null,
+      decision: null,
+    };
+  }
 
   const decisions = new Set(closed.map(closedDecision));
   if (decisions.size === 1) {
@@ -436,6 +466,25 @@ export function deriveHumanStatusFromInspectV1(inspected) {
 
   if (inspected.recovery.state === "no_active_execution") {
     const history = selectClosedHistoryFocusV1(inspected);
+    if (history.status === "multiple_independent_closed_histories") {
+      return withMilestones({
+        schemaVersion: "OwlCodaRunKitHumanStatusV1",
+        status: "projected",
+        overall: "closed",
+        headline: "Multiple independent closed histories are trusted; no lineage head was selected.",
+        stage: "closeout",
+        currentExecutionId: null,
+        completedSteps: ["multiple_independent_closed_histories"],
+        remainingGates: [],
+        remainingGateCount: 0,
+        control: { status: "healthy", issueCodes: [] },
+        nextAllowedAction: inspected.recovery.nextAllowedAction,
+        authorizationGranted: false,
+        gitAuthorization: false,
+        releaseAuthorization: false,
+        deployAuthorization: false,
+      }, inspected);
+    }
     if (history.status === "ambiguous_history") {
       return withMilestones(blockedProjection({
         headline: "Closed execution history has conflicting outcomes without proven chronology.",

package/scripts/runkit-contract/inspect-presentation.mjs

@@ -27,10 +27,38 @@ function selectedFocus(inspected) {
     : null;
 }
 
-export function buildInspectSummary(inspected) {
+function closeoutDecisionCounts(inspected) {
+  const counts = { accepted: 0, blocked: 0, rejected: 0 };
+  for (const execution of inspected.executions) {
+    if (execution.lifecycle !== "closed") continue;
+    if (Object.hasOwn(counts, execution.closeout?.decision)) {
+      counts[execution.closeout.decision] += 1;
+    }
+  }
+  return counts;
+}
+
+export function buildInspectSummary(
+  inspected,
+  { maintenanceNextAction = null } = {},
+) {
   const humanStatus = deriveHumanStatusFromInspectV1(inspected);
   const focus = selectedFocus(inspected);
   const latestClosed = chronologySelectedCloseout(inspected);
+  const controlHistory = inspected.controlState?.closedHistory ?? null;
+  const closedRunCount = inspected.executions.filter(
+    (execution) => execution.lifecycle === "closed",
+  ).length;
+  const independentHistory = controlHistory?.status
+    === "multiple_independent_closed_histories"
+    && controlHistory?.blocking === false;
+  const selectedHeadCloseout = latestClosed
+    ? {
+        runId: latestClosed.runId,
+        decision: latestClosed.closeout?.decision ?? "invalid",
+        trustLevel: latestClosed.recovery?.evidenceTrustLevel ?? "invalid",
+      }
+    : null;
   const holders = inspected.executions
     .flatMap(execution => (execution.recovery?.lease?.activeWorkItemIds ?? []).map(workItemId => ({
       runId: execution.runId,
@@ -60,13 +88,21 @@ export function buildInspectSummary(inspected) {
       activeRunIds: [...inspected.recovery.activeRunIds],
       openCount: inspected.recovery.activeRunIds.length,
     },
-    latestIndexedCloseout: latestClosed
-      ? {
-          runId: latestClosed.runId,
-          decision: latestClosed.closeout?.decision ?? "invalid",
-          trustLevel: latestClosed.recovery?.evidenceTrustLevel ?? "invalid",
-        }
-      : null,
+    latestIndexedCloseout: selectedHeadCloseout,
+    selectedHeadCloseout,
+    closedHistory: {
+      status: controlHistory?.status ?? "unavailable",
+      runCount: closedRunCount,
+      blocking: controlHistory?.blocking === true
+        || controlHistory?.status === "ambiguous_history",
+      selectedHeadRunId: selectedHeadCloseout?.runId ?? null,
+      selectionReason: selectedHeadCloseout
+        ? "verified_lineage_head"
+        : closedRunCount === 0
+          ? "no_closed_history"
+          : "no_unique_lineage_head",
+      decisionCounts: controlHistory?.decisionCounts ?? closeoutDecisionCounts(inspected),
+    },
     source: {
       status: delivery?.status ?? "none",
       sourceFingerprint: delivery?.sourceFingerprint ?? verification?.sourceFingerprint ?? null,
@@ -106,6 +142,9 @@ export function buildInspectSummary(inspected) {
       code: humanStatus.nextAllowedAction,
       reasons: [...reasons],
     },
+    lifecycleNextAction: inspected.recovery.nextAllowedAction,
+    maintenanceNextAction,
+    optionalReviewAction: independentHistory ? "inspect_closed_history" : null,
     nextAllowedAction: humanStatus.nextAllowedAction,
     authorizationGranted: false,
     gitAuthorization: false,
@@ -119,9 +158,9 @@ function value(value) {
 }
 
 function summaryLines(summary, humanStatus) {
-  const latest = summary.latestIndexedCloseout
-    ? `${summary.latestIndexedCloseout.runId} ${summary.latestIndexedCloseout.decision}`
-    : "none";
+  const selectedHead = summary.selectedHeadCloseout
+    ? `${summary.selectedHeadCloseout.runId} ${summary.selectedHeadCloseout.decision}`
+    : `none (${summary.closedHistory.selectionReason})`;
   const visibleHolders = summary.leases.holders.slice(0, 5)
     .map(holder => `${holder.runId}/${holder.workItemId}`);
   const holders = visibleHolders.length === 0
@@ -133,7 +172,8 @@ function summaryLines(summary, humanStatus) {
     `Status: ${humanStatus.overall}`,
     `Summary: ${humanStatus.headline}`,
     `Current execution: ${value(summary.currentExecution.selectedRunId)}`,
-    `Latest indexed closeout: ${latest}`,
+    `Closed history: ${summary.closedHistory.status} (${summary.closedHistory.runCount} runs, ${summary.closedHistory.blocking ? "blocking" : "non-blocking"})`,
+    `Selected lineage head: ${selectedHead}`,
     `Source status: ${summary.source.status}`,
     `Source/data readiness: ${humanStatus.milestones.sourceData.status}`,
     `Release package: ${humanStatus.milestones.releasePackage.status}`,
@@ -154,6 +194,12 @@ function summaryLines(summary, humanStatus) {
     `Receipt reuse: ${summary.resourcePreflight.receiptReuse.appliedCount}/${summary.resourcePreflight.receiptReuse.reusableCount}`,
     `Dominant gap: ${summary.dominantGap.code}`,
     `Next allowed action: ${summary.nextAllowedAction}`,
+    ...(summary.maintenanceNextAction
+      ? [`Maintenance: ${summary.maintenanceNextAction}`]
+      : []),
+    ...(summary.optionalReviewAction
+      ? [`Optional review: ${summary.optionalReviewAction}`]
+      : []),
     `Release authorization: ${summary.releaseAuthorization}`,
   ].map(escapeHumanControls);
 }

package/scripts/runkit-contract/onboarding-doctor.mjs

@@ -550,6 +550,7 @@ function profilesCheck(root) {
       return { status: "invalid" };
     }
     const launcherWarnings = [];
+    const launcherIssues = [];
     for (const profile of profiles.profiles) {
       for (const command of profile?.commands ?? []) {
         const identity = `${profile?.id ?? "unknown"}:${command?.id ?? "unknown"}`;
@@ -560,19 +561,22 @@ function profilesCheck(root) {
         try {
           const stat = lstatSync(command.executable);
           if (stat.isSymbolicLink()) {
-            launcherWarnings.push(`profile_launcher_symlink_rejected:${identity}`);
+            launcherIssues.push(`profile_launcher_symlink_rejected:${identity}`);
           } else if (!stat.isFile() || realpathSync(command.executable) !== path.resolve(command.executable)) {
-            launcherWarnings.push(`profile_launcher_not_regular_file:${identity}`);
+            launcherIssues.push(`profile_launcher_not_regular_file:${identity}`);
           }
         } catch {
-          launcherWarnings.push(`profile_launcher_unavailable:${identity}`);
+          launcherIssues.push(`profile_launcher_unavailable:${identity}`);
         }
       }
     }
+    const uniqueLauncherIssues = [...new Set(launcherIssues)].sort();
     return {
-      status: "ok",
+      status: uniqueLauncherIssues.length === 0 ? "ok" : "invalid",
       count: profiles.profiles.length,
       launcherWarnings: [...new Set(launcherWarnings)].sort(),
+      launcherIssues: uniqueLauncherIssues,
+      ...(uniqueLauncherIssues.length > 0 ? { issues: uniqueLauncherIssues } : {}),
     };
   } catch {
     return { status: "invalid" };
@@ -585,6 +589,7 @@ export function readProfileLauncherReadiness({ workspaceRoot } = {}) {
   return {
     status: profiles.status,
     launcherWarnings,
+    launcherIssues: profiles.launcherIssues ?? [],
     ready: profiles.status === "ok" && launcherWarnings.length === 0,
   };
 }
@@ -703,16 +708,19 @@ export async function runDoctor({
     issueCodes.push("registry_install_binding_mismatch");
   }
   const uniqueIssues = [...new Set(issueCodes)].sort();
+  const profileLauncherWarningCount = (profiles.launcherWarnings ?? []).length;
   const warningCodes = [
     ...runtimeIsolation.affectedScripts
       .map(({ script, tool }) => `runkit_runtime_collection_risk:${tool}:${script}`),
-    ...(profiles.launcherWarnings ?? []),
+    ...(profileLauncherWarningCount > 0 ? ["profile_launcher_warnings"] : []),
   ].sort();
+  const lifecycleNextAction = lifecycle.recovery.nextAllowedAction;
+  const maintenanceNextAction = profileLauncherWarningCount > 0
+    ? "review_profile_launchers"
+    : null;
   const nextAllowedAction = uniqueIssues.length === 0
-    ? lifecycle.recovery.nextAllowedAction !== "plan_new_execution"
-      ? lifecycle.recovery.nextAllowedAction
-      : (profiles.launcherWarnings ?? []).length > 0
-      ? "review_profile_launchers"
+    ? lifecycleNextAction !== "plan_new_execution"
+      ? lifecycleNextAction
       : adoption.status === "ok"
         ? "plan_new_execution"
         : "adopt_current_release"
@@ -733,12 +741,22 @@ export async function runDoctor({
     checks,
     issueCodes: uniqueIssues,
     warningCodes,
+    profileLauncherWarnings: {
+      count: profileLauncherWarningCount,
+      blocking: false,
+      recommendedAction: maintenanceNextAction,
+    },
+    lifecycleNextAction,
+    maintenanceNextAction,
     nextAllowedAction,
     authorizationGranted: false,
   };
 }
 
 export function formatDoctorHuman(report) {
+  const otherWarnings = report.warningCodes.filter(
+    (code) => code !== "profile_launcher_warnings",
+  );
   return [
     `Doctor: ${report.status}`,
     `Node: ${report.checks.node.status} (${report.checks.node.version})`,
@@ -749,10 +767,16 @@ export function formatDoctorHuman(report) {
     `Adoption: ${report.checks.adoption.status}`,
     `Lifecycle: ${report.checks.lifecycle.status}`,
     ...(report.issueCodes.length > 0 ? [`Issues: ${report.issueCodes.join(", ")}`] : []),
-    ...(report.warningCodes.length > 0 ? [`Warnings: ${report.warningCodes.join(", ")}`] : []),
+    ...(report.profileLauncherWarnings.count > 0
+      ? [`Profile launcher warnings: ${report.profileLauncherWarnings.count} (non-blocking)`]
+      : []),
+    ...(otherWarnings.length > 0 ? [`Warnings: ${otherWarnings.join(", ")}`] : []),
     `Next: ${report.nextAllowedAction === "adopt_current_release"
       ? `owlrunkit adopt --workspace . --exact ${PACKAGE_NAME}@${EXPECTED_VERSION}`
       : report.nextAllowedAction}`,
+    ...(report.maintenanceNextAction
+      ? [`Maintenance: ${report.maintenanceNextAction}`]
+      : []),
     "",
   ].join("\n");
 }

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

@@ -18,6 +18,12 @@ 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.17.2", new Set([
+    "sha256:67b883b8a763253b873fb6047c7e7e01c81123aa5250a0db5feaabd13cc4d860",
+  ])],
+  ["0.17.1", new Set([
+    "sha256:5376f3736dd17c07598df8b655a6bbceb3b64b44f3e6630e69f966e420d82e26",
+  ])],
   ["0.17.0", new Set([
     "sha256:0c0c52e7f6299bdd3d3ea49005c8ceef0b28831d60af25d77da65a4e4de714c9",
   ])],

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

@@ -600,6 +600,10 @@ function closedHistoryProjection(executions, continuationEdges, issues) {
     }
   }
 
+  const decisionCounts = { accepted: 0, blocked: 0, rejected: 0 };
+  for (const execution of closed) {
+    decisionCounts[execution.closeout.decision] += 1;
+  }
   const decisions = new Set(closed.map(execution => execution.closeout.decision));
   if (decisions.size === 1) {
     return {
@@ -611,12 +615,25 @@ function closedHistoryProjection(executions, continuationEdges, issues) {
       issues: [...issues],
     };
   }
+  if (issues.length === 0) {
+    return {
+      status: "multiple_independent_closed_histories",
+      runIds,
+      headRunId: null,
+      decision: null,
+      decisionCounts,
+      lineageVerified: false,
+      blocking: false,
+      issues: [],
+    };
+  }
   return {
     status: "ambiguous_history",
     runIds,
     headRunId: null,
     decision: null,
     lineageVerified: false,
+    blocking: true,
     issues: [...issues],
   };
 }