agentweaver 0.1.14 → 0.1.16

package/dist/doctor/checks/flow-readiness.js

@@ -1,12 +1,54 @@
 import { existsSync, readdirSync } from "node:fs";
 import path from "node:path";
-import { DoctorStatus } from "../types.js";
+import { DoctorImpact, DoctorStatus, WorkflowContinuityState } from "../types.js";
 import { CATEGORY } from "./category.js";
 import { BUILT_IN_COMMAND_FLOW_IDS } from "../../pipeline/flow-catalog.js";
 import { validateStructuredArtifact } from "../../structured-artifacts.js";
-import { designJsonFile, planJsonFile, scopeArtifactsDir } from "../../artifacts.js";
+import { designJsonFile, latestArtifactIteration, planJsonFile, taskContextJsonFile, } from "../../artifacts.js";
+import { inspectLatestPlanningBundle } from "../../runtime/planning-bundle.js";
 const GO_BINARY_PATTERNS = ["go", "go.exe"];
 const GIT_BINARY_PATTERNS = ["git", "git.exe"];
+function statePriority(state) {
+    switch (state) {
+        case WorkflowContinuityState.InvalidState:
+            return 3;
+        case WorkflowContinuityState.NotConfigured:
+            return 2;
+        case WorkflowContinuityState.NeedsPreviousStage:
+            return 1;
+        case WorkflowContinuityState.Available:
+        default:
+            return 0;
+    }
+}
+function formatState(state) {
+    switch (state) {
+        case WorkflowContinuityState.Available:
+            return "available";
+        case WorkflowContinuityState.NeedsPreviousStage:
+            return "requires previous stage outputs";
+        case WorkflowContinuityState.NotConfigured:
+            return "not configured";
+        case WorkflowContinuityState.InvalidState:
+            return "invalid state";
+        default:
+            return state;
+    }
+}
+function setEntryState(entry, state, reason) {
+    if (statePriority(state) > statePriority(entry.state)) {
+        entry.state = state;
+    }
+    entry.reasons.push(reason);
+}
+function createEntry(flowId, mode) {
+    return {
+        flowId,
+        ...(mode ? { mode } : {}),
+        state: WorkflowContinuityState.Available,
+        reasons: [],
+    };
+}
 function findBinary(name) {
     const envPath = process.env.PATH ?? "";
     const pathDirs = envPath.split(path.delimiter);
@@ -20,233 +62,146 @@ function findBinary(name) {
     }
     return null;
 }
-function checkBinaryPresence(flowId) {
-    const goFlows = new Set([
-        "run-go-tests-loop",
-        "run-go-linter-loop",
-        "auto-golang",
-    ]);
-    const gitFlows = new Set(["git-commit", "gitlab-review", "gitlab-diff-review", "mr-description"]);
-    if (goFlows.has(flowId)) {
-        return findBinary("go");
-    }
-    if (gitFlows.has(flowId)) {
-        return findBinary("git");
-    }
-    return null;
-}
 function isJiraConfigured() {
     return !!(process.env.JIRA_API_KEY && process.env.JIRA_BASE_URL);
 }
 function isGitLabConfigured() {
     return !!process.env.GITLAB_TOKEN;
 }
