@cassiomc1/forgeloop 1.5.0 → 1.6.0

package/src/core/information-gain-projection.js

@@ -0,0 +1,283 @@
+import { diagnosticEventsForTask } from "./diagnostic-projection.js";
+import { normalizeDiagnosticSnapshot, computeInformationGain } from "./information-gain.js";
+import { computeFailureSignature } from "./failure-signature.js";
+
+function snapshotFor(event) {
+  const details = event.details ?? {};
+  if (event.event === "DIAGNOSTIC_CASE_RECORDED") {
+    return normalizeDiagnosticSnapshot({ ...details, legacy: false });
+  }
+  return normalizeDiagnosticSnapshot({ ...details, legacy: true });
+}
+
+const sameSortedSet = (a, b) =>
+  JSON.stringify([...(a ?? [])].sort()) === JSON.stringify([...(b ?? [])].sort());
+
+// Cycle interval rule (documented contract):
+//   For diagnostic event D[n], the analysis interval is
+//   (D[n-1].sequence, D[n].sequence] — previous diagnostic sequence exclusive,
+//   current diagnostic sequence inclusive.
+// Events inside an interval belong to the *current* cycle's knowledge state;
+// they are never attributed retroactively to the earlier diagnosis.
+function intervalEvents(taskEvents, fromExclusive, toInclusive) {
+  return taskEvents.filter((event) =>
+    event.seq > fromExclusive && event.seq <= toInclusive);
+}
+
+function failureStateByCycle(taskEvents) {
+  const surfaces = new Map();
+  const signatures = new Map();
+  const record = (cycle, details) => {
+    if (!Number.isInteger(cycle)) cycle = Number(cycle) || 1;
+    if (!surfaces.has(cycle)) surfaces.set(cycle, new Set());
+    if (!signatures.has(cycle)) signatures.set(cycle, new Set());
+    const requirement = details.requirement ?? details.id ?? details.checkId;
+    if (!requirement) return;
+    if (details.status === "failed" || details.status === "blocked") {
+      surfaces.get(cycle).add(requirement);
+      signatures.get(cycle).add(computeFailureSignature({
+        requirement,
+        status: details.status,
+        exitCode: Number.isInteger(details.exitCode) ? details.exitCode : null,
+        failureToken: typeof details.failureToken === "string" ? details.failureToken : (typeof details.details?.failureToken === "string" ? details.details.failureToken : null),
+      }));
+    }
+  };
+  for (const event of taskEvents) {
+    if (event.event === "VERIFICATION_STARTED") {
+      const cycle = event.details?.verificationCycle;
+      if (Number.isInteger(cycle)) {
+        if (!surfaces.has(cycle)) surfaces.set(cycle, new Set());
+        if (!signatures.has(cycle)) signatures.set(cycle, new Set());
+      }
+    }
+    if (event.event === "VERIFICATION_RECORDED") {
+      record(event.details?.verificationCycle ?? 1, event.details ?? {});
+    }
+  }
+  return { surfaces, signatures };
+}
+
+
+function strategyFingerprintFor(diagnosticEvent, interventionsUpTo) {
+  const details = diagnosticEvent?.details ?? {};
+  const components = {
+    hypotheses: (details.hypotheses ?? []).map((hypothesis) => `${hypothesis.statement}`.trim().toLowerCase()),
+    contributors: (details.contributors ?? []).map((contributor) => `${contributor.statement}`.trim().toLowerCase()),
+    legacyHypothesis: diagnosticEvent?.event === "DIAGNOSIS_RECORDED"
+      ? [`${details.hypothesis ?? ""}`.trim().toLowerCase()]
+      : [],
+    interventions: interventionsUpTo.map((entry) => entry.fingerprint),
+  };
+  return JSON.stringify([
+    [...components.hypotheses, ...components.legacyHypothesis].sort(),
+    components.contributors.sort(),
+    components.interventions.sort(),
+  ]);
+}
+
+function snapshotHasContentDelta(previousDetails, currentDetails) {
+  const statementsOf = (details) => ({
+    observations: new Set((details.observations ?? []).map((o) => `${o.statement}`.trim().toLowerCase())),
+    contributors: new Set((details.contributors ?? []).map((c) => `${c.statement}`.trim().toLowerCase())),
+    hypotheses: new Set((details.hypotheses ?? []).map((h) => `${h.statement}`.trim().toLowerCase())),
+    legacyHypothesis: details.hypothesis ? new Set([`${details.hypothesis}`.trim().toLowerCase()]) : null,
+    evidence: new Set([
+      ...((details.hypotheses ?? []).flatMap((h) => h.evidenceRefs ?? [])),
+      ...((details.observations ?? []).map((o) => o.evidenceRef).filter(Boolean)),
+      ...(details.evidenceRefs ?? []),
+    ]),
+  });
+  const prev = statementsOf(previousDetails);
+  const cur = statementsOf(currentDetails);
+  const differs = (a, b) => {
+    if (!a || !b) return false;
+    for (const value of b) if (!a.has(value)) return true;
+    return false;
+  };
+  return differs(prev.observations, cur.observations)
+    || differs(prev.contributors, cur.contributors)
+    || differs(prev.hypotheses, cur.hypotheses)
+    || differs(prev.legacyHypothesis, cur.legacyHypothesis)
+    || differs(prev.evidence, cur.evidence);
+}
+
+export function buildInformationGainProjection(events, taskId) {
+  const taskEvents = (events ?? [])
+    .filter((event) => !taskId || !event.taskId || event.taskId === taskId)
+    .sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
+
+  const diagnosticEvents = diagnosticEventsForTask(taskEvents, taskId)
+    .sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
+  if (diagnosticEvents.length === 0) return [];
+
+  const failure = failureStateByCycle(taskEvents);
+
+  // Build final per-cycle entries first; effectiveGain is computed once at the
+  // end from fully final dimensions (no post-mutation anywhere).
+  const built = [];
+  let previousDiagnostic = null;
+  for (const diagnostic of diagnosticEvents) {
+    const intervalStart = previousDiagnostic ? previousDiagnostic.seq : -Infinity;
+    const interval = intervalEvents(taskEvents, intervalStart, diagnostic.seq);
+
+    const hypothesisDispositionChanged =
+      interval.some((event) => event.event === "HYPOTHESIS_DISPOSITION_RECORDED");
+
+    // Intervention deltas recognize only genuinely NEW semantic interventions:
+    // recorded after the previous diagnosis, attributed to the current
+    // correction cycle, and never attempted before. Repeating an already-known
+    // intervention — or merely having executed the previous cycle's corrective
+    // action — is not new information.
+    const knownUpToPrev = new Set(
+      taskEvents
+        .filter((event) => event.event === "INTERVENTION_RECORDED"
+          && (previousDiagnostic ? (event.seq ?? 0) <= previousDiagnostic.seq : false))
+        .map((event) => event.details?.interventionSemanticFingerprint
+          ?? `${event.details?.intervention?.statement ?? ""}`.trim().toLowerCase())
+        .filter(Boolean),
+    );
+    const novelInInterval = interval
+      .filter((event) => event.event === "INTERVENTION_RECORDED")
+      .map((event) => event.details?.interventionSemanticFingerprint
+        ?? `${event.details?.intervention?.statement ?? ""}`.trim().toLowerCase())
+      .filter((fingerprint) => fingerprint && !knownUpToPrev.has(fingerprint));
+    // A genuinely new intervention counts as information only when the
+    // diagnosis itself moves: an identical re-proposal of the previous
+    // diagnosis after executing its already-known corrective action carries
+    // no new semantic state.
+    const sameSemanticsAsPrevious = Boolean(previousDiagnostic)
+      && !snapshotHasContentDelta(previousDiagnostic.details ?? {}, diagnostic.details ?? {});
+    const interventionChanged = Boolean(previousDiagnostic)
+      && novelInInterval.length > 0
+      && !sameSemanticsAsPrevious;
+
+    const cycle = diagnostic.details?.verificationCycle ?? 1;
+    const previousCycle = previousDiagnostic?.details?.verificationCycle ?? null;
+    const surface = [...(failure.surfaces.get(cycle) ?? new Set())].sort();
+    const signatures = [...(failure.signatures.get(cycle) ?? new Set())].sort();
+    const previousSurface = previousCycle != null
+      ? [...(failure.surfaces.get(previousCycle) ?? new Set())].sort()
+      : null;
+    const previousSignatures = previousCycle != null
+      ? [...(failure.signatures.get(previousCycle) ?? new Set())].sort()
+      : null;
+    const hasPreviousFailureState = previousSurface !== null;
+    const failureSurfaceChanged = hasPreviousFailureState
+      ? !sameSortedSet(surface, previousSurface)
+      : false;
+    const failureSignatureChanged = hasPreviousFailureState
+      ? !sameSortedSet(signatures, previousSignatures)
+      : false;
+
+    // Strategy compares the PROPOSED diagnostic approach: the case's own
+    // semantic content on both sides (identical bases, so the delta is real).
+    const strategyFingerprint = strategyFingerprintFor(diagnostic, []);
+    const previousStrategyFingerprint = previousDiagnostic
+      ? strategyFingerprintFor(previousDiagnostic, [])
+      : null;
+    const strategyChanged = Boolean(previousStrategyFingerprint
+      && strategyFingerprint !== previousStrategyFingerprint);
+
+    const snapshot = snapshotFor(diagnostic);
+
+    built.push({
+      verificationCycle: cycle,
+      sequence: diagnostic.seq ?? null,
+      diagnosticSequence: diagnostic.seq ?? null,
+      sourceModel: diagnostic.event === "DIAGNOSTIC_CASE_RECORDED"
+        ? "STRUCTURED_DIAGNOSTIC_CASE_V1"
+        : "LEGACY_DIAGNOSIS_V1",
+      snapshot,
+      dimensionsInput: {
+        hypothesisDispositionChanged,
+        failureSignatureChanged,
+        failureSurfaceChanged,
+        interventionChanged,
+        strategyChanged,
+        hypothesisEliminated: false,
+      },
+      evidence: {
+        semanticRefs: [...(snapshot.evidenceRefs ?? [])].sort(),
+        surface, signatures, strategyFingerprint,
+      },
+    });
+
+    previousDiagnostic = diagnostic;
+  }
+
+  // Hypothesis elimination: an id disappearing only counts as elimination when
+  // no surviving hypothesis carries the same normalized statement — ID-only
+  // churn is artificial novelty and must never create gain.
+  for (let i = 1; i < built.length; i++) {
+    if (built[i].sourceModel !== "STRUCTURED_DIAGNOSTIC_CASE_V1"
+      || built[i - 1].sourceModel !== "STRUCTURED_DIAGNOSTIC_CASE_V1") continue;
+    const previousHypotheses = diagnosticEvents[i - 1]?.details?.hypotheses ?? [];
+    const currentHypotheses = diagnosticEvents[i]?.details?.hypotheses ?? [];
+    const currentStatements = new Set(currentHypotheses.map(
+      (hypothesis) => `${hypothesis.statement}`.trim().toLowerCase()));
+    built[i].dimensionsInput.hypothesisEliminated = previousHypotheses.some((hypothesis) => {
+      const survivedById = currentHypotheses.some((candidate) => candidate.id === hypothesis.id);
+      return !survivedById
+        && !currentStatements.has(`${hypothesis.statement}`.trim().toLowerCase());
+    });
+  }
+
+  // Final classification + single-point effectiveGain computation.
+  const entries = computeInformationGain(built.map((entry) => ({
+    verificationCycle: entry.verificationCycle,
+    sequence: entry.sequence,
+    snapshot: entry.snapshot,
+    context: entry.dimensionsInput,
+  })));
+
+  return built.map((entry, index) => {
+    const { dimensions, classification, effectiveGain } = entries[index];
+    return Object.freeze({
+      verificationCycle: entry.verificationCycle,
+      sequence: entry.sequence,
+      diagnosticSequence: entry.diagnosticSequence,
+      sourceModel: entry.sourceModel,
+      evidence: Object.freeze({
+        semanticRefs: Object.freeze(entry.evidence.semanticRefs),
+        failureSurface: Object.freeze(entry.evidence.surface),
+        failureSignatures: Object.freeze(entry.evidence.signatures),
+        strategyFingerprint: entry.evidence.strategyFingerprint,
+      }),
+      dimensions: Object.freeze({ ...dimensions }),
+      classification,
+      effectiveGain,
+    });
+  });
+}
+
+// One canonical structured-stall policy (fail-fast):
+//   The latest comparable diagnostic state that produces no effective
+//   information gain is stalled and may not trigger another blind correction
+//   retry. The first diagnosis is never stalled. Legacy diagnosis keeps its
+//   own compatibility rule (informationGain === NONE).
+export function evaluateStructuredDiagnosticStall(gainProjection, { verificationCycle = null } = {}) {
+  const candidates = verificationCycle == null
+    ? (gainProjection ?? [])
+    : (gainProjection ?? []).filter((entry) => entry.verificationCycle === verificationCycle);
+
+  const latest = candidates.at(-1) ?? null;
+  if (!latest) {
+    return { stalled: false, latestGain: null, reason: null };
+  }
+  if (latest.classification === "FIRST_DIAGNOSIS") {
+    return { stalled: false, latestGain: latest, reason: null };
+  }
+  const stalled = latest.effectiveGain === false;
+  return {
+    stalled,
+    latestGain: latest,
+    reason: stalled ? "NO_DIAGNOSTIC_INFORMATION_GAIN" : null,
+  };
+}
+
+export function computeCycleInformationGain(events, taskId, verificationCycle) {
+  const projection = buildInformationGainProjection(events, taskId);
+  const matching = projection.filter((entry) => entry.verificationCycle === verificationCycle);
+  return matching.at(-1) ?? null;
+}

