pumuki 6.3.113 → 6.3.115

package/integrations/lifecycle/doctor.ts

@@ -1,40 +1,21 @@
 import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { readEvidenceResult } from '../evidence/readEvidence';
+import { appendTrackingActionableContext } from '../git/aiGateRepoPolicyFindings';
 import { resolvePolicyForStage } from '../gate/stagePolicies';
 import { getPumukiHooksStatus, resolvePumukiHooksDirectory } from './hookManager';
 import { LifecycleGitService, type ILifecycleGitService } from './gitService';
 import { buildLifecycleVersionReport, getCurrentPumukiVersion } from './packageInfo';
-import {
-  readLifecycleExperimentalFeaturesSnapshot,
-  type LifecycleExperimentalFeaturesSnapshot,
-} from './experimentalFeaturesSnapshot';
 import {
   readLifecyclePolicyValidationSnapshot,
   type LifecyclePolicyValidationSnapshot,
 } from './policyValidationSnapshot';
-import {
-  doctorGovernanceIsBlocking,
-  doctorGovernanceNeedsAttention,
-  readGovernanceObservationSnapshot,
-  type GovernanceObservationSnapshot,
-} from './governanceObservationSnapshot';
-import {
-  readGovernanceNextAction,
-  type GovernanceNextActionReader,
-  type GovernanceNextActionSummary,
-} from './governanceNextAction';
 import { readLifecycleState, type LifecycleState } from './state';
 import {
   detectOpenSpecInstallation,
   evaluateOpenSpecCompatibility,
   isOpenSpecProjectInitialized,
 } from '../sdd/openSpecCli';
-import {
-  formatTrackingActionableContext,
-  resolveRepoTrackingState,
-  type RepoTrackingState,
-} from './trackingState';
 
 export type DoctorIssueSeverity = 'warning' | 'error';
 
