@mingchuno/agent-workflows 0.4.0 → 0.5.0

package/dist/src/validation-selection.js

@@ -0,0 +1,29 @@
+const openingFence = /^ {0,3}```agent-workflows-validation[ \t]*$/;
+const closingFence = /^ {0,3}```[ \t]*$/;
+const profileName = /^[a-zA-Z0-9_-]+$/;
+/** Resolve the one ticket-selected set against project-owned commands. */
+export function selectValidation(body, project) {
+    const lines = body.split(/\r?\n/);
+    let profile;
+    for (let index = 0; index < lines.length; index++) {
+        if (!openingFence.test(lines[index]))
+            continue;
+        if (profile !== undefined)
+            throw new Error("Duplicate agent-workflows validation block");
+        const selected = lines[++index]?.trim();
+        if (!selected || !profileName.test(selected))
+            throw new Error("Invalid agent-workflows validation profile name");
+        if (!closingFence.test(lines[++index] ?? ""))
+            throw new Error("Validation block must contain one profile name and a closing fence");
+        if (!Object.hasOwn(project.validationProfiles, selected))
+            throw new Error(`Unknown validation profile: ${selected}`);
+        profile = selected;
+    }
+    return {
+        ...(profile === undefined ? {} : { profile }),
+        commands: [
+            ...project.validation,
+            ...(profile === undefined ? [] : project.validationProfiles[profile]),
+        ],
+    };
+}

package/dist/src/workspace.js