package/src/core/information-gain.js

@@ -0,0 +1,138 @@
+export const GAIN_DIMENSIONS = Object.freeze([
+  "newObservation",
+  "newContributor",
+  "newHypothesis",
+  "hypothesisDispositionChanged",
+  "failureSignatureChanged",
+  "failureSurfaceChanged",
+  "interventionChanged",
+  "strategyChanged",
+  "newEvidence",
+  "hypothesisEliminated",
+]);
+
+function statementSet(values) {
+  return new Set((values ?? []).map((value) => `${value}`.trim().toLowerCase()).filter(Boolean));
+}
+
+export function normalizeDiagnosticSnapshot(input) {
+  // Idempotent: already-normalized snapshots pass through unchanged so
+  // repeated normalization never fabricates empty semantic sets.
+  if (input
+    && input.observationStatements instanceof Set
+    && input.contributorStatements instanceof Set
+    && input.hypothesisStatements instanceof Set
+    && input.evidenceRefs instanceof Set) {
+    return input;
+  }
+  if (!input) {
+    return {
+      observationStatements: new Set(),
+      contributorStatements: new Set(),
+      hypothesisStatements: new Set(),
+      evidenceRefs: new Set(),
+    };
+  }
+  const legacyHypothesis = input.legacy
+    ? [input.hypothesis ?? ""]
+    : (input.hypotheses ?? []).map((hypothesis) => hypothesis.statement ?? "");
+  const evidenceRefs = input.legacy
+    ? (input.evidenceRefs ?? [])
+    : [
+        ...(input.hypotheses ?? []).flatMap((hypothesis) => hypothesis.evidenceRefs ?? []),
+        ...(input.observations ?? []).map((observation) => observation.evidenceRef).filter(Boolean),
+      ];
+  return {
+    observationStatements: statementSet(input.legacy ? [] : (input.observations ?? []).map((observation) => observation.statement)),
+    contributorStatements: statementSet(input.legacy ? [] : (input.contributors ?? []).map((contributor) => contributor.statement)),
+    hypothesisStatements: statementSet(legacyHypothesis),
+    evidenceRefs: statementSet(evidenceRefs),
+    hypothesisIds: new Set(input.legacy ? [] : (input.hypotheses ?? []).map((hypothesis) => hypothesis.id)),
+  };
+}
+
+function hasNewValue(previousSet, currentSet) {
+  for (const value of currentSet) {
+    if (!previousSet.has(value)) return true;
+  }
+  return false;
+}
+
+export function compareDiagnosticCycles(previousInput, currentInput, context = {}) {
+  const previous = previousInput instanceof Set || Array.isArray(previousInput)
+    ? normalizeDiagnosticSnapshot(null)
+    : normalizeDiagnosticSnapshot(previousInput);
+  const current = normalizeDiagnosticSnapshot(currentInput);
+
+  const dimensions = {
+    newObservation: hasNewValue(previous.observationStatements, current.observationStatements),
+    newContributor: hasNewValue(previous.contributorStatements, current.contributorStatements),
+    newHypothesis: hasNewValue(previous.hypothesisStatements, current.hypothesisStatements),
+    hypothesisDispositionChanged: Boolean(context.hypothesisDispositionChanged),
+    failureSignatureChanged: Boolean(context.failureSignatureChanged),
+    failureSurfaceChanged: Boolean(context.failureSurfaceChanged),
+    interventionChanged: Boolean(context.interventionChanged),
+    strategyChanged: Boolean(context.strategyChanged),
+    newEvidence: hasNewValue(previous.evidenceRefs, current.evidenceRefs),
+    // Elimination is decided semantically by the cycle analysis projection:
+    // an id disappearing while its statement survives is ID-only churn, not gain.
+    hypothesisEliminated: Boolean(context.hypothesisEliminated),
+  };
+  return dimensions;
+}
+
+const CLASSIFICATION = Object.freeze({
+  FIRST_DIAGNOSIS: "FIRST_DIAGNOSIS",
+  NEW_HYPOTHESIS: "NEW_HYPOTHESIS",
+  NEW_EVIDENCE: "NEW_EVIDENCE",
+  NEW_HYPOTHESIS_AND_EVIDENCE: "NEW_HYPOTHESIS_AND_EVIDENCE",
+  NONE: "NONE",
+});
+
+export function classifyGain(dimensions, { first = false } = {}) {
+  if (first) return CLASSIFICATION.FIRST_DIAGNOSIS;
+  const hypothesis = dimensions.newHypothesis;
+  const evidence = dimensions.newEvidence;
+  if (hypothesis && evidence) return CLASSIFICATION.NEW_HYPOTHESIS_AND_EVIDENCE;
+  if (hypothesis) return CLASSIFICATION.NEW_HYPOTHESIS;
+  if (evidence) return CLASSIFICATION.NEW_EVIDENCE;
+  return CLASSIFICATION.NONE;
+}
+
+export function isEffectiveGain(dimensions, classification) {
+  if (classification !== CLASSIFICATION.NONE) return true;
+
+  // Every meaningful semantic dimension counts as effective gain.
+  // newHypothesis and newEvidence remain covered by the compatibility
+  // classification above; the remaining dimensions are checked explicitly.
+  return Boolean(
+    dimensions.newObservation
+    || dimensions.newContributor
+    || dimensions.hypothesisDispositionChanged
+    || dimensions.failureSignatureChanged
+    || dimensions.failureSurfaceChanged
+    || dimensions.interventionChanged
+    || dimensions.strategyChanged
+    || dimensions.hypothesisEliminated
+  );
+}
+
+export function computeInformationGain(entries) {
+  const results = [];
+  let previous = null;
+  let seenFirst = false;
+  for (const entry of entries) {
+    const dimensions = compareDiagnosticCycles(previous?.snapshot ?? null, entry.snapshot, entry.context ?? {});
+    const classification = classifyGain(dimensions, { first: !seenFirst });
+    seenFirst = true;
+    results.push({
+      verificationCycle: entry.verificationCycle,
+      sequence: entry.sequence ?? null,
+      effectiveGain: isEffectiveGain(dimensions, classification),
+      classification,
+      dimensions,
+    });
+    previous = entry;
+  }
+  return results;
+}

