agentweaver 0.1.15 → 0.1.16

package/README.md

@@ -10,7 +10,7 @@ Typical usage looks like:
 
 The important part is not that exact chain. The point is that AgentWeaver lets you design, operate, and evolve durable agent harnesses instead of accumulating one-off prompts and shell glue.
 
-Для planning-heavy задач типовой путь теперь может включать и `plan -> design-review -> implement`, где `design-review` проверяет качество артефактов планирования до начала кодинга.
+For planning-heavy work, a typical path can now include `plan -> design-review -> implement`, where `design-review` critiques planning artifacts before coding starts.
 
 ## What It Does
 
@@ -62,7 +62,7 @@ This keeps workflow design in JSON while keeping implementation details in typed
 - `src/pipeline/` — declarative flow loading, compilation, validation, runtime, and built-in flow specs
 - `src/pipeline/nodes/` — reusable runtime nodes used by flow specs
 - `src/runtime/` — shared runtime services such as command resolution and subprocess execution
-- `src/interactive-ui.ts` — full-screen interactive UI
+- `src/interactive/` — Ink-based interactive session, controller, state, and view-model logic
 - `src/markdown.ts` — markdown rendering for terminal output
 - `src/structured-artifact-schemas.json` — schemas for machine-readable artifacts
 - `tests/` — automated tests for pipeline behavior
@@ -72,7 +72,7 @@ This keeps workflow design in JSON while keeping implementation details in typed
 User-invokable built-in commands currently map to these flow specs:
 
 - `plan` — fetches Jira task with attachments, generates clarifying questions for the developer, collects answers, and produces design, implementation plan, and QA plan as structured JSON and markdown artifacts
-- `design-review` — выполняет структурированную критику planning artifacts и пишет dedicated artifact `design-review/v1`; статус `approved_with_warnings` считается ready-to-proceed и по-прежнему допускает `ready-to-merge.md`
+- `design-review` — performs a structured critique of the latest planning artifacts and writes a dedicated `design-review/v1` artifact; `approved_with_warnings` is treated as ready to proceed and may still produce `ready-to-merge.md`
 - `task-describe` — generates a brief task description from a Jira issue or from manual input; when Jira is provided, fetches the issue and summarizes it; otherwise accepts free-form text and analyzes the codebase to produce a richer description
 - `implement` — runs LLM-backed implementation based on previously approved design and plan artifacts; executes code changes locally in the project working directory
 - `review` — performs code review of current changes against the task design and plan; produces structured review findings with severity levels and a ready-to-merge verdict
@@ -87,7 +87,8 @@ User-invokable built-in commands currently map to these flow specs:
 - `run-go-tests-loop` — runs `run_go_tests.py` and analyzes failures; if tests fail, sends the error output to LLM for a fix and retries; repeats up to 5 attempts, stopping early on success
 - `run-go-linter-loop` — runs `run_go_linter.py` and analyzes output; if the linter reports issues, sends them to LLM for a fix and retries; repeats up to 5 attempts, stopping early on success
 - `auto-golang` — end-to-end resumable pipeline for Go projects: plan → implement → linter loop → test loop → review loop → final linter loop → final test loop; supports `--from` to restart from a specific phase and `auto-status`/`auto-reset` for state management
-- `auto-common` — end-to-end resumable pipeline without language-specific checks: plan → implement → review loop; simplified alternative to auto-golang for projects that do not need Go linter/test loops
+- `auto-common` — planning-aware pipeline with a mandatory design-review gate before implementation: plan → design-review loop → implement → review loop; design-review can iterate with `plan-revise` up to 3 times, and if the final verdict still requires revision the operator must explicitly choose whether to continue with the latest planning artifacts or stop
+- `auto-simple` — preserved simplified pipeline equivalent to the legacy auto-common behavior: plan → implement → review loop; no planning review gate, suitable for projects that do not need design review before coding
 - `doctor` — diagnostics command that runs system, executor, and flow readiness health checks; supports filtering by category or check ID and JSON output
 
 There are also built-in nested/helper flows that are loaded declaratively but are not direct top-level CLI commands, for example `review-project` (project-level code review used internally when no prior design/plan artifacts are present).
@@ -220,6 +221,7 @@ agentweaver run-go-tests-loop DEMO-1234
 agentweaver run-go-linter-loop DEMO-1234
 agentweaver auto-golang DEMO-1234
 agentweaver auto-common DEMO-1234
