@gr8ful/spf 0.8.1 → 0.8.3

package/README.md

@@ -608,23 +608,28 @@ for those.
 ```yaml
 # .spf/spf.config.yaml
 notifications:
-  events: errors            # off (default) | errors | all
+  events: attention         # off (default) | errors | attention | all
   channels:
     - kind: slack            # slack | teams | webhook
       webhook_url_env: SLACK_WEBHOOK_URL   # optional; this is the default for slack
 ```
 
-`events` is the whole filter: `errors` sends only failed runs/phases, blocked
-issues, watch errors, and a spec needing feedback (`spec_needs_feedback` —
-see "Human-in-the-loop escalation" above; it's `error`-level on purpose, the
-same class of event as a blocked issue, so an `errors`-scope channel sees it
-too); `all` adds every milestone — run started/finished, issue claimed, PR
-opened, issue done, a container's roll-up (`feature_done` — see "Container
-roll-up" above), and a spec reaching actual completion (`spec_done` —
-distinct from `spec_refined`, which fires the moment a tree is published;
-see "Human-in-the-loop escalation" above). A channel's own `events`
-overrides the top-level scope for just that channel. `spf doctor` reports
-whether each configured channel's env var is set.
+`events` is the whole filter, narrowest to widest:
+
+- `errors` sends only true failures — a failed run/phase (`run_failed`,
+  `phase_failed`) or a `watch_error`.
+- `attention` adds anything that needs a human but isn't itself a failure —
+  a blocked issue (`issue_blocked`) or a spec needing feedback
+  (`spec_needs_feedback` — see "Human-in-the-loop escalation" above).
+- `all` adds every remaining milestone — run started/finished, issue
+  claimed, PR opened, issue done, a container's roll-up (`feature_done` —
+  see "Container roll-up" above), and a spec reaching actual completion
+  (`spec_done` — distinct from `spec_refined`, which fires the moment a
+  tree is published; see "Human-in-the-loop escalation" above).
+
+Each tier includes everything the narrower tiers send. A channel's own
+`events` overrides the top-level scope for just that channel. `spf doctor`
+reports whether each configured channel's env var is set.
 
 The webhook URL is a secret and lives only in `.env` — `webhook_url_env`
 names the key, never the URL itself, matching `GITHUB_TOKEN`/

package/assets/skill/references/config.md

@@ -247,7 +247,7 @@ default; adding it is entirely additive.
 
 | Field | Type | Meaning |
 |---|---|---|
-| `events` | `"off"` \| `"errors"` \| `"all"` | The whole filter. `off` (default): nothing. `errors`: only failed runs/phases, blocked issues, watch errors, and a spec needing feedback (`spec_needs_feedback` — `error`-level on purpose, same class as a blocked issue). `all`: every curated milestone (run started, issue claimed, PR opened, ...) plus errors. |
+| `events` | `"off"` \| `"errors"` \| `"attention"` \| `"all"` | The whole filter, narrowest to widest. `off` (default): nothing. `errors`: only true failures — failed runs/phases (`run_failed`/`phase_failed`), `watch_error`. `attention`: `errors` plus anything needing a human but not itself a failure — a blocked issue (`issue_blocked`) or a spec needing feedback (`spec_needs_feedback`). `all`: every curated milestone (run started, issue claimed, PR opened, ...) plus `attention` and `errors`. |
 | `timeout_ms` | int | Per-request timeout for a channel's HTTP POST. Default `5000`. |
 | `channels[]` | array | See below. |
 