-function getLatestDesignIteration(scopeKey) {
-    const artifactsDir = scopeArtifactsDir(scopeKey);
-    if (!existsSync(artifactsDir)) {
-        return null;
-    }
-    const files = readdirSync(artifactsDir);
-    const designFiles = files.filter((f) => /^design-.*-\d+\.json$/.test(f));
-    if (designFiles.length === 0) {
-        return null;
-    }
-    const iterations = designFiles.map((f) => {
-        const match = f.match(/^design-.*-(\d+)\.json$/);
-        return match?.[1] ? parseInt(match[1], 10) : 0;
-    });
-    return Math.max(...iterations);
-}
-function getLatestPlanIteration(scopeKey) {
-    const artifactsDir = scopeArtifactsDir(scopeKey);
-    if (!existsSync(artifactsDir)) {
-        return null;
-    }
-    const files = readdirSync(artifactsDir);
-    const planFiles = files.filter((f) => /^plan-.*-\d+\.json$/.test(f));
-    if (planFiles.length === 0) {
-        return null;
-    }
-    const iterations = planFiles.map((f) => {
-        const match = f.match(/^plan-.*-(\d+)\.json$/);
-        return match?.[1] ? parseInt(match[1], 10) : 0;
-    });
-    return Math.max(...iterations);
+function getLatestJsonArtifactIteration(scopeKey, prefix) {
+    return latestArtifactIteration(scopeKey, prefix, "json");
 }
-function checkImplementFlowReadiness(scopeKey) {
-    const blockers = [];
-    const latestDesignIteration = getLatestDesignIteration(scopeKey);
-    const latestPlanIteration = getLatestPlanIteration(scopeKey);
-    if (latestDesignIteration === null) {
-        blockers.push("design artifact not found");
+function checkStructuredArtifactFile(entry, artifactPath, schemaId, missingReason, invalidReasonPrefix) {
+    if (!existsSync(artifactPath)) {
+        setEntryState(entry, WorkflowContinuityState.NeedsPreviousStage, missingReason);
+        return;
     }
-    else {
-        const designPath = designJsonFile(scopeKey, latestDesignIteration);
-        if (!existsSync(designPath)) {
-            blockers.push(`design artifact not found at ${designPath}`);
-        }
-        else {
-            try {
-                validateStructuredArtifact(designPath, "implementation-design/v1");
-            }
-            catch (error) {
-                blockers.push(`design artifact schema invalid: ${error.message}`);
-            }
-        }
-    }
-    if (latestPlanIteration === null) {
-        blockers.push("plan artifact not found");
+    try {
+        validateStructuredArtifact(artifactPath, schemaId);
     }
-    else {
-        const planPath = planJsonFile(scopeKey, latestPlanIteration);
-        if (!existsSync(planPath)) {
-            blockers.push(`plan artifact not found at ${planPath}`);
-        }
-        else {
-            try {
-                validateStructuredArtifact(planPath, "implementation-plan/v1");
-            }
-            catch (error) {
-                blockers.push(`plan artifact schema invalid: ${error.message}`);
-            }
-        }
+    catch (error) {
+        setEntryState(entry, WorkflowContinuityState.InvalidState, `${invalidReasonPrefix}: ${error.message}`);
     }
-    return {
-        flowId: "implement",
-        status: blockers.length === 0 ? "ready" : "not_ready",
-        blockers,
-    };
 }
-function checkReviewProjectFlowReadiness(scopeKey) {
-    const blockers = [];
-    const latestDesignIteration = getLatestDesignIteration(scopeKey);
-    if (latestDesignIteration === null) {
-        blockers.push("design artifact not found");
+function checkImplementWorkflowContinuity(scopeKey) {
+    const entry = createEntry("implement");
+    const planningBundle = inspectLatestPlanningBundle(scopeKey);
+    if (planningBundle.status === "missing") {
+        setEntryState(entry, WorkflowContinuityState.NeedsPreviousStage, planningBundle.errorMessage);
     }
-    else {
-        const designPath = designJsonFile(scopeKey, latestDesignIteration);
-        if (!existsSync(designPath)) {
-            blockers.push(`design artifact not found at ${designPath}`);
-        }
+    else if (planningBundle.status === "incomplete") {
+        setEntryState(entry, WorkflowContinuityState.InvalidState, planningBundle.errorMessage);
     }
-    return {
-        flowId: "review",
-        mode: "project",
-        status: blockers.length === 0 ? "ready" : "not_ready",
-        blockers,
-    };
+    else if (planningBundle.status === "invalid") {
+        setEntryState(entry, WorkflowContinuityState.InvalidState, planningBundle.errorMessage);
+    }
+    if (entry.state === WorkflowContinuityState.NeedsPreviousStage) {
+        entry.nextStep = "Run plan to generate design, plan, and QA artifacts for this scope.";
+    }
+    else if (entry.state === WorkflowContinuityState.InvalidState) {
+        entry.nextStep = "Regenerate the planning artifacts for this scope before running implement.";
+    }
+    return entry;
 }
-function checkReviewJiraFlowReadiness(scopeKey) {
-    const blockers = [];
+function checkReviewProjectWorkflowContinuity() {
+    return createEntry("review", "project");
+}
+function checkReviewJiraWorkflowContinuity(scopeKey) {
+    const entry = createEntry("review", "jira");
     if (!isJiraConfigured()) {
-        blockers.push("Jira not configured (JIRA_API_KEY or JIRA_BASE_URL missing)");
+        setEntryState(entry, WorkflowContinuityState.NotConfigured, "Jira integration is not configured (JIRA_API_KEY or JIRA_BASE_URL missing).");
     }
-    const latestDesignIteration = getLatestDesignIteration(scopeKey);
+    const latestDesignIteration = getLatestJsonArtifactIteration(scopeKey, "design");
+    const latestPlanIteration = getLatestJsonArtifactIteration(scopeKey, "plan");
     if (latestDesignIteration === null) {
-        blockers.push("design artifact not found");
+        setEntryState(entry, WorkflowContinuityState.NeedsPreviousStage, "Missing design artifact from the planning stage.");
     }
     else {
-        const designPath = designJsonFile(scopeKey, latestDesignIteration);
-        if (!existsSync(designPath)) {
-            blockers.push(`design artifact not found at ${designPath}`);
-        }
+        checkStructuredArtifactFile(entry, designJsonFile(scopeKey, latestDesignIteration), "implementation-design/v1", "Missing design artifact from the planning stage.", "Design artifact schema is invalid");
     }
-    const latestPlanIteration = getLatestPlanIteration(scopeKey);
     if (latestPlanIteration === null) {
-        blockers.push("plan artifact not found");
+        setEntryState(entry, WorkflowContinuityState.NeedsPreviousStage, "Missing plan artifact from the planning stage.");
     }
     else {
-        const planPath = planJsonFile(scopeKey, latestPlanIteration);
-        if (!existsSync(planPath)) {
-            blockers.push(`plan artifact not found at ${planPath}`);
-        }
+        checkStructuredArtifactFile(entry, planJsonFile(scopeKey, latestPlanIteration), "implementation-plan/v1", "Missing plan artifact from the planning stage.", "Plan artifact schema is invalid");
     }
-    return {
-        flowId: "review",
-        mode: "jira",
-        status: blockers.length === 0 ? "ready" : "not_ready",
-        blockers,
-    };
+    if (entry.state === WorkflowContinuityState.NotConfigured) {
+        entry.nextStep = "Configure Jira access and ensure the planning artifacts exist before running review:jira.";
+    }
+    else if (entry.state === WorkflowContinuityState.NeedsPreviousStage) {
+        entry.nextStep = "Run plan first to generate the design and plan artifacts required by review:jira.";
+    }
+    else if (entry.state === WorkflowContinuityState.InvalidState) {
+        entry.nextStep = "Regenerate invalid planning artifacts before running review:jira.";
+    }
+    return entry;
 }
-function checkPlanJiraFlowReadiness(scopeKey) {
-    const blockers = [];
+function checkPlanJiraWorkflowContinuity(scopeKey) {
+    const entry = createEntry("plan", "jira");
     if (!isJiraConfigured()) {
-        blockers.push("Jira not configured (JIRA_API_KEY or JIRA_BASE_URL missing)");
+        setEntryState(entry, WorkflowContinuityState.NotConfigured, "Jira integration is not configured (JIRA_API_KEY or JIRA_BASE_URL missing).");
     }
     if (!process.env.JIRA_ISSUE_KEY && !scopeKey.includes("@")) {
-        blockers.push("Jira issue key not available");
+        setEntryState(entry, WorkflowContinuityState.NotConfigured, "No Jira issue key is available for the current scope.");
     }
-    return {
-        flowId: "plan",
-        mode: "jira",
-        status: blockers.length === 0 ? "ready" : "not_ready",
-        blockers,
-    };
+    if (entry.state === WorkflowContinuityState.NotConfigured) {
+        entry.nextStep = "Set Jira environment variables and provide a Jira issue key or browse URL before running plan:jira.";
+    }
+    return entry;
 }
-function checkPlanProjectFlowReadiness(scopeKey) {
-    const blockers = [];
-    const latestDesignIteration = getLatestDesignIteration(scopeKey);
-    if (latestDesignIteration === null) {
-        blockers.push("design artifact not found (task-describe output required)");
+function checkPlanProjectWorkflowContinuity(scopeKey) {
+    const entry = createEntry("plan", "project");
+    const latestTaskContextIteration = getLatestJsonArtifactIteration(scopeKey, "task-context");
+    if (latestTaskContextIteration === null) {
+        setEntryState(entry, WorkflowContinuityState.NeedsPreviousStage, "Missing normalized task-context artifact.");
     }
     else {
-        const designPath = designJsonFile(scopeKey, latestDesignIteration);
-        if (!existsSync(designPath)) {
-            blockers.push("design artifact not found");
-        }
+        checkStructuredArtifactFile(entry, taskContextJsonFile(scopeKey, latestTaskContextIteration), "task-context/v1", "Missing normalized task-context artifact.", "Task-context artifact schema is invalid");
     }
-    return {
-        flowId: "plan",
-        mode: "project",
-        status: blockers.length === 0 ? "ready" : "not_ready",
-        blockers,
-    };
+    if (entry.state === WorkflowContinuityState.NeedsPreviousStage) {
+        entry.nextStep = "Run a source flow that produces task-context for this scope before running plan:project.";
+    }
+    else if (entry.state === WorkflowContinuityState.InvalidState) {
+        entry.nextStep = "Regenerate the task-context artifact before running plan:project.";
+    }
+    return entry;
 }
-function checkGenericFlowReadiness(flowId, scopeKey) {
-    const blockers = [];
-    const binaryPath = checkBinaryPresence(flowId);
-    if (binaryPath === null) {
-        const requiredBinaries = {
-            "run-go-tests-loop": "go",
-            "run-go-linter-loop": "go",
-            "auto-golang": "go",
-            "git_commit": "git",
-            "gitlab-review": "git",
-            "gitlab-diff-review": "git",
-            "mr-description": "git",
-        };
-        const required = requiredBinaries[flowId];
-        if (required) {
-            blockers.push(`${required} binary not found in PATH`);
-        }
+function checkGenericWorkflowContinuity(flowId) {
+    const entry = createEntry(flowId);
+    const goFlows = new Set(["run-go-tests-loop", "run-go-linter-loop", "auto-golang"]);
+    const gitFlows = new Set(["git-commit", "gitlab-review", "gitlab-diff-review", "mr-description"]);
+    const gitLabFlows = new Set(["gitlab-review", "gitlab-diff-review", "mr-description"]);
+    if (goFlows.has(flowId) && findBinary("go") === null) {
+        setEntryState(entry, WorkflowContinuityState.NotConfigured, "Go binary is not available in PATH.");
+        entry.nextStep = "Install Go and ensure the go binary is available in PATH.";
     }
-    const jiraFlows = new Set(["gitlab-review", "gitlab-diff-review", "mr-description"]);
-    if (jiraFlows.has(flowId) && isGitLabConfigured()) {
-        // GitLab configured - could add connectivity check here
+    if (gitFlows.has(flowId) && findBinary("git") === null) {
+        setEntryState(entry, WorkflowContinuityState.NotConfigured, "Git binary is not available in PATH.");
+        entry.nextStep = "Install Git and ensure the git binary is available in PATH.";
     }
-    return {
-        flowId,
-        status: blockers.length === 0 ? "ready" : "not_ready",
-        blockers,
-    };
+    if (gitLabFlows.has(flowId) && !isGitLabConfigured()) {
+        setEntryState(entry, WorkflowContinuityState.NotConfigured, "GitLab integration is not configured (GITLAB_TOKEN missing).");
+        entry.nextStep = "Set GITLAB_TOKEN before running this GitLab-backed flow.";
+    }
+    return entry;
 }
-function determineFlowReadiness(flowId, scopeKey) {
+function determineWorkflowContinuity(flowId, scopeKey) {
     if (flowId === "implement") {
-        return [checkImplementFlowReadiness(scopeKey)];
+        return [checkImplementWorkflowContinuity(scopeKey)];
     }
     if (flowId === "review") {
         return [
-            checkReviewProjectFlowReadiness(scopeKey),
-            checkReviewJiraFlowReadiness(scopeKey),
+            checkReviewProjectWorkflowContinuity(),
+            checkReviewJiraWorkflowContinuity(scopeKey),
         ];
     }
     if (flowId === "plan") {
         return [
-            checkPlanJiraFlowReadiness(scopeKey),
-            checkPlanProjectFlowReadiness(scopeKey),
+            checkPlanJiraWorkflowContinuity(scopeKey),
+            checkPlanProjectWorkflowContinuity(scopeKey),
         ];
     }
-    return [checkGenericFlowReadiness(flowId, scopeKey)];
+    return [checkGenericWorkflowContinuity(flowId)];
 }
 function getScopeKey() {
     const cwd = process.cwd();
@@ -260,46 +215,100 @@ function getScopeKey() {
     }
     return entries[0];
 }
+function buildSummary(entries) {
+    return {
+        available: entries.filter((entry) => entry.state === WorkflowContinuityState.Available).length,
+        needsPreviousStage: entries.filter((entry) => entry.state === WorkflowContinuityState.NeedsPreviousStage).length,
+        notConfigured: entries.filter((entry) => entry.state === WorkflowContinuityState.NotConfigured).length,
+        invalidState: entries.filter((entry) => entry.state === WorkflowContinuityState.InvalidState).length,
+    };
+}
+function buildMessage(summary) {
+    const parts = [`${summary.available} flows available`];
+    if (summary.needsPreviousStage > 0) {
+        parts.push(`${summary.needsPreviousStage} require earlier stage outputs`);
+    }
+    if (summary.notConfigured > 0) {
+        parts.push(`${summary.notConfigured} not configured`);
+    }
+    if (summary.invalidState > 0) {
+        parts.push(`${summary.invalidState} in invalid state`);
+    }
+    return parts.join(", ");
+}
+function buildDetails(scopeKey, entries) {
+    const lines = [`scope: ${scopeKey}`];
+    for (const entry of entries) {
+        const modeSuffix = entry.mode ? `:${entry.mode}` : "";
+        lines.push(`  ${entry.flowId}${modeSuffix}: ${formatState(entry.state)}`);
+        for (const reason of entry.reasons) {
+            lines.push(`    - ${reason}`);
+        }
+        if (entry.nextStep) {
+            lines.push(`    next: ${entry.nextStep}`);
+        }
+    }
+    return lines.join("\n");
+}
 function performFlowReadinessCheck() {
     const scopeKey = getScopeKey();
-    const allEntries = [];
+    const entries = [];
     for (const flowId of BUILT_IN_COMMAND_FLOW_IDS) {
-        const entries = determineFlowReadiness(flowId, scopeKey);
-        allEntries.push(...entries);
-    }
-    const readyCount = allEntries.filter((e) => e.status === "ready").length;
-    const notReadyCount = allEntries.filter((e) => e.status === "not_ready").length;
-    const notConfiguredCount = allEntries.filter((e) => e.status === "not_configured").length;
-    const lines = [];
-    for (const entry of allEntries) {
-        const modeStr = entry.mode ? `:${entry.mode}` : "";
-        const statusStr = entry.status === "ready" ? "✓ ready" : entry.status === "not_configured" ? "⚠ not configured" : "✗ not ready";
-        lines.push(`  ${entry.flowId}${modeStr}: ${statusStr}`);
-        for (const blocker of entry.blockers) {
-            lines.push(`    - ${blocker}`);
-        }
+        entries.push(...determineWorkflowContinuity(flowId, scopeKey));
+    }
+    const summary = buildSummary(entries);
+    const message = buildMessage(summary);
+    const details = buildDetails(scopeKey, entries);
+    const data = {
+        kind: "workflow-continuity",
+        scopeKey,
+        summary,
+        entries,
+    };
+    if (summary.invalidState > 0) {
+        return {
+            status: DoctorStatus.Warn,
+            impact: DoctorImpact.Blocking,
+            message,
+            hint: "Current scope contains invalid workflow artifacts. Regenerate or clean them up before continuing those flows.",
+            details,
+            data,
+        };
+    }
+    if (summary.needsPreviousStage > 0 || summary.notConfigured > 0) {
+        return {
+            status: DoctorStatus.Warn,
+            impact: DoctorImpact.Advisory,
+            message,
+            hint: "These continuity findings describe what can be continued in the current scope and do not affect overall application readiness.",
+            details,
+            data,
+        };
     }
-    const overallStatus = notReadyCount > 0 ? DoctorStatus.Fail : notConfiguredCount > 0 ? DoctorStatus.Warn : DoctorStatus.Ok;
-    const message = `${readyCount} flows ready, ${notReadyCount} not ready, ${notConfiguredCount} not configured`;
     return {
-        status: overallStatus,
+        status: DoctorStatus.Ok,
+        impact: DoctorImpact.Advisory,
         message,
-        details: lines.join("\n"),
+        details,
+        data,
     };
 }
 export const flowReadinessCheck = {
     id: "flow-readiness-01",
     category: CATEGORY.FLOW_READINESS,
-    title: "flow-readiness",
+    title: "workflow-continuity",
     dependencies: ["env-diagnostics-01", "cwd-context-01"],
     execute: async () => {
         const result = performFlowReadinessCheck();
         return {
             id: "flow-readiness-01",
+            impact: result.impact,
             status: result.status,
-            title: "flow-readiness",
+            title: "workflow-continuity",
             message: result.message,
+            ...(result.hint ? { hint: result.hint } : {}),
             details: result.details,
+            data: result.data,
         };
     },
 };

package/dist/doctor/index.js

@@ -1,4 +1,4 @@
-export { DoctorStatus, ReadinessStatus } from "./types.js";
+export { DoctorImpact, DoctorStatus, ReadinessStatus, WorkflowContinuityState } from "./types.js";
 export { CheckRegistry, REGISTRY } from "./registry.js";
 export { DoctorOrchestrator } from "./orchestrator.js";
 export { runDoctorCommand } from "./runner.js";

package/dist/doctor/orchestrator.js

@@ -1,6 +1,5 @@
-import { DoctorStatus, ReadinessStatus } from "./types.js";
+import { DoctorImpact, DoctorStatus, ReadinessStatus } from "./types.js";
 import { REGISTRY } from "./registry.js";
-import { SOFT_CHECK_IDS } from "./checks/cwd-context.js";
 class DoctorOrchestrator {
     async run(checks, filter) {
         let checksToRun;
@@ -35,7 +34,7 @@ class DoctorOrchestrator {
         for (const check of checksToRun) {
             const result = await this.executeCheck(check);
             results.push(result);
-            if (result.status === DoctorStatus.Fail) {
+            if (result.status === DoctorStatus.Fail && result.impact === DoctorImpact.Blocking) {
                 break;
             }
         }
@@ -48,28 +47,40 @@ class DoctorOrchestrator {
     }
     async executeCheck(check) {
         const timeout = check.timeout ?? 30000;
+        let timeoutHandle;
         try {
             const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => reject(new Error(`Check '${check.id}' timed out after ${timeout}ms`)), timeout);
+                timeoutHandle = setTimeout(() => reject(new Error(`Check '${check.id}' timed out after ${timeout}ms`)), timeout);
+                timeoutHandle.unref?.();
             });
             const result = await Promise.race([check.execute(), timeoutPromise]);
-            return result;
+            return {
+                ...result,
+                impact: result.impact ?? check.impact ?? DoctorImpact.Blocking,
+            };
         }
         catch (error) {
             return {
                 id: check.id,
+                impact: check.impact ?? DoctorImpact.Blocking,
                 status: DoctorStatus.Fail,
                 title: check.title,
                 message: error instanceof Error ? error.message : "Unknown error occurred",
                 hint: `Check execution failed: ${check.id}`,
             };
         }
+        finally {
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+        }
     }
     aggregateReadiness(results) {
-        if (results.some((r) => r.status === DoctorStatus.Fail)) {
+        const blockingResults = results.filter((result) => result.impact === DoctorImpact.Blocking);
+        if (blockingResults.some((r) => r.status === DoctorStatus.Fail)) {
             return ReadinessStatus.NotReady;
         }
-        if (results.some((r) => r.status === DoctorStatus.Warn && !SOFT_CHECK_IDS.includes(r.id))) {
+        if (blockingResults.some((r) => r.status === DoctorStatus.Warn)) {
             return ReadinessStatus.ReadyWithWarnings;
         }
         return ReadinessStatus.Ready;

package/dist/doctor/runner.js

@@ -1,4 +1,4 @@
-import { DoctorStatus, ReadinessStatus } from "./types.js";
+import { DoctorImpact, DoctorStatus, ReadinessStatus } from "./types.js";
 import { REGISTRY } from "./registry.js";
 import { DoctorOrchestrator } from "./orchestrator.js";
 import { CATEGORY } from "./checks/category.js";
@@ -17,8 +17,13 @@ const CATEGORY_LABELS = {
     [CATEGORY.SYSTEM]: "System",
     [CATEGORY.EXECUTORS]: "Executors",
     [CATEGORY.ENV_DIAGNOSTICS]: "Environment",
-    [CATEGORY.FLOW_READINESS]: "Flow Readiness",
+    [CATEGORY.FLOW_READINESS]: "Workflow Continuity",
 };
+function formatCheckLine(result) {
+    const icon = STATUS_ICONS[result.status];
+    const impactLabel = result.impact === DoctorImpact.Advisory ? " (advisory)" : "";
+    return `[${icon}] ${result.title}${impactLabel} - ${result.message}`;
+}
 async function runDoctorCommand(args) {
     const jsonMode = args.includes("--json");
     const filter = args.find((arg) => arg !== "--json");
@@ -51,9 +56,7 @@ async function runDoctorCommand(args) {
         console.log(`## ${label}`);
         console.log();
         for (const result of items) {
-            const icon = STATUS_ICONS[result.status];
-            const line = `[${icon}] ${result.title} - ${result.message}`;
-            console.log(line);
+            console.log(formatCheckLine(result));
             if (result.hint) {
                 console.log(`  Hint: ${result.hint}`);
             }
@@ -70,9 +73,7 @@ async function runDoctorCommand(args) {
         console.log(`## ${label}`);
         console.log();
         for (const result of items) {
-            const icon = STATUS_ICONS[result.status];
-            const line = `[${icon}] ${result.title} - ${result.message}`;
-            console.log(line);
+            console.log(formatCheckLine(result));
             if (result.hint) {
                 console.log(`  Hint: ${result.hint}`);
             }

package/dist/doctor/types.js

@@ -4,9 +4,21 @@ export var DoctorStatus;
     DoctorStatus["Warn"] = "warn";
     DoctorStatus["Fail"] = "fail";
 })(DoctorStatus || (DoctorStatus = {}));
+export var DoctorImpact;
+(function (DoctorImpact) {
+    DoctorImpact["Blocking"] = "blocking";
+    DoctorImpact["Advisory"] = "advisory";
+})(DoctorImpact || (DoctorImpact = {}));
 export var ReadinessStatus;
 (function (ReadinessStatus) {
     ReadinessStatus["Ready"] = "ready";
     ReadinessStatus["ReadyWithWarnings"] = "ready_with_warnings";
     ReadinessStatus["NotReady"] = "not_ready";
 })(ReadinessStatus || (ReadinessStatus = {}));
+export var WorkflowContinuityState;
+(function (WorkflowContinuityState) {
+    WorkflowContinuityState["Available"] = "available";
+    WorkflowContinuityState["NeedsPreviousStage"] = "needs_previous_stage";
+    WorkflowContinuityState["NotConfigured"] = "not_configured";
+    WorkflowContinuityState["InvalidState"] = "invalid_state";
+})(WorkflowContinuityState || (WorkflowContinuityState = {}));