agentweaver 0.1.15 → 0.1.17

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
 
@@ -34,13 +34,21 @@ In practice, this means you can treat an agent workflow like an engineered syste
 
 ## Core Concepts
 
-- `flow spec`: declarative JSON under `src/pipeline/flow-specs/` or project-local `.agentweaver/.flows/`
+- `flow spec`: declarative JSON under `src/pipeline/flow-specs/`, global `~/.agentweaver/.flows/`, or project-local `.agentweaver/.flows/`
 - `node`: reusable runtime unit from `src/pipeline/nodes/`
 - `executor`: integration layer for Jira, Codex, OpenCode, GitLab, shell/process execution, Telegram notifications, and related actions
 - `scope`: isolated workspace key for artifacts and flow state; usually based on Jira task, otherwise derived from git context
 - `artifact`: file produced or consumed by flows, used as the stable contract between stages
 - `flow state`: compact persisted execution metadata used for resume/restart in long-running flows such as `auto-golang`
 
+## Семантика Запуска
+
+- `resume` возобновляет только реально прерванный запуск и использует сохранённое состояние исполнения без пересборки уже выполненных шагов
+- `continue` предназначен для завершённых итерационных циклов и запускает следующую итерацию от последних валидных артефактов без удаления исторических артефактов
+- `restart` считается новым запуском: текущая активная попытка архивируется в `.agentweaver/scopes/<scope>/.artifacts/restart-archives/attempt-XXXX`, после чего создаётся новая активная попытка
+- Для неоднозначных запусков оператор должен явно выбрать действие: в интерактивном режиме через подтверждение, в неинтерактивном режиме через `--resume`, `--continue` или `--restart`
+- Контракт распространяется на `auto-common`, `auto-simple`, `auto-golang`, `instant-task`, `review-loop`, `run-go-linter-loop` и `run-go-tests-loop`
+
 ## Declarative Workflow Model
 
 The center of the system is the declarative flow spec:
@@ -62,7 +70,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 +80,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 +95,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).
@@ -117,6 +126,34 @@ node dist/index.js --help
 
 Global install after publishing:
 
+## Plugin SDK
+
+AgentWeaver supports local plugins and custom declarative flows from both global and project-local `.agentweaver` directories.
+
+Plugin authors must use only the public SDK subpath: `agentweaver/plugin-sdk`.
+The package root `agentweaver`, internal paths such as `agentweaver/dist/*` and `agentweaver/src/*`, and repository-relative source imports are not part of the supported SDK contract.
+
+Supported plugin manifest locations are:
+
+- `~/.agentweaver/.plugins/<plugin-id>/plugin.json`
+- `.agentweaver/.plugins/<plugin-id>/plugin.json`
+
+The plugin directory name and manifest `id` must match exactly.
+
+Use the dedicated guide at [docs/plugin-sdk.md](docs/plugin-sdk.md) for:
+
+- the executor versus node architecture
+- manifest and entrypoint rules
+- optional routing metadata for plugin LLM executors
+- runtime context APIs available to plugin code
+- global and project-local flow wiring under `~/.agentweaver/.flows/` and `.agentweaver/.flows/`
+- compatibility, testing, troubleshooting, and a complete end-to-end walkthrough
+
+Repository reference examples live under `docs/examples/`, for example:
+
+- `docs/examples/.plugins/claude-example-plugin/`
+- `docs/examples/.flows/claude-example.json`
+
 ```bash
 npm install -g agentweaver
 agentweaver --help
@@ -182,7 +219,7 @@ OPENCODE_MODEL=minimax-coding-plan/MiniMax-M2.7
 
 The full-screen TUI is not a cosmetic wrapper. It is the operator console for the harness:
 
-- browse built-in and project-local workflows
+- browse built-in, global, and project-local workflows
 - launch flows in the current scope
 - inspect progress by phase and step
 - follow activity, prompts, summaries, and statuses
@@ -220,6 +257,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 +281,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 +296,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 +312,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 +341,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,34 +354,45 @@ 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/`
-- project-local flows are loaded from `.agentweaver/.flows/`
-- both built-in and project-local flow specs are validated at load time
-- duplicate flow ids fail fast
-- project-local flows are shown separately in the UI
+- global custom flows are loaded from `~/.agentweaver/.flows/`
+- project-local custom flows are loaded from `.agentweaver/.flows/`
+- all discovered flow specs are validated at load time
+- duplicate flow ids fail fast across built-in, global, and project-local sources
+- custom flows are shown separately in the UI as global and project-local groups
 
-## Project-Local Flows
+## Custom Flows
 
-You can add project-specific flow specs under:
+You can add custom flow specs under either:
 
 ```bash
+~/.agentweaver/.flows/**/*.json
 .agentweaver/.flows/**/*.json
 ```
 
-Project-local flows:
+Custom flows:
 
 - are discovered recursively
 - get their flow id from the relative path without `.json`
 - share the same validator and runtime as built-in flows
 - cannot conflict with an existing built-in or other discovered flow id
 
-Nested `flow-run` steps can reference built-in or project-local specs by file name, as long as the name resolves unambiguously.
+Use the global directory for reusable personal flows and plugins across repositories, and the project-local directory for repo-specific wiring.
+
+Nested `flow-run` steps can reference built-in, global, or project-local specs by file name, as long as the name resolves unambiguously.
 
 ## Development
 

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

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync } from "node:fs";
+import { cpSync, existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
 import path from "node:path";
 import process from "node:process";
 import { TaskRunnerError } from "./errors.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`);
 }