@@ -261,7 +261,7 @@ kind.
 
 ```yaml
 notifications:
-  events: errors
+  events: attention
   channels:
     - kind: slack
       webhook_url_env: SLACK_WEBHOOK_URL   # optional; this is the default for slack

package/assets/templates/ts.spf.config.yaml

@@ -91,11 +91,12 @@ agents:
 # Optional: push notifications for unattended work — spf watch's daemon
 # lifecycle, and every chain run (including watch's own per-issue runs).
 # Interactive commands (doctor, list, sessions, ...) never notify. events:
-# "errors" sends only failures/blocked issues; "all" adds every milestone.
-# The webhook URL is a secret — put it in .env under the key named below,
-# never here. See the main README's "Notifications" section.
+# "errors" sends only true failures; "attention" adds blocked issues and
+# feedback requests; "all" adds every milestone too. The webhook URL is a
+# secret — put it in .env under the key named below, never here. See the
+# main README's "Notifications" section.
 # notifications:
-#   events: errors            # off (default) | errors | all
+#   events: attention          # off (default) | errors | attention | all
 #   channels:
 #     - kind: slack            # slack | teams | webhook
 #       webhook_url_env: SLACK_WEBHOOK_URL

package/dist/cli/commands/doctor.js

@@ -53,6 +53,33 @@ async function withProbeStatus(label, run) {
  * a plain `✓` so a real negative finding (e.g. "unreachable", a `/v1`
  * double-path warning) can't be mistaken for a pass at a glance.
  */
+/**
+ * Cross-check ONE chain's own `requiredAgents`/`requiredSuites` (derived
+ * from what it actually does — `resolveRequiredAgents`/`resolveRequiredSuites`,
+ * same as `spf list`/a real dispatch would resolve) against what `cfg`
+ * actually has. Shared by the repo-chain loop below (every `.spf/chains/
+ * *.yaml` chain) and `watch.chain`/`watch.refine.chain` — the two chains
+ * `spf watch` will ACTUALLY dispatch, built-in or not. Extracted specifically
+ * because the repo-chain loop used to be the ONLY place this ran, and it
+ * skips every built-in chain by construction (`.filter((c) => c.source !==
+ * undefined)`) — so a `watch.chain` naming a built-in like `plan-build-test`
+ * never went through it at all: `spf doctor` could report clean while `spf
+ * watch`'s very first claimed issue failed at runtime on a missing
+ * `quality.suites` entry doctor never actually looked for.
+ */
+function checkChainRequirements(report, label, chain, cfg) {
+    const owners = resolveRequiredAgents(chain, {});
+    const missingOwners = owners.filter((o) => !cfg.agents.some((a) => a.name === o));
+    check(report, `${label} owners`, missingOwners.length === 0, missingOwners.length === 0 ? owners.join(", ") || "(none)" : `unknown agent(s): ${missingOwners.join(", ")} — not in cfg.agents`);
+    const suiteNames = resolveRequiredSuites(chain, {});
+    const missingSuites = suiteNames.filter((s) => !(s in cfg.quality.suites));
+    const missingChecks = missingSuites.length === 0 ? suiteNames.flatMap((s) => cfg.quality.suites[s].filter((n) => !cfg.quality.checks.some((c) => c.name === n))) : [];
+    check(report, `${label} suites`, missingSuites.length === 0 && missingChecks.length === 0, missingSuites.length > 0
+        ? `unknown suite(s): ${missingSuites.join(", ")} — not in cfg.quality.suites`
+        : missingChecks.length > 0
+            ? `suite(s) name unknown check(s): ${missingChecks.join(", ")}`
+            : suiteNames.join(", ") || "(none)");
+}
 function check(report, name, ok, detail, severity) {
     report.checks.push({ name, ok, detail, severity });
     if (!ok)
@@ -468,17 +495,7 @@ export async function doctorCommand(argv) {
         check(report, `repo chain ${problem.file}`, false, problem.message);
     }
     for (const chain of allChains().filter((c) => c.source !== undefined)) {
-        const owners = resolveRequiredAgents(chain, {});
-        const missingOwners = owners.filter((o) => !cfg.agents.some((a) => a.name === o));
-        check(report, `repo chain "${chain.name}" owners`, missingOwners.length === 0, missingOwners.length === 0 ? owners.join(", ") || "(none)" : `unknown agent(s): ${missingOwners.join(", ")} — not in cfg.agents`);
-        const suiteNames = resolveRequiredSuites(chain, {});
-        const missingSuites = suiteNames.filter((s) => !(s in cfg.quality.suites));
-        const missingChecks = missingSuites.length === 0 ? suiteNames.flatMap((s) => cfg.quality.suites[s].filter((n) => !cfg.quality.checks.some((c) => c.name === n))) : [];
-        check(report, `repo chain "${chain.name}" suites`, missingSuites.length === 0 && missingChecks.length === 0, missingSuites.length > 0
-            ? `unknown suite(s): ${missingSuites.join(", ")} — not in cfg.quality.suites`
-            : missingChecks.length > 0
-                ? `suite(s) name unknown check(s): ${missingChecks.join(", ")}`
-                : suiteNames.join(", ") || "(none)");
+        checkChainRequirements(report, `repo chain "${chain.name}"`, chain, cfg);
         // Informational: the derived sequence itself, same string `spf list`
         // shows — printed here so the chain's author can eyeball what they
         // actually wrote without a second command.
@@ -537,6 +554,19 @@ export async function doctorCommand(argv) {
         // same way it would for `spf watch` itself, no special-casing needed.
         const watchChain = findChain(cfg.watch.chain);
         check(report, "watch.chain", Boolean(watchChain), watchChain ? `${cfg.watch.chain}${watchChain.source ? ` (repo: ${repoChainLabel(watchChain.source)})` : ""}` : `"${cfg.watch.chain}" is not a registered chain`);
+        // The "repo chain X suites/owners" loop above only covers chains with a
+        // `.source` (loaded from `.spf/chains/*.yaml`) — a BUILT-IN chain named
+        // by `watch.chain` (the common case: `plan-build-test`, etc.) never went
+        // through that check, and the "roster + suites validate" call earlier
+        // only validates suites already present in `cfg.quality.suites`, not
+        // whether `watch.chain` actually NEEDS one that's missing entirely. That
+        // gap is exactly how `spf doctor` can report clean while `spf watch`'s
+        // very first claimed issue fails at runtime with "quality.suites.\"test\"
+        // is not configured" — this closes it by checking the chain `spf watch`
+        // will ACTUALLY dispatch, the same way the repo-chain loop already does.
+        if (watchChain) {
+            checkChainRequirements(report, `watch.chain "${cfg.watch.chain}"`, watchChain, cfg);
+        }
         // Informational only, never a failure: a chain that skips review and/or
         // never commits is a legitimate choice (e.g. `scout`, `plan`) — this is
         // here so an unattended `spf watch` posture is a visible fact, not a
@@ -558,6 +588,9 @@ export async function doctorCommand(argv) {
         if (cfg.watch.refine.enabled) {
             const refineChain = findChain(cfg.watch.refine.chain);
             check(report, "watch.refine.chain", Boolean(refineChain), refineChain ? `${cfg.watch.refine.chain}${refineChain.source ? ` (repo: ${repoChainLabel(refineChain.source)})` : ""}` : `"${cfg.watch.refine.chain}" is not a registered chain`);
+            if (refineChain) {
+                checkChainRequirements(report, `watch.refine.chain "${cfg.watch.refine.chain}"`, refineChain, cfg);
+            }
             check(report, "watch.refine issue authoring", cfg.watch.issue_provider === "github" || cfg.watch.issue_provider === "jira", cfg.watch.issue_provider === "github"
                 ? "github supports issue authoring (createIssue/sub-issues)"
                 : cfg.watch.issue_provider === "jira"

package/dist/cli/commands/init.js

@@ -112,12 +112,13 @@ const STARTER_CONFIG = `# .spf/spf.config.yaml — merged ON TOP of spf's packag
 # lifecycle, and every chain run (spf <chain> / spf run, including watch's
 # own per-issue runs). Interactive commands (doctor, list, sessions, ...)
 # never notify — you're already looking at the terminal for those. events:
-# "errors" sends only failures/blocked issues; "all" adds every milestone
-# (run started, issue claimed, PR opened, ...). The URL is a secret and
-# lives only in .env — never in this file. See README.md's "Notifications"
-# section for how to get each webhook URL.
+# "errors" sends only true failures; "attention" adds blocked issues and
+# feedback requests; "all" adds every milestone too (run started, issue
+# claimed, PR opened, ...). The URL is a secret and lives only in .env —
+# never in this file. See README.md's "Notifications" section for how to
+# get each webhook URL.
 # notifications:
-#   events: errors            # off (default) | errors | all
+#   events: attention          # off (default) | errors | attention | all
 #   channels:
 #     - kind: slack            # slack | teams | webhook
 #       webhook_url_env: SLACK_WEBHOOK_URL   # default for slack; TEAMS_WEBHOOK_URL / SPF_WEBHOOK_URL for the others

package/dist/cli/interview.js

@@ -345,9 +345,10 @@ export async function runInterview(asker, ctx) {
     let notifications = null;
     if (enableNotify) {
         const events = await asker.select("Notify on", [
-            { value: "errors", label: "errors — failed runs, blocked issues, watch errors" },
-            { value: "all", label: "all — every milestone (claimed, PR opened, done, ...) plus errors" },
-        ], "errors");
+            { value: "errors", label: "errors — failed runs and watch errors only" },
+            { value: "attention", label: "attention — errors, plus blocked issues and feedback requests" },
+            { value: "all", label: "all — every milestone (claimed, PR opened, done, ...) plus attention and errors" },
+        ], "attention");
         const channels = [];
         for (;;) {
             const kind = await asker.select("Channel", [

package/dist/core/data_types.d.ts

@@ -681,33 +681,38 @@ export type WatchConfig = v.InferOutput<typeof WatchConfigSchema>;
  * everything else (`spf doctor`, `list`, `sessions`, ...) is interactive, so
  * it stays console-only on purpose; see `core/notify/notifier.ts`.
  *
- * `events` is the whole filter: "off" sends nothing, "errors" sends only
- * NotifyEvents whose `level` is "error", "all" sends every curated
- * milestone. A channel's own `events` overrides the top-level scope for
- * just that channel (e.g. Slack gets everything, Teams gets errors only).
+ * `events` is the whole filter, from narrowest to widest:
+ *   - "off": sends nothing.
+ *   - "errors": only NotifyEvents whose `level` is "error" (true failures —
+ *     run_failed, phase_failed, watch_error).
+ *   - "attention": "errors" PLUS `level: "notice"` events — things that
+ *     need a human but aren't a failure (issue_blocked, spec_needs_feedback).
+ *   - "all": every curated milestone, `level: "info"` included.
+ * A channel's own `events` overrides the top-level scope for just that
+ * channel (e.g. Slack gets everything, Teams gets errors only).
  *
  * `webhook_url_env` names the .env key holding the secret URL — never the
  * URL itself, matching GITHUB_TOKEN/JIRA_API_TOKEN. Empty = the kind's own
  * default key (see core/notify/notifier.ts's DEFAULT_ENV_KEY).
  */