@@ -86,8 +86,9 @@ export class ExistingCheckout {
         const diff = await this.git(project, "diff", "HEAD", "--binary", "--no-ext-diff");
         const tracked = await this.git(project, "diff", "HEAD", "--no-renames", "--name-only", "-z");
         const untracked = await this.git(project, "ls-files", "--others", "--exclude-standard", "-z");
+        const untrackedPaths = new Set(untracked.split("\0").filter(Boolean));
         const paths = [
-            ...new Set([...tracked.split("\0"), ...untracked.split("\0")].filter(Boolean)),
+            ...new Set([...tracked.split("\0"), ...untrackedPaths].filter(Boolean)),
         ].sort();
         const hash = createHash("sha256")
             .update(head)
@@ -105,7 +106,7 @@ export class ExistingCheckout {
                 const content = await readFile(absolute);
                 files[path] = fileStateDigest(content, stat.mode);
                 hash.update(path).update(content).update(String(stat.mode));
-                if (untracked.split("\0").includes(path))
+                if (untrackedPaths.has(path))
                     fullDiff += `\n--- /dev/null\n+++ b/${path}\n${content.toString()}`;
             }
             catch (error) {

package/docs/api.md

@@ -12,7 +12,7 @@ Omitting it preserves current-working-directory behavior for SDK callers.
 `promptBaseDirectory` retains its narrower role and, when both are supplied,
 overrides only relative prompt files.
 
-`start()` validates registration, acquires ownership, launches DBOS, registers concurrency-one project queues, and starts polling. `poll(projectId?)` performs an immediate scan. `pause(projectId)` stops new starts while active work continues. `resume(projectId)` refuses blocked checkouts. `stop(runId)` waits for the active invocation/process to end, or cancels queued work. `retry(runId)` requires a terminal failed/blocked/cancelled run and a clean checkout, then returns a new linked run ID. `recover(runId)` returns a new execution ID for publication recovery of the same run. `shutdown()` stops intake, cancels and awaits active work, closes DBOS and releases ownership.
+`start()` validates registration, acquires ownership, launches DBOS, registers concurrency-one project queues, and starts polling. `poll(projectId?)` performs an immediate scan. `pause(projectId)` stops new starts while active work continues. `resume(projectId)` refuses blocked checkouts. `stop(runId)` waits for the active invocation/process to end, or cancels queued work. `retry(runId)` requires a terminal failed/blocked/cancelled run and a clean checkout, then returns a new linked run ID using its saved issue. `retry(runId, commandId, { refreshIssue: true })` fetches and validates the current hosted issue once during admission, saving it on the new run. `recover(runId)` returns a new execution ID for publication recovery of the same run. `shutdown()` stops intake, cancels and awaits active work, closes DBOS and releases ownership.
 
 Use `try/finally` to call `shutdown()`, including failed startup. A custom `workflowVersion` must change when its durable step order changes; finish existing work before replacing an incompatible version.
 

package/docs/configuration.md

@@ -28,11 +28,44 @@ part of the public SDK `Configuration` type.
 | `pollIntervalMs`       | 30000; minimum 100                                                                                  |
 | `includeAgentCoAuthors` | `true`; append co-author trailers for providers whose writable invocations produced retained changes |
 | `validation`           | Array of `{command,args,timeoutMs}`; no shell expansion; timeout defaults to 300000 ms              |
+| `validationProfiles`   | Named, nonempty arrays of validation commands selectable by a ticket; defaults to `{}`                |
 | `agent`                | Required default profile                                                                            |
 | `stages`               | `implementation`, `publication`, `review`; each has optional `profile`, `prompt`, `promptFile`, `timeoutMs` |
 
 Issues are selected in ascending issue-number order within each intake scan. Deduplication persists across restarts. An explicit retry is a new numbered attempt linked through `retryOf`.
 
+## Ticket-selected validation
+
+Define optional checks under a project in `validationProfiles` using the same
+command format as `validation`:
+
+```json
+{
+  "validation": [{ "command": "pnpm", "args": ["lint"] }],
+  "validationProfiles": {
+    "migration": [{ "command": "pnpm", "args": ["test:migrations"] }]
+  }
+}
+```
+
+An issue description selects one profile with a standalone fenced block:
+
+````markdown
+```agent-workflows-validation
+migration
+```
+````
+
+The runner executes the project's `validation` commands first, then the selected
+profile's commands. Without the block, only the baseline runs. The block must
+contain exactly one configured profile name (`A-Z`, `a-z`, digits, `_`, or `-`);
+duplicate, malformed, and unknown selections fail the run before checkout
+preparation or agent invocation. The issue body is saved with the run, so edits
+to the hosted issue do not change an existing run. A plain retry creates a new
+run from its recorded issue. Use `retry RUN --refresh-issue` (or `R` in the
+monitor) to snapshot the current hosted issue and its validation selection for
+the new run. Later issue edits do not change that run.
+
 Absolute configuration paths remain absolute. Effective state and checkout
 paths are normalized once during startup before safety and ownership checks, so
 a later working-directory change cannot redirect a running process. Validation

package/docs/operations.md

@@ -10,11 +10,12 @@ All commands accept `--config PATH` before the subcommand.
 | `run [--project ID ...]`           | Start selected projects in the foreground                       |
 | `status [--json]`                  | Projects, runs and command outcomes                             |
 | `inspect RUN`                      | Full run and invocation/session records as JSON                 |
-| `logs RUN [--invocation ID]`       | Local agent and validation artifacts                            |
+| `logs RUN [--invocation ID]`       | Local stage, agent and validation artifacts                     |
 | `pause PROJECT` / `resume PROJECT` | Queue an intake control command                                 |
 | `stop RUN`                         | Queue cancellation; success means active local work has stopped |
 | `recover RUN`                      | Continue a failed publication step using completed checkpoints |
 | `retry RUN`                        | Queue an explicit new attempt after checkout validation         |
+| `retry RUN --refresh-issue`        | Queue a new attempt using the current hosted issue              |
 | `monitor [--notify]`               | Attach an interactive terminal view; optionally alert on outcomes |
 
 Control commands return a command ID and `pending`; inspect `status --json` or the monitor for success/failure. With no runner, commands stay pending. Run and monitor are separate processes. Closing the monitor never cancels work. Ctrl-C on the runner stops intake, cancels active work, waits for process termination and releases ownership. Queued issues remain durable for the next start.
@@ -57,7 +58,7 @@ fallback. An overflowing document shows its visible line range in the heading.
 | Context | Keys |
 | --- | --- |
 | Dashboard | Left/Right project; Tab/Shift+Tab pane; Up/Down selection or scroll |
-| Details | Enter opens; Up/Down or PgUp/PgDn scroll; Esc returns; `l` opens the latest current-execution session, preferring a running session |
+| Details | Enter opens; Up/Down or PgUp/PgDn scroll; Esc returns; `l` opens the latest current-execution session, or the stage diagnostic before a session exists |
 | Progress | `[`/`]` inspect step history; End follows latest event |
 | Sessions | `a` focuses session list; Up/Down selects invocation; `l` opens log |
 | Validation | `v` opens validation logs |
@@ -176,7 +177,7 @@ After a blocked/failed task that cannot be recovered:
 1. Read `inspect RUN`, logs, session IDs and the local Git diff.
 2. Establish that no worker/process group is still running. If startup reports an old PID or process journal, inspect that exact process and stop it before recovery. Never remove a live owner's lease.
 3. Preserve unfinished work on a developer-owned commit/branch or move it to a safe location. Resolve merge/rebase state yourself. Do not rely on DBOS to restore files.
-4. Once the checkout is clean, request `retry RUN`. This creates a new attempt and branch from the configured base, keeping the old run and files/commits inspectable.
+4. Once the checkout is clean, request `retry RUN`. This creates a new attempt and branch from the configured base, keeping the old run and files/commits inspectable. Use `retry RUN --refresh-issue` to capture the current hosted issue description and validation selection in the new run. The hosted issue must retain its identity, be open, and have the required labels; its selected validation profile must be configured.
 
 A failed review after publication remains a failed automation attempt, even if its draft request exists. Explicit retry starts the full workflow as a new attempt; it does not silently modify the old request. Human review/merging remains separate. A stale review never claims coverage of a changed remote head.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mingchuno/agent-workflows",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Local durable coding workflows on DBOS",
   "type": "module",
   "license": "MIT",

package/dist/src/tui/actions.d.ts

@@ -1,16 +0,0 @@
-import type { RunRecord } from "../domain.js";
-import type { ProjectState } from "../store.js";
-/** Display eligibility only; the runner still validates command admission. */
-export declare function actionAvailability({ run, project, projectRuns, pending, }: {
-    run?: RunRecord;
-    project?: ProjectState;
-    projectRuns: RunRecord[];
-    pending: boolean;
-}): {
-    recoveryReason: string | undefined;
-    available: {
-        stop: boolean;
-        retry: boolean;
-        recover: boolean;
-    };
-};

package/dist/src/tui/actions.js

@@ -1,23 +0,0 @@
-import { recoveryUnavailable } from "../recovery.js";
-/** Display eligibility only; the runner still validates command admission. */
-export function actionAvailability({ run, project, projectRuns, pending, }) {
-    const recoveryReason = run
-        ? (recoveryUnavailable(run) ??
-            project?.blocked ??
-            (projectRuns.some((item) => item.taskKey === run.taskKey && item.attempt > run.attempt)
-                ? "A newer attempt has superseded this run"
-                : undefined))
-        : undefined;
-    return {
-        recoveryReason,
-        available: {
-            stop: Boolean(run && !pending && ["queued", "running"].includes(run.outcome)),
-            retry: Boolean(run &&
-                !pending &&
-                ["failed", "blocked", "cancelled"].includes(run.outcome) &&
-                !projectRuns.some((item) => item.taskKey === run.taskKey &&
-                    ["queued", "running"].includes(item.outcome))),
-            recover: Boolean(run && !pending && !recoveryReason),
-        },
-    };
-}