@gobing-ai/spur 0.3.28 → 0.3.29

package/spur.js

@@ -37121,6 +37121,7 @@ var init_finding_codes = __esm(() => {
     "L3.solution-file-line",
     "L3.review-priority-table",
     "L3.testing-coverage",
+    "L3.required-section-placeholder",
     "L3.plan-format",
     "L3.unchecked-checklist",
     "L3.ac-checklist-text",
@@ -37150,8 +37151,9 @@ var init_finding_codes = __esm(() => {
     "L4.uncovered-feature-scenario",
     "L4.verifying-incomplete-tasks",
     "L4.dogfood-missing",
-    "L4.scenario-unverified",
-    "L4.stale-line-anchor"
+    "L4.stale-line-anchor",
+    "L4.malformed-verdict-artifact",
+    "L4.scenario-unverified"
   ];
   FINDING_CODES = {
     L1_MARKDOWN_PARSE: "L1.markdown-parse",
@@ -37165,6 +37167,7 @@ var init_finding_codes = __esm(() => {
     L3_SOLUTION_FILE_LINE: "L3.solution-file-line",
     L3_REVIEW_PRIORITY_TABLE: "L3.review-priority-table",
     L3_TESTING_COVERAGE: "L3.testing-coverage",
+    L3_REQUIRED_SECTION_PLACEHOLDER: "L3.required-section-placeholder",
     L3_PLAN_FORMAT: "L3.plan-format",
     L3_UNCHECKED_CHECKLIST: "L3.unchecked-checklist",
     L3_AC_CHECKLIST_TEXT: "L3.ac-checklist-text",
@@ -37192,10 +37195,11 @@ var init_finding_codes = __esm(() => {
     L4_ORPHAN_SCENARIOS: "L4.orphan-scenarios",
     L4_UNCOVERED_TASK_SCENARIO: "L4.uncovered-task-scenario",
     L4_UNCOVERED_FEATURE_SCENARIO: "L4.uncovered-feature-scenario",
-    L4_VERIFYING_INCOMPLETE_TASKS: "L4.verifying-incomplete-tasks",
     L4_DOGFOOD_MISSING: "L4.dogfood-missing",
-    L4_SCENARIO_UNVERIFIED: "L4.scenario-unverified",
-    L4_STALE_LINE_ANCHOR: "L4.stale-line-anchor"
+    L4_VERIFYING_INCOMPLETE_TASKS: "L4.verifying-incomplete-tasks",
+    L4_STALE_LINE_ANCHOR: "L4.stale-line-anchor",
+    L4_MALFORMED_VERDICT_ARTIFACT: "L4.malformed-verdict-artifact",
+    L4_SCENARIO_UNVERIFIED: "L4.scenario-unverified"
   };
 });
 
@@ -37269,7 +37273,7 @@ function buildConfigFromEnv(env = process.env) {
     }
   });
 }
-var SPUR_ENV_VARS, SPUR_LOG_LEVELS, DEFAULT_TASKS_DIR = "docs/tasks", DEFAULT_FEATURES_DIR = "docs/features", DEFAULT_DATABASE_URL = ".spur/spur.db", IN_MEMORY_DATABASE_URL = ":memory:", folderConfigSchema, tasksConfigSchema, featuresConfigSchema, EXECUTOR_CAPABILITY_TIERS, executorCapabilityTierSchema, AgentExecutorConfigSchema, AGENT_ID_REGEX, TeamMemberConfigSchema, TeamConfigSchema, AgentConfigSchema, RulesConfigSchema, WorkflowsConfigSchema, RedactionConfigSchema, spurConfigSchema, configSchema2;
+var SPUR_ENV_VARS, SPUR_LOG_LEVELS, DEFAULT_TASKS_DIR = "docs/tasks", DEFAULT_FEATURES_DIR = "docs/features", DEFAULT_DATABASE_URL = ".spur/spur.db", IN_MEMORY_DATABASE_URL = ":memory:", folderConfigSchema, tasksConfigSchema, featuresConfigSchema, EXECUTOR_CAPABILITY_TIERS, executorCapabilityTierSchema, AgentExecutorConfigSchema, AGENT_ID_REGEX, TeamMemberConfigSchema, TeamConfigSchema, AgentOutputConfigSchema, AgentConfigSchema, RulesConfigSchema, WorkflowsConfigSchema, RedactionConfigSchema, spurConfigSchema, configSchema2;
 var init_src = __esm(() => {
   init_zod();
   init_finding_codes();
@@ -37339,11 +37343,16 @@ var init_src = __esm(() => {
     autostart: exports_external.boolean().optional(),
     members: exports_external.array(TeamMemberConfigSchema).min(1)
   });
+  AgentOutputConfigSchema = exports_external.object({
+    "max-bytes": exports_external.number().int().positive().optional(),
+    "max-lines": exports_external.number().int().positive().optional()
+  });
   AgentConfigSchema = exports_external.object({
     default: exports_external.string().optional(),
     executors: exports_external.array(AgentExecutorConfigSchema).optional(),
     "default-by-phase": exports_external.record(exports_external.string(), exports_external.string()).optional(),
-    team: exports_external.record(exports_external.string(), TeamConfigSchema).optional()
+    team: exports_external.record(exports_external.string(), TeamConfigSchema).optional(),
+    output: AgentOutputConfigSchema.optional()
   }).superRefine((value, ctx) => {
     const executors = value.executors;
     if (executors !== undefined) {
@@ -37356,6 +37365,13 @@ var init_src = __esm(() => {
             path: ["executors", index2, "name"]
           });
         }
+        if (executor.name === "inline" || executor.name === "auto") {
+          ctx.addIssue({
+            code: exports_external.ZodIssueCode.custom,
+            message: `Executor name "${executor.name}" is reserved (the --agent selector value '${executor.name}' has fixed semantics); rename executor at index ${index2}.`,
+            path: ["executors", index2, "name"]
+          });
+        }
         seen.add(executor.name);
       }
     }
@@ -39182,7 +39198,7 @@ async function loadStructuredSpurConfig(configPath, opts) {
 function defaultFoldersConfig() {
   return {
     active_folder: DEFAULT_TASKS_DIR,
-    folders: { [DEFAULT_TASKS_DIR]: { base_counter: 0 } }
+    folders: { [DEFAULT_TASKS_DIR]: { baseCounter: 0 } }
   };
 }
 function defaultPlanningFolders() {
@@ -39219,8 +39235,7 @@ async function resolvePlanningFoldersUncached(fs2) {
     const tasks = tasksConfigSchema.parse(parsed.tasks);
     const folders = {};
     for (const [path8, fc] of Object.entries(tasks.folders)) {
-      const validated = folderConfigSchema.parse(fc);
-      folders[path8] = { base_counter: validated.baseCounter, label: validated.label };
+      folders[path8] = folderConfigSchema.parse(fc);
     }
     const foldersConfig = {
       active_folder: tasks.active,
@@ -58289,9 +58304,6 @@ function normalizeCapabilityTier(value) {
 function isTierEligible(candidateTier, minTier) {
   return TIER_RANK[candidateTier] >= TIER_RANK[minTier];
 }
-function pickStartingTier(policy) {
-  return policy.min_tier;
-}
 function getNextFallback(policy, signal, currentTier) {
   const currentRank = currentTier ? TIER_RANK[currentTier] : 0;
   const match = policy.fallback.find((f) => f.trigger === signal && TIER_RANK[f.tier] > currentRank);
@@ -58357,12 +58369,12 @@ function parseStageRecord(raw, consumerVersion = STAGE_REGISTRY_SCHEMA_VERSION)
 function getCanonicalStage(idOrAlias) {
   return CANONICAL_STAGE_BY_KEY.get(idOrAlias);
 }
-var STAGE_REGISTRY_SCHEMA_VERSION, stageSchemaVersionSchema, AUTHORITY_LANES, MUTATION_CLASSES, EXECUTION_KINDS, inlineExecutionSchema, subprocessExecutionSchema, deterministicExecutionSchema, hitlExecutionSchema, irreversibleExecutionSchema, executionKindSchema, ARTIFACT_DIRECTIONS, stageArtifactSchema, stageGateSchema, stageRetryPolicySchema, CAPABILITY_TIERS, LEGACY_CAPABLE_ALIAS = "capable", capabilityTierSchema, stageModelPolicySchema, TIER_RANK, CONTEXT_LAYER_NAMES, stageContextLayerSchema, stageEventSchema, STAGE_ID_PATTERN, stageRecordSchema, StageRegistryError, REGISTERED_CANONICAL_STAGES, CANONICAL_STAGE_BY_KEY;
+var STAGE_REGISTRY_SCHEMA_VERSION, stageSchemaVersionSchema, AUTHORITY_LANES, MUTATION_CLASSES, EXECUTION_KINDS, inlineExecutionSchema, subprocessExecutionSchema, deterministicExecutionSchema, hitlExecutionSchema, irreversibleExecutionSchema, executionKindSchema, ARTIFACT_DIRECTIONS, stageArtifactSchema, stageGateSchema, stageRetryPolicySchema, CAPABILITY_TIERS, LEGACY_CAPABLE_ALIAS = "capable", capabilityTierSchema, objectiveEscalationTriggerSchema, stageModelPolicySchema, TIER_RANK, CONTEXT_LAYER_NAMES, stageContextLayerSchema, stageEventSchema, STAGE_ID_PATTERN, stageRecordSchema, StageRegistryError, REGISTERED_CANONICAL_STAGES, CANONICAL_STAGE_BY_KEY;
 var init_schema4 = __esm(() => {
   init_zod();
   STAGE_REGISTRY_SCHEMA_VERSION = {
     major: 1,
-    minor: 0
+    minor: 1
   };
   stageSchemaVersionSchema = exports_external.object({
     major: exports_external.number().int().nonnegative(),
@@ -58433,11 +58445,18 @@ var init_schema4 = __esm(() => {
   }).strict();
   CAPABILITY_TIERS = ["cheap", "standard", "capable-1", "capable-2", "capable-3"];
   capabilityTierSchema = exports_external.preprocess(normalizeCapabilityTier, exports_external.enum(CAPABILITY_TIERS));
+  objectiveEscalationTriggerSchema = exports_external.enum([
+    "gate-fail",
+    "timeout",
+    "insufficient-evidence",
+    "retry-exhausted",
+    "resource-exhaustion"
+  ]);
   stageModelPolicySchema = exports_external.object({
     min_tier: capabilityTierSchema,
     fallback: exports_external.array(exports_external.object({
       tier: capabilityTierSchema,
-      trigger: exports_external.enum(["gate-fail", "timeout", "insufficient-evidence", "retry-exhausted"])
+      trigger: objectiveEscalationTriggerSchema
     }).strict()),
     override_key: exports_external.string().optional()
   }).strict();
@@ -58508,7 +58527,10 @@ var init_schema4 = __esm(() => {
       retry: { max_attempts: 3, terminal_stop: "block" },
       model_policy: {
         min_tier: "standard",
-        fallback: [{ tier: "capable-2", trigger: "gate-fail" }]
+        fallback: [
+          { tier: "capable-2", trigger: "gate-fail" },
+          { tier: "capable-2", trigger: "resource-exhaustion" }
+        ]
       },
       context_layers: [],
       observability: [],
@@ -58527,7 +58549,10 @@ var init_schema4 = __esm(() => {
       retry: { max_attempts: 3, terminal_stop: "block" },
       model_policy: {
         min_tier: "capable-2",
-        fallback: [{ tier: "capable-3", trigger: "gate-fail" }]
+        fallback: [
+          { tier: "capable-3", trigger: "gate-fail" },
+          { tier: "capable-3", trigger: "resource-exhaustion" }
+        ]
       },
       context_layers: [],
       observability: [],
@@ -58548,7 +58573,8 @@ var init_schema4 = __esm(() => {
         min_tier: "standard",
         fallback: [
           { tier: "capable-1", trigger: "gate-fail" },
-          { tier: "capable-1", trigger: "timeout" }
+          { tier: "capable-1", trigger: "timeout" },
+          { tier: "capable-1", trigger: "resource-exhaustion" }
         ]
       },
       context_layers: [],
@@ -58567,8 +58593,11 @@ var init_schema4 = __esm(() => {
       mutation_class: "tests",
       retry: { max_attempts: 3, terminal_stop: "block" },
       model_policy: {
-        min_tier: "standard",
-        fallback: [{ tier: "capable-1", trigger: "gate-fail" }]
+        fallback: [
+          { tier: "capable-1", trigger: "gate-fail" },
+          { tier: "capable-1", trigger: "resource-exhaustion" }
+        ],
+        min_tier: "standard"
       },
       context_layers: [],
       observability: [],
@@ -58606,7 +58635,10 @@ var init_schema4 = __esm(() => {
       retry: { max_attempts: 2, terminal_stop: "block" },
       model_policy: {
         min_tier: "standard",
-        fallback: [{ tier: "capable-1", trigger: "gate-fail" }]
+        fallback: [
+          { tier: "capable-1", trigger: "gate-fail" },
+          { tier: "capable-1", trigger: "resource-exhaustion" }
+        ]
       },
       context_layers: [],
       observability: [],
@@ -58625,7 +58657,10 @@ var init_schema4 = __esm(() => {
       retry: { max_attempts: 2, terminal_stop: "block" },
       model_policy: {
         min_tier: "standard",
-        fallback: [{ tier: "capable-1", trigger: "gate-fail" }]
+        fallback: [
+          { tier: "capable-1", trigger: "gate-fail" },
+          { tier: "capable-1", trigger: "resource-exhaustion" }
+        ]
       },
       context_layers: [],
       observability: [],
@@ -60268,13 +60303,13 @@ __export(exports_src, {
   queryEtlRecords: () => queryEtlRecords,
   queryAllEtlRecords: () => queryAllEtlRecords,
   projectSnapshotSchema: () => projectSnapshotSchema,
-  pickStartingTier: () => pickStartingTier,
   passAllResolver: () => passAllResolver,
   parseStageRecord: () => parseStageRecord,
   parseHistoryLine: () => parseHistoryLine,
   parseFeature: () => parseFeature,
   parseExistingAcTags: () => parseExistingAcTags,
   parseChecklist: () => parseChecklist,
+  objectiveEscalationTriggerSchema: () => objectiveEscalationTriggerSchema,
   normalizeTitle: () => normalizeTitle,
   normalizeTaskStatusSafe: () => normalizeTaskStatusSafe,
   normalizeTaskStatus: () => normalizeTaskStatus,
@@ -60588,92 +60623,159 @@ class AgentService {
     if (!resolved.ok) {
       return { ok: false, exitCode: resolved.exitCode, message: resolved.message };
     }
-    const agent = resolved.agent;
-    if (!jsonOutput && TIER2_AGENTS.has(agent)) {
-      this.ctx.output.error(`Warning: ${agent} is a Tier-2 agent (TUI/gateway only)`);
+    const runFlags = { ...flags };
+    let currentAgent = resolved.agent;
+    let currentModel = resolved.model;
+    let currentSource = resolved.source;
+    let currentStage = resolved.stage;
+    const maxEscalations = currentStage?.policy.fallback.length ?? 0;
+    const attemptedExecutors = new Set(currentStage ? [currentStage.executorName] : []);
+    if (!jsonOutput && TIER2_AGENTS.has(currentAgent)) {
+      this.ctx.output.error(`Warning: ${currentAgent} is a Tier-2 agent (TUI/gateway only)`);
     }
-    const translated = prompt !== undefined && isClaudeStyleSlashCommand(prompt) ? translateSlashCommand(agent, prompt) : undefined;
-    const input = translated ?? prompt;
+    const explicitModel = stringFlag(flags, "model", "") || undefined;
     const purpose = stringFlag(flags, "purpose", "") || undefined;
     const tags = parseTagsFlag(flags);
     const systemPrompt = stringFlag(flags, "system-prompt", "") || undefined;
     const taskId = stringFlag(flags, "task", "") || undefined;
-    const explicitModel = stringFlag(flags, "model", "") || undefined;
-    const model = explicitModel ?? resolved.model;
-    const promptOptions = {
-      input,
-      continue: continueFlag || undefined,
-      model,
-      mode,
-      ...purpose !== undefined ? { purpose } : {},
-      ...tags !== undefined ? { tags } : {},
-      ...systemPrompt !== undefined ? { systemPrompt } : {},
-      ...taskId !== undefined ? { taskId } : {}
-    };
-    let shimCommand;
-    try {
-      shimCommand = typeof runner.buildPromptCommand === "function" ? runner.buildPromptCommand(agent, promptOptions, { cwd: cwd || undefined }) : getAgentShim(agent).getPromptCommand(promptOptions);
-      if (!jsonOutput) {
-        const version3 = (await detector.detectOne(agent)).version;
-        this.ctx.output.error(`\u2699\uFE0F  ${agent}${version3 !== null ? ` v${version3}` : ""}
-   ${shimCommand.command} ${shimCommand.args.join(" ")}`);
-      }
-    } catch (error51) {
-      return { ok: false, exitCode: 2, message: error51 instanceof Error ? error51.message : String(error51) };
-    }
-    const traceInput = input === undefined ? undefined : traceSafePrompt(input);
-    const invocation = {
-      agent,
-      source: resolved.source,
-      command: shimCommand.command,
-      argv: sanitizeInvocationArgv(shimCommand.args, input, traceInput),
-      ...cwd !== "" ? { cwd } : {},
-      mode,
-      outputMode,
-      ...timeoutMs !== undefined ? { timeoutMs } : {},
-      continue: continueFlag,
-      stdinInteractive: false,
-      ...model !== undefined ? { model } : {},
-      ...translated !== undefined && prompt !== undefined ? { translatedFrom: traceSafePrompt(prompt) } : {}
-    };
-    let result;
     const controller = new AbortController;
     const onTerminate = () => controller.abort();
     const onExternalAbort = () => controller.abort();
     const lifecycle = new AgentExecutionLifecycle(options.execution?.observer, options.execution?.correlation, configuredSecretValues(this.ctx.env), options.execution?.heartbeatMs);
-    lifecycle.start({
-      agent,
-      ...model !== undefined ? { model } : {},
-      invocation: `${invocation.command} ${invocation.argv.join(" ")}`,
-      ...timeoutMs !== undefined ? { timeoutMs } : {}
-    });
-    const dispatchStartedAt = Date.now();
+    process.on("SIGTERM", onTerminate);
+    process.on("SIGINT", onTerminate);
+    options.execution?.signal?.addEventListener("abort", onExternalAbort, { once: true });
+    if (options.execution?.signal?.aborted === true)
+      controller.abort();
+    let result;
+    let invocation;
+    let dispatchStartedAt = Date.now();
     try {
-      process.on("SIGTERM", onTerminate);
-      process.on("SIGINT", onTerminate);
-      options.execution?.signal?.addEventListener("abort", onExternalAbort, { once: true });
-      if (options.execution?.signal?.aborted === true)
-        controller.abort();
-      result = await runner.runPromptCommand(agent, promptOptions, {
-        cwd: cwd || undefined,
-        ...timeoutMs !== undefined ? { timeout: timeoutMs } : {},
-        signal: controller.signal,
-        correlation: lifecycle.identity,
-        onOutput: (output2) => lifecycle.observe(output2)
-      });
-    } catch (error51) {
-      lifecycle.finish({
-        exitCode: null,
-        durationMs: Date.now() - dispatchStartedAt,
-        ...controller.signal.aborted ? { reason: "cancelled" } : {},
-        ...!controller.signal.aborted ? { reason: error51 instanceof Error ? error51.message : String(error51) } : {}
-      });
-      return { ok: false, exitCode: 2, message: error51 instanceof Error ? error51.message : String(error51) };
+      for (let attempt = 0;; attempt++) {
+        const agent = currentAgent;
+        const model = explicitModel ?? currentModel;
+        const translated = prompt !== undefined && isClaudeStyleSlashCommand(prompt) ? translateSlashCommand(agent, prompt) : undefined;
+        const input = translated ?? prompt;
+        const promptOptions = {
+          input,
+          continue: continueFlag || undefined,
+          model,
+          mode,
+          ...purpose !== undefined ? { purpose } : {},
+          ...tags !== undefined ? { tags } : {},
+          ...systemPrompt !== undefined ? { systemPrompt } : {},
+          ...taskId !== undefined ? { taskId } : {}
+        };
+        let shimCommand;
+        try {
+          shimCommand = typeof runner.buildPromptCommand === "function" ? runner.buildPromptCommand(agent, promptOptions, { cwd: cwd || undefined }) : getAgentShim(agent).getPromptCommand(promptOptions);
+          if (!jsonOutput) {
+            const version3 = (await detector.detectOne(agent)).version;
+            this.ctx.output.error(`\u2699\uFE0F  ${agent}${version3 !== null ? ` v${version3}` : ""}
+   ${shimCommand.command} ${shimCommand.args.join(" ")}`);
+          }
+        } catch (error51) {
+          if (attempt === 0) {
+            return {
+              ok: false,
+              exitCode: 2,
+              message: error51 instanceof Error ? error51.message : String(error51)
+            };
+          }
+          if (!jsonOutput) {
+            this.ctx.output.error(`Escalation aborted: ${error51 instanceof Error ? error51.message : String(error51)}`);
+          }
+          break;
+        }
+        const traceInput = input === undefined ? undefined : traceSafePrompt(input);
+        const attemptInvocation = {
+          agent,
+          source: currentSource,
+          command: shimCommand.command,
+          argv: sanitizeInvocationArgv(shimCommand.args, input, traceInput),
+          ...cwd !== "" ? { cwd } : {},
+          mode,
+          outputMode,
+          ...timeoutMs !== undefined ? { timeoutMs } : {},
+          continue: continueFlag,
+          stdinInteractive: false,
+          ...model !== undefined ? { model } : {},
+          ...translated !== undefined && prompt !== undefined ? { translatedFrom: traceSafePrompt(prompt) } : {}
+        };
+        if (attempt === 0) {
+          lifecycle.start({
+            agent,
+            ...model !== undefined ? { model } : {},
+            invocation: `${attemptInvocation.command} ${attemptInvocation.argv.join(" ")}`,
+            ...timeoutMs !== undefined ? { timeoutMs } : {}
+          });
+          dispatchStartedAt = Date.now();
+        }
+        try {
+          result = await runner.runPromptCommand(agent, promptOptions, {
+            cwd: cwd || undefined,
+            ...timeoutMs !== undefined ? { timeout: timeoutMs } : {},
+            signal: controller.signal,
+            correlation: lifecycle.identity,
+            onOutput: (output2) => lifecycle.observe(output2)
+          });
+        } catch (error51) {
+          if (attempt === 0) {
+            lifecycle.finish({
+              exitCode: null,
+              durationMs: Date.now() - dispatchStartedAt,
+              ...controller.signal.aborted ? { reason: "cancelled" } : {},
+              ...!controller.signal.aborted ? { reason: error51 instanceof Error ? error51.message : String(error51) } : {}
+            });
+            return {
+              ok: false,
+              exitCode: 2,
+              message: error51 instanceof Error ? error51.message : String(error51)
+            };
+          }
+          if (!jsonOutput) {
+            this.ctx.output.error(`Escalation dispatch failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+          }
+          break;
+        }
+        invocation = attemptInvocation;
+        if (result.exitCode === 0)
+          break;
+        const escalationSignal = classifyObjectiveFailure(result);
+        if (escalationSignal === undefined || currentStage === undefined || attempt >= maxEscalations) {
+          break;
+        }
+        runFlags.signal = escalationSignal;
+        runFlags["from-executor"] = currentStage.executorName;
+        const nextResolved = await this.resolveAgent(prompt, runFlags, doctorRunner);
+        if (!nextResolved.ok || nextResolved.stage === undefined || attemptedExecutors.has(nextResolved.stage.executorName)) {
+          if (!jsonOutput) {
+            this.ctx.output.error(`Escalation chain exhausted after ${attempt + 1} attempt(s); executors tried: ${[...attemptedExecutors].join(", ")}`);
+          }
+          break;
+        }
+        if (!jsonOutput) {
+          this.ctx.output.error(`Escalating: ${currentStage.executorName} (tier ${currentStage.executorTier}) failed with ${escalationSignal}; retrying on ${nextResolved.stage.executorName} (tier ${nextResolved.stage.executorTier})`);
+        }
+        currentAgent = nextResolved.agent;
+        currentModel = nextResolved.model;
+        currentSource = nextResolved.source;
+        currentStage = nextResolved.stage;
+        attemptedExecutors.add(nextResolved.stage.executorName);
+      }
     } finally {
       process.off("SIGTERM", onTerminate);
       process.off("SIGINT", onTerminate);
       options.execution?.signal?.removeEventListener("abort", onExternalAbort);
     }
+    if (result === undefined || invocation === undefined) {
+      lifecycle.finish({
+        exitCode: null,
+        durationMs: Date.now() - dispatchStartedAt,
+        reason: "no dispatch attempted"
+      });
+      return { ok: false, exitCode: 2, message: "No dispatch attempted" };
+    }
     lifecycle.finish({
       exitCode: result.exitCode,
       durationMs: result.durationMs,
@@ -60703,6 +60805,13 @@ class AgentService {
     const raw = stringFlag(flags, "agent", "auto");
     if (raw === "auto")
       return this.resolveAgentAuto(prompt, flags, doctorRunner);
+    if (raw === "inline") {
+      return {
+        ok: false,
+        exitCode: 2,
+        message: "'inline' selects in-session execution and cannot be passed to 'spur agent run', which always starts a subprocess. Run the backing skill directly in the current session, or use '--agent auto' for subprocess dispatch with a tier-resolved executor."
+      };
+    }
     return this.resolveExecutorSelector(raw, doctorRunner, "explicit");
   }
   async resolveAgentAuto(prompt, flags, doctorRunner) {
@@ -60773,7 +60882,13 @@ class AgentService {
           ok: true,
           agent: canonical,
           model: executor.model,
-          source: "stage"
+          source: "stage",
+          stage: {
+            stageId: stageRecord.id,
+            policy,
+            executorName: executor.name,
+            executorTier: getExecutorTier(executor)
+          }
         };
       }
     }
@@ -60821,8 +60936,15 @@ class AgentService {
       };
     }
     const canonical = resolveAgentName(selector);
-    if (canonical === undefined)
-      return { ok: false, exitCode: 2, message: `Unknown agent: ${selector}` };
+    if (canonical === undefined) {
+      const names = this.ctx.agentConfig?.executors?.map((e) => e.name) ?? [];
+      const available = names.length > 0 ? names.join(", ") : "(no executors configured; use a canonical agent name)";
+      return {
+        ok: false,
+        exitCode: 2,
+        message: `Unknown agent: '${selector}'. Available executors: ${available}.`
+      };
+    }
     const usable = await this.checkUsable(canonical, doctorRunner);
     if (!usable.ok)
       return usable.result;
@@ -61008,6 +61130,17 @@ function getExecutorTier(executor) {
     return "capable-1";
   return "standard";
 }
+function classifyObjectiveFailure(result) {
+  if (result.signal !== undefined)
+    return "timeout";
+  if (result.exitCode === 0)
+    return;
+  const text4 = `${result.stderr} ${result.stdout}`.toLowerCase();
+  if (/\b(rate[\s-]?limit|429|too many requests|quota|token limit|token budget|context length|maximum context|context window)\b/.test(text4)) {
+    return "resource-exhaustion";
+  }
+  return;
+}
 var TRACE_SAFE_SLASH_COMMAND, TRACE_SAFE_SLASH_TOKEN, SENSITIVE_FLAG, SENSITIVE_INLINE_FLAG;
 var init_agent_service = __esm(() => {
   init_src2();
@@ -61861,11 +61994,106 @@ var init_planning_check_base = __esm(() => {
 // ../../packages/app/src/services/feature-check.ts
 var exports_feature_check = {};
 __export(exports_feature_check, {
+  findOtherP0InStatus: () => findOtherP0InStatus,
   defaultVerdictRunDir: () => defaultVerdictRunDir,
   FeatureCheckService: () => FeatureCheckService,
   DEFAULT_FEATURE_MATRIX: () => DEFAULT_FEATURE_MATRIX
 });
 import { dirname as dirname8, join as join8 } from "path";
+function isGroupFeature(fm) {
+  const tags = fm.tags;
+  return Array.isArray(tags) && tags.includes("group") ? "group" : "standard";
+}
+async function findOtherP0InStatus(fs3, featuresDir, currentId, statuses) {
+  try {
+    const entries = await fs3.readDir(featuresDir);
+    for (const entry of entries) {
+      if (!entry.endsWith(".md"))
+        continue;
+      const match = /^([A-Z][1-9]*)_/.exec(entry);
+      if (match === null)
+        continue;
+      const otherId = match[1];
+      if (otherId === undefined)
+        continue;
+      if (otherId === currentId)
+        continue;
+      try {
+        const raw = await fs3.readFile(`${featuresDir}/${entry}`);
+        const doc2 = MarkdownDocument.parse(raw, "feature");
+        const otherFm = doc2.frontmatterData ?? {};
+        const otherPriority = otherFm.priority;
+        const otherStatus = otherFm.status ?? "backlog";
+        if (otherPriority === "P0" && statuses.includes(otherStatus)) {
+          return { id: otherId, status: otherStatus };
+        }
+      } catch {}
+    }
+  } catch {}
+  return null;
+}
+function decodeVerdictRows(source, sectionName, required2) {
+  if (source === undefined) {
+    return {
+      rows: [],
+      rejected: 0,
+      invalidFields: required2 ? [`${sectionName} (missing array)`] : [],
+      state: "absent"
+    };
+  }
+  if (!Array.isArray(source)) {
+    return {
+      rows: [],
+      rejected: 0,
+      invalidFields: [`${sectionName} (expected array)`],
+      state: "invalid"
+    };
+  }
+  const rows = [];
+  const invalidFields = new Set;
+  let rejected = 0;
+  for (const r of source) {
+    if (typeof r !== "object" || r === null) {
+      rejected++;
+      invalidFields.add(`${sectionName}[non-object]`);
+      continue;
+    }
+    const row = r;
+    const hasId = Object.hasOwn(row, "id");
+    const hasScenario = Object.hasOwn(row, "scenario");
+    const idStr = typeof row.id === "string";
+    const scStr = typeof row.scenario === "string";
+    const statusOk = typeof row.status === "string";
+    if (!statusOk) {
+      rejected++;
+      invalidFields.add(`${sectionName}.status`);
+      continue;
+    }
+    if (hasId && hasScenario) {
+      if (idStr && scStr && row.id === row.scenario) {
+        rows.push({ id: row.id, status: row.status });
+      } else {
+        rejected++;
+        invalidFields.add(`${sectionName}.id/scenario conflict`);
+      }
+      continue;
+    }
+    if (hasId && idStr) {
+      rows.push({ id: row.id, status: row.status });
+    } else if (hasScenario && scStr) {
+      rows.push({ id: row.scenario, status: row.status });
+    } else {
+      rejected++;
+      invalidFields.add(`${sectionName}.id/scenario missing`);
+    }
+  }
+  return {
+    rows,
+    rejected,
+    invalidFields: [...invalidFields],
+    state: source.length === 0 ? "empty" : "populated"
+  };
+}
 function defaultVerdictRunDir(tasksDir) {
   const norm = tasksDir.replace(/\\/g, "/");
   if (/\/docs\/tasks\d*$/.test(norm) || /\/docs\/tasks$/.test(norm)) {
@@ -61911,6 +62139,35 @@ var init_feature_check = __esm(() => {
           required: ["Notes"],
           optional: ["Goal", "Scope", "Acceptance Criteria", "Tasks", "History"]
         }
+      },
+      group: {
+        backlog: {
+          required: [],
+          optional: ["Goal", "Scope", "Acceptance Criteria", "Tasks", "Notes", "History"]
+        },
+        active: {
+          required: ["Goal", "Scope"],
+          optional: ["Acceptance Criteria", "Tasks", "Notes", "History"],
+          gate: true
+        },
+        verifying: {
+          required: ["Goal", "Scope"],
+          optional: ["Acceptance Criteria", "Tasks", "Notes", "History"],
+          gate: true
+        },
+        blocked: {
+          required: ["Goal", "Notes"],
+          optional: ["Scope", "Acceptance Criteria", "Tasks", "History"]
+        },
+        done: {
+          required: ["Goal", "Scope", "Tasks"],
+          optional: ["Acceptance Criteria", "Notes", "History"],
+          gate: true
+        },
+        cancelled: {
+          required: ["Notes"],
+          optional: ["Goal", "Scope", "Acceptance Criteria", "Tasks", "History"]
+        }
       }
     }
   };
@@ -61934,11 +62191,11 @@ var init_feature_check = __esm(() => {
       }
       const fm = doc2.frontmatterData ?? {};
       const status = fm.status ?? "backlog";
-      const entry = this.resolveMatrixEntry("standard", status);
+      const entry = this.resolveMatrixEntry(isGroupFeature(fm), status);
       this.runL2(doc2, entry, findings);
       this.runL3(doc2, findings);
       if (options?.featuresDir) {
-        await this.checkOneActiveGoal(fm, featureId2, options.featuresDir, findings);
+        await this.checkOneActiveGoal(fm, featureId2, options.featuresDir, findings, options.asStatus);
         await this.checkChildrenLimit(featureId2, options.featuresDir, findings);
       }
       const dogfoodDir = options?.dogfoodDir ?? (options?.featuresDir ? join8(dirname8(options.featuresDir), "dogfood") : undefined);
@@ -62011,44 +62268,24 @@ var init_feature_check = __esm(() => {
         }
       }
     }
-    async checkOneActiveGoal(fm, currentId, featuresDir, findings) {
+    async checkOneActiveGoal(fm, currentId, featuresDir, findings, asStatus) {
       const priority = fm.priority;
-      const status = fm.status;
+      const status = fm.status ?? "backlog";
+      const effectiveStatus = asStatus ?? status;
       if (priority !== "P0")
         return;
-      if (status !== "active" && status !== "verifying")
+      if (effectiveStatus !== "active")
         return;
-      try {
-        const entries = await this.fs.readDir(featuresDir);
-        for (const entry of entries) {
-          if (!entry.endsWith(".md"))
-            continue;
-          const otherPath = `${featuresDir}/${entry}`;
-          const match = /^([A-Z][1-9]*)_/.exec(entry);
-          if (!match)
-            continue;
-          const otherId = match[1];
-          if (otherId === currentId)
-            continue;
-          try {
-            const raw = await this.fs.readFile(otherPath);
-            const doc2 = MarkdownDocument.parse(raw, "feature");
-            const otherFm = doc2.frontmatterData ?? {};
-            const otherPriority = otherFm.priority;
-            const otherStatus = otherFm.status;
-            if (otherPriority === "P0" && (otherStatus === "active" || otherStatus === "verifying")) {
-              findings.push({
-                layer: "L3",
-                code: FINDING_CODES.L3_ONE_ACTIVE_GOAL,
-                severity: "error",
-                section: "",
-                message: `One-active-goal violated: P0 feature "${otherId}" is already ${otherStatus}`
-              });
-              return;
-            }
-          } catch {}
-        }
-      } catch {}
+      const conflict = await findOtherP0InStatus(this.fs, featuresDir, currentId, ["active"]);
+      if (conflict !== null) {
+        findings.push({
+          layer: "L3",
+          code: FINDING_CODES.L3_ONE_ACTIVE_GOAL,
+          severity: "error",
+          section: "",
+          message: `One-active-goal violated: P0 feature "${conflict.id}" is already ${conflict.status}`
+        });
+      }
     }
     async checkChildrenLimit(featureId2, featuresDir, findings) {
       let children = 0;
@@ -62209,11 +62446,42 @@ var init_feature_check = __esm(() => {
         }
         covers[sc.title] = linked;
       }
+      const doneWbs = new Set;
+      for (const sc of scenarioAliases) {
+        for (const task of covers[sc.title] ?? []) {
+          if (task.status === "done")
+            doneWbs.add(task.wbs);
+        }
+      }
+      const artifacts2 = new Map;
+      for (const wbs of doneWbs) {
+        const artifact = await this.readVerdictArtifact(runDir, wbs);
+        artifacts2.set(wbs, artifact);
+        const diagnosticParts = [];
+        if (artifact.diagnostics.artifactError !== undefined) {
+          diagnosticParts.push(artifact.diagnostics.artifactError);
+        }
+        if (artifact.diagnostics.rejectedRowCount > 0) {
+          diagnosticParts.push(`${artifact.diagnostics.rejectedRowCount} rejected coverage row(s)`);
+        }
+        if (artifact.diagnostics.invalidFields.length > 0) {
+          diagnosticParts.push(`invalid fields: ${artifact.diagnostics.invalidFields.join(", ")}`);
+        }
+        if (diagnosticParts.length > 0) {
+          findings.push({
+            layer: "L4",
+            code: FINDING_CODES.L4_MALFORMED_VERDICT_ARTIFACT,
+            severity: "warning",
+            section: "Acceptance Criteria",
+            message: `Task ${wbs} verdict artifact (${artifact.path}) is invalid: ${diagnosticParts.join("; ")}. ` + "Rows were not silently dropped \u2014 verify the artifact uses canonical `id` " + "(or `scenario` alias) and `status` fields."
+          });
+        }
+      }
       for (const sc of scenarioAliases) {
         const linked = covers[sc.title] ?? [];
         if (linked.length === 0)
           continue;
-        const verified = await this.isScenarioVerified(sc, linked, runDir);
+        const verified = this.isScenarioVerified(sc, linked, artifacts2);
         if (!verified) {
           findings.push({
             layer: "L4",
@@ -62225,12 +62493,12 @@ var init_feature_check = __esm(() => {
         }
       }
     }
-    async isScenarioVerified(sc, linked, runDir) {
+    isScenarioVerified(sc, linked, artifacts2) {
       for (const task of linked) {
         if (task.status !== "done")
           continue;
-        const artifact = await this.readVerdictArtifact(runDir, task.wbs);
-        if (artifact === null)
+        const artifact = artifacts2.get(task.wbs);
+        if (artifact === undefined)
           continue;
         if (artifact.verdict !== "PASS")
           continue;
@@ -62242,20 +62510,35 @@ var init_feature_check = __esm(() => {
       return false;
     }
     async readVerdictArtifact(runDir, wbs) {
-      try {
-        const raw = await this.fs.readFile(join8(runDir, `${wbs}-verdict.json`));
-        const parsed = JSON.parse(raw);
-        if (typeof parsed.verdict !== "string")
-          return null;
-        const pickRows = (arr) => (arr ?? []).filter((r) => typeof r?.id === "string" && typeof r?.status === "string").map((r) => ({ id: r.id, status: r.status }));
-        const requirements = pickRows(parsed.requirements);
-        const acceptanceCriteria = pickRows(parsed.acceptanceCriteria);
-        if (requirements.length === 0 && acceptanceCriteria.length === 0)
-          return null;
-        return { verdict: parsed.verdict, requirements, acceptanceCriteria };
-      } catch {
-        return null;
+      const loaded = await readVerdictArtifact(this.fs, runDir, wbs);
+      if (loaded.artifact === undefined) {
+        return {
+          path: loaded.path,
+          requirements: [],
+          acceptanceCriteria: [],
+          diagnostics: {
+            artifactError: loaded.readError ?? "artifact is missing",
+            rejectedRowCount: 0,
+            invalidFields: [],
+            arrayStates: { requirements: "unavailable", acceptanceCriteria: "unavailable" }
+          }
+        };
       }
+      const parsed = loaded.artifact;
+      const req = decodeVerdictRows(parsed.requirements, "requirements", true);
+      const ac = decodeVerdictRows(parsed.acceptanceCriteria, "acceptanceCriteria", false);
+      return {
+        path: loaded.path,
+        verdict: typeof parsed.verdict === "string" ? parsed.verdict : undefined,
+        requirements: req.rows,
+        acceptanceCriteria: ac.rows,
+        diagnostics: {
+          artifactError: typeof parsed.verdict === "string" ? undefined : "invalid `verdict` field",
+          rejectedRowCount: req.rejected + ac.rejected,
+          invalidFields: [...new Set([...req.invalidFields, ...ac.invalidFields])],
+          arrayStates: { requirements: req.state, acceptanceCriteria: ac.state }
+        }
+      };
     }
   };
 });
@@ -62323,6 +62606,25 @@ class TaskLocator {
     }
     return null;
   }
+  async findDuplicateWbs() {
+    const wbsMap = new Map;
+    for (const dir of this.folderDirs()) {
+      for (const name of await readDirIfPresent(this.fs, dir)) {
+        const captured = TASK_FILENAME_RE.exec(name);
+        if (captured === null)
+          continue;
+        const wbs = captured[1];
+        const hit = { wbs, name, filePath: `${dir}/${name}` };
+        const existing = wbsMap.get(wbs);
+        if (existing) {
+          existing.push(hit);
+        } else {
+          wbsMap.set(wbs, [hit]);
+        }
+      }
+    }
+    return [...wbsMap.values()].filter((hits) => hits.length > 1);
+  }
 }
 var TASK_FILENAME_RE;
 var init_task_locator = __esm(() => {
@@ -62609,11 +62911,32 @@ class FeatureService {
     }
     const appliedHops = [];
     for (const hop of hops) {
+      if (hop === "active") {
+        const conflict = await this.findOneActiveGoalConflict(featureId2);
+        if (conflict !== null) {
+          return {
+            proposal: {
+              ...proposal,
+              reason: `Activation blocked by one-active-goal: P0 feature "${conflict.featureId}" is already ${conflict.status}`
+            },
+            applied: false,
+            appliedHops,
+            goalConflict: conflict
+          };
+        }
+      }
       await this.transition(featureId2, hop);
       appliedHops.push(hop);
     }
     return { proposal, applied: true, appliedHops };
   }
+  async findOneActiveGoalConflict(featureId2) {
+    const feature = await this.show(featureId2);
+    if (feature === null || feature.frontmatter.priority !== "P0")
+      return null;
+    const conflict = await findOtherP0InStatus(this.ctx.fs, this.ctx.featuresDir, featureId2, ["active"]);
+    return conflict === null ? null : { featureId: conflict.id, status: conflict.status };
+  }
   async syncAllFeatures(options) {
     const allFeatures = await this.list();
     const tasksByFeature = await this.collectTasksByFeature();
@@ -65347,6 +65670,21 @@ var init_task_check = __esm(() => {
           });
         }
       }
+      const requiredSections = new Set(entry?.required ?? []);
+      for (const sectionName of ["Testing", "Solution"]) {
+        if (!requiredSections.has(sectionName))
+          continue;
+        const body = doc2.getSection(sectionName);
+        if (body === null || !isPlaceholderBody(body))
+          continue;
+        findings.push({
+          layer: "L3",
+          code: FINDING_CODES.L3_REQUIRED_SECTION_PLACEHOLDER,
+          severity: "error",
+          section: sectionName,
+          message: `${sectionName} is required at status '${status}' but is still placeholder-only \u2014 run \`spur task record <wbs>\` to fill it from the verdict artifact, or author it directly`
+        });
+      }
       const testBody = doc2.getSection("Testing");
       if (testBody !== null && !isPlaceholderBody(testBody)) {
         const hasCoverage = /coverage|\u2265\d+%|\d+\.\d+%|N\/A/i.test(testBody);
@@ -66219,15 +66557,15 @@ class TaskService {
     const variant = params.template ?? (params.featureId !== undefined ? "feature-impl" : DEFAULT_TASK_VARIANT);
     const status = params.status ?? (params.featureId !== undefined ? "todo" : "backlog");
     return this.writeService.createAllocated(folder, async () => {
-      if (params.dedupeWithinSec !== undefined && params.featureId !== undefined) {
-        const collision = await this.findDuplicateFollowUp(params.featureId, params.title, params.dedupeWithinSec);
+      const dedupeWithinSec = params.dedupeWithinSec === null ? undefined : params.dedupeWithinSec ?? 300;
+      if (dedupeWithinSec !== undefined && params.featureId !== undefined) {
+        const collision = await this.findDuplicateFollowUp(params.featureId, params.title, dedupeWithinSec);
         if (collision !== null) {
           throw new DuplicateFollowUpError(collision.wbs, collision.name, params.title);
         }
       }
-      const wbs = await this.allocateWbs();
       const slug = this.slugify(params.title);
-      const filePath = this.resolveTaskPath(wbs, slug);
+      const { wbs, filePath } = await this.allocateWbsChecked(slug);
       const now = new Date().toISOString();
       const rawTemplate = this.ctx.resolveTemplate?.(variant);
       if (rawTemplate !== undefined) {
@@ -66630,9 +66968,8 @@ ${issues}`);
     const status = hasSpec ? "todo" : "backlog";
     const variant = item.template ?? (item.feature_id !== undefined && item.feature_id !== null ? "feature-impl" : DEFAULT_TASK_VARIANT);
     return this.writeService.createAllocated(folder, async () => {
-      const wbs = await this.allocateWbs();
       const slug = this.slugify(item.name);
-      const filePath = this.resolveTaskPath(wbs, slug);
+      const { wbs, filePath } = await this.allocateWbsChecked(slug);
       const now = new Date().toISOString();
       const rawTemplate = this.ctx.resolveTemplate?.(variant);
       if (rawTemplate !== undefined) {
@@ -66785,9 +67122,15 @@ ${block}` : block);
   }
   async allocateWbs() {
     let max = 0;
-    const dirs = this.ctx.foldersConfig ? [...new Set([this.ctx.tasksDir, ...Object.keys(this.ctx.foldersConfig.folders)])] : [this.ctx.tasksDir];
+    const dirs = this.allFolderDirs();
+    const folderFloors = new Map;
+    if (this.ctx.foldersConfig) {
+      for (const [key, entry] of Object.entries(this.ctx.foldersConfig.folders)) {
+        folderFloors.set(this.ctx.fs.resolve(key), entry.baseCounter);
+      }
+    }
     for (const dir of dirs) {
-      const baseCounter = this.ctx.foldersConfig?.folders[dir]?.base_counter ?? 0;
+      const baseCounter = folderFloors.get(dir) ?? 0;
       if (baseCounter > max)
         max = baseCounter;
       try {
@@ -66804,6 +67147,14 @@ ${block}` : block);
     }
     return String(max + 1).padStart(4, "0");
   }
+  async allocateWbsChecked(slug) {
+    const wbs = await this.allocateWbs();
+    const existing = await this.locator.findByWbs(wbs);
+    if (existing !== null) {
+      throw new WbsCollisionError(wbs, existing.filePath, this.resolveTaskPath(wbs, slug));
+    }
+    return { wbs, filePath: this.resolveTaskPath(wbs, slug) };
+  }
   async getFilePath(wbs) {
     const result = await this.findTaskFileName(wbs);
     if (!result)
@@ -66865,7 +67216,7 @@ ${block}` : block);
     return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
   }
 }
-var DependencyMutationError, SectionMutationError, DuplicateFollowUpError, ROSTER_START = "<!-- AUTO-GENERATED by spur task refresh-roster -->", ROSTER_END = "<!-- END AUTO-GENERATED -->", ROSTER_REGION_RE, TASK_ACTION_COMMANDS, DEFAULT_CREATION_SECTIONS;
+var DependencyMutationError, SectionMutationError, DuplicateFollowUpError, WbsCollisionError, ROSTER_START = "<!-- AUTO-GENERATED by spur task refresh-roster -->", ROSTER_END = "<!-- END AUTO-GENERATED -->", ROSTER_REGION_RE, TASK_ACTION_COMMANDS, DEFAULT_CREATION_SECTIONS;
 var init_task_service = __esm(() => {
   init_src2();
   init_task_locator();
@@ -66898,6 +67249,18 @@ var init_task_service = __esm(() => {
       this.attemptedName = attemptedName;
     }
   };
+  WbsCollisionError = class WbsCollisionError extends Error {
+    wbs;
+    existingPath;
+    attemptedPath;
+    constructor(wbs, existingPath, attemptedPath) {
+      super(`wbs-collision: WBS ${wbs} already exists at "${existingPath}". ` + `Refusing to overwrite with "${attemptedPath}". ` + `Re-run create; if the collision persists, inspect the corpus with: spur task check.`);
+      this.name = "WbsCollisionError";
+      this.wbs = wbs;
+      this.existingPath = existingPath;
+      this.attemptedPath = attemptedPath;
+    }
+  };
   ROSTER_REGION_RE = /<!--[ \t]*AUTO-GENERATED[^>]*-->[\s\S]*?<!--[ \t]*END[ \t]*AUTO-GENERATED[^>]*-->/g;
   TASK_ACTION_COMMANDS = {
     refine: (wbs) => `/sp:dev-refine ${wbs} --auto`,
@@ -67884,6 +68247,110 @@ var init_token_ledger_watcher = __esm(() => {
   init_token_ledger_service();
 });
 
+// ../../packages/app/src/observability/run-output-sink.ts
+import { closeSync as closeSync4, mkdirSync as mkdirSync6, openSync as openSync4, writeSync as writeSync2 } from "fs";
+import { join as join14 } from "path";
+
+class RunOutputSink {
+  filePath;
+  maxBytes;
+  maxLines;
+  fd;
+  bytes = 0;
+  lines = 0;
+  truncated = false;
+  closed = false;
+  constructor(options) {
+    this.filePath = join14(options.dir, `${options.runId}-output.log`);
+    this.maxBytes = options.maxBytes ?? DEFAULT_OUTPUT_MAX_BYTES;
+    this.maxLines = options.maxLines;
+    try {
+      mkdirSync6(options.dir, { recursive: true });
+      this.fd = openSync4(this.filePath, "a");
+    } catch {
+      this.fd = undefined;
+    }
+  }
+  get isTruncated() {
+    return this.truncated;
+  }
+  observe(event2) {
+    if (this.fd === undefined || this.closed)
+      return;
+    switch (event2.kind) {
+      case "output":
+        this.appendChunk(event2.at, event2.stream, event2.chunk);
+        break;
+      case "started":
+        this.append(`# agent output \u2014 run ${event2.runId} \u2014 ${event2.agent} \u2014 ${event2.at}
+`);
+        this.append(`# invocation: ${event2.invocation}
+`);
+        break;
+      case "dropped":
+        this.append(`
+=== [dropped] ${event2.chunks} chunk(s) discarded by the lifecycle relay under backpressure ===
+`);
+        break;
+      case "finished":
+        this.append(`
+=== run ${event2.outcome} (exit ${event2.exitCode}) after ${event2.durationMs}ms ===
+`);
+        break;
+      default:
+        break;
+    }
+  }
+  close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    if (this.fd !== undefined) {
+      try {
+        closeSync4(this.fd);
+      } catch {}
+      this.fd = undefined;
+    }
+  }
+  appendChunk(at, stream, chunk) {
+    if (this.truncated)
+      return;
+    const text4 = `[${at}] ${stream}: ${chunk}
+`;
+    const chunkBytes = Buffer.byteLength(text4);
+    const chunkLines = countNewlines(text4);
+    if (this.bytes + chunkBytes > this.maxBytes || this.maxLines !== undefined && this.lines + chunkLines > this.maxLines) {
+      this.truncated = true;
+      this.append(TRUNCATION_MARKER);
+      return;
+    }
+    this.append(text4);
+  }
+  append(text4) {
+    if (this.fd === undefined || this.closed)
+      return;
+    try {
+      writeSync2(this.fd, text4);
+      this.bytes += Buffer.byteLength(text4);
+      this.lines += countNewlines(text4);
+    } catch {}
+  }
+}
+function countNewlines(text4) {
+  let count3 = 0;
+  for (let i2 = 0;i2 < text4.length; i2 += 1) {
+    if (text4.charCodeAt(i2) === 10)
+      count3 += 1;
+  }
+  return count3;
+}
+var DEFAULT_OUTPUT_MAX_BYTES, TRUNCATION_MARKER = `
+=== [truncated] agent output capture reached its configured bound; further chunks were not written ===
+`;
+var init_run_output_sink = __esm(() => {
+  DEFAULT_OUTPUT_MAX_BYTES = 1024 * 1024;
+});
+
 // ../../packages/app/src/workflow/steering.ts
 class WorkflowSteeringController {
   onAck;
@@ -68126,16 +68593,18 @@ var init_steering = __esm(() => {
 });
 
 // ../../packages/app/src/workflow/actions/agent-run.ts
-import { dirname as dirname12, isAbsolute as isAbsolute2, join as join14 } from "path";
+import { dirname as dirname12, isAbsolute as isAbsolute2, join as join15 } from "path";
 
 class AgentRunActionRunner {
   observabilityBus;
   steeringController;
+  outputLog;
   kind = KIND;
   agentService;
-  constructor(agentService, observabilityBus, steeringController) {
+  constructor(agentService, observabilityBus, steeringController, outputLog) {
     this.observabilityBus = observabilityBus;
     this.steeringController = steeringController;
+    this.outputLog = outputLog;
     this.agentService = agentService;
   }
   async execute(options, context4) {
@@ -68146,7 +68615,8 @@ class AgentRunActionRunner {
     const cwd = asOptionalString(options.cwd) ?? context4.workdir ?? ".";
     let continueFlag = asOptionalBoolean(options.continue);
     const latch = context4.vars.__agentSession;
-    if (continueFlag === undefined && latch === "open") {
+    const latchAutoContinued = continueFlag === undefined && latch === "open";
+    if (latchAutoContinued) {
       continueFlag = true;
     }
     if (input === undefined && !continueFlag) {
@@ -68178,78 +68648,100 @@ class AgentRunActionRunner {
     const expectFile = asOptionalString(options.expectFile);
     const capture = asOptionalBoolean(options.capture) || answerFile !== undefined;
     const agentLabel = agent ?? "<default>";
-    const observer = this.observabilityBus === undefined ? undefined : (event2) => {
+    const outputLog = this.outputLog;
+    const sink = outputLog === undefined ? undefined : new RunOutputSink({
+      dir: join15(cwd, ".spur", "run"),
+      runId: context4.runId,
+      ...outputLog.maxBytes !== undefined ? { maxBytes: outputLog.maxBytes } : {},
+      ...outputLog.maxLines !== undefined ? { maxLines: outputLog.maxLines } : {}
+    });
+    const observer = this.observabilityBus === undefined && sink === undefined ? undefined : (event2) => {
+      sink?.observe(event2);
       this.observabilityBus?.emit("workflow.agent", event2);
     };
     const actionId = context4.actionId ?? `${context4.runId}:${context4.stateOrNodeId}`;
     const steeringPolicy = parseSteeringPolicy(options);
-    let steeringSignal = this.steeringController?.begin(context4.runId, actionId, steeringPolicy);
+    let resumeRetried = false;
     let steeringNote;
     let traced;
-    while (true) {
-      traced = await this.agentService.runTraced(input, flags, undefined, {
-        correlation: {
-          runId: context4.runId,
-          executionId: crypto.randomUUID(),
-          actionId
-        },
-        ...observer !== undefined ? { observer } : {},
-        ...steeringSignal !== undefined ? { signal: steeringSignal } : {}
-      });
-      if (this.steeringController === undefined)
+    try {
+      for (;; ) {
+        steeringNote = undefined;
+        let steeringSignal = this.steeringController?.begin(context4.runId, actionId, steeringPolicy);
+        while (true) {
+          traced = await this.agentService.runTraced(input, flags, undefined, {
+            correlation: {
+              runId: context4.runId,
+              executionId: crypto.randomUUID(),
+              actionId
+            },
+            ...observer !== undefined ? { observer } : {},
+            ...steeringSignal !== undefined ? { signal: steeringSignal } : {}
+          });
+          if (this.steeringController === undefined)
+            break;
+          const decision = await this.steeringController.boundary(traced.exitCode === 0);
+          if (decision.operation === "retry") {
+            steeringSignal = this.steeringController.nextAttempt();
+            continue;
+          }
+          if (decision.operation === "note")
+            steeringNote = decision.note;
+          if (decision.operation === "abort" && traced.exitCode === 0) {
+            traced = {
+              ...traced,
+              exitCode: 3,
+              signal: "STEERING_ABORT",
+              message: "aborted at steering boundary"
+            };
+          }
+          break;
+        }
+        this.steeringController?.complete();
+        if (!resumeRetried && latchAutoContinued && traced.exitCode === 2) {
+          resumeRetried = true;
+          delete flags.continue;
+          continue;
+        }
         break;
-      const decision = await this.steeringController.boundary(traced.exitCode === 0);
-      if (decision.operation === "retry") {
-        steeringSignal = this.steeringController.nextAttempt();
-        continue;
       }
-      if (decision.operation === "note")
-        steeringNote = decision.note;
-      if (decision.operation === "abort" && traced.exitCode === 0) {
-        traced = {
-          ...traced,
-          exitCode: 3,
-          signal: "STEERING_ABORT",
-          message: "aborted at steering boundary"
-        };
+      const { exitCode, stdout: answer } = traced;
+      const ok = exitCode === 0;
+      const invocation = traced.invocation;
+      if (capture && answerFile !== undefined) {
+        const target = isAbsolute2(answerFile) ? answerFile : join15(cwd, answerFile);
+        const fs3 = createNodeFileSystem3(cwd);
+        await fs3.ensureDir(dirname12(target));
+        await fs3.writeFile(target, answer);
+      }
+      if (ok && expectFile !== undefined) {
+        const target = isAbsolute2(expectFile) ? expectFile : join15(cwd, expectFile);
+        const fs3 = createNodeFileSystem3(cwd);
+        if (!await fs3.exists(target)) {
+          return {
+            ok: false,
+            data: buildResultData(exitCode, agentLabel, capture, answer, invocation),
+            error: `agent.run (${agentLabel}) exited 0 but expected file is absent: ${expectFile}`
+          };
+        }
       }
-      break;
-    }
-    this.steeringController?.complete();
-    const { exitCode, stdout: answer } = traced;
-    const ok = exitCode === 0;
-    const invocation = traced.invocation;
-    if (capture && answerFile !== undefined) {
-      const target = isAbsolute2(answerFile) ? answerFile : join14(cwd, answerFile);
-      const fs3 = createNodeFileSystem3(cwd);
-      await fs3.ensureDir(dirname12(target));
-      await fs3.writeFile(target, answer);
-    }
-    if (ok && expectFile !== undefined) {
-      const target = isAbsolute2(expectFile) ? expectFile : join14(cwd, expectFile);
-      const fs3 = createNodeFileSystem3(cwd);
-      if (!await fs3.exists(target)) {
-        return {
-          ok: false,
-          data: buildResultData(exitCode, agentLabel, capture, answer, invocation),
-          error: `agent.run (${agentLabel}) exited 0 but expected file is absent: ${expectFile}`
-        };
+      if (!ok) {
+        await writePartialWorkArtifact(context4, agentLabel, model, traced, cwd);
       }
+      const stepLabel = context4.stateOrNodeId;
+      const error51 = ok ? undefined : traced.signal !== undefined ? timeoutMs !== undefined ? `agent.run '${stepLabel}' (${agentLabel}) terminated by signal ${traced.signal} (configured timeout: ${timeoutMs}ms; timeout or cancellation); see partial-work artifact` : `agent.run '${stepLabel}' (${agentLabel}) was cancelled by signal ${traced.signal}; see partial-work artifact` : traced.message !== undefined ? `agent.run '${stepLabel}' (${agentLabel}) dispatch failed: ${traced.message}` : `agent.run '${stepLabel}' (${agentLabel}) exited with code ${exitCode}`;
+      return {
+        ok,
+        data: buildResultData(exitCode, agentLabel, capture, answer, invocation),
+        error: error51,
+        setVars: ok ? {
+          __agentSession: resumeRetried ? "no-resume" : "open",
+          ...steeringNote !== undefined ? { __steeringNote: steeringNote } : {}
+        } : undefined
+      };
+    } finally {
+      sink?.close();
     }
-    if (!ok) {
-      await writePartialWorkArtifact(context4, agentLabel, model, traced, cwd);
-    }
-    const stepLabel = context4.stateOrNodeId;
-    const error51 = ok ? undefined : traced.signal !== undefined ? timeoutMs !== undefined ? `agent.run '${stepLabel}' (${agentLabel}) terminated by signal ${traced.signal} (configured timeout: ${timeoutMs}ms; timeout or cancellation); see partial-work artifact` : `agent.run '${stepLabel}' (${agentLabel}) was cancelled by signal ${traced.signal}; see partial-work artifact` : traced.message !== undefined ? `agent.run '${stepLabel}' (${agentLabel}) dispatch failed: ${traced.message}` : `agent.run '${stepLabel}' (${agentLabel}) exited with code ${exitCode}`;
-    return {
-      ok,
-      data: buildResultData(exitCode, agentLabel, capture, answer, invocation),
-      error: error51,
-      setVars: ok ? {
-        __agentSession: "open",
-        ...steeringNote !== undefined ? { __steeringNote: steeringNote } : {}
-      } : undefined
-    };
   }
 }
 function buildResultData(exitCode, agentLabel, capture, answer, invocation) {
@@ -68335,7 +68827,7 @@ async function writePartialWorkArtifact(context4, agentLabel, model, traced, cwd
       ""
     ].join(`
 `);
-    const target = join14(cwd, ".spur", "run", `${context4.runId}-${context4.stateOrNodeId}-partial.md`);
+    const target = join15(cwd, ".spur", "run", `${context4.runId}-${context4.stateOrNodeId}-partial.md`);
     const fs3 = createNodeFileSystem3(cwd);
     await fs3.ensureDir(dirname12(target));
     await fs3.writeFile(target, body);
@@ -68365,6 +68857,7 @@ ${text4.slice(text4.length - maxChars)}`;
 var PARTIAL_ARTIFACT_TAIL_CHARS = 4000, KIND = "agent.run";
 var init_agent_run = __esm(() => {
   init_dist5();
+  init_run_output_sink();
   init_steering();
 });
 
@@ -68893,7 +69386,7 @@ var init_rule_check = __esm(() => {
 // ../../packages/app/src/workflow/builtins.ts
 function registerSpurBuiltins(host, options) {
   const fileSystem = options.fileSystem ?? createNodeFileSystem3();
-  host.registerAction(new AgentRunActionRunner(options.agentService, options.observabilityBus, options.steeringController), "builtin");
+  host.registerAction(new AgentRunActionRunner(options.agentService, options.observabilityBus, options.steeringController, options.outputLog), "builtin");
   host.registerAction(new RuleCheckActionRunner(options.ruleService), "builtin");
   host.registerAction(new FileExistsActionRunner(fileSystem), "builtin");
   host.registerAction(new FileReadActionRunner(fileSystem), "builtin");
@@ -69073,7 +69566,7 @@ var init_observability = __esm(() => {
 
 // ../../packages/app/src/services/workflow-service.ts
 import { homedir as homedir5 } from "os";
-import { join as join15, resolve as resolve4 } from "path";
+import { join as join16, resolve as resolve4 } from "path";
 function signalSubprocess(pid) {
   if (!Number.isInteger(pid) || pid <= 1)
     return false;
@@ -69296,7 +69789,7 @@ class WorkflowAppService {
   }
   async list(workflowPaths = [".spur/workflows/"]) {
     const projectRoot = this.ctx.cwd;
-    const globalRoot = join15(homedir5(), ".config", "spur");
+    const globalRoot = join16(homedir5(), ".config", "spur");
     const layers = [];
     const entries = [];
     const scannedPaths = new Set;
@@ -69400,7 +69893,12 @@ class WorkflowAppService {
         });
       }
     }
-    return { run, events: events2 };
+    const outputArtifact = await outputArtifactForRun(this.ctx.cwd, runId);
+    return {
+      run,
+      events: events2,
+      ...outputArtifact !== undefined ? { outputArtifact } : {}
+    };
   }
   async createEngineService(opts = {}) {
     const processExec = this.ctx.processExecutor?.();
@@ -69413,7 +69911,8 @@ class WorkflowAppService {
       httpRequester: this.ctx.httpRequester?.(),
       hostAllowlist: this.ctx.hostAllowlist?.(),
       ...bus !== undefined ? { observabilityBus: bus } : {},
-      ...opts.steeringController !== undefined ? { steeringController: opts.steeringController } : {}
+      ...opts.steeringController !== undefined ? { steeringController: opts.steeringController } : {},
+      outputLog: await resolveOutputLogConfig(this.ctx.cwd)
     });
     const db2 = await this.ctx.getDb();
     let persistence2 = new DbWorkflowPersistenceAdapter(db2);
@@ -69428,6 +69927,23 @@ async function fileExists(path9) {
   const fs3 = createNodeFileSystem3();
   return await fs3.exists(path9);
 }
+async function resolveOutputLogConfig(cwd) {
+  try {
+    const output2 = (await loadSpurConfig(cwd)).agent?.output;
+    if (output2 === undefined)
+      return {};
+    return {
+      ...output2["max-bytes"] !== undefined ? { maxBytes: output2["max-bytes"] } : {},
+      ...output2["max-lines"] !== undefined ? { maxLines: output2["max-lines"] } : {}
+    };
+  } catch {
+    return {};
+  }
+}
+async function outputArtifactForRun(cwd, runId) {
+  const relative4 = join16(".spur", "run", `${runId}-output.log`);
+  return await fileExists(join16(cwd, relative4)) ? relative4 : undefined;
+}
 async function scanWorkflowFiles(rootPath, source) {
   const entries = [];
   const fs3 = createNodeFileSystem3();
@@ -69507,6 +70023,7 @@ function rowToTraceEntry(row) {
 }
 var TASK_PIPELINE_WORKFLOW = "task-pipeline", EMBEDDED_SCHEMA_PREFIX = "\x00embedded-spur", SPUR_SCHEMA_MANIFEST = "@gobing-ai/spur/package.json", PIPELINE_LINK_KIND = "pipeline";
 var init_workflow_service = __esm(() => {
+  init_loader();
   init_src2();
   init_dist7();
   init_dist5();
@@ -69740,7 +70257,7 @@ function formatDuration(ms) {
 var isAgentExecution = (e) => ("executionId" in e), isActionStarted = (e) => ("kind" in e) && ("node" in e), isActionFinished = (e) => ("durationMs" in e) && ("ok" in e), isPhase = (e) => ("phase" in e), isTransition = (e) => ("from" in e) && ("to" in e);
 
 // ../../packages/app/src/workflow/trace-writer.ts
-import { dirname as dirname13, join as join16 } from "path";
+import { dirname as dirname13, join as join17 } from "path";
 
 class WorkflowTraceWriter {
   path;
@@ -69748,7 +70265,7 @@ class WorkflowTraceWriter {
   pending = Promise.resolve();
   constructor(cwd, runId) {
     const safeRunId = runId.replace(/[^A-Za-z0-9._-]/g, "_");
-    this.path = join16(cwd, ".spur", "runs", "workflow", `${safeRunId}.jsonl`);
+    this.path = join17(cwd, ".spur", "runs", "workflow", `${safeRunId}.jsonl`);
   }
   attach(bus) {
     bus.on("workflow.run.started", (event2) => this.enqueue("workflow.run.started", event2));
@@ -69840,6 +70357,7 @@ __export(exports_src2, {
   WorkflowTraceWriter: () => WorkflowTraceWriter,
   WorkflowSteeringController: () => WorkflowSteeringController,
   WorkflowAppService: () => WorkflowAppService,
+  WbsCollisionError: () => WbsCollisionError,
   UnsupportedProcessPlatformError: () => UnsupportedProcessPlatformError,
   TokenLedgerWatcher: () => TokenLedgerWatcher,
   TokenLedgerService: () => TokenLedgerService,
@@ -77571,7 +78089,7 @@ init_loader();
 init_src2();
 import { existsSync as existsSync9 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join17, resolve as resolve5 } from "path";
+import { join as join18, resolve as resolve5 } from "path";
 
 // src/workflow/resolve-spur-bin.ts
 import { basename as basename3 } from "path";
@@ -77589,22 +78107,22 @@ function resolveSpurBin() {
 }
 
 // src/workflow/make-lifecycle-adapter.ts
-var GLOBAL_CONFIG_DIR = join17(".config", "spur");
+var GLOBAL_CONFIG_DIR = join18(".config", "spur");
 function globalConfigRoot(context4) {
   const override = context4.env.SPUR_GLOBAL_RULES_DIR;
-  return override !== undefined && override.length > 0 ? resolve5(context4.cwd, override) : join17(homedir6(), GLOBAL_CONFIG_DIR);
+  return override !== undefined && override.length > 0 ? resolve5(context4.cwd, override) : join18(homedir6(), GLOBAL_CONFIG_DIR);
 }
 function resolveWorkflowPath(context4, profile) {
   const bundledRoot = bundledConfigRoot();
   if (bundledRoot !== null) {
-    const bundledPath = join17(bundledRoot, "workflows", `${profile.workflowName}.yaml`);
+    const bundledPath = join18(bundledRoot, "workflows", `${profile.workflowName}.yaml`);
     if (existsSync9(bundledPath))
       return bundledPath;
   }
-  const projectPath = join17(context4.cwd, ".spur", "workflows", `${profile.workflowName}.yaml`);
+  const projectPath = join18(context4.cwd, ".spur", "workflows", `${profile.workflowName}.yaml`);
   if (existsSync9(projectPath))
     return projectPath;
-  const globalPath = join17(globalConfigRoot(context4), "workflows", `${profile.workflowName}.yaml`);
+  const globalPath = join18(globalConfigRoot(context4), "workflows", `${profile.workflowName}.yaml`);
   if (existsSync9(globalPath))
     return globalPath;
   return null;
@@ -77745,9 +78263,9 @@ function registerFeatureCommand(program2, context4) {
       let next = forwardPath[current];
       while (next !== undefined) {
         if (current === "active") {
-          await assertFeatureCheckPass(context4, id, options.folder, false);
+          await assertFeatureCheckPass(context4, id, options.folder, false, "verifying");
         } else if (current === "verifying") {
-          await assertFeatureCheckPass(context4, id, options.folder, true);
+          await assertFeatureCheckPass(context4, id, options.folder, true, "done");
         }
         const result = await svc.transition(id, next);
         history.push({ from: result.fromStatus ?? current, to: result.toStatus ?? next });
@@ -77837,7 +78355,7 @@ function registerFeatureCommand(program2, context4) {
       context4.setExitCode(1);
     }
   });
-  feature.command("check").summary("Validate feature file(s) through the four-layer check (design \xA73).").argument("[id]", "Feature ID (validates all features in the folder when omitted)").option("--strict", "Elevate warnings to failures").option("--folder <path>", "Custom features folder").option("--json", "Output machine-readable JSON").action(async (id, options) => {
+  feature.command("check").summary("Validate feature file(s) through the four-layer check (design \xA73).").argument("[id]", "Feature ID (validates all features in the folder when omitted)").option("--strict", "Elevate warnings to failures").option("--as <status>", "Evaluate the one-active-goal rule as if the feature were in <status> (0418: lifecycle FSM guards pass the transition target)").option("--folder <path>", "Custom features folder").option("--json", "Output machine-readable JSON").action(async (id, options) => {
     const resolved = await resolvePlanningFolders(context4.fs);
     const featuresDir = options.folder ?? context4.fs.resolve(resolved.featuresDir);
     const tasksDir = context4.fs.resolve(resolved.tasksDir);
@@ -77860,7 +78378,8 @@ function registerFeatureCommand(program2, context4) {
           featuresDir,
           tasksDir,
           runDir: context4.fs.resolve(".spur/run"),
-          severityOverrides: resolved.severityOverrides
+          severityOverrides: resolved.severityOverrides,
+          asStatus: options.as
         });
         results.push(result);
         if (!json3) {
@@ -77900,7 +78419,7 @@ ${result.id} (${result.status}): ${result.pass ? "PASS" : "FAIL"}`);
         } else {
           context4.output.write(`Evaluated ${result.evaluated}/${result.totalFeatures} features; updated ${result.updatedCount} feature(s).`);
           for (const res of result.results) {
-            const tag = res.applied ? "UPDATED" : res.proposal.from === res.proposal.to ? "NOOP" : "SKIPPED";
+            const tag = res.applied ? "UPDATED" : res.goalConflict !== undefined ? "GOAL-CONFLICT" : res.proposal.from === res.proposal.to ? "NOOP" : "SKIPPED";
             context4.output.write(`  [${tag}] ${res.proposal.featureId}: ${res.proposal.from} -> ${res.proposal.to} (${res.proposal.reason})`);
           }
         }
@@ -77912,7 +78431,7 @@ ${result.id} (${result.status}): ${result.pass ? "PASS" : "FAIL"}`);
         if (options.json) {
           context4.output.write(toJson2(result));
         } else {
-          const tag = result.applied ? "UPDATED" : result.proposal.from === result.proposal.to ? "NOOP" : "SKIPPED";
+          const tag = result.applied ? "UPDATED" : result.goalConflict !== undefined ? "GOAL-CONFLICT" : result.proposal.from === result.proposal.to ? "NOOP" : "SKIPPED";
           context4.output.write(`Feature ${id}: [${tag}] ${result.proposal.from} -> ${result.proposal.to} (${result.proposal.reason})`);
         }
       }
@@ -77940,7 +78459,7 @@ async function makeService(context4, folderOverride) {
     foldersConfig: resolved.foldersConfig
   });
 }
-async function assertFeatureCheckPass(context4, id, folderOverride, strict) {
+async function assertFeatureCheckPass(context4, id, folderOverride, strict, asStatus) {
   const resolved = await resolvePlanningFolders(context4.fs);
   const featuresDir = folderOverride ?? context4.fs.resolve(resolved.featuresDir);
   const tasksDir = context4.fs.resolve(resolved.tasksDir);
@@ -77952,7 +78471,8 @@ async function assertFeatureCheckPass(context4, id, folderOverride, strict) {
   const result = await new FeatureCheckService(context4.fs).check(`${featuresDir}/${fileName}`, id, {
     strict,
     featuresDir,
-    tasksDir
+    tasksDir,
+    asStatus
   });
   if (!result.pass) {
     const details = result.findings.map((f) => `${f.layer} ${f.section}: ${f.message}`).join("; ");
@@ -78006,13 +78526,13 @@ init_loader();
 init_src2();
 init_dist10();
 import { homedir as homedir7 } from "os";
-import { join as join18, resolve as resolve6 } from "path";
+import { join as join19, resolve as resolve6 } from "path";
 
 // src/config.ts
 var CLI_CONFIG = {
   binaryName: "spur",
   binaryLabel: "spur",
-  binaryVersion: "0.3.28",
+  binaryVersion: "0.3.29",
   configDir: ".spur",
   configFile: ".spur/config.yaml",
   databaseFile: ".spur/spur.db"
@@ -78063,8 +78583,8 @@ var SCAFFOLD_MANIFEST = [
 ];
 
 // src/commands/init.ts
-var GLOBAL_CONFIG_DIR2 = join18(".config", "spur");
-var GLOBAL_RULES_DIR2 = join18(GLOBAL_CONFIG_DIR2, "rules");
+var GLOBAL_CONFIG_DIR2 = join19(".config", "spur");
+var GLOBAL_RULES_DIR2 = join19(GLOBAL_CONFIG_DIR2, "rules");
 var GLOBAL_CONFIG_EXAMPLE = "config.example.yaml";
 var GLOBAL_CONFIG_FILE2 = "config.yaml";
 var INDEXED_CONTEXT_MARKER = "## Indexed context";
@@ -78095,7 +78615,7 @@ If \`.spur/context/\` is absent, proceed normally. Never block work on its absen
 `;
 function globalRulesRoot(context4) {
   const override = context4.env.SPUR_GLOBAL_RULES_DIR;
-  return override !== undefined && override.length > 0 ? resolve6(context4.cwd, override) : join18(homedir7(), GLOBAL_RULES_DIR2);
+  return override !== undefined && override.length > 0 ? resolve6(context4.cwd, override) : join19(homedir7(), GLOBAL_RULES_DIR2);
 }
 async function writeIfNew(context4, path9, content, force, result) {
   if (!force && await context4.fs.exists(path9)) {
@@ -78112,11 +78632,11 @@ async function seedGlobalRules(context4) {
   const target = globalRulesRoot(context4);
   let written = 0;
   for (const relPath of await listBundledRuleFiles()) {
-    const destination = join18(target, relPath);
+    const destination = join19(target, relPath);
     if (await context4.fs.exists(destination))
       continue;
-    await context4.fs.ensureDir(join18(target, ...relPath.split("/").slice(0, -1)));
-    await context4.fs.writeFile(destination, await context4.fs.readFile(join18(source, relPath)));
+    await context4.fs.ensureDir(join19(target, ...relPath.split("/").slice(0, -1)));
+    await context4.fs.writeFile(destination, await context4.fs.readFile(join19(source, relPath)));
     written += 1;
   }
   return written;
@@ -78126,20 +78646,20 @@ async function seedGlobalConfig(context4) {
   if (source === null)
     return 0;
   const globalOverride = context4.env.SPUR_GLOBAL_RULES_DIR;
-  const target = globalOverride !== undefined && globalOverride.length > 0 ? resolve6(context4.cwd, globalOverride) : join18(homedir7(), GLOBAL_CONFIG_DIR2);
+  const target = globalOverride !== undefined && globalOverride.length > 0 ? resolve6(context4.cwd, globalOverride) : join19(homedir7(), GLOBAL_CONFIG_DIR2);
   let written = 0;
   for (const relPath of listBundledConfigFiles()) {
     if (relPath === GLOBAL_CONFIG_EXAMPLE)
       continue;
-    const destination = join18(target, relPath);
+    const destination = join19(target, relPath);
     if (await context4.fs.exists(destination))
       continue;
-    await context4.fs.ensureDir(join18(target, ...relPath.split("/").slice(0, -1)));
-    await context4.fs.writeFile(destination, await context4.fs.readFile(join18(source, relPath)));
+    await context4.fs.ensureDir(join19(target, ...relPath.split("/").slice(0, -1)));
+    await context4.fs.writeFile(destination, await context4.fs.readFile(join19(source, relPath)));
     written += 1;
   }
-  const examplePath = join18(source, GLOBAL_CONFIG_EXAMPLE);
-  const globalConfigPath = join18(target, GLOBAL_CONFIG_FILE2);
+  const examplePath = join19(source, GLOBAL_CONFIG_EXAMPLE);
+  const globalConfigPath = join19(target, GLOBAL_CONFIG_FILE2);
   if (await context4.fs.exists(examplePath) && !await context4.fs.exists(globalConfigPath)) {
     await context4.fs.ensureDir(target);
     await context4.fs.writeFile(globalConfigPath, await context4.fs.readFile(examplePath));
@@ -78153,7 +78673,7 @@ function registerInitCommand(program2, context4) {
     const force = options.force === true;
     const minimal = options.minimal === true;
     const projectName = options.name ?? "default";
-    const configPath = join18(context4.cwd, CLI_CONFIG.configFile);
+    const configPath = join19(context4.cwd, CLI_CONFIG.configFile);
     if (!force && await context4.fs.exists(configPath)) {
       const message = `Already initialized: ${CLI_CONFIG.configFile}. Use --force to overwrite.`;
       context4.output.write(json3 ? toJson2({ ok: false, reason: "already-initialized", config: CLI_CONFIG.configFile }) : message);
@@ -78188,13 +78708,13 @@ function registerInitCommand(program2, context4) {
     ].join(`
 `)}
 `;
-    await context4.fs.ensureDir(join18(context4.cwd, CLI_CONFIG.configDir));
+    await context4.fs.ensureDir(join19(context4.cwd, CLI_CONFIG.configDir));
     await context4.fs.writeFile(configPath, configYaml);
     result.created.push(configPath);
-    const agentsDir = join18(context4.cwd, CLI_CONFIG.configDir, "agents");
+    const agentsDir = join19(context4.cwd, CLI_CONFIG.configDir, "agents");
     await context4.fs.ensureDir(agentsDir);
-    await writeIfNew(context4, join18(agentsDir, ".gitkeep"), "", force, result);
-    const gitignorePath = join18(context4.cwd, ".gitignore");
+    await writeIfNew(context4, join19(agentsDir, ".gitkeep"), "", force, result);
+    const gitignorePath = join19(context4.cwd, ".gitignore");
     const contextEntry = ".spur/context/";
     if (await context4.fs.exists(gitignorePath)) {
       const existing = await context4.fs.readFile(gitignorePath);
@@ -78216,20 +78736,20 @@ ${contextEntry}
         for (const relPath of listBundledProjectSeedFiles()) {
           if (relPath.startsWith("templates/docs/"))
             continue;
-          const sourcePath = join18(configRoot, relPath);
+          const sourcePath = join19(configRoot, relPath);
           if (!await context4.fs.exists(sourcePath))
             continue;
-          const targetPath = join18(context4.cwd, CLI_CONFIG.configDir, relPath);
-          await context4.fs.ensureDir(join18(targetPath, ".."));
+          const targetPath = join19(context4.cwd, CLI_CONFIG.configDir, relPath);
+          await context4.fs.ensureDir(join19(targetPath, ".."));
           await writeIfNew(context4, targetPath, await context4.fs.readFile(sourcePath), force, result);
         }
         for (const entry of SCAFFOLD_MANIFEST) {
-          const sourcePath = join18(configRoot, entry.source);
+          const sourcePath = join19(configRoot, entry.source);
           if (!await context4.fs.exists(sourcePath))
             continue;
-          const baseDir = entry.root === true ? context4.cwd : join18(context4.cwd, CLI_CONFIG.configDir);
-          const targetPath = join18(baseDir, entry.target);
-          await context4.fs.ensureDir(join18(targetPath, ".."));
+          const baseDir = entry.root === true ? context4.cwd : join19(context4.cwd, CLI_CONFIG.configDir);
+          const targetPath = join19(baseDir, entry.target);
+          await context4.fs.ensureDir(join19(targetPath, ".."));
           const entryForce = entry.preserve === true ? false : force;
           let body = await context4.fs.readFile(sourcePath);
           if (entry.target === "AGENTS.md") {
@@ -78242,7 +78762,7 @@ ${contextEntry}
         }
       }
     }
-    const agentsMdPath = join18(context4.cwd, "AGENTS.md");
+    const agentsMdPath = join19(context4.cwd, "AGENTS.md");
     if (await context4.fs.exists(agentsMdPath)) {
       const existing = await context4.fs.readFile(agentsMdPath);
       if (!existing.includes(INDEXED_CONTEXT_MARKER)) {
@@ -78420,10 +78940,10 @@ function parseInterval2(raw) {
 
 // src/commands/migrate.ts
 init_src2();
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 function registerMigrateCommand(program2, context4) {
   program2.command("migrate").summary("apply CLI-owned schema migrations").option("--json", "Output machine-readable JSON").action(async (options) => {
-    const migrations = await loadSqlMigrations(join19(context4.cwd, "drizzle")).catch(() => {
+    const migrations = await loadSqlMigrations(join20(context4.cwd, "drizzle")).catch(() => {
       return;
     });
     const applied = await applyCliMigrations(await context4.getDb(), migrations);
@@ -78839,7 +79359,7 @@ function formatTraceDetail(detail) {
 
 // src/commands/serve.ts
 init_src();
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 
 // ../server/src/index.ts
 init_src();
@@ -78849,11 +79369,11 @@ init_src3();
 init_src();
 init_loader();
 init_src2();
-import { basename as basename6, dirname as dirname15, isAbsolute as isAbsolute3, join as join22 } from "path";
+import { basename as basename6, dirname as dirname15, isAbsolute as isAbsolute3, join as join23 } from "path";
 init_dist5();
 
 // ../server/src/bootstrap.ts
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 
 // ../../node_modules/.bun/radash@12.1.1/node_modules/radash/dist/esm/async.mjs
 var guard = (func, shouldGuard) => {
@@ -84088,6 +84608,9 @@ var contextInjector = (appRt) => async function contextInjectorMiddleware(c3, ne
   await next();
 };
 
+// ../server/src/middleware/error-handler.ts
+init_src3();
+
 // ../server/src/errors.ts
 init_errors5();
 
@@ -84150,6 +84673,14 @@ function resolveError(err, requestId, isProd) {
       details: { requestId }
     };
   }
+  if (err instanceof WbsCollisionError) {
+    return {
+      status: 409,
+      apiCode: "WBS_COLLISION",
+      message: isProd ? "WBS collision - task already exists" : message,
+      details: { requestId, wbs: err.wbs, existingPath: err.existingPath, attemptedPath: err.attemptedPath }
+    };
+  }
   if (err instanceof LockTimeoutError) {
     return {
       status: 503,
@@ -87737,7 +88268,7 @@ function createApp(appRt, opts) {
     app.use("*", async (c3, next) => {
       const pathname = c3.req.path === "/" ? "/index.html" : c3.req.path;
       try {
-        const file2 = Bun.file(join20(webDistPath, pathname));
+        const file2 = Bun.file(join21(webDistPath, pathname));
         if (await file2.exists()) {
           const headers = new Headers({ "content-type": file2.type });
           return new Response(file2.stream(), { headers });
@@ -87750,7 +88281,7 @@ function createApp(appRt, opts) {
         return c3.json({ error: "Not Found" }, 404);
       }
       try {
-        const indexFile = Bun.file(join20(webDistPath, "index.html"));
+        const indexFile = Bun.file(join21(webDistPath, "index.html"));
         if (await indexFile.exists()) {
           return new Response(indexFile.stream(), {
             headers: { "content-type": "text/html; charset=utf-8" }
@@ -87771,7 +88302,7 @@ init_src3();
 init_src();
 init_src2();
 init_dist5();
-import { dirname as dirname14, join as join21 } from "path";
+import { dirname as dirname14, join as join22 } from "path";
 var NOOP_OUTPUT = { write: (_s) => {}, error: (_s) => {} };
 
 class LazyPlanningEventEmitter {
@@ -87794,7 +88325,7 @@ class LazyPlanningEventEmitter {
 var DEFAULT_PLANNING_FOLDERS = {
   tasksDir: DEFAULT_TASKS_DIR,
   featuresDir: DEFAULT_FEATURES_DIR,
-  foldersConfig: { active_folder: DEFAULT_TASKS_DIR, folders: { [DEFAULT_TASKS_DIR]: { base_counter: 0 } } }
+  foldersConfig: { active_folder: DEFAULT_TASKS_DIR, folders: { [DEFAULT_TASKS_DIR]: { baseCounter: 0 } } }
 };
 
 class NotConfiguredError extends Error {
@@ -87806,7 +88337,7 @@ class NotConfiguredError extends Error {
 function createServerContext(appRt, options) {
   const cwd = options.cwd;
   const fs3 = options.fs;
-  const dbUrl = options.dbUrl ?? join21(cwd, DEFAULT_DATABASE_URL);
+  const dbUrl = options.dbUrl ?? join22(cwd, DEFAULT_DATABASE_URL);
   const eventsBus = options.eventsBus ?? appRt.events;
   const jobQueueEnabled = options.jobQueueEnabled ?? false;
   const folders = options.folders ?? DEFAULT_PLANNING_FOLDERS;
@@ -88166,15 +88697,15 @@ async function handleFeatureActionJob(ctx, env, payload) {
   await runFeatureActionJob(ctx, env, payload);
 }
 async function resolveWebDistPath(configuredPath) {
-  const candidates = configuredPath && configuredPath.trim() !== "" ? [isAbsolute3(configuredPath) ? configuredPath : join22(process.cwd(), configuredPath)] : [
-    join22(process.cwd(), "dist/web"),
-    join22(import.meta.dir, "web"),
-    join22(dirname15(process.execPath), "web"),
-    join22(dirname15(process.execPath), "../web"),
-    join22(import.meta.dir, "../../../dist/web")
+  const candidates = configuredPath && configuredPath.trim() !== "" ? [isAbsolute3(configuredPath) ? configuredPath : join23(process.cwd(), configuredPath)] : [
+    join23(process.cwd(), "dist/web"),
+    join23(import.meta.dir, "web"),
+    join23(dirname15(process.execPath), "web"),
+    join23(dirname15(process.execPath), "../web"),
+    join23(import.meta.dir, "../../../dist/web")
   ];
   for (const candidate of candidates) {
-    if (await Bun.file(join22(candidate, "index.html")).exists()) {
+    if (await Bun.file(join23(candidate, "index.html")).exists()) {
       return candidate;
     }
   }
@@ -88333,7 +88864,7 @@ if (false) {}
 
 // src/commands/serve.ts
 function resolveServeDbUrl(cwd, env, configuredUrl) {
-  return env.DATABASE_URL === undefined ? join23(cwd, DEFAULT_DATABASE_URL) : configuredUrl;
+  return env.DATABASE_URL === undefined ? join24(cwd, DEFAULT_DATABASE_URL) : configuredUrl;
 }
 function registerServeCommand(program2, context4) {
   program2.command("serve").summary("start the Spur web server (local fallback)").option("--port <n>", "Server port (env: PORT, default: 3000)", parseInt).option("--host <addr>", "Bind address (env: HOST, default: localhost)").option("--no-open", "Skip opening the browser").option("--cwd <path>", "Working directory", context4.cwd).option("--json", "Output { port, url, pid } and exit").action(async (options) => {
@@ -88372,7 +88903,7 @@ function registerServeCommand(program2, context4) {
 }
 
 // src/commands/status.ts
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 
 // src/errors.ts
 class CommandError extends Error {
@@ -88443,8 +88974,8 @@ function registerStatusCommand(program2, context4) {
 }
 async function runStatusCore(path9, options, context4) {
   const [packageJsonExists, spurConfigExists, git, agentSpecs] = await Promise.all([
-    context4.fs.exists(join24(context4.cwd, "package.json")),
-    context4.fs.exists(join24(context4.cwd, ".spur", "config.yaml")),
+    context4.fs.exists(join25(context4.cwd, "package.json")),
+    context4.fs.exists(join25(context4.cwd, ".spur", "config.yaml")),
     gitContext(context4.cwd),
     listAgentSpecIds(context4)
   ]);
@@ -88472,14 +89003,14 @@ async function runStatusCore(path9, options, context4) {
   return status.ok ? 0 : 1;
 }
 async function listAgentSpecIds(context4) {
-  const dir = join24(context4.cwd, ".spur", "agents");
+  const dir = join25(context4.cwd, ".spur", "agents");
   if (!await context4.fs.exists(dir))
     return [];
   const entries = await context4.fs.readDir(dir);
   return entries.filter((entry) => entry.endsWith(".yaml") || entry.endsWith(".yml")).map((entry) => entry.replace(/\.ya?ml$/, "")).sort();
 }
 async function readTargetStatus(context4, targetPath) {
-  const resolved = join24(context4.cwd, targetPath);
+  const resolved = join25(context4.cwd, targetPath);
   const stat = await context4.fs.stat(resolved);
   if (stat === null)
     throw new CommandError(`status failed: path does not exist at ${resolved}`);
@@ -88492,7 +89023,7 @@ init_loader();
 init_src2();
 init_dist5();
 import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 // schemas/section-matrix.schema.json
 var section_matrix_schema_default = {
   $schema: "http://json-schema.org/draft-07/schema#",
@@ -88804,7 +89335,7 @@ var spur_config_schema_default = {
     },
     tasks: {
       type: "object",
-      description: "Task-folder registration (design \xA79). Absorbs the legacy docs/.tasks/config.json folders + base_counter concepts. Mirrors @gobing-ai/spur-config tasksConfigSchema (Zod is SSOT).",
+      description: "Task-folder registration (design \xA79). Absorbs the legacy docs/.tasks/config.json folders + baseCounter concepts. Mirrors @gobing-ai/spur-config tasksConfigSchema (Zod is SSOT).",
       properties: {
         folders: {
           type: "object",
@@ -89083,12 +89614,17 @@ function renderMigrationReport(report, dryRun, corpusDir) {
 }
 function registerTaskCommand(program2, context4) {
   const task = program2.command("task").summary("manage tasks");
-  task.command("create").summary("Create a new task with race-safe WBS allocation.").argument("<title>", "Task title").option("--feature <id>", "Feature ID for traceability and Goal\u2192Background derivation").option("--parent <wbs>", "Parent WBS for sub-task grouping").option("--template <variant>", `Template variant (${TASK_VARIANTS.join("|")})`).option("--folder <path>", "Custom tasks folder").option("--dedupe-within <seconds>", "Refuse creation if an existing task under the same feature has an identical name created within the last N seconds (task 0341 R4)", (v) => Number.parseInt(v, 10)).option("--allow-duplicate-name", "Override the --dedupe-within guard (creates anyway)").option("--json", "Output machine-readable JSON").action(async (title2, options) => {
+  task.command("create").summary("Create a new task with race-safe WBS allocation.").argument("<title>", "Task title").option("--feature <id>", "Feature ID for traceability and Goal\u2192Background derivation").option("--parent <wbs>", "Parent WBS for sub-task grouping").option("--template <variant>", `Template variant (${TASK_VARIANTS.join("|")})`).option("--folder <path>", "Custom tasks folder").option("--dedupe-within <seconds>", "Override the default dedup window (seconds). Guard is on (300s) by default when --feature is set.", Number).option("--allow-duplicate-name", "Disable the dedup guard entirely (creates anyway)").option("--json", "Output machine-readable JSON").action(async (title2, options) => {
     if (options.template !== undefined && !TASK_VARIANTS.includes(options.template)) {
       context4.output.error(`Unknown template variant "${options.template}". Valid: ${TASK_VARIANTS.join(", ")}`);
       context4.setExitCode(2);
       return;
     }
+    if (options.dedupeWithin !== undefined && (!Number.isInteger(options.dedupeWithin) || options.dedupeWithin <= 0)) {
+      context4.output.error("--dedupe-within must be a positive integer");
+      context4.setExitCode(2);
+      return;
+    }
     const svc = await makeService2(context4, options.folder);
     try {
       const result = await svc.create({
@@ -89096,7 +89632,7 @@ function registerTaskCommand(program2, context4) {
         featureId: options.feature,
         parentWbs: options.parent,
         template: options.template,
-        dedupeWithinSec: options.allowDuplicateName ? undefined : options.dedupeWithin
+        dedupeWithinSec: options.allowDuplicateName ? null : options.dedupeWithin
       });
       if (options.json) {
         context4.output.write(toJson2(result));
@@ -89104,8 +89640,37 @@ function registerTaskCommand(program2, context4) {
         context4.output.write(`Created task ${result.ref.id}: ${result.ref.filePath}`);
       }
     } catch (err) {
-      if (err instanceof DuplicateFollowUpError) {
-        context4.output.error(err.message);
+      if (err instanceof WbsCollisionError) {
+        if (options.json) {
+          context4.output.write(toJson2({
+            ok: false,
+            error: {
+              code: "wbs-collision",
+              message: err.message,
+              wbs: err.wbs,
+              existingPath: err.existingPath,
+              attemptedPath: err.attemptedPath
+            }
+          }));
+        } else {
+          context4.output.error(err.message);
+        }
+        context4.setExitCode(3);
+      } else if (err instanceof DuplicateFollowUpError) {
+        if (options.json) {
+          context4.output.write(toJson2({
+            ok: false,
+            error: {
+              code: "duplicate-follow-up",
+              message: err.message,
+              existingWbs: err.existingWbs,
+              existingName: err.existingName,
+              attemptedName: err.attemptedName
+            }
+          }));
+        } else {
+          context4.output.error(err.message);
+        }
         context4.setExitCode(3);
       } else {
         context4.output.error(String(err));
@@ -89176,7 +89741,7 @@ ${result.content}`);
         let forcedDoneVerdict;
         if (status === "done") {
           const current = await svc.show(wbs);
-          const verdictDir = options.verdictDir ?? join25(context4.cwd, ".spur", "run");
+          const verdictDir = options.verdictDir ?? join26(context4.cwd, ".spur", "run");
           const loaded = await readVerdictArtifact(context4.fs, verdictDir, wbs);
           const guardOutcome = evaluateDoneTransition({
             wbs,
@@ -89435,8 +90000,26 @@ ${result.content}`);
         }
       }
     } catch (err) {
-      context4.output.error(String(err));
-      context4.setExitCode(1);
+      if (err instanceof WbsCollisionError) {
+        if (options.json) {
+          context4.output.write(toJson2({
+            ok: false,
+            error: {
+              code: "wbs-collision",
+              message: err.message,
+              wbs: err.wbs,
+              existingPath: err.existingPath,
+              attemptedPath: err.attemptedPath
+            }
+          }));
+        } else {
+          context4.output.error(err.message);
+        }
+        context4.setExitCode(3);
+      } else {
+        context4.output.error(String(err));
+        context4.setExitCode(1);
+      }
     }
   });
   task.command("record").summary("Record pipeline results into the task file \u2014 Testing, Review, and optional Solution backfill.").argument("<wbs>", "Task WBS number").option("--verdict-file <path>", "Path to verdict JSON (default: .spur/run/<wbs>-verdict.json)").option("--solution-from-diff", "Backfill Solution from git diff when bare").option("--transition <status>", "Optional lifecycle transition (e.g. testing)").option("--folder <path>", "Custom tasks folder").option("--json", "Output machine-readable JSON").action(async (wbs, options) => {
@@ -89574,6 +90157,23 @@ ${result.wbs} (${result.status}): ${result.pass ? "PASS" : "FAIL"}`);
           }
         }
       }
+      if (!wbs) {
+        const locator = await makeTaskLocator(context4);
+        const duplicates2 = await locator.findDuplicateWbs();
+        for (const dup of duplicates2) {
+          const [first] = dup;
+          if (first === undefined)
+            continue;
+          const msg = `Duplicate WBS ${first.wbs} found in ${dup.length} files:
+` + dup.map((h2) => `  ${h2.filePath}`).join(`
+`);
+          if (json3) {
+            results.push({ wbs: first.wbs, pass: false, status: "duplicate", findings: [msg] });
+          } else {
+            context4.output.error(msg);
+          }
+        }
+      }
       if (json3) {
         context4.output.write(toJson2(results));
       }
@@ -89716,7 +90316,7 @@ function loadTemplateContent(projectRoot, variant) {
     return templateContentCache.get(variant);
   if (templateMissSet.has(variant))
     return;
-  const localPath = join25(projectRoot, ".spur", "tasks", "templates", `${variant}.md`);
+  const localPath = join26(projectRoot, ".spur", "tasks", "templates", `${variant}.md`);
   if (existsSync10(localPath)) {
     const content = readFileSync9(localPath, "utf8");
     templateContentCache.set(variant, content);
@@ -89724,7 +90324,7 @@ function loadTemplateContent(projectRoot, variant) {
   }
   const root = bundledConfigRoot();
   if (root !== null) {
-    const templatePath = join25(root, "templates", "task", `${variant}.md`);
+    const templatePath = join26(root, "templates", "task", `${variant}.md`);
     if (existsSync10(templatePath)) {
       const content = readFileSync9(templatePath, "utf8");
       templateContentCache.set(variant, content);
@@ -89740,13 +90340,13 @@ function loadTemplateBodies(projectRoot, variant) {
   if (cached2 !== undefined)
     return cached2;
   let bodies = {};
-  const localPath = join25(projectRoot, ".spur", "tasks", "templates", `${variant}.md`);
+  const localPath = join26(projectRoot, ".spur", "tasks", "templates", `${variant}.md`);
   if (existsSync10(localPath)) {
     bodies = extractTemplateBodies(readFileSync9(localPath, "utf8"));
   } else {
     const root = bundledConfigRoot();
     if (root !== null) {
-      const templatePath = join25(root, "templates", "task", `${variant}.md`);
+      const templatePath = join26(root, "templates", "task", `${variant}.md`);
       if (existsSync10(templatePath)) {
         bodies = extractTemplateBodies(readFileSync9(templatePath, "utf8"));
       }
@@ -89799,7 +90399,7 @@ async function loadSectionMatrixUncached(projectRoot) {
   }
   const root = bundledConfigRoot();
   if (root !== null) {
-    const matrixPath = join25(root, "tasks", "section-matrix.yaml");
+    const matrixPath = join26(root, "tasks", "section-matrix.yaml");
     if (await fs3.exists(matrixPath)) {
       const data = await loadStructuredSpurConfig(matrixPath, {
         validateJsonSchema: true,
@@ -90518,6 +91118,10 @@ function formatTraceTimeline(result) {
     `Started: ${run.startedAt}   Completed: ${run.completedAt ?? "-"}   Events: ${events2.length}`,
     ""
   ];
+  if (result.outputArtifact !== undefined) {
+    lines.push(`Agent output: ${result.outputArtifact} (tail -f for live view)`);
+    lines.push("");
+  }
   for (const event2 of events2) {
     lines.push(formatTimelineEvent(event2));
   }
@@ -90598,7 +91202,7 @@ init_src3();
 init_src();
 init_src2();
 init_dist5();
-import { dirname as dirname16, join as join26, resolve as resolve9 } from "path";
+import { dirname as dirname16, join as join27, resolve as resolve9 } from "path";
 import { isatty as isatty4 } from "tty";
 
 // ../../node_modules/.bun/@clack+core@1.4.1/node_modules/@clack/core/dist/index.mjs
@@ -92020,7 +92624,7 @@ function createCliContext(options) {
 function noopSetExitCode(_code) {}
 async function createMigratedDbAdapter(cwd = process.cwd(), env = process.env, dbUrl) {
   const config4 = buildConfigFromEnv(env);
-  const configuredUrl = env.DATABASE_URL === undefined ? join26(cwd, DEFAULT_DATABASE_URL) : config4.database.url;
+  const configuredUrl = env.DATABASE_URL === undefined ? join27(cwd, DEFAULT_DATABASE_URL) : config4.database.url;
   const url2 = dbUrl ?? configuredUrl;
   if (url2 !== IN_MEMORY_DATABASE_URL) {
     await createNodeFileSystem3().ensureDir(dirname16(url2));