-export declare const NotifyScopeSchema: v.PicklistSchema<["off", "errors", "all"], undefined>;
+export declare const NotifyScopeSchema: v.PicklistSchema<["off", "errors", "attention", "all"], undefined>;
 export type NotifyScope = v.InferOutput<typeof NotifyScopeSchema>;
 export declare const NotifyChannelKindSchema: v.PicklistSchema<["slack", "teams", "webhook"], undefined>;
 export type NotifyChannelKind = v.InferOutput<typeof NotifyChannelKindSchema>;
 export declare const NotifyChannelSchema: v.ObjectSchema<{
     readonly kind: v.PicklistSchema<["slack", "teams", "webhook"], undefined>;
     readonly webhook_url_env: v.OptionalSchema<v.StringSchema<undefined>, "">;
-    readonly events: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["off", "errors", "all"], undefined>, undefined>, undefined>;
+    readonly events: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["off", "errors", "attention", "all"], undefined>, undefined>, undefined>;
     readonly name: v.OptionalSchema<v.StringSchema<undefined>, "">;
 }, undefined>;
 export type NotifyChannel = v.InferOutput<typeof NotifyChannelSchema>;
 export declare const NotificationsConfigSchema: v.ObjectSchema<{
-    readonly events: v.OptionalSchema<v.PicklistSchema<["off", "errors", "all"], undefined>, "off">;
+    readonly events: v.OptionalSchema<v.PicklistSchema<["off", "errors", "attention", "all"], undefined>, "off">;
     readonly timeout_ms: v.OptionalSchema<v.NumberSchema<undefined>, 5000>;
     readonly channels: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
         readonly kind: v.PicklistSchema<["slack", "teams", "webhook"], undefined>;
         readonly webhook_url_env: v.OptionalSchema<v.StringSchema<undefined>, "">;
-        readonly events: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["off", "errors", "all"], undefined>, undefined>, undefined>;
+        readonly events: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["off", "errors", "attention", "all"], undefined>, undefined>, undefined>;
         readonly name: v.OptionalSchema<v.StringSchema<undefined>, "">;
     }, undefined>, undefined>, () => never[]>;
 }, undefined>;