package/src/core/inspect.js

@@ -12,6 +12,99 @@ import { trustedAuthorityConfiguration } from "./trusted-authority.js";
 import { reconcileContinuity } from "./continuity-reconciliation.js";
 import { continuityFinding, continuityIsHealthy } from "./continuity-observability.js";
 import { findTaskById } from "./task-discovery.js";
+import { buildTaskTrace } from "./trace.js";
+import { evaluateProgress } from "./progress.js";
+import { readEvents } from "./events.js";
+
+function reasonCodesFor({ state, trace, progress }) {
+  const codes = [];
+  codes.push(trace.integrity.valid ? "LEDGER_VALID" : "LEDGER_INCONSISTENT");
+  if (state?.status === "VALID" || state?.status === "FRESH") codes.push("REPOSITORY_FRESH");
+  if (["STALE", "REVALIDATION_REQUIRED"].includes(state?.status)) codes.push("REPOSITORY_STALE");
+  if (trace.task.phase === "COMPLETE") codes.push("COMPLETION_VALID");
+  else codes.push("COMPLETION_INCOMPLETE");
+  if (progress.status === "ADVANCING") codes.push("DIAGNOSTIC_PROGRESS_ADVANCING");
+  if (progress.status === "STALLED") codes.push("DIAGNOSTIC_PROGRESS_STALLED");
+  return codes;
+}
+
+async function buildTaskInspection({ target, packageRoot, taskId, state, classifiedStatus = null }) {
+  const trace = await buildTaskTrace({ target, packageRoot, taskId });
+  const events = await readEvents(target, packageRoot, { taskId });
+  const progress = evaluateProgress({ state, events });
+  const failedRequirements = [...new Set(
+    trace.checks
+      .filter((check) => check.currentResult === "failed" || check.currentResult === "blocked")
+      .map((check) => check.requirement ?? check.id),
+  )].sort();
+
+  const issues = [];
+  if (!trace.snapshot.consistent) {
+    issues.push({ code: "E_TRACE_SNAPSHOT_INCONSISTENT", message: "Task artifacts changed while being read; rerun inspect for a consistent view." });
+  }
+  for (const error of trace.integrity.errors) {
+    issues.push({ code: error.code ?? "E_EVENT_INVALID", message: error.message });
+  }
+  if (failedRequirements.length > 0 && trace.diagnostics.cases.length === 0 && trace.diagnostics.legacyDiagnoses.length === 0) {
+    issues.push({ code: "E_DIAGNOSIS_REQUIRED", message: "Failed requirements have no recorded diagnosis." });
+  }
+
+  const explanation = {
+    result: failedRequirements.length > 0 ? "INCOMPLETE_VERIFICATION" : (trace.task.phase === "COMPLETE" ? "COMPLETE" : "INCOMPLETE"),
+    reasons: reasonCodesFor({ state: { status: classifiedStatus }, trace, progress }),
+  };
+
+  return {
+    task: taskId,
+    snapshot: {
+      consistent: trace.snapshot.consistent,
+      stateRevision: trace.snapshot.stateRevision,
+      ledgerTailSequence: trace.snapshot.ledgerTailSequence,
+    },
+    lifecycle: {
+      phase: trace.task.phase,
+      verificationCycle: trace.task.verificationCycle,
+      transitions: trace.transitions,
+    },
+    history: {
+      eventCount: trace.events.length,
+      quality: trace.historyQuality,
+    },
+    verification: {
+      checks: trace.checks.map((check) => ({
+        id: check.id,
+        requirement: check.requirement,
+        currentResult: check.currentResult,
+        attemptCount: check.attemptCount,
+        failedAttempts: check.failedAttempts,
+      })),
+      failedRequirements,
+    },
+    diagnostics: {
+      legacyDiagnosisCount: trace.diagnostics.legacyDiagnoses.length,
+      diagnosticCaseCount: trace.diagnostics.cases.length,
+      interventionCount: trace.diagnostics.interventions.length,
+      dispositionCount: trace.diagnostics.dispositions.length,
+      latestCase: trace.diagnostics.cases.at(-1) ?? null,
+    },
+    progress,
+    failureSurfaces: trace.failureSurfaces,
+    failureSignatures: trace.failureSignatures.map((entry) => ({
+      signature: entry.signature,
+      requirements: entry.requirements,
+      cycles: entry.cycles,
+    })),
+    integrity: {
+      valid: trace.integrity.valid,
+      errors: trace.integrity.errors,
+    },
+    audit: {},
+    completion: {},
+    issues,
+    explanation,
+    next: { command: `forgeloop next --task ${taskId} --json` },
+  };
+}
 
 function profileMetadata(bytes) {
   const text = bytes.toString("utf8");
@@ -40,7 +133,8 @@ export async function inspectTarget({ target, packageRoot, contractFile = null,
   const effectiveStateRel = stateFile ?? (taskId ? taskArtifactPath(taskId, "state") : WORK_STATE_PATH);
   const statePath = ensureWithin(target, effectiveStateRel);
   const statePresent = await fileExists(statePath);
-  const state = await readAndClassifyWorkState({ target, packageRoot, contractFile, taskId, stateFile: effectiveStateRel });
+  const classifiedState = await readAndClassifyWorkState({ target, packageRoot, contractFile, taskId, stateFile: effectiveStateRel });
+  const rawState = classifiedState?.state ?? null;
   const taskInfo = taskId ? await findTaskById(target, taskId, packageRoot) : null;
   const continuity = await reconcileContinuity({ target, packageRoot, taskId });
   const schemaRoot = manifest?.layoutVersion >= 2
@@ -95,12 +189,12 @@ export async function inspectTarget({ target, packageRoot, contractFile = null,
     });
   }
 
-  if (state.status === "INVALID") {
+  if (classifiedState.status === "INVALID") {
     findings.push({
       code: "state-invalid",
       severity: "error",
-      path: WORK_STATE_PATH,
-      message: state.error ?? "Work state is invalid.",
+      path: effectiveStateRel,
+      message: classifiedState.error ?? "Work state is invalid.",
       remediation: "Repair or clear the checkpoint after reviewing the parse error.",
       evidence: createEvidence({ kind: "BLOCKED", source: WORK_STATE_PATH, result: "invalid" }),
     });
@@ -113,9 +207,12 @@ export async function inspectTarget({ target, packageRoot, contractFile = null,
   })];
   const evidence = [
     ...(doctor.evidence ?? []),
-    ...(state.evidence ?? []),
+    ...(classifiedState.evidence ?? []),
     ...protocolEvidence,
   ];
+  const taskInspection = taskId
+    ? await buildTaskInspection({ target, packageRoot, taskId, state: rawState, classifiedStatus: classifiedState.status })
+    : null;
   return {
     target: { path: target },
     authority: trustedAuthorityConfiguration({ target, authorityContext, runtimeContext }),
@@ -148,7 +245,7 @@ export async function inspectTarget({ target, packageRoot, contractFile = null,
       schemas: schemaHealth.schemas,
       evidence: protocolEvidence,
     },
-    state: { ...state, path: WORK_STATE_PATH, present: statePresent },
+    state: { ...classifiedState, path: effectiveStateRel, present: statePresent },
     recovery: taskInfo?.recovery ?? null,
     claims: taskInfo ? {
       state: taskInfo.claimState,
@@ -165,11 +262,12 @@ export async function inspectTarget({ target, packageRoot, contractFile = null,
     },
     findings,
     evidence,
+    ...(taskInspection ? { taskInspection } : {}),
     ok: doctor.ok
       && !manifestError
       && schemaHealth.status === "valid"
       && taskInfo?.ownershipValid !== false
-      && !["INVALID", "REVALIDATION_REQUIRED"].includes(state.status)
+      && !["INVALID", "REVALIDATION_REQUIRED"].includes(classifiedState.status)
       && continuityIsHealthy(continuity),
   };
 }