+agentweaver auto-simple DEMO-1234
 agentweaver doctor
 agentweaver doctor --json
 agentweaver doctor <category>|<check-id>
@@ -243,6 +245,7 @@ agentweaver --help
 agentweaver --version
 agentweaver auto-golang --help-phases
 agentweaver auto-common --help-phases
+agentweaver auto-simple --help-phases
 agentweaver auto-golang --from <phase> DEMO-1234
 agentweaver auto-status DEMO-1234
 agentweaver auto-reset DEMO-1234
@@ -257,13 +260,13 @@ Notes:
 - `--prompt <text>` appends extra instructions to the prompt
 - `--scope <name>` is supported by scope-flexible flows such as `implement`, `review`, `review-fix`, `review-loop`, `run-go-tests-loop`, `run-go-linter-loop`, `gitlab-review`, and `gitlab-diff-review`
 - `--md-lang <en|ru>` currently applies to `plan`
-- `--force` only affects interactive mode and forces regeneration of task summary in Jira-backed flows
+- `--force` only affects interactive mode: it skips loading cached summary-pane content on startup so Jira-backed flows that regenerate summary artifacts can repopulate it during the run
 - Jira-backed flows ask for Jira input interactively when it is omitted
 - `task-describe` can also work from manual task description input without Jira
 - `gitlab-review` and `gitlab-diff-review` ask for a GitLab merge request URL interactively
 - `auto-status` and `auto-reset` currently operate on persisted state for `auto-golang`
 
-## `auto-golang` and `auto-common`
+## `auto-golang`, `auto-common`, and `auto-simple`
 
 `auto-golang` is the main resumable end-to-end automation flow. It stores persisted execution state and supports:
 
@@ -273,7 +276,9 @@ Notes:
 - reset via `auto-reset`
 - resume validation against saved launch profile and required artifacts
 
-`auto-common` is a separate built-in automation flow with its own phase list, but it does not currently have dedicated `auto-status` or `auto-reset` commands.
+`auto-common` is the planning-aware built-in automation flow. After `plan`, it runs a `design-review` loop and blocks implementation until the verdict is `approved` or `approved_with_warnings`. When the verdict is `needs_revision`, it runs `plan-revise` and then another `design-review`, for up to 3 design-review iterations total. If the final verdict still requires revision, the pipeline asks the operator whether to continue with the latest planning artifacts or stop before `implement`.
+
+`auto-simple` is the preserved simplified pipeline: `plan → implement → review loop`, with no planning review gate and no revise rounds. It is behaviorally equivalent to the legacy `auto-common` before the planning gate was introduced.
 
 ## Launch Profiles and Resume
 
@@ -300,7 +305,12 @@ The runtime uses artifacts as the contract between stages, including markdown ou
 
 ## Interactive TUI
 
-Running without a command opens the full-screen TUI. It acts as the operator console for the harness: browsing flows, launching them in scope, following activity, and reviewing summaries.
+Running without a command opens the full-screen TUI. It acts as the operator console for the harness: browsing flows, launching them in scope, following current execution, and reviewing summaries.
+
+Interactive mode is Ink-only. It requires:
+
+- a real TTY for both stdin and stdout
+- installed runtime dependencies from `npm install`
 
 Current navigation:
 
@@ -308,10 +318,17 @@ Current navigation:
 - `Left` / `Right` — collapse or expand folders
 - `Enter` — toggle folder or run selected flow
 - `Tab` / `Shift+Tab` — switch panes
-- `PgUp` / `PgDn` / `Home` / `End` — scroll focused pane
+- `PgUp` / `PgDn` — scroll focused pane
 - `h` — open help
 - `q` or `Ctrl+C` — exit
 
+Current layout:
+
+- left column: `Flows`, `Flow Description`, `Status`
+- right column: `Current Flow`, optional `Task Summary`, `Activity`
+- `Current Flow` is intentionally tall and scrollable; in the current layout it uses the same height budget as `Flows`
+- the `Task Summary` pane is runtime-driven and shows whichever markdown artifact the active flow publishes into summary state, such as a normalized task context or a cached task summary
+
 Flow discovery behavior:
 
 - built-in flows are loaded from `src/pipeline/flow-specs/`

package/dist/artifact-manifest.js