@@ -1013,21 +1018,21 @@ export declare const SFConfigSchema: v.ObjectSchema<{
         };
     }>;
     readonly notifications: v.OptionalSchema<v.ObjectSchema<{
-        readonly events: v.OptionalSchema<v.PicklistSchema<["off", "errors", "all"], undefined>, "off">;
+        readonly events: v.OptionalSchema<v.PicklistSchema<["off", "errors", "attention", "all"], undefined>, "off">;
         readonly timeout_ms: v.OptionalSchema<v.NumberSchema<undefined>, 5000>;
         readonly channels: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
             readonly kind: v.PicklistSchema<["slack", "teams", "webhook"], undefined>;
             readonly webhook_url_env: v.OptionalSchema<v.StringSchema<undefined>, "">;
-            readonly events: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["off", "errors", "all"], undefined>, undefined>, undefined>;
+            readonly events: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["off", "errors", "attention", "all"], undefined>, undefined>, undefined>;
             readonly name: v.OptionalSchema<v.StringSchema<undefined>, "">;
         }, undefined>, undefined>, () => never[]>;
     }, undefined>, () => {
-        events: "all" | "errors" | "off";
+        events: "all" | "attention" | "errors" | "off";
         timeout_ms: number;
         channels: {
             kind: "slack" | "teams" | "webhook";
             webhook_url_env: string;
-            events?: "all" | "errors" | "off" | null | undefined;
+            events?: "all" | "attention" | "errors" | "off" | null | undefined;
             name: string;
         }[];
     }>;