@@ -115,10 +96,7 @@ export type LifecycleDoctorReport = {
   hooksDirectory: string;
   hooksDirectoryResolution: 'git-rev-parse' | 'git-config' | 'default';
   policyValidation: LifecyclePolicyValidationSnapshot;
-  experimentalFeatures: LifecycleExperimentalFeaturesSnapshot;
-  governanceObservation: GovernanceObservationSnapshot;
-  governanceNextAction: GovernanceNextActionSummary;
-  tracking: RepoTrackingState;
+  policy_signature_remediation?: string;
   issues: ReadonlyArray<DoctorIssue>;
   deep?: DoctorDeepReport;
   parity_profile?: DoctorParityProfile;
@@ -126,13 +104,14 @@ export type LifecycleDoctorReport = {
 };
 
 const buildDoctorIssues = (params: {
+  repoRoot: string;
   trackedNodeModulesPaths: ReadonlyArray<string>;
   hookStatus: ReturnType<typeof getPumukiHooksStatus>;
   hooksDirectory: string;
   lifecycleState: LifecycleState;
-  tracking: RepoTrackingState;
 }): ReadonlyArray<DoctorIssue> => {
   const issues: DoctorIssue[] = [];
+  const evidenceResult = readEvidenceResult(params.repoRoot);
 
   if (params.trackedNodeModulesPaths.length > 0) {
     issues.push({
@@ -170,25 +149,29 @@ const buildDoctorIssues = (params: {
     });
   }
 
-  if (params.tracking.enforced) {
-    if (!params.tracking.canonical_path || !params.tracking.canonical_present) {
+  if (evidenceResult.kind === 'valid') {
+    const evidence = evidenceResult.evidence;
+    const blocked =
+      evidence.snapshot.outcome === 'BLOCK' ||
+      evidence.ai_gate.status === 'BLOCKED' ||
+      evidence.severity_metrics.gate_status === 'BLOCKED';
+    if (blocked) {
+      const blockedStage = evidence?.snapshot?.stage ?? 'PRE_WRITE';
       issues.push({
-        severity: 'warning',
-        message:
-          'Tracking contract is declared but the canonical tracking file is missing or unresolved.',
-      });
-    } else if (params.tracking.conflict) {
-      issues.push({
-        severity: 'warning',
-        message:
-          `Tracking contract has conflicting canonical declarations (${params.tracking.declarations.map((declaration) => declaration.resolved_path).join(', ')}).`,
+        severity: 'error',
+        message: appendTrackingActionableContext({
+          repoRoot: params.repoRoot,
+          message: `Governance is blocked (${blockedStage}).`,
+        }),
       });
-    } else if (!params.tracking.single_in_progress_valid) {
-      const actionableContext = formatTrackingActionableContext(params.tracking);
+    } else if (evidence.snapshot.outcome === 'WARN') {
+      const warnStage = evidence?.snapshot?.stage ?? 'PRE_WRITE';
       issues.push({
         severity: 'warning',
-        message:
-          `Canonical tracking is inconsistent for ${params.tracking.canonical_path} (in_progress_count=${params.tracking.in_progress_count}, active_task=${params.tracking.active_task_id ?? 'unknown'}, last_run_status=${params.tracking.last_run_status ?? 'absent'}).${actionableContext ? ` ${actionableContext}` : ''}`,
+        message: appendTrackingActionableContext({
+          repoRoot: params.repoRoot,
+          message: `Governance requires attention (${warnStage}).`,
+        }),
       });
     }
   }
@@ -196,28 +179,6 @@ const buildDoctorIssues = (params: {
   return issues;
 };
 
-const appendGovernanceBlockingIssue = (params: {
-  issues: ReadonlyArray<DoctorIssue>;
-  governanceObservation: GovernanceObservationSnapshot;
-  governanceNextAction: GovernanceNextActionSummary;
-}): ReadonlyArray<DoctorIssue> => {
-  if (!doctorGovernanceIsBlocking(params.governanceObservation)) {
-    return params.issues;
-  }
-  if (params.issues.some((issue) => issue.severity === 'error')) {
-    return params.issues;
-  }
-  return [
-    ...params.issues,
-    {
-      severity: 'error',
-      message:
-        `Governance is blocked (${params.governanceNextAction.reason_code}). ` +
-        params.governanceNextAction.instruction,
-    },
-  ];
-};
-
 const DEEP_EVIDENCE_MAX_AGE_SECONDS = 1800;
 
 const toCanonicalPath = (value: string): string => {
@@ -862,12 +823,20 @@ const compareDoctorParityProfile = (params: {
   };
 };
 
+const buildPolicySignatureRemediation = (
+  policyValidation: LifecyclePolicyValidationSnapshot
+): string | undefined => {
+  const mismatch = Object.values(policyValidation.stages).some(
+    (stage) => stage.validationCode === 'POLICY_AS_CODE_SIGNATURE_MISMATCH'
+  );
+  return mismatch ? 'pumuki policy reconcile --apply' : undefined;
+};
+
 export const runLifecycleDoctor = (params?: {
   cwd?: string;
   git?: ILifecycleGitService;
   deep?: boolean;
   parity?: boolean;
-  governanceNextActionReader?: GovernanceNextActionReader;
 }): LifecycleDoctorReport => {
   const git = params?.git ?? new LifecycleGitService();
   const cwd = params?.cwd ?? process.cwd();
@@ -876,14 +845,13 @@ export const runLifecycleDoctor = (params?: {
   const hooksDirectory = resolvePumukiHooksDirectory(repoRoot);
   const hookStatus = getPumukiHooksStatus(repoRoot);
   const lifecycleState = readLifecycleState(git, repoRoot);
-  const tracking = resolveRepoTrackingState(repoRoot);
 
   const issues = buildDoctorIssues({
+    repoRoot,
     trackedNodeModulesPaths,
     hookStatus,
     hooksDirectory: hooksDirectory.path,
     lifecycleState,
-    tracking,
   });
   const deep = params?.deep
     ? buildDoctorDeepReport({
@@ -897,25 +865,6 @@ export const runLifecycleDoctor = (params?: {
     repoRoot,
     lifecycleVersion: lifecycleState.version,
   });
-  const policyValidation = readLifecyclePolicyValidationSnapshot(repoRoot);
-  const experimentalFeatures = readLifecycleExperimentalFeaturesSnapshot();
-  const governanceObservation = readGovernanceObservationSnapshot({
-    repoRoot,
-    experimentalFeatures,
-    policyValidation,
-    git,
-  });
-  const governanceStage = governanceObservation.evidence.snapshot_stage ?? 'PRE_WRITE';
-  const governanceNextAction = (params?.governanceNextActionReader ?? readGovernanceNextAction)({
-    repoRoot,
-    stage: governanceStage,
-    governanceObservation,
-  });
-  const canonicalIssues = appendGovernanceBlockingIssue({
-    issues,
-    governanceObservation,
-    governanceNextAction,
-  });
 
   const parity_profile =
     params?.parity === true
@@ -929,6 +878,9 @@ export const runLifecycleDoctor = (params?: {
       ? compareDoctorParityProfile({ repoRoot, actual: parity_profile })
       : undefined;
 
+  const policyValidation = readLifecyclePolicyValidationSnapshot(repoRoot);
+  const policySignatureRemediation = buildPolicySignatureRemediation(policyValidation);
+
   return {
     repoRoot,
     packageVersion: version.effective,
@@ -939,11 +891,10 @@ export const runLifecycleDoctor = (params?: {
     hooksDirectory: hooksDirectory.path,
     hooksDirectoryResolution: hooksDirectory.source,
     policyValidation,
-    experimentalFeatures,
-    governanceNextAction,
-    governanceObservation,
-    tracking,
-    issues: canonicalIssues,
+    ...(policySignatureRemediation
+      ? { policy_signature_remediation: policySignatureRemediation }
+      : {}),
+    issues,
     deep,
     parity_profile,
     parity_comparison,
@@ -955,16 +906,3 @@ export const doctorHasBlockingIssues = (report: LifecycleDoctorReport): boolean
 
 export const doctorHasParityMismatch = (report: LifecycleDoctorReport): boolean =>
   typeof report.parity_comparison !== 'undefined' && report.parity_comparison.matches === false;
-
-export const doctorHasGovernanceAttention = (report: LifecycleDoctorReport): boolean =>
-  doctorGovernanceNeedsAttention(report.governanceObservation);
-
-export const doctorCommandShouldWarnHuman = (report: LifecycleDoctorReport): boolean =>
-  report.issues.length > 0
-  || report.deep?.checks.some((check) => check.status !== 'pass') === true
-  || doctorHasGovernanceAttention(report);
-
-export const doctorCommandShouldFailExit = (report: LifecycleDoctorReport): boolean =>
-  doctorHasBlockingIssues(report)
-  || doctorHasParityMismatch(report)
-  || doctorGovernanceIsBlocking(report.governanceObservation);

package/integrations/lifecycle/index.ts

@@ -1,4 +1,6 @@
 export { runLifecycleDoctor, doctorHasBlockingIssues } from './doctor';
+export { runLifecycleAudit } from './audit';
+export type { LifecycleAuditResult, LifecycleAuditStage } from './audit';
 export { runLifecycleInstall } from './install';
 export { runLifecycleUninstall } from './uninstall';
 export { runLifecycleRemove } from './remove';

package/integrations/lifecycle/install.ts

@@ -13,7 +13,6 @@ import { createEmptyEvaluationMetrics } from '../evidence/evaluationMetrics';
 import { readOpenSpecManagedArtifacts, writeLifecycleState } from './state';
 import { ensureRuntimeArtifactsIgnored } from './artifacts';
 import { runLifecycleAdapterInstall } from './adapter';
-import { writeLifecycleBootstrapManifest } from './bootstrapManifest';
 import { runPolicyReconcile } from './policyReconcile';
 
 export type LifecycleInstallResult = {
@@ -22,10 +21,6 @@ export type LifecycleInstallResult = {
   changedHooks: ReadonlyArray<string>;
   openSpecBootstrap?: OpenSpecBootstrapResult;
   degradedDoctorBypass?: boolean;
-  bootstrapManifest: {
-    path: string;
-    changed: boolean;
-  };
 };
 
 const shouldBootstrapEvidence = (repoRoot: string): boolean =>
@@ -130,20 +125,12 @@ export const runLifecycleInstall = (params?: {
       });
       ensureRepoBaselineAdapter(report.repoRoot);
       materializeStrictPolicyAsCode(report.repoRoot);
-      const bootstrapManifest = writeLifecycleBootstrapManifest({
-        git,
-        repoRoot: report.repoRoot,
-      });
       return {
         repoRoot: report.repoRoot,
         version,
         changedHooks,
         openSpecBootstrap: undefined,
         degradedDoctorBypass: true,
-        bootstrapManifest: {
-          path: bootstrapManifest.path,
-          changed: bootstrapManifest.changed,
-        },
       };
     }
     const renderedIssues = report.issues.map((issue) => `- [${issue.severity}] ${issue.message}`).join('\n');
@@ -178,19 +165,11 @@ export const runLifecycleInstall = (params?: {
   });
   ensureRepoBaselineAdapter(report.repoRoot);
   materializeStrictPolicyAsCode(report.repoRoot);
-  const bootstrapManifest = writeLifecycleBootstrapManifest({
-    git,
-    repoRoot: report.repoRoot,
-  });
 
   return {
     repoRoot: report.repoRoot,
     version,
     changedHooks,
     openSpecBootstrap,
-    bootstrapManifest: {
-      path: bootstrapManifest.path,
-      changed: bootstrapManifest.changed,
-    },
   };
 };

package/integrations/lifecycle/packageInfo.ts

@@ -49,126 +49,15 @@ const hasPathExecutionHazard = (repoRoot?: string): boolean =>
   repoRoot.trim().length > 0 &&
   repoRoot.includes(delimiter);
 
-type ConsumerNodeRuntimeSpec = {
-  version: string;
-  source: 'volta' | '.nvmrc' | 'package.engines';
-  commandPrefix: 'volta' | 'nvm';
-};
-
-const normalizeNodeVersionToken = (value: string): string =>
-  value.trim().replace(/^node@/i, '').replace(/^v/i, '');
-
-const extractNodeVersionToken = (value: string): string | null => {
-  const normalized = normalizeNodeVersionToken(value);
-  const exactVersion = normalized.match(/\d+\.\d+\.\d+/)?.[0];
-  if (exactVersion) {
-    return exactVersion;
-  }
-  const majorOnly = normalized.match(/^\d+$/)?.[0];
-  return majorOnly ?? null;
-};
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === 'object' && value !== null && !Array.isArray(value);
-
-const readNestedString = (
-  source: Record<string, unknown>,
-  path: ReadonlyArray<string>
-): string | undefined => {
-  let cursor: unknown = source;
-  for (const segment of path) {
-    if (!isRecord(cursor)) {
-      return undefined;
-    }
-    cursor = cursor[segment];
-  }
-  return typeof cursor === 'string' && cursor.trim().length > 0 ? cursor.trim() : undefined;
-};
-
-const readConsumerNodeRuntimeSpec = (repoRoot?: string): ConsumerNodeRuntimeSpec | null => {
-  if (typeof repoRoot !== 'string' || repoRoot.trim().length === 0) {
-    return null;
-  }
-
-  const packageJsonPath = join(repoRoot, 'package.json');
-  if (existsSync(packageJsonPath)) {
-    try {
-      const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8')) as unknown;
-      if (isRecord(parsed)) {
-        const voltaNode = readNestedString(parsed, ['volta', 'node']);
-        const voltaVersion = voltaNode ? extractNodeVersionToken(voltaNode) : null;
-        if (voltaVersion) {
-          return {
-            version: voltaVersion,
-            source: 'volta',
-            commandPrefix: 'volta',
-          };
-        }
-
-        const enginesNode = readNestedString(parsed, ['engines', 'node']);
-        const enginesVersion = enginesNode ? extractNodeVersionToken(enginesNode) : null;
-        if (enginesVersion) {
-          return {
-            version: enginesVersion,
-            source: 'package.engines',
-            commandPrefix: 'nvm',
-          };
-        }
-      }
-    } catch {
-      return null;
-    }
-  }
-
-  const nvmrcPath = join(repoRoot, '.nvmrc');
-  if (existsSync(nvmrcPath)) {
-    try {
-      const nvmrcVersion = extractNodeVersionToken(readFileSync(nvmrcPath, 'utf8'));
-      if (nvmrcVersion) {
-        return {
-          version: nvmrcVersion,
-          source: '.nvmrc',
-          commandPrefix: 'nvm',
-        };
-      }
-    } catch {
-      return null;
-    }
-  }
-
-  return null;
-};
-
-const buildConsumerNodeAlignmentCommand = (repoRoot?: string): string | null => {
-  const runtimeSpec = readConsumerNodeRuntimeSpec(repoRoot);
-  if (!runtimeSpec) {
-    return null;
-  }
-
-  const currentNodeVersion = normalizeNodeVersionToken(process.version);
-  if (currentNodeVersion === runtimeSpec.version) {
-    return null;
-  }
-
-  if (runtimeSpec.commandPrefix === 'volta') {
-    return `volta install node@${runtimeSpec.version} && volta pin node@${runtimeSpec.version}`;
-  }
-
-  return `nvm install ${runtimeSpec.version} && nvm use ${runtimeSpec.version}`;
-};
-
 export const buildLifecycleAlignmentCommand = (
   runtimeVersion: string,
   repoRoot?: string
 ): string => {
-  const consumerNodeAlignmentCommand = buildConsumerNodeAlignmentCommand(repoRoot);
   const installStep = `npm install --save-exact pumuki@${runtimeVersion}`;
   const runStep = hasPathExecutionHazard(repoRoot)
     ? `${buildLocalPumukiCommand()} install`
     : `npx --yes --package pumuki@${runtimeVersion} pumuki install`;
-  return [consumerNodeAlignmentCommand, installStep, runStep]
-    .filter((value): value is string => typeof value === 'string' && value.length > 0)
-    .join(' && ');
+  return `${installStep} && ${runStep}`;
 };
 
 export const resolvePumukiVersionMetadata = (params?: { repoRoot?: string }): PumukiVersionMetadata => {
@@ -225,17 +114,11 @@ export const buildLifecycleVersionReport = (params?: {
   const driftFromConsumerInstalled =
     metadata.consumerInstalledVersion !== null &&
     metadata.consumerInstalledVersion !== metadata.runtimeVersion;
-  const consumerNodeSpec = readConsumerNodeRuntimeSpec(params?.repoRoot);
-  const consumerNodeVersion = consumerNodeSpec?.version ?? null;
-  const currentNodeVersion = normalizeNodeVersionToken(process.version);
-  const driftFromConsumerNode =
-    consumerNodeVersion !== null && currentNodeVersion !== consumerNodeVersion;
   const driftFromLifecycleInstalled =
     lifecycleInstalled !== null && metadata.resolvedVersion !== lifecycleInstalled;
   const driftTargets = [
     driftFromRuntime ? `runtime=${metadata.runtimeVersion}` : null,
     driftFromConsumerInstalled ? `consumer=${metadata.consumerInstalledVersion}` : null,
-    driftFromConsumerNode ? `node=${consumerNodeVersion}` : null,
     driftFromLifecycleInstalled ? `lifecycle=${lifecycleInstalled}` : null,
   ].filter((value): value is string => value !== null);
   const pathExecutionHazard = hasPathExecutionHazard(params?.repoRoot);

package/integrations/lifecycle/state.ts

@@ -49,17 +49,10 @@ export const writeLifecycleState = (params: {
   openSpecManagedArtifacts?: ReadonlyArray<string>;
 }): void => {
   const { git, repoRoot, version } = params;
-  const existingInstalledAt = git.localConfig(repoRoot, PUMUKI_CONFIG_KEYS.installedAt);
   git.applyLocalConfig(repoRoot, PUMUKI_CONFIG_KEYS.installed, 'true');
   git.applyLocalConfig(repoRoot, PUMUKI_CONFIG_KEYS.version, version);
   git.applyLocalConfig(repoRoot, PUMUKI_CONFIG_KEYS.hooks, PUMUKI_MANAGED_HOOKS.join(','));
-  git.applyLocalConfig(
-    repoRoot,
-    PUMUKI_CONFIG_KEYS.installedAt,
-    typeof existingInstalledAt === 'string' && existingInstalledAt.trim().length > 0
-      ? existingInstalledAt
-      : new Date().toISOString()
-  );
+  git.applyLocalConfig(repoRoot, PUMUKI_CONFIG_KEYS.installedAt, new Date().toISOString());
   if (params.openSpecManagedArtifacts) {
     const serialized = serializeManagedArtifacts(params.openSpecManagedArtifacts);
     if (serialized) {

package/integrations/lifecycle/status.ts

@@ -1,6 +1,8 @@
 import { getPumukiHooksStatus, resolvePumukiHooksDirectory } from './hookManager';
 import { LifecycleGitService, type ILifecycleGitService } from './gitService';
 import { buildLifecycleVersionReport } from './packageInfo';
+import { readEvidenceResult } from '../evidence/readEvidence';
+import { appendTrackingActionableContext } from '../git/aiGateRepoPolicyFindings';
 import {
   readLifecycleExperimentalFeaturesSnapshot,
   type LifecycleExperimentalFeaturesSnapshot,
@@ -9,23 +11,8 @@ import {
   readLifecyclePolicyValidationSnapshot,
   type LifecyclePolicyValidationSnapshot,
 } from './policyValidationSnapshot';
-import {
-  readGovernanceObservationSnapshot,
-  doctorGovernanceIsBlocking,
-  type GovernanceObservationSnapshot,
-} from './governanceObservationSnapshot';
-import {
-  readGovernanceNextAction,
-  type GovernanceNextActionReader,
-  type GovernanceNextActionSummary,
-} from './governanceNextAction';
-import type { DoctorIssue } from './doctor';
 import { readLifecycleState, type LifecycleState } from './state';
-import {
-  formatTrackingActionableContext,
-  resolveRepoTrackingState,
-  type RepoTrackingState,
-} from './trackingState';
+import type { DoctorIssue } from './doctor';
 
 export type LifecycleStatus = {
   repoRoot: string;
@@ -38,44 +25,54 @@ export type LifecycleStatus = {
   trackedNodeModulesCount: number;
   policyValidation: LifecyclePolicyValidationSnapshot;
   experimentalFeatures: LifecycleExperimentalFeaturesSnapshot;
-  governanceObservation: GovernanceObservationSnapshot;
-  governanceNextAction: GovernanceNextActionSummary;
-  tracking: RepoTrackingState;
   issues: ReadonlyArray<DoctorIssue>;
 };
 
-const buildLifecycleIssues = (params: {
-  governanceObservation: GovernanceObservationSnapshot;
-  governanceNextAction: GovernanceNextActionSummary;
-  tracking: RepoTrackingState;
-}): ReadonlyArray<DoctorIssue> => {
-  const issues: DoctorIssue[] = [];
-
-  if (doctorGovernanceIsBlocking(params.governanceObservation)) {
-    issues.push({
-      severity: 'error',
-      message:
-        `Governance is blocked (${params.governanceNextAction.reason_code}). ` +
-        params.governanceNextAction.instruction,
-    });
+const buildLifecycleIssues = (repoRoot: string): ReadonlyArray<DoctorIssue> => {
+  const evidenceResult = readEvidenceResult(repoRoot);
+  if (evidenceResult.kind !== 'valid') {
+    return [];
   }
 
-  if (params.tracking.enforced && params.tracking.single_in_progress_valid === false) {
-    const actionableContext = formatTrackingActionableContext(params.tracking);
-    issues.push({
-      severity: 'warning',
-      message:
-        `Canonical tracking is inconsistent for ${params.tracking.canonical_path ?? 'unknown'} (in_progress_count=${params.tracking.in_progress_count}, active_task=${params.tracking.active_task_id ?? 'unknown'}, last_run_status=${params.tracking.last_run_status ?? 'absent'}).${actionableContext ? ` ${actionableContext}` : ''}`,
-    });
+  const evidence = evidenceResult.evidence;
+  const blocked =
+    evidence.snapshot.outcome === 'BLOCK' ||
+    evidence.ai_gate.status === 'BLOCKED' ||
+    evidence.severity_metrics.gate_status === 'BLOCKED';
+
+  if (!blocked) {
+    if (evidence.snapshot.outcome !== 'WARN') {
+      return [];
+    }
+
+    const warnStage = evidence?.snapshot?.stage ?? 'PRE_WRITE';
+    return [
+      {
+        severity: 'warning',
+        message: appendTrackingActionableContext({
+          repoRoot,
+          message: `Governance requires attention (${warnStage}).`,
+        }),
+      },
+    ];
   }
 
-  return issues;
+  const blockedStage = evidence?.snapshot?.stage ?? 'PRE_WRITE';
+  const message = appendTrackingActionableContext({
+    repoRoot,
+    message: `Governance is blocked (${blockedStage}).`,
+  });
+  return [
+    {
+      severity: 'error',
+      message,
+    },
+  ];
 };
 
 export const readLifecycleStatus = (params?: {
   cwd?: string;
   git?: ILifecycleGitService;
-  governanceNextActionReader?: GovernanceNextActionReader;
 }): LifecycleStatus => {
   const git = params?.git ?? new LifecycleGitService();
   const cwd = params?.cwd ?? process.cwd();
@@ -89,20 +86,7 @@ export const readLifecycleStatus = (params?: {
   });
   const policyValidation = readLifecyclePolicyValidationSnapshot(repoRoot);
   const experimentalFeatures = readLifecycleExperimentalFeaturesSnapshot();
-  const governanceObservation = readGovernanceObservationSnapshot({
-    repoRoot,
-    experimentalFeatures,
-    policyValidation,
-    git,
-  });
-  const governanceStage = governanceObservation.evidence.snapshot_stage ?? 'PRE_WRITE';
-  const governanceNextAction = (params?.governanceNextActionReader ?? readGovernanceNextAction)({
-    repoRoot,
-    stage: governanceStage,
-    governanceObservation,
-  });
-  const tracking = resolveRepoTrackingState(repoRoot);
-  const issues = buildLifecycleIssues({ governanceObservation, governanceNextAction, tracking });
+  const issues = buildLifecycleIssues(repoRoot);
 
   return {
     repoRoot,
@@ -115,9 +99,6 @@ export const readLifecycleStatus = (params?: {
     trackedNodeModulesCount,
     policyValidation,
     experimentalFeatures,
-    governanceNextAction,
-    governanceObservation,
-    tracking,
     issues,
   };
 };

package/integrations/lifecycle/watch.ts

@@ -736,7 +736,7 @@ export const runLifecycleWatch = async (
           driftFromRuntime,
           driftWarning,
           alignmentCommand: driftFromRuntime
-            ? buildLifecycleAlignmentCommand(versionMetadata.runtimeVersion, repoRoot)
+            ? buildLifecycleAlignmentCommand(versionMetadata.runtimeVersion)
             : null,
         },
         stage,