@@ -199,8 +214,78 @@ export function gitlabDiffReviewInputJsonFile(taskKey) {
 export function flowStateFile(scopeKey, flowId) {
     return scopeArtifactsFile(scopeKey, `.agentweaver-flow-state-${encodeURIComponent(flowId)}.json`);
 }
-export function planArtifacts(taskKey) {
-    return [designFile(taskKey), designJsonFile(taskKey), planFile(taskKey), planJsonFile(taskKey), qaFile(taskKey), qaJsonFile(taskKey)];
+export function restartArchivesDir(scopeKey) {
+    return scopeArtifactsFile(scopeKey, "restart-archives");
+}
+function nextRestartArchiveName(scopeKey) {
+    const archiveRoot = restartArchivesDir(scopeKey);
+    if (!existsSync(archiveRoot)) {
+        return "attempt-0001";
+    }
+    const attemptNumbers = readdirSync(archiveRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => /^attempt-(\d{4})$/.exec(entry.name)?.[1] ?? null)
+        .filter((value) => value !== null)
+        .map((value) => Number.parseInt(value, 10));
+    const nextNumber = (attemptNumbers.length === 0 ? 0 : Math.max(...attemptNumbers)) + 1;
+    return `attempt-${String(nextNumber).padStart(4, "0")}`;
+}
+export function archiveActiveAttempt(scopeKey) {
+    const workspaceDir = scopeWorkspaceDir(scopeKey);
+    if (!existsSync(workspaceDir)) {
+        return null;
+    }
+    const workspaceEntries = readdirSync(workspaceDir, { withFileTypes: true })
+        .filter((entry) => entry.name !== ".artifacts");
+    const artifactEntries = readdirSync(scopeArtifactsDir(scopeKey), { withFileTypes: true })
+        .filter((entry) => entry.name !== "restart-archives");
+    if (workspaceEntries.length === 0 && artifactEntries.length === 0) {
+        return null;
+    }
+    const archiveRoot = restartArchivesDir(scopeKey);
+    mkdirSync(archiveRoot, { recursive: true });
+    const archiveDir = path.join(archiveRoot, nextRestartArchiveName(scopeKey));
+    const workspaceArchiveDir = path.join(archiveDir, "workspace");
+    const artifactsArchiveDir = path.join(archiveDir, "artifacts");
+    mkdirSync(workspaceArchiveDir, { recursive: true });
+    mkdirSync(artifactsArchiveDir, { recursive: true });
+    try {
+        for (const entry of workspaceEntries) {
+            cpSync(path.join(workspaceDir, entry.name), path.join(workspaceArchiveDir, entry.name), {
+                recursive: true,
+                errorOnExist: true,
+                force: false,
+            });
+        }
+        for (const entry of artifactEntries) {
+            cpSync(path.join(scopeArtifactsDir(scopeKey), entry.name), path.join(artifactsArchiveDir, entry.name), {
+                recursive: true,
+                errorOnExist: true,
+                force: false,
+            });
+        }
+    }
+    catch (error) {
+        rmSync(archiveDir, { recursive: true, force: true });
+        throw new TaskRunnerError(`Failed to archive active attempt for restart: ${error.message}`);
+    }
+    for (const entry of workspaceEntries) {
+        rmSync(path.join(workspaceDir, entry.name), { recursive: true, force: true });
+    }
+    for (const entry of artifactEntries) {
+        rmSync(path.join(scopeArtifactsDir(scopeKey), entry.name), { recursive: true, force: true });
+    }
+    return archiveDir;
+}
+export function planArtifacts(taskKey, iteration) {
+    return [
+        designFile(taskKey, iteration),
+        designJsonFile(taskKey, iteration),
+        planFile(taskKey, iteration),
+        planJsonFile(taskKey, iteration),
+        qaFile(taskKey, iteration),
+        qaJsonFile(taskKey, iteration),
+    ];
 }
 export function bugAnalyzeArtifacts(taskKey) {
     return [

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/executors.js

@@ -1,7 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { DoctorStatus } from "../types.js";
 import { CATEGORY } from "./category.js";
-import { ALLOWED_MODELS_BY_EXECUTOR } from "../../pipeline/launch-profile-config.js";
+import { allowedModelsForExecutor } from "../../pipeline/launch-profile-config.js";
 import { findCmdPath, isExecutable } from "../../runtime/command-resolution.js";
 function getEnvVarName(executorId) {
     return executorId === "codex" ? "CODEX_BIN" : "OPENCODE_BIN";
@@ -72,7 +72,7 @@ function checkExecutor(executorId) {
     if (versionOutput === null) {
         return createResult(executorId, DoctorStatus.Fail, `${executorId} --version check failed`, `${executorId} --version did not produce expected output`, `path: ${resolution.path}, source: ${resolution.source}`, resolution, null);
     }
-    const allowedModels = ALLOWED_MODELS_BY_EXECUTOR[executorId];
+    const allowedModels = allowedModelsForExecutor(executorId);
     const modelWarnings = [];
     for (const model of allowedModels) {
         const modelResult = spawnSync(resolution.path, ["--model", model, "--version"], { encoding: "utf8", stdio: "pipe" });