package/dist/core/data_types.js

@@ -538,16 +538,21 @@ export const WatchConfigSchema = v.object({
  * everything else (`spf doctor`, `list`, `sessions`, ...) is interactive, so
  * it stays console-only on purpose; see `core/notify/notifier.ts`.
  *
- * `events` is the whole filter: "off" sends nothing, "errors" sends only
- * NotifyEvents whose `level` is "error", "all" sends every curated
- * milestone. A channel's own `events` overrides the top-level scope for
- * just that channel (e.g. Slack gets everything, Teams gets errors only).
+ * `events` is the whole filter, from narrowest to widest:
+ *   - "off": sends nothing.
+ *   - "errors": only NotifyEvents whose `level` is "error" (true failures —
+ *     run_failed, phase_failed, watch_error).
+ *   - "attention": "errors" PLUS `level: "notice"` events — things that
+ *     need a human but aren't a failure (issue_blocked, spec_needs_feedback).
+ *   - "all": every curated milestone, `level: "info"` included.
+ * A channel's own `events` overrides the top-level scope for just that
+ * channel (e.g. Slack gets everything, Teams gets errors only).
  *
  * `webhook_url_env` names the .env key holding the secret URL — never the
  * URL itself, matching GITHUB_TOKEN/JIRA_API_TOKEN. Empty = the kind's own
  * default key (see core/notify/notifier.ts's DEFAULT_ENV_KEY).
  */
-export const NotifyScopeSchema = v.picklist(["off", "errors", "all"]);
+export const NotifyScopeSchema = v.picklist(["off", "errors", "attention", "all"]);
 export const NotifyChannelKindSchema = v.picklist(["slack", "teams", "webhook"]);
 export const NotifyChannelSchema = v.object({
     kind: NotifyChannelKindSchema,

package/dist/core/notify/channel.d.ts

@@ -14,8 +14,14 @@
 export type NotifyKind = "run_started" | "run_finished" | "run_failed" | "phase_failed" | "phase_retry" | "watch_started" | "watch_stopped" | "watch_error" | "issue_claimed" | "pr_opened" | "issue_done" | "issue_blocked" | "spec_refined" | "spec_needs_feedback" | "feature_done" | "spec_done";
 export interface NotifyEvent {
     kind: NotifyKind;
-    /** "error" sends under both `events: errors` and `events: all`; "info" only under `all`. */
-    level: "info" | "error";
+    /**
+     * The whole filter predicate a scope applies (see `NotifyScopeSchema` in
+     * `core/data_types.ts`): "error" is a true failure (sends under `errors`,
+     * `attention`, and `all`); "notice" needs a human but isn't a failure
+     * (sends under `attention` and `all`); "info" is a routine milestone
+     * (sends only under `all`).
+     */
+    level: "info" | "notice" | "error";
     /** One line, e.g. "run failed — plan-build-test". */
     title: string;
     /** The error text / PR body / block detail, if any. */

package/dist/core/notify/notifier.js

@@ -7,12 +7,17 @@ export const DEFAULT_NOTIFY_ENV_KEY = {
     teams: "TEAMS_WEBHOOK_URL",
     webhook: "SPF_WEBHOOK_URL",
 };
-/** `errors` mode only sends `level: "error"`; `all` sends everything; `off` sends nothing. */
+/**
+ * `off` sends nothing; `errors` only `level: "error"`; `attention` also
+ * lets `level: "notice"` through; `all` sends everything.
+ */
 function scopeAllows(scope, level) {
     if (scope === "off")
         return false;
     if (scope === "all")
         return true;
+    if (scope === "attention")
+        return level === "error" || level === "notice";
     return level === "error";
 }
 export class Notifier {

package/dist/core/notify/slack_channel.js

@@ -6,7 +6,7 @@ export class SlackChannel {
         this.label = name ? `slack (${name})` : "slack";
     }
     async send(event, timeoutMs) {
-        const emoji = event.level === "error" ? ":x:" : ":white_check_mark:";
+        const emoji = event.level === "error" ? ":x:" : event.level === "notice" ? ":warning:" : ":white_check_mark:";
         const fieldsText = event.fields.map(([k, v]) => `*${k}:* ${v}`).join("  ·  ");
         const body = {
             text: `${emoji} ${event.title}`,

package/dist/core/notify/teams_channel.js

@@ -6,7 +6,7 @@ export class TeamsChannel {
         this.label = name ? `teams (${name})` : "teams";
     }
     async send(event, timeoutMs) {
-        const color = event.level === "error" ? "attention" : "good";
+        const color = event.level === "error" ? "attention" : event.level === "notice" ? "warning" : "good";
         const facts = event.fields.map(([title, value]) => ({ title, value }));
         const card = {
             type: "AdaptiveCard",

package/dist/core/watch.js

@@ -134,7 +134,7 @@ export async function reconcileOrphans(deps, state) {
             deps.log(`watch: ${issue.id} orphaned past ${MAX_ORPHAN_ATTEMPTS} attempts — blocked`);
             deps.notify({
                 kind: "issue_blocked",
-                level: "error",
+                level: "notice",
                 title: `issue ${issue.id} blocked`,
                 detail: `Gave up after ${MAX_ORPHAN_ATTEMPTS} orphaned attempts.`,
                 fields: [["issue", issue.id], ["title", issue.title]],
@@ -348,11 +348,11 @@ async function escalateSpec(deps, issue, marker, questions, adwId, round) {
             .join("\n\n---\n\n") +
         `\n\n---\n\nAnswer inline, then add the \`${deps.labelPrefix}:continue-refinement\` label — refinement resumes from where it left off (adw_id \`${adwId}\`).`;
     deps.notify({
-        // "error" level, not "info" — this is the same class of event as
-        // issue_blocked ("spf needs a human"), and it belongs on an `errors`-scope
-        // channel just as much as an `all`-scope one.
+        // "notice" level, not "info" — this is the same class of event as
+        // issue_blocked ("spf needs a human"), and it belongs on an
+        // `attention`-scope channel just as much as an `all`-scope one.
         kind: "spec_needs_feedback",
-        level: "error",
+        level: "notice",
         title: `spec ${issue.id} needs feedback`,
         detail: `${questions.length} question(s), round ${round}.`,
         fields: [
@@ -398,7 +398,7 @@ export async function reconcileRefining(deps, state) {
             deps.log(`watch: spec ${issue.id} orphaned after asking round ${marker.feedback.rounds} — finishing the transition to needs-feedback`);
             deps.notify({
                 kind: "spec_needs_feedback",
-                level: "error",
+                level: "notice",
                 title: `spec ${issue.id} needs feedback`,
                 detail: `Round ${marker.feedback.rounds}.`,
                 fields: [["issue", issue.id], ["title", issue.title], ["round", String(marker.feedback.rounds)]],
@@ -419,7 +419,7 @@ export async function reconcileRefining(deps, state) {
             deps.log(`watch: spec ${issue.id} orphaned past ${MAX_ORPHAN_ATTEMPTS} attempts — blocked`);
             deps.notify({
                 kind: "issue_blocked",
-                level: "error",
+                level: "notice",
                 title: `spec ${issue.id} blocked`,
                 detail: `Gave up after ${MAX_ORPHAN_ATTEMPTS} orphaned refine attempts.`,
                 fields: [["issue", issue.id], ["title", issue.title]],
@@ -530,7 +530,7 @@ export async function finishReviews(deps) {
             deps.log(`watch: ${issue.id}'s PR #${marker.pr} closed without merging — blocked`);
             deps.notify({
                 kind: "issue_blocked",
-                level: "error",
+                level: "notice",
                 title: `issue ${issue.id} blocked`,
                 detail: `PR #${marker.pr} was closed without merging.`,
                 fields: [["issue", issue.id], ["title", issue.title], ["pr", `#${marker.pr}`]],
@@ -569,7 +569,7 @@ async function runIssue(deps, issue) {
             const detail = result.detail || `Chain "${deps.chain}" (adw_id ${adwId}) did not complete successfully. Run \`spf phases ${adwId}\` for detail.`;
             deps.notify({
                 kind: "issue_blocked",
-                level: "error",
+                level: "notice",
                 title: `issue ${issue.id} blocked`,
                 detail,
                 fields: [["issue", issue.id], ["title", issue.title], ["chain", deps.chain], ["adw_id", adwId]],
@@ -583,7 +583,7 @@ async function runIssue(deps, issue) {
             deps.log(`watch: ${issue.id}: chain succeeded but committed nothing — blocked`);
             deps.notify({
                 kind: "issue_blocked",
-                level: "error",
+                level: "notice",
                 title: `issue ${issue.id} blocked`,
                 detail: `Chain "${deps.chain}" (adw_id ${adwId}) completed but left no committed changes.`,
                 fields: [["issue", issue.id], ["title", issue.title], ["chain", deps.chain], ["adw_id", adwId]],
@@ -722,7 +722,7 @@ async function runSpec(deps, issue) {
             const detail = result.detail || `Refine chain "${deps.refineChain}" (adw_id ${adwId}) did not complete successfully. Run \`spf phases ${adwId}\` for detail.`;
             deps.notify({
                 kind: "issue_blocked",
-                level: "error",
+                level: "notice",
                 title: `spec ${issue.id} blocked`,
                 detail,
                 fields: [["issue", issue.id], ["title", issue.title], ["chain", deps.refineChain], ["adw_id", adwId]],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gr8ful/spf",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "Super Portable Factory — a global CLI for repeatable agents-plus-code workflows (ADWs)",
   "type": "module",
   "license": "MIT",