@@ -0,0 +1,219 @@
+import path from "node:path";
+import { TaskRunnerError } from "./errors.js";
+import { validateStructuredArtifactValue } from "./structured-artifacts.js";
+export const ARTIFACT_MANIFEST_SCHEMA_ID = "artifact-manifest/v1";
+export const ARTIFACT_MANIFEST_SCHEMA_VERSION = 1;
+export const ARTIFACT_LIFECYCLE_STATUSES = ["ready", "superseded", "stale"];
+export const ARTIFACT_PAYLOAD_FAMILIES = [
+    "structured-json",
+    "markdown",
+    "plain-text",
+    "helper-json",
+    "opaque-file",
+];
+const STRUCTURED_JSON_SCHEMAS_BY_PREFIX = [
+    { prefix: "bug-analyze-", schemaId: "bug-analysis/v1" },
+    { prefix: "bug-fix-design-", schemaId: "bug-fix-design/v1" },
+    { prefix: "bug-fix-plan-", schemaId: "bug-fix-plan/v1" },
+    { prefix: "design-review-", schemaId: "design-review/v1" },
+    { prefix: "design-", schemaId: "implementation-design/v1" },
+    { prefix: "gitlab-diff-", schemaId: "gitlab-mr-diff/v1" },
+    { prefix: "gitlab-review-", schemaId: "gitlab-review/v1" },
+    { prefix: "jira-description-", schemaId: "jira-description/v1" },
+    { prefix: "mr-description-", schemaId: "mr-description/v1" },
+    { prefix: "plan-", schemaId: "implementation-plan/v1" },
+    { prefix: "planning-questions-", schemaId: "planning-questions/v1" },
+    { prefix: "qa-", schemaId: "qa-plan/v1" },
+    { prefix: "review-assessment-", schemaId: "review-assessment/v1" },
+    { prefix: "review-fix-", schemaId: "review-fix-report/v1" },
+    { prefix: "review-", schemaId: "review-findings/v1" },
+    { prefix: "task-context-", schemaId: "task-context/v1" },
+    { prefix: "task-", schemaId: "task-summary/v1" },
+];
+const LOGICAL_KEY_PATTERN = "^[a-z0-9][a-z0-9._/-]*$";
+const CONTENT_HASH_PATTERN = "^sha256:[a-f0-9]{64}$";
+const ARTIFACT_ID_PATTERN = /^(?<scope>.+):(?<logicalKey>[a-z0-9][a-z0-9._/-]*):v(?<version>[1-9]\d*)$/;
+const LOGICAL_REF_PATTERN = /^(?<logicalKey>[a-z0-9][a-z0-9._/-]*)@(?<selector>latest|v[1-9]\d*)$/;
+export function parseSchemaVersion(schemaId) {
+    const match = /\/v(\d+)$/.exec(schemaId);
+    return match ? Number.parseInt(match[1] ?? "1", 10) : 1;
+}
+function normalizePathSeparators(value) {
+    return value.replace(/\\/g, "/");
+}
+function removeScopeSuffix(baseName, scopeKey) {
+    if (!scopeKey) {
+        return baseName;
+    }
+    const ext = path.extname(baseName);
+    const stem = ext ? baseName.slice(0, -ext.length) : baseName;
+    const escapedScope = scopeKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const patterns = [
+        new RegExp(`-${escapedScope}-iter-\\d+$`),
+        new RegExp(`-${escapedScope}-\\d+$`),
+        new RegExp(`-${escapedScope}$`),
+    ];
+    for (const pattern of patterns) {
+        if (pattern.test(stem)) {
+            return `${stem.replace(pattern, "")}${ext}`;
+        }
+    }
+    if (stem === scopeKey) {
+        return `scope${ext}`;
+    }
+    return baseName;
+}
+export function buildLogicalKeyForPayload(scopeKey, payloadPath) {
+    const normalized = normalizePathSeparators(payloadPath);
+    const normalizedScopeKey = typeof scopeKey === "string" && scopeKey.trim().length > 0 ? scopeKey : null;
+    const scopeMarker = normalizedScopeKey
+        ? normalizePathSeparators(`/.agentweaver/scopes/${normalizedScopeKey}/`)
+        : null;
+    const markerIndex = scopeMarker ? normalized.lastIndexOf(scopeMarker) : -1;
+    const artifactsMarker = normalizePathSeparators("/.artifacts/");
+    const artifactsIndex = normalized.lastIndexOf(artifactsMarker);
+    const relative = markerIndex >= 0 && scopeMarker
+        ? normalized.slice(markerIndex + scopeMarker.length)
+        : artifactsIndex >= 0
+            ? normalized.slice(artifactsIndex + 1)
+            : path.basename(normalized);
+    const directory = path.posix.dirname(relative);
+    const baseName = path.posix.basename(relative);
+    const normalizedBaseName = removeScopeSuffix(baseName, normalizedScopeKey)
+        .replace(/-\d+(?=\.[^.]+$)/, "")
+        .replace(/[^a-zA-Z0-9._/-]+/g, "-")
+        .replace(/-+/g, "-")
+        .toLowerCase();
+    const combined = directory === "." ? normalizedBaseName : `${directory}/${normalizedBaseName}`;
+    return combined.replace(/^\.artifacts\//, "artifacts/");
+}
+export function buildPublicationKey(input) {
+    return `${input.publicationRunId ?? input.runId}:${input.flowId}:${input.phaseId}:${input.stepId}:${input.logicalKey}`;
+}
+export function buildArtifactId(scopeKey, logicalKey, version) {
+    return `${scopeKey}:${logicalKey}:v${version}`;
+}
+export function parseArtifactId(value) {
+    const match = ARTIFACT_ID_PATTERN.exec(value);
+    if (!match?.groups) {
+        return null;
+    }
+    const scopeKey = match.groups.scope;
+    const logicalKey = match.groups.logicalKey;
+    const versionText = match.groups.version;
+    if (!scopeKey || !logicalKey || !versionText) {
+        return null;
+    }
+    return {
+        scopeKey,
+        logicalKey,
+        version: Number.parseInt(versionText, 10),
+    };
+}
+export function parseArtifactReference(value) {
+    const parsedId = parseArtifactId(value);
+    if (parsedId) {
+        return {
+            kind: "artifact-id",
+            artifactId: value,
+            parsedId,
+        };
+    }
+    const match = LOGICAL_REF_PATTERN.exec(value);
+    if (!match?.groups) {
+        return null;
+    }
+    const logicalKey = match.groups.logicalKey;
+    const selector = match.groups.selector;
+    if (!logicalKey || !selector) {
+        return null;
+    }
+    return {
+        kind: "logical-ref",
+        logicalKey,
+        version: selector === "latest" ? "latest" : Number.parseInt(selector.slice(1), 10),
+    };
+}
+export function inferPayloadContract(scopeKey, payloadPath, override) {
+    if (override?.payloadFamily && override.schemaId && override.schemaVersion) {
+        return {
+            payloadFamily: override.payloadFamily,
+            schemaId: override.schemaId,
+            schemaVersion: override.schemaVersion,
+        };
+    }
+    const baseName = path.basename(payloadPath);
+    if (override?.schemaId) {
+        return {
+            payloadFamily: override.payloadFamily ?? "structured-json",
+            schemaId: override.schemaId,
+            schemaVersion: override.schemaVersion ?? parseSchemaVersion(override.schemaId),
+        };
+    }
+    if (payloadPath.endsWith(".json")) {
+        if (baseName === `${scopeKey}.json` || baseName === `${scopeKey}-enriched.json`) {
+            return { payloadFamily: "helper-json", schemaId: "helper-json/v1", schemaVersion: 1 };
+        }
+        if (baseName.startsWith("jira-attachments-")) {
+            return { payloadFamily: "helper-json", schemaId: "helper-json/v1", schemaVersion: 1 };
+        }
+        if (baseName.startsWith("planning-answers-")) {
+            return { payloadFamily: "structured-json", schemaId: "user-input/v1", schemaVersion: 1 };
+        }
+        if (baseName.startsWith("instant-task-input-")) {
+            return { payloadFamily: "structured-json", schemaId: "user-input/v1", schemaVersion: 1 };
+        }
+        for (const candidate of STRUCTURED_JSON_SCHEMAS_BY_PREFIX) {
+            if (baseName.startsWith(candidate.prefix)) {
+                return {
+                    payloadFamily: "structured-json",
+                    schemaId: candidate.schemaId,
+                    schemaVersion: parseSchemaVersion(candidate.schemaId),
+                };
+            }
+        }
+        return { payloadFamily: "helper-json", schemaId: "helper-json/v1", schemaVersion: 1 };
+    }
+    if (payloadPath.endsWith(".md")) {
+        return { payloadFamily: "markdown", schemaId: "markdown/v1", schemaVersion: 1 };
+    }
+    if (payloadPath.endsWith(".txt")) {
+        return { payloadFamily: "plain-text", schemaId: "plain-text/v1", schemaVersion: 1 };
+    }
+    return { payloadFamily: "opaque-file", schemaId: "opaque-file/v1", schemaVersion: 1 };
+}
+export function createProducerSummary(input) {
+    const parts = [input.node];
+    if (input.executor) {
+        parts.push(`via ${input.executor}`);
+    }
+    if (input.model) {
+        parts.push(`model ${input.model}`);
+    }
+    return parts.join(" ");
+}
+export function validateArtifactManifest(manifest, label = "$") {
+    validateStructuredArtifactValue(manifest, ARTIFACT_MANIFEST_SCHEMA_ID, label);
+    if (!new RegExp(LOGICAL_KEY_PATTERN).test(manifest.logical_key)) {
+        throw new TaskRunnerError(`Structured artifact ${label} failed schema ${ARTIFACT_MANIFEST_SCHEMA_ID} validation:\n${label}.logical_key must be a string with the expected format`);
+    }
+    if (!new RegExp(CONTENT_HASH_PATTERN).test(manifest.content_hash)) {
+        throw new TaskRunnerError(`Structured artifact ${label} failed schema ${ARTIFACT_MANIFEST_SCHEMA_ID} validation:\n${label}.content_hash must be a string with the expected format`);
+    }
+}
+export function diagnosticsForManifest(manifest, validatePayload) {
+    try {
+        validatePayload(manifest.schema_id, manifest.payload_path);
+        return [];
+    }
+    catch (error) {
+        const message = error.message;
+        return [
+            {
+                code: message.includes("not registered") ? "missing-schema" : "invalid-schema",
+                severity: "error",
+                message,
+            },
+        ];
+    }
+}

package/dist/artifacts.js

@@ -24,6 +24,12 @@ export function scopeArtifactsDir(scopeKey) {
 export function scopeArtifactsFile(scopeKey, fileName) {
     return path.join(scopeArtifactsDir(scopeKey), fileName);
 }
+export function artifactManifestSidecarPath(payloadPath) {
+    return `${payloadPath}.manifest.json`;
+}
+export function artifactIndexFile(scopeKey) {
+    return scopeArtifactsFile(scopeKey, "artifact-index.json");
+}
 export function taskWorkspaceDir(taskKey) {
     return scopeWorkspaceDir(taskKey);
 }
@@ -151,9 +157,18 @@ export function jiraDescriptionFile(taskKey, iteration) {
 export function jiraDescriptionJsonFile(taskKey, iteration) {
     return versionedJsonArtifactFile(taskKey, "jira-description", iteration);
 }
+export function taskContextFile(taskKey, iteration) {
+    return versionedMarkdownArtifactFile(taskKey, "task-context", iteration);
+}
+export function taskContextJsonFile(taskKey, iteration) {
+    return versionedJsonArtifactFile(taskKey, "task-context", iteration);
+}
 export function taskDescribeInputJsonFile(taskKey) {
     return taskArtifactsFile(taskKey, `task-describe-input-${taskKey}.json`);
 }
+export function instantTaskInputJsonFile(taskKey) {
+    return taskArtifactsFile(taskKey, `instant-task-input-${taskKey}.json`);
+}
 export function gitStatusJsonFile(taskKey) {
     return taskArtifactsFile(taskKey, `git-status-${taskKey}.json`);
 }

package/dist/doctor/checks/env-diagnostics.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { DoctorImpact, DoctorStatus } from "../types.js";
 import { CATEGORY } from "./category.js";
 import { detectJiraDeployment } from "../../jira.js";
+import { AGENTWEAVER_REVIEW_BLOCKING_SEVERITIES_ENV, parseReviewSeverityCsv, } from "../../review-severity.js";
 const MONITORED_KEYS = [
     "JIRA_API_KEY",
     "JIRA_USERNAME",
@@ -11,6 +12,7 @@ const MONITORED_KEYS = [
     "JIRA_BASE_URL",
     "GITLAB_TOKEN",
     "AGENTWEAVER_HOME",
+    "AGENTWEAVER_REVIEW_BLOCKING_SEVERITIES",
     "CODEX_BIN",
     "CODEX_MODEL",
     "OPENCODE_BIN",
@@ -23,6 +25,7 @@ const KEY_NOTES = {
     JIRA_USERNAME: "Required only for Jira Cloud basic auth.",
     GITLAB_TOKEN: "Required for GitLab-backed flows.",
     AGENTWEAVER_HOME: "Optional override for the AgentWeaver package home.",
+    AGENTWEAVER_REVIEW_BLOCKING_SEVERITIES: "Optional default list of merge-blocking severities for review and review-fix.",
     CODEX_BIN: "Optional override for the codex executable path.",
     CODEX_MODEL: "Optional fallback model override for Codex-backed executors.",
     OPENCODE_BIN: "Optional override for the opencode executable path.",
@@ -86,6 +89,9 @@ function defaultNote(key) {
     if (key === "JIRA_AUTH_MODE") {
         return "Defaults to auto.";
     }
+    if (key === AGENTWEAVER_REVIEW_BLOCKING_SEVERITIES_ENV) {
+        return "Defaults to blocker,critical,high.";
+    }
     return null;
 }
 function validateJiraAuthMode(value) {
@@ -94,6 +100,18 @@ function validateJiraAuthMode(value) {
     }
     return JIRA_AUTH_MODE_ALLOWED_VALUES.includes(value.trim().toLowerCase());
 }
+function validateReviewBlockingSeverities(value) {
+    if (value === null) {
+        return true;
+    }
+    try {
+        parseReviewSeverityCsv(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function keyNote(key) {
     return KEY_NOTES[key];
 }
@@ -165,6 +183,7 @@ function checkEnvDiagnostics() {
     const jiraUsername = process.env.JIRA_USERNAME?.trim() || null;
     const jiraAuthModeRaw = process.env.JIRA_AUTH_MODE?.trim() || null;
     const jiraBaseUrl = process.env.JIRA_BASE_URL?.trim() || null;
+    const reviewBlockingSeveritiesRaw = process.env[AGENTWEAVER_REVIEW_BLOCKING_SEVERITIES_ENV]?.trim() || null;
     for (const key of MONITORED_KEYS) {
         const currentValue = process.env[key]?.trim() || null;
         const isSecret = SECRET_KEYS.has(key);
@@ -180,6 +199,9 @@ function checkEnvDiagnostics() {
         if (key === "JIRA_AUTH_MODE" && currentValue !== null && !validateJiraAuthMode(currentValue)) {
             state = "invalid";
         }
+        if (key === AGENTWEAVER_REVIEW_BLOCKING_SEVERITIES_ENV && currentValue !== null && !validateReviewBlockingSeverities(currentValue)) {
+            state = "invalid";
+        }
         const note = state === "defaulted" ? defaultHint ?? undefined : keyNote(key);
         keyInfos.push({
             key,
@@ -197,6 +219,9 @@ function checkEnvDiagnostics() {
     if (jiraAuthModeRaw !== null && !validateJiraAuthMode(jiraAuthModeRaw)) {
         warnings.push("JIRA_AUTH_MODE must be one of: auto, basic, bearer.");
     }
+    if (reviewBlockingSeveritiesRaw !== null && !validateReviewBlockingSeverities(reviewBlockingSeveritiesRaw)) {
+        warnings.push("AGENTWEAVER_REVIEW_BLOCKING_SEVERITIES must be a comma-separated list of: blocker, critical, high, medium, low, info.");
+    }
     if (jiraHasCorePair && jiraBaseUrl) {
         const authMode = jiraAuthModeRaw?.toLowerCase() || "auto";
         const isCloud = detectJiraDeployment(jiraBaseUrl) === "cloud";

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,27 @@
+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 = 2;
 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 +33,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 +41,10 @@ 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;
     return {
         schemaVersion: FLOW_STATE_SCHEMA_VERSION,
         flowId,
@@ -38,10 +53,52 @@ 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 } : {}),
         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" } } : {}),
+    };
+}
+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 === 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;
+    }
+    return state;
+}
 export function loadFlowRunState(scopeKey, flowId) {
     const filePath = flowStateFile(scopeKey, flowId);
     if (!existsSync(filePath)) {
@@ -54,20 +111,20 @@ 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;
+    }
     ensureScopeWorkspaceDir(state.scopeKey);
     writeFileSync(flowStateFile(state.scopeKey, state.flowId), `${JSON.stringify({
         ...state,
@@ -101,10 +158,12 @@ 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,6 +230,7 @@ export function prepareFlowStateForResume(state) {
     state.currentStep = null;
     state.executionState = {
         ...state.executionState,
+        publicationRunId: randomUUID(),
         terminated: false,
         phases: state.executionState.phases.map(normalizePhaseState),
     };