agentweaver 0.1.15 → 0.1.17

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

@@ -4,7 +4,8 @@ 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, jiraDescriptionJsonFile, latestArtifactIteration, planJsonFile, } 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) {
@@ -84,19 +85,15 @@ function checkStructuredArtifactFile(entry, artifactPath, schemaId, missingReaso
 }
 function checkImplementWorkflowContinuity(scopeKey) {
     const entry = createEntry("implement");
-    const latestDesignIteration = getLatestJsonArtifactIteration(scopeKey, "design");
-    const latestPlanIteration = getLatestJsonArtifactIteration(scopeKey, "plan");
-    if (latestDesignIteration === null) {
-        setEntryState(entry, WorkflowContinuityState.NeedsPreviousStage, "Missing design artifact from the planning stage.");
+    const planningBundle = inspectLatestPlanningBundle(scopeKey);
+    if (planningBundle.status === "missing") {
+        setEntryState(entry, WorkflowContinuityState.NeedsPreviousStage, planningBundle.errorMessage);
     }
-    else {
-        checkStructuredArtifactFile(entry, designJsonFile(scopeKey, latestDesignIteration), "implementation-design/v1", "Missing design artifact from the planning stage.", "Design artifact schema is invalid");
+    else if (planningBundle.status === "incomplete") {
+        setEntryState(entry, WorkflowContinuityState.InvalidState, planningBundle.errorMessage);
     }
-    if (latestPlanIteration === null) {
-        setEntryState(entry, WorkflowContinuityState.NeedsPreviousStage, "Missing plan artifact from the planning stage.");
-    }
-    else {
-        checkStructuredArtifactFile(entry, planJsonFile(scopeKey, latestPlanIteration), "implementation-plan/v1", "Missing plan artifact from the planning stage.", "Plan artifact schema is invalid");
+    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.";
@@ -154,18 +151,18 @@ function checkPlanJiraWorkflowContinuity(scopeKey) {
 }
 function checkPlanProjectWorkflowContinuity(scopeKey) {
     const entry = createEntry("plan", "project");
-    const latestDescriptionIteration = getLatestJsonArtifactIteration(scopeKey, "jira-description");
-    if (latestDescriptionIteration === null) {
-        setEntryState(entry, WorkflowContinuityState.NeedsPreviousStage, "Missing task description artifact from task-describe.");
+    const latestTaskContextIteration = getLatestJsonArtifactIteration(scopeKey, "task-context");
+    if (latestTaskContextIteration === null) {
+        setEntryState(entry, WorkflowContinuityState.NeedsPreviousStage, "Missing normalized task-context artifact.");
     }
     else {
-        checkStructuredArtifactFile(entry, jiraDescriptionJsonFile(scopeKey, latestDescriptionIteration), "jira-description/v1", "Missing task description artifact from task-describe.", "Task description artifact schema is invalid");
+        checkStructuredArtifactFile(entry, taskContextJsonFile(scopeKey, latestTaskContextIteration), "task-context/v1", "Missing normalized task-context artifact.", "Task-context artifact schema is invalid");
     }
     if (entry.state === WorkflowContinuityState.NeedsPreviousStage) {
-        entry.nextStep = "Run task-describe first to create a task description artifact for this scope.";
+        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 description artifact before running plan:project.";
+        entry.nextStep = "Regenerate the task-context artifact before running plan:project.";
     }
     return entry;
 }

package/dist/flow-state.js

@@ -1,16 +1,45 @@
+import { randomUUID } from "node:crypto";
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { ensureScopeWorkspaceDir, flowStateFile } from "./artifacts.js";
 import { TaskRunnerError } from "./errors.js";
-const FLOW_STATE_SCHEMA_VERSION = 1;
+import { isFlowRunResumeEnvelope } from "./pipeline/flow-run-resume.js";
+import { resolveStoredExecutionRoutingSnapshot, singleLaunchProfileExecutionRouting } from "./runtime/execution-routing.js";
+const FLOW_STATE_SCHEMA_VERSION = 3;
+const CONTINUABLE_FLOW_KINDS = new Set([
+    "design-review-loop-flow",
+    "review-loop-flow",
+    "review-project-loop-flow",
+    "run-go-linter-loop-flow",
+    "run-go-tests-loop-flow",
+]);
+const CONTINUABLE_PARENT_FLOW_IDS = new Set([
+    "auto-common",
+    "auto-simple",
+    "auto-golang",
+    "instant-task",
+]);
+const CONTINUABLE_DIRECT_FLOW_IDS = new Set([
+    "review-loop",
+    "run-go-linter-loop",
+    "run-go-tests-loop",
+]);
 function nowIso8601() {
     return new Date().toISOString();
 }
+function ensurePublicationRunId(executionState) {
+    executionState.publicationRunId ??= randomUUID();
+    return executionState.publicationRunId;
+}
 export function stripExecutionStatePayload(executionState) {
+    ensurePublicationRunId(executionState);
     return {
+        ...(executionState.runId ? { runId: executionState.runId } : {}),
+        ...(executionState.publicationRunId ? { publicationRunId: executionState.publicationRunId } : {}),
         flowKind: executionState.flowKind,
         flowVersion: executionState.flowVersion,
         terminated: executionState.terminated,
         ...(executionState.terminationReason ? { terminationReason: executionState.terminationReason } : {}),
+        ...(executionState.terminationOutcome ? { terminationOutcome: executionState.terminationOutcome } : {}),
         phases: executionState.phases.map((phase) => ({
             id: phase.id,
             status: phase.status,
@@ -22,6 +51,7 @@ export function stripExecutionStatePayload(executionState) {
                 status: step.status,
                 ...(step.outputs ? { outputs: step.outputs } : {}),
                 ...(step.value !== undefined ? { value: step.value } : {}),
+                ...(step.publishedArtifacts ? { publishedArtifacts: step.publishedArtifacts } : {}),
                 ...(step.startedAt ? { startedAt: step.startedAt } : {}),
                 ...(step.finishedAt ? { finishedAt: step.finishedAt } : {}),
                 ...(step.stopFlow !== undefined ? { stopFlow: step.stopFlow } : {}),
@@ -29,7 +59,11 @@ export function stripExecutionStatePayload(executionState) {
         })),
     };
 }
-export function createFlowRunState(scopeKey, flowId, executionState, jiraRef, launchProfile) {
+export function createFlowRunState(scopeKey, flowId, executionState, jiraRef, launchProfile, executionRouting, selectedRoutingPreset) {
+    ensurePublicationRunId(executionState);
+    const effectiveExecutionRouting = executionRouting ?? (launchProfile ? singleLaunchProfileExecutionRouting(launchProfile) : undefined);
+    const effectiveLaunchProfile = launchProfile ?? effectiveExecutionRouting?.defaultRoute;
+    const continuation = inferContinuationMetadata(flowId, executionState);
     return {
         schemaVersion: FLOW_STATE_SCHEMA_VERSION,
         flowId,
@@ -38,10 +72,98 @@ export function createFlowRunState(scopeKey, flowId, executionState, jiraRef, la
         status: "pending",
         currentStep: null,
         updatedAt: nowIso8601(),
-        ...(launchProfile ? { launchProfile } : {}),
+        ...(effectiveLaunchProfile ? { launchProfile: effectiveLaunchProfile } : {}),
+        ...(effectiveExecutionRouting ? { executionRouting: effectiveExecutionRouting, routingFingerprint: effectiveExecutionRouting.fingerprint } : {}),
+        ...(selectedRoutingPreset ? { selectedRoutingPreset } : {}),
+        continuation,
         executionState: stripExecutionStatePayload(executionState),
     };
 }
+function upgradeFlowRunStateV1(state) {
+    const executionRouting = state.launchProfile ? singleLaunchProfileExecutionRouting(state.launchProfile) : undefined;
+    return {
+        ...state,
+        schemaVersion: FLOW_STATE_SCHEMA_VERSION,
+        ...(executionRouting ? { executionRouting, routingFingerprint: executionRouting.fingerprint } : {}),
+        ...(executionRouting ? { selectedRoutingPreset: { kind: "custom", label: "Legacy launch profile" } } : {}),
+        continuation: {
+            continueEligible: false,
+        },
+    };
+}
+function upgradeFlowRunStateV2(state) {
+    return {
+        ...state,
+        schemaVersion: FLOW_STATE_SCHEMA_VERSION,
+        continuation: {
+            continueEligible: false,
+        },
+    };
+}
+function parseTerminationLocation(terminationReason) {
+    if (typeof terminationReason !== "string") {
+        return {};
+    }
+    const match = /^Stopped by ([^:]+):(.+)$/.exec(terminationReason.trim());
+    if (!match) {
+        return {};
+    }
+    const stopPhaseId = match[1];
+    const stopStepId = match[2];
+    return {
+        ...(stopPhaseId ? { stopPhaseId } : {}),
+        ...(stopStepId ? { stopStepId } : {}),
+    };
+}
+function inferContinuationMetadata(flowId, executionState) {
+    const stopLocation = parseTerminationLocation(executionState.terminationReason);
+    const continueEligible = CONTINUABLE_FLOW_KINDS.has(executionState.flowKind)
+        || (CONTINUABLE_PARENT_FLOW_IDS.has(flowId) && Boolean(stopLocation.stopPhaseId && stopLocation.stopStepId));
+    return {
+        continueEligible,
+        ...(stopLocation.stopPhaseId ? { stopPhaseId: stopLocation.stopPhaseId } : {}),
+        ...(stopLocation.stopStepId ? { stopStepId: stopLocation.stopStepId } : {}),
+    };
+}
+function normalizeFlowRunState(raw, flowId, filePath) {
+    if (!raw || typeof raw !== "object") {
+        throw new TaskRunnerError(`Invalid flow state file format: ${filePath}`);
+    }
+    const schemaVersion = raw.schemaVersion;
+    let state;
+    if (schemaVersion === 1) {
+        state = upgradeFlowRunStateV1(raw);
+    }
+    else if (schemaVersion === 2) {
+        state = upgradeFlowRunStateV2(raw);
+    }
+    else if (schemaVersion === FLOW_STATE_SCHEMA_VERSION) {
+        state = raw;
+    }
+    else {
+        throw new TaskRunnerError(`Unsupported flow state schema in ${filePath}: ${String(schemaVersion ?? "unknown")}`);
+    }
+    if (state.flowId !== flowId) {
+        throw new TaskRunnerError(`Flow state ${filePath} belongs to flow '${state.flowId}', expected '${flowId}'`);
+    }
+    if (state.executionRouting) {
+        const executionRouting = resolveStoredExecutionRoutingSnapshot(state.executionRouting);
+        state.executionRouting = executionRouting;
+        state.routingFingerprint = executionRouting.fingerprint;
+        state.launchProfile = executionRouting.defaultRoute;
+    }
+    else if (state.launchProfile) {
+        const executionRouting = singleLaunchProfileExecutionRouting(state.launchProfile);
+        state.executionRouting = executionRouting;
+        state.routingFingerprint = executionRouting.fingerprint;
+    }
+    const inferredContinuation = inferContinuationMetadata(state.flowId, state.executionState);
+    state.continuation = {
+        ...inferredContinuation,
+        continueEligible: inferredContinuation.continueEligible && state.continuation?.continueEligible !== false,
+    };
+    return state;
+}
 export function loadFlowRunState(scopeKey, flowId) {
     const filePath = flowStateFile(scopeKey, flowId);
     if (!existsSync(filePath)) {
@@ -54,20 +176,21 @@ export function loadFlowRunState(scopeKey, flowId) {
     catch (error) {
         throw new TaskRunnerError(`Failed to parse flow state file ${filePath}: ${error.message}`);
     }
-    if (!raw || typeof raw !== "object") {
-        throw new TaskRunnerError(`Invalid flow state file format: ${filePath}`);
-    }
-    const state = raw;
-    if (state.schemaVersion !== FLOW_STATE_SCHEMA_VERSION) {
-        throw new TaskRunnerError(`Unsupported flow state schema in ${filePath}: ${state.schemaVersion}`);
-    }
-    if (state.flowId !== flowId) {
-        throw new TaskRunnerError(`Flow state ${filePath} belongs to flow '${state.flowId}', expected '${flowId}'`);
-    }
-    return state;
+    return normalizeFlowRunState(raw, flowId, filePath);
 }
 export function saveFlowRunState(state) {
     state.updatedAt = nowIso8601();
+    state.schemaVersion = FLOW_STATE_SCHEMA_VERSION;
+    if (state.executionRouting) {
+        state.executionRouting = resolveStoredExecutionRoutingSnapshot(state.executionRouting);
+        state.routingFingerprint = state.executionRouting.fingerprint;
+        state.launchProfile = state.executionRouting.defaultRoute;
+    }
+    else if (state.launchProfile) {
+        state.executionRouting = singleLaunchProfileExecutionRouting(state.launchProfile);
+        state.routingFingerprint = state.executionRouting.fingerprint;
+    }
+    state.continuation = inferContinuationMetadata(state.flowId, state.executionState);
     ensureScopeWorkspaceDir(state.scopeKey);
     writeFileSync(flowStateFile(state.scopeKey, state.flowId), `${JSON.stringify({
         ...state,
@@ -97,14 +220,63 @@ export function hasResumableFlowState(state) {
     }
     return state.executionState.phases.some((phase) => phase.steps.some((step) => step.status === "done" || step.status === "running"));
 }
+function hasContinuableFlowState(state) {
+    if (!state) {
+        return false;
+    }
+    if (!state.executionState.terminated && state.status !== "completed") {
+        return false;
+    }
+    return state.continuation?.continueEligible === true;
+}
+export function classifyFlowLaunchAvailability(state) {
+    if (!state) {
+        return {
+            hasExistingState: false,
+            requiresExplicitChoice: false,
+            resume: { available: false, reason: "No saved state found." },
+            continue: { available: false, reason: "No saved state found." },
+            restart: { available: true, reason: "Start a fresh attempt." },
+        };
+    }
+    const resumeAvailable = hasResumableFlowState(state);
+    const continueAvailable = hasContinuableFlowState(state);
+    const availability = {
+        hasExistingState: true,
+        requiresExplicitChoice: resumeAvailable || continueAvailable,
+        resume: resumeAvailable
+            ? { available: true, reason: "Continue the interrupted execution state." }
+            : {
+                available: false,
+                reason: state.executionState.terminated || state.status === "completed"
+                    ? "The saved run already terminated and cannot be resumed."
+                    : "The saved state is not resumable.",
+            },
+        continue: continueAvailable
+            ? { available: true, reason: "Start the next iteration from the latest active artifacts." }
+            : {
+                available: false,
+                reason: state.schemaVersion < FLOW_STATE_SCHEMA_VERSION
+                    ? "Legacy flow state lacks safe continuation metadata."
+                    : "The saved run does not expose a continuable loop boundary.",
+            },
+        restart: {
+            available: true,
+            reason: "Archive the active attempt and start a fresh run.",
+        },
+    };
+    return availability;
+}
 function normalizeStepState(step) {
     if (step.status !== "running") {
         return step;
     }
-    const { finishedAt: _finishedAt, outputs: _outputs, value: _value, stopFlow: _stopFlow, ...rest } = step;
+    const resumeValue = isFlowRunResumeEnvelope(step.value) ? step.value : undefined;
+    const { finishedAt: _finishedAt, outputs: _outputs, value: _value, publishedArtifacts: _publishedArtifacts, stopFlow: _stopFlow, ...rest } = step;
     return {
         ...rest,
         status: "pending",
+        ...(resumeValue ? { value: resumeValue } : {}),
     };
 }
 function normalizePhaseState(phase) {
@@ -171,9 +343,34 @@ export function prepareFlowStateForResume(state) {
     state.currentStep = null;
     state.executionState = {
         ...state.executionState,
+        publicationRunId: randomUUID(),
         terminated: false,
         phases: state.executionState.phases.map(normalizePhaseState),
     };
     delete state.executionState.terminationReason;
     return state;
 }
+export function prepareFlowStateForContinue(state, orderedPhases) {
+    state.status = "pending";
+    state.lastError = null;
+    state.currentStep = null;
+    const flowKind = state.executionState.flowKind;
+    if (CONTINUABLE_FLOW_KINDS.has(flowKind) || CONTINUABLE_DIRECT_FLOW_IDS.has(state.flowId)) {
+        state.executionState = {
+            ...state.executionState,
+            publicationRunId: randomUUID(),
+            terminated: false,
+            phases: orderedPhases.map(createPendingPhaseState),
+        };
+        delete state.executionState.terminationReason;
+        delete state.executionState.terminationOutcome;
+        return state;
+    }
+    const targetPhaseId = state.continuation?.stopPhaseId ?? parseTerminationLocation(state.executionState.terminationReason).stopPhaseId;
+    if (!targetPhaseId) {
+        throw new TaskRunnerError("Continue is impossible because the stop phase could not be determined safely. Use restart.");
+    }
+    rewindFlowRunStateToPhase(state, orderedPhases, targetPhaseId);
+    state.executionState.publicationRunId = randomUUID();
+    return state;
+}