@wrongstack/sdd 0.306.4 → 0.307.1

package/dist/index.d.ts

@@ -29,4 +29,6 @@ export { makeLlmSubtaskGenerator, makePlanningDecomposer, type PlanningDecompose
 export { splitGraphNode, type SplitGraphNodeOptions } from './graph-split.js';
 export { assessTaskNodeAtomicity, decomposeNonAtomicTasks, type DecompositionProposal, type PlanDecomposeOptions, type PlanDecomposeResult, } from './plan-decompose.js';
 export { makePreferSideConflictResolver, makeLlmConflictResolver, resolveConflictText, hasConflictMarkers, type ConflictSide, type LlmConflictResolverOptions, } from './conflict-resolver.js';
+export { synthesizeVibeSpec, buildCoderContract, auditVibeExecution, formatVibeReport, isIdentifierLikeExclusion, type VibeScopeBoundaries, type VibeSpecSynthesizerResult, type VibeCoderContract, type VibeAuditCheck, type VibeAuditVerdict, type VibeVerificationReport, } from './vibe-protocol.js';
+export { installVibeProtocol, VIBE_PROTOCOL_META_KEY } from './vibe-protocol-wiring.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1801,6 +1801,7 @@ function buildQuestioningPrompt(session, min, max) {
     "- Questions must be specific and contextual \u2014 never generic",
     "- Adapt based on previous answers",
     "- Cover: scope, constraints, edge cases, integrations, security, performance as relevant",
+    "- When asking questions with distinct architectural or trade-off choices, include 2 to 4 recommended options as a list (e.g. 1. ... 2. ...) so the operator can quickly choose or customize",
     "- When you have enough info, respond with the full specification in JSON format",
     "- This is a planning interview: respond with TEXT ONLY (a question, or the spec JSON).",
     "  Do NOT write or edit files, and do NOT run shell/terminal commands \u2014 the code is",
@@ -2168,6 +2169,29 @@ var AISpecBuilder = class {
     this.autoSave();
     return this.session.phase;
   }
+  /**
+   * Rewind the session to an earlier phase (e.g. rejecting plan to re-specify,
+   * or moving from spec review back to questioning).
+   */
+  rewindTo(targetPhase) {
+    if (targetPhase === this.session.phase) return this.session.phase;
+    this.session.phase = targetPhase;
+    this.session.approved = false;
+    if (targetPhase === "questioning") {
+      this.session.spec = void 0;
+      this.session.implementation = void 0;
+      this.session.taskGraphId = void 0;
+    } else if (targetPhase === "spec_review") {
+      this.session.implementation = void 0;
+      this.session.taskGraphId = void 0;
+    } else if (targetPhase === "implementation") {
+      this.session.implementation = void 0;
+      this.session.taskGraphId = void 0;
+    }
+    this.session.updatedAt = Date.now();
+    this.autoSave();
+    return this.session.phase;
+  }
   /**
    * Set the implementation plan text.
    */
@@ -2509,15 +2533,18 @@ var SddInterviewDriver = class {
       implementationDetected: false,
       tasksDetected: false
     };
-    if (!this.builder.getSession().spec) {
-      const spec = this.builder.tryParseSpecFromOutput(text);
-      if (spec) {
+    const currentSpec = this.builder.getSession().spec;
+    const spec = this.builder.tryParseSpecFromOutput(text);
+    if (spec) {
+      const isNewOrUpdated = !currentSpec || currentSpec.title !== spec.title || currentSpec.overview !== spec.overview || JSON.stringify(currentSpec.requirements) !== JSON.stringify(spec.requirements) || JSON.stringify(currentSpec.sections) !== JSON.stringify(spec.sections);
+      if (isNewOrUpdated) {
         this.builder.setSpec(spec);
         await this.persistSpec(spec);
         result.specDetected = true;
       }
     }
-    if (this.builder.getPhase() === "implementation") {
+    const phase = this.builder.getPhase();
+    if (phase === "implementation" || phase === "task_review") {
       if (this.trySaveImplementationPlan(text)) result.implementationDetected = true;
     }
     const session = this.builder.getSession();
@@ -2543,6 +2570,21 @@ var SddInterviewDriver = class {
     }
     return { phase, prompt: this.builder.getAIPrompt() };
   }
+  /**
+   * Rewind the interview to an earlier phase (e.g. reject plan, back to spec review,
+   * or back to questioning).
+   */
+  async rewind(targetPhase) {
+    const cur = this.builder.getPhase();
+    const target = targetPhase ?? (cur === "task_review" ? "implementation" : cur === "implementation" ? "spec_review" : cur === "spec_review" ? "questioning" : cur === "executing" ? "task_review" : "questioning");
+    const phase = this.builder.rewindTo(target);
+    if (target === "questioning" || target === "spec_review" || target === "implementation") {
+      this.tracker = null;
+      this.graph = null;
+    }
+    await this.builder.saveSession();
+    return { phase, prompt: this.builder.getAIPrompt() };
+  }
   /**
    * Ensure a TaskGraph exists for the approved spec. If the agent already
    * produced one (via `ingestAgentOutput`), returns it; otherwise builds a
@@ -3055,6 +3097,133 @@ var SddTaskDecomposer = class {
   }
 };
 
+// src/sdd-worktree-integration.ts
+function forgetTaskWorktree(state, taskId, opts = {}) {
+  state.taskWorktrees.delete(taskId);
+  state.taskCwds.delete(taskId);
+  if (!opts.keepBranchLabel) state.taskBranches.delete(taskId);
+}
+async function allocateTaskWorktrees(opts, state, tasks) {
+  const wt = opts.worktrees;
+  if (!wt) return;
+  for (const task of tasks) {
+    if (state.taskWorktrees.has(task.id)) continue;
+    try {
+      const handle = await wt.allocate(`sdd-${task.id}`, {
+        slugHint: task.title,
+        ownerLabel: task.title
+      });
+      if (handle.status === "active") {
+        state.taskWorktrees.set(task.id, handle);
+        state.taskCwds.set(task.id, handle.dir);
+        state.taskBranches.set(task.id, handle.branch);
+        const node = opts.tracker.getNode(task.id);
+        if (node) node.metadata = { ...node.metadata, worktreeBranch: handle.branch };
+      }
+    } catch {
+    }
+  }
+}
+async function resolveTaskWorktrees(opts, state, tasks) {
+  const wt = opts.worktrees;
+  if (!wt) return;
+  for (const task of tasks) {
+    const handle = state.taskWorktrees.get(task.id);
+    if (!handle) continue;
+    const node = opts.tracker.getNode(task.id);
+    const status = node?.status;
+    const cancelled = Boolean(node?.metadata?.cancelled);
+    try {
+      if (cancelled) {
+        await wt.release(handle, { keep: false });
+        forgetTaskWorktree(state, task.id, { keepBranchLabel: false });
+      } else if (status === "completed") {
+        await wt.commitAll(handle, `sdd(${task.title}): ${task.id}`);
+        await wt.merge(handle, { squash: true });
+        await wt.release(handle, { keep: false });
+        forgetTaskWorktree(state, task.id);
+      } else if (status === "failed") {
+        await wt.release(handle, { keep: false });
+        forgetTaskWorktree(state, task.id, { keepBranchLabel: false });
+      } else {
+        await wt.release(handle, { keep: false });
+        forgetTaskWorktree(state, task.id, { keepBranchLabel: false });
+      }
+    } catch {
+      forgetTaskWorktree(state, task.id);
+    }
+  }
+}
+async function integrateTaskWorktree(params) {
+  const { opts, state, task, result, runId, emit, abortRun } = params;
+  const wt = opts.worktrees;
+  if (!wt) return { ok: true };
+  const handle = state.taskWorktrees.get(task.id);
+  if (!handle) return { ok: true };
+  try {
+    await wt.commitAll(handle, `sdd(${task.title}): ${task.id}`);
+    const baseShaBefore = await wt.baseHead(handle);
+    const baseSha = opts.conflictResolver ? baseShaBefore : null;
+    const res = await wt.merge(handle, {
+      squash: true,
+      ...opts.conflictResolver ? {
+        resolve: (info) => opts.conflictResolver({
+          task,
+          conflictFiles: info.conflictFiles,
+          cwd: info.cwd
+        })
+      } : {}
+    });
+    if (res.ok) {
+      if (res.resolved && opts.verifyTask && baseSha) {
+        let regressed;
+        try {
+          const verdict = await opts.verifyTask({
+            task,
+            result: result ?? {},
+            cwd: opts.projectRoot
+          });
+          if (!verdict.ok)
+            regressed = verdict.reason ?? "verification failed after conflict resolution";
+        } catch (err) {
+          regressed = `verification error after conflict resolution: ${String(err)}`;
+        }
+        if (regressed) {
+          const rolledBack = await wt.revertBaseTo(handle, baseSha).catch(() => false);
+          if (!rolledBack) {
+            abortRun(
+              `cannot roll back invalid merge of "${task.title}" (${task.id}): ${regressed}`
+            );
+            await wt.release(handle, { keep: true }).catch(() => {
+            });
+            forgetTaskWorktree(state, task.id, { keepBranchLabel: true });
+            return { ok: false, conflictFiles: [], reason: regressed, fatal: true };
+          }
+          await wt.release(handle, { keep: false }).catch(() => {
+          });
+          forgetTaskWorktree(state, task.id, { keepBranchLabel: true });
+          return { ok: false, conflictFiles: [], reason: regressed };
+        }
+      }
+      const baseShaAfter = await wt.baseHead(handle);
+      if (baseShaAfter && baseShaAfter !== baseShaBefore) {
+        state.mergedCommits.push({ taskId: task.id, sha: baseShaAfter, title: task.title });
+        emit("sdd.task.merged", { runId, taskId: task.id, sha: baseShaAfter });
+      }
+      await wt.release(handle, { keep: false });
+      forgetTaskWorktree(state, task.id);
+      return { ok: true };
+    }
+    await wt.release(handle, { keep: false }).catch(() => {
+    });
+    forgetTaskWorktree(state, task.id, { keepBranchLabel: true });
+    return { ok: false, conflictFiles: res.conflictFiles ?? [] };
+  } catch {
+    forgetTaskWorktree(state, task.id);
+    return { ok: false, conflictFiles: [] };
+  }
+}
+
 // src/sdd-parallel-run.ts
 var SddParallelRun = class {
   constructor(opts) {
@@ -3732,95 +3901,28 @@ var SddParallelRun = class {
    * disabled or none was allocated for this task. Never throws — a merge hiccup
    * degrades to a (retryable) failure rather than wedging the run.
    */
+  get worktreeState() {
+    return {
+      taskCwds: this.taskCwds,
+      taskBranches: this.taskBranches,
+      taskWorktrees: this.taskWorktrees,
+      mergedCommits: this.mergedCommits
+    };
+  }
   async integrateWorktree(task, result) {
-    const wt = this.opts.worktrees;
-    if (!wt) return { ok: true };
-    const handle = this.taskWorktrees.get(task.id);
-    if (!handle) return { ok: true };
-    try {
-      await wt.commitAll(handle, `sdd(${task.title}): ${task.id}`);
-      const baseShaBefore = await wt.baseHead(handle);
-      const baseSha = this.opts.conflictResolver ? baseShaBefore : null;
-      const res = await wt.merge(handle, {
-        squash: true,
-        ...this.opts.conflictResolver ? {
-          resolve: (info) => this.opts.conflictResolver({
-            task,
-            conflictFiles: info.conflictFiles,
-            cwd: info.cwd
-          })
-        } : {}
-      });
-      if (res.ok) {
-        if (res.resolved && this.opts.verifyTask && baseSha) {
-          let regressed;
-          try {
-            const verdict = await this.opts.verifyTask({
-              task,
-              result: result ?? {},
-              cwd: this.opts.projectRoot
-            });
-            if (!verdict.ok)
-              regressed = verdict.reason ?? "verification failed after conflict resolution";
-          } catch (err) {
-            regressed = `verification error after conflict resolution: ${String(err)}`;
-          }
-          if (regressed) {
-            const rolledBack = await wt.revertBaseTo(handle, baseSha).catch(() => false);
-            if (!rolledBack) {
-              this.abortRun(
-                `cannot roll back invalid merge of "${task.title}" (${task.id}): ${regressed}`
-              );
-              await wt.release(handle, { keep: true }).catch(() => {
-              });
-              this.forgetWorktree(task.id, { keepBranchLabel: true });
-              return { ok: false, conflictFiles: [], reason: regressed, fatal: true };
-            }
-            await wt.release(handle, { keep: false }).catch(() => {
-            });
-            this.forgetWorktree(task.id, { keepBranchLabel: true });
-            return { ok: false, conflictFiles: [], reason: regressed };
-          }
-        }
-        const baseShaAfter = await wt.baseHead(handle);
-        if (baseShaAfter && baseShaAfter !== baseShaBefore) {
-          this.mergedCommits.push({ taskId: task.id, sha: baseShaAfter, title: task.title });
-          this.emit("sdd.task.merged", { runId: this.runId, taskId: task.id, sha: baseShaAfter });
-        }
-        await wt.release(handle, { keep: false });
-        this.forgetWorktree(task.id);
-        return { ok: true };
-      }
-      await wt.release(handle, { keep: false }).catch(() => {
-      });
-      this.forgetWorktree(task.id, { keepBranchLabel: true });
-      return { ok: false, conflictFiles: res.conflictFiles ?? [] };
-    } catch {
-      this.forgetWorktree(task.id);
-      return { ok: false, conflictFiles: [] };
-    }
+    return integrateTaskWorktree({
+      opts: this.opts,
+      state: this.worktreeState,
+      task,
+      result,
+      runId: this.runId,
+      emit: this.emit.bind(this),
+      abortRun: this.abortRun.bind(this)
+    });
   }
   /** Allocate a fresh git worktree per task in the batch (no-op without a manager). */
   async allocateWorktrees(tasks) {
-    const wt = this.opts.worktrees;
-    if (!wt) return;
-    for (const task of tasks) {
-      if (this.taskWorktrees.has(task.id)) continue;
-      try {
-        const handle = await wt.allocate(`sdd-${task.id}`, {
-          slugHint: task.title,
-          ownerLabel: task.title
-        });
-        if (handle.status === "active") {
-          this.taskWorktrees.set(task.id, handle);
-          this.taskCwds.set(task.id, handle.dir);
-          this.taskBranches.set(task.id, handle.branch);
-          const node = this.opts.tracker.getNode(task.id);
-          if (node) node.metadata = { ...node.metadata, worktreeBranch: handle.branch };
-        }
-      } catch {
-      }
-    }
+    await allocateTaskWorktrees(this.opts, this.worktreeState, tasks);
   }
   /**
    * Resolve each task's worktree after its result is known. Serialized merges
@@ -3828,39 +3930,10 @@ var SddParallelRun = class {
    * guarantees dependency order (a task's blockers merged in an earlier wave).
    */
   async resolveWorktrees(tasks) {
-    const wt = this.opts.worktrees;
-    if (!wt) return;
-    for (const task of tasks) {
-      const handle = this.taskWorktrees.get(task.id);
-      if (!handle) continue;
-      const node = this.opts.tracker.getNode(task.id);
-      const status = node?.status;
-      const cancelled = Boolean(node?.metadata?.cancelled);
-      try {
-        if (cancelled) {
-          await wt.release(handle, { keep: false });
-          this.forgetWorktree(task.id, { keepBranchLabel: false });
-        } else if (status === "completed") {
-          await wt.commitAll(handle, `sdd(${task.title}): ${task.id}`);
-          await wt.merge(handle, { squash: true });
-          await wt.release(handle, { keep: false });
-          this.forgetWorktree(task.id);
-        } else if (status === "failed") {
-          await wt.release(handle, { keep: false });
-          this.forgetWorktree(task.id, { keepBranchLabel: false });
-        } else {
-          await wt.release(handle, { keep: false });
-          this.forgetWorktree(task.id, { keepBranchLabel: false });
-        }
-      } catch {
-        this.forgetWorktree(task.id);
-      }
-    }
+    await resolveTaskWorktrees(this.opts, this.worktreeState, tasks);
   }
   forgetWorktree(taskId, opts = {}) {
-    this.taskWorktrees.delete(taskId);
-    this.taskCwds.delete(taskId);
-    if (!opts.keepBranchLabel) this.taskBranches.delete(taskId);
+    forgetTaskWorktree(this.worktreeState, taskId, opts);
   }
   /** Persist a task's retry count into node metadata (survives crash → resume). */
   persistRetries(taskId, retries) {
@@ -5707,6 +5780,239 @@ function makeLlmConflictResolver(opts) {
     return true;
   };
 }
+
+// src/vibe-protocol.ts
+import { stripVibeTag } from "@wrongstack/requirement-intake";
+function isIdentifierLikeExclusion(excluded) {
+  const trimmed = excluded.trim();
+  if (trimmed.length < 2) return false;
+  if (/^['"`].+['"`]$/.test(trimmed)) return true;
+  return !/\s/.test(trimmed);
+}
+function synthesizeVibeSpec(rawPrompt, projectContext = "") {
+  const cleanPrompt = stripVibeTag(rawPrompt);
+  const lines = cleanPrompt.split(/[\n;]+/).map((line) => line.trim()).filter(Boolean);
+  const coreIntent = lines[0] ?? "Implement requested feature according to project standards";
+  const sensibleDefaults = [
+    "Apply sensible defaults for unstated edge cases without breaking existing API contracts",
+    "Follow project conventions and strict type safety"
+  ];
+  if (/admin|role|auth|yetki/i.test(cleanPrompt)) {
+    sensibleDefaults.push("Enforce role-based permission checks before executing privileged actions");
+  }
+  if (/sil|delete|remove|uçur/i.test(cleanPrompt)) {
+    sensibleDefaults.push("Confirm deletion intent and handle non-existent resource gracefully");
+  }
+  if (/sepet|cart|ekle|add|art/i.test(cleanPrompt)) {
+    sensibleDefaults.push("Ensure idempotency and optimistic UI updates for cart/counter operations");
+  }
+  const acceptanceCriteria = lines.map(
+    (line, idx) => `Given user interaction, should correctly handle step ${idx + 1}: ${line}`
+  );
+  if (acceptanceCriteria.length === 0) {
+    acceptanceCriteria.push("Given standard input, action executes and updates state successfully");
+  }
+  const scopeBoundaries = {
+    included: [coreIntent],
+    excluded: ["Unrelated UI refactors", "Unrequested third-party dependency additions"]
+  };
+  const formattedSpecMarkdown = [
+    "## \u{1F30A} VIBE Synthesized Specification",
+    `**Core Intent:** ${coreIntent}`,
+    "",
+    "### \u{1F9E9} Sensible Defaults & Assumptions",
+    ...sensibleDefaults.map((item) => `- ${item}`),
+    "",
+    "### \u{1F4CB} Acceptance Criteria",
+    ...acceptanceCriteria.map((ac) => `- [ ] ${ac}`),
+    "",
+    "### \u{1F6A7} Scope Boundaries",
+    "**Included:**",
+    ...scopeBoundaries.included.map((item) => `  - ${item}`),
+    "**Excluded:**",
+    ...scopeBoundaries.excluded.map((item) => `  - ${item}`),
+    ...projectContext ? ["", "### \u{1F4C1} Context", projectContext] : []
+  ].join("\n");
+  return {
+    coreIntent,
+    sensibleDefaults,
+    acceptanceCriteria,
+    scopeBoundaries,
+    formattedSpecMarkdown
+  };
+}
+function buildCoderContract(spec, targetFiles = []) {
+  const instructions = [
+    `Implement core intent: ${spec.coreIntent}`,
+    ...spec.sensibleDefaults.map((d) => `Respect default: ${d}`),
+    ...spec.acceptanceCriteria.map((ac) => `Satisfy acceptance criterion: ${ac}`),
+    ...spec.scopeBoundaries.excluded.map((exc) => `DO NOT introduce: ${exc}`)
+  ];
+  return {
+    specSummary: spec.coreIntent,
+    instructions,
+    targetFiles,
+    acceptanceChecklist: spec.acceptanceCriteria
+  };
+}
+function auditVibeExecution(input) {
+  const { spec, coderOutput } = input;
+  const checks = [];
+  const reworkDirectives = [];
+  const hasCoderOutput = coderOutput.trim().length > 0;
+  checks.push({
+    id: "intent-fidelity",
+    name: "Intent Fidelity (Did coder address the synthesized spec?)",
+    passed: hasCoderOutput,
+    details: hasCoderOutput ? "Coder output produced against synthesized spec" : "No code changes provided by coder"
+  });
+  if (!hasCoderOutput) {
+    reworkDirectives.push("Coder must generate implementation matching the spec.");
+  }
+  let scopeClean = true;
+  for (const excluded of spec.scopeBoundaries.excluded) {
+    if (!isIdentifierLikeExclusion(excluded)) continue;
+    if (coderOutput.toLowerCase().includes(excluded.toLowerCase())) {
+      scopeClean = false;
+      checks.push({
+        id: "scope-bleed",
+        name: `Scope Violation Check (${excluded})`,
+        passed: false,
+        details: `Coder output appears to touch excluded scope: ${excluded}`
+      });
+      reworkDirectives.push(`Remove changes related to excluded scope: ${excluded}`);
+    }
+  }
+  if (scopeClean) {
+    checks.push({
+      id: "scope-fidelity",
+      name: "Scope Boundary Check",
+      passed: true,
+      details: "Implementation stays within specified boundaries without scope bleed"
+    });
+  }
+  checks.push({
+    id: "acceptance-criteria",
+    name: "Acceptance Criteria Alignment",
+    passed: hasCoderOutput,
+    details: hasCoderOutput ? `Coder produced output against a contract of ${spec.acceptanceCriteria.length} acceptance criteria (not independently executed)` : "No coder output to align with acceptance criteria"
+  });
+  const allPassed = checks.every((c) => c.passed);
+  const score = Math.round(checks.filter((c) => c.passed).length / checks.length * 100);
+  return {
+    verdict: allPassed ? "PASS" : "REJECT",
+    score,
+    checks,
+    ...reworkDirectives.length > 0 ? { reworkDirectives } : {},
+    summary: allPassed ? "Auditor approved: Code aligns with synthesized spec, no hallucinations or scope violations detected." : `Auditor rejected: ${reworkDirectives.join("; ")}`
+  };
+}
+function formatVibeReport(rawPrompt, spec, coder, audit) {
+  return [
+    "### \u{1F30A} [VIBE Protocol: Spec-Synthesizer]",
+    ...rawPrompt.trim().length > 0 ? [`- **\u{1F5E3}\uFE0F Raw Prompt:** ${rawPrompt.trim()}`] : [],
+    `- **\u{1F3AF} Core Intent:** ${spec.coreIntent}`,
+    "- **\u{1F9E9} Sensible Defaults:**",
+    ...spec.sensibleDefaults.map((d) => `  \u2022 ${d}`),
+    "- **\u{1F4CB} Acceptance Criteria:**",
+    ...spec.acceptanceCriteria.map((ac) => `  - [ ] ${ac}`),
+    "- _Auditor did not independently execute these criteria._",
+    "",
+    "---",
+    "",
+    "### \u{1F4BB} [Coder Contract]",
+    `- **Target Files:** ${coder.targetFiles.length > 0 ? coder.targetFiles.join(", ") : "Inferred from project context"}`,
+    `- **Directives:** ${coder.instructions.length} generated guidelines`,
+    "",
+    "---",
+    "",
+    "### \u{1F6E1}\uFE0F [Auditor Verdict]",
+    `- **Verdict:** ${audit.verdict === "PASS" ? "\u2705 PASS" : "\u274C REJECT"} (Score: ${audit.score}%)`,
+    `- **Summary:** ${audit.summary}`,
+    ...audit.checks.map((c) => `  - ${c.passed ? "\u2705" : "\u274C"} **${c.name}**: ${c.details}`),
+    ...audit.reworkDirectives && audit.reworkDirectives.length > 0 ? ["", "**\u{1F527} Rework Instructions:**", ...audit.reworkDirectives.map((r) => `  - ${r}`)] : []
+  ].join("\n");
+}
+
+// src/vibe-protocol-wiring.ts
+import { hasVibeTag } from "@wrongstack/requirement-intake";
+var VIBE_PROTOCOL_META_KEY = "vibeProtocol";
+function formatCoderInput(spec, coder) {
+  return [
+    "[vibe_protocol]",
+    "The user explicitly requested the VIBE three-stage verification protocol.",
+    "Implement the request using the synthesized specification and coder contract below.",
+    "Do not merely describe the contract: perform the requested work, verify it, and report the result.",
+    "",
+    spec.formattedSpecMarkdown,
+    "",
+    "## Coder Contract",
+    ...coder.instructions.map((instruction) => `- ${instruction}`),
+    "[/vibe_protocol]"
+  ].join("\n");
+}
+function installVibeProtocol(pipelines) {
+  let active;
+  const userInput = {
+    name: "VibeProtocolInput",
+    owner: "sdd",
+    async handler(payload, next) {
+      active = void 0;
+      delete payload.ctx.meta[VIBE_PROTOCOL_META_KEY];
+      if (!hasVibeTag(payload.text)) return next(payload);
+      const rawPrompt = payload.text;
+      const spec = synthesizeVibeSpec(rawPrompt);
+      const coder = buildCoderContract(spec);
+      const contractBlock = { type: "text", text: formatCoderInput(spec, coder) };
+      payload.content = [...payload.content, contractBlock];
+      payload.text = `${payload.text}
+
+${contractBlock.text}`;
+      active = { rawPrompt, spec, coder, ctx: payload.ctx };
+      payload.ctx.meta[VIBE_PROTOCOL_META_KEY] = {
+        isVibeMode: true,
+        stage: "coder",
+        synthesizer: spec,
+        coder
+      };
+      return next(payload);
+    }
+  };
+  const response = {
+    name: "VibeProtocolAuditor",
+    owner: "sdd",
+    async handler(value, next) {
+      const run = active;
+      if (!run || value.content.some((block) => block.type === "tool_use")) return next(value);
+      const coderOutput = value.content.filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
+      if (!coderOutput) return next(value);
+      const audit = auditVibeExecution({
+        rawPrompt: run.rawPrompt,
+        spec: run.spec,
+        coderOutput
+      });
+      const markdown = formatVibeReport(run.rawPrompt, run.spec, run.coder, audit);
+      const report = {
+        isVibeMode: true,
+        stage: audit.verdict === "PASS" ? "passed" : "auditor",
+        synthesizer: run.spec,
+        coder: run.coder,
+        audit,
+        markdown
+      };
+      active = void 0;
+      run.ctx.meta[VIBE_PROTOCOL_META_KEY] = report;
+      return next({
+        ...value,
+        content: [...value.content, { type: "text", text: `
+
+${markdown}` }]
+      });
+    }
+  };
+  pipelines.userInput.use(userInput);
+  pipelines.response.use(response);
+}
 export {
   AISpecBuilder,
   AutoExecutor,
@@ -5727,6 +6033,7 @@ export {
   TaskGenerator,
   TaskGraphStore,
   TaskTracker3 as TaskTracker,
+  VIBE_PROTOCOL_META_KEY,
   analyzeCriticalPath,
   applySddLifecycle,
   assertSpecTaskGraphCoverage,
@@ -5734,8 +6041,10 @@ export {
   assertTaskGraphRequirementCoverage,
   assessGeneratedTaskAtomicity,
   assessTaskNodeAtomicity,
+  auditVibeExecution,
   buildBoardSnapshot,
   buildBoardTasks,
+  buildCoderContract,
   cleanupSddWorktrees,
   cleanupStaleSddWorktrees,
   cleanupStaleWorktrees,
@@ -5745,12 +6054,15 @@ export {
   destroySddProject,
   evaluateTaskGraphRequirementCoverage,
   extractVerificationCommand,
+  formatVibeReport,
   gatherProjectContext,
   getTemplate,
   hasConflictMarkers,
+  installVibeProtocol,
   intakeToInterviewKickoff,
   isAISpecSession,
   isExplanatoryText,
+  isIdentifierLikeExclusion,
   listTemplates,
   makeAcceptanceCriteriaVerifier,
   makeCommandVerifier,
@@ -5769,6 +6081,7 @@ export {
   splitGraphNode,
   startInterviewFromIntake,
   startSddRun,
+  synthesizeVibeSpec,
   templateToMarkdown,
   tokenizeCommand
 };

package/dist/sdd-interview-driver.d.ts

@@ -116,6 +116,14 @@ export declare class SddInterviewDriver {
         phase: AISpecPhase;
         prompt: string;
     }>;
+    /**
+     * Rewind the interview to an earlier phase (e.g. reject plan, back to spec review,
+     * or back to questioning).
+     */
+    rewind(targetPhase?: AISpecPhase): Promise<{
+        phase: AISpecPhase;
+        prompt: string;
+    }>;
     /**
      * Ensure a TaskGraph exists for the approved spec. If the agent already
      * produced one (via `ingestAgentOutput`), returns it; otherwise builds a

package/dist/sdd-parallel-run.d.ts

@@ -253,6 +253,7 @@ export declare class SddParallelRun {
      * disabled or none was allocated for this task. Never throws — a merge hiccup
      * degrades to a (retryable) failure rather than wedging the run.
      */
+    private get worktreeState();
     private integrateWorktree;
     /** Allocate a fresh git worktree per task in the batch (no-op without a manager). */
     private allocateWorktrees;

package/dist/sdd-worktree-integration.d.ts

@@ -0,0 +1,33 @@
+import type { TaskNode, TaskResult } from '@wrongstack/core/types';
+import type { WorktreeHandle } from '@wrongstack/core/worktree';
+import type { SddParallelRunOptions } from './sdd-parallel-run-types.js';
+export interface SddWorktreeState {
+    taskCwds: Map<string, string>;
+    taskBranches: Map<string, string>;
+    taskWorktrees: Map<string, WorktreeHandle>;
+    mergedCommits: Array<{
+        taskId: string;
+        sha: string;
+        title: string;
+    }>;
+}
+export declare function forgetTaskWorktree(state: SddWorktreeState, taskId: string, opts?: {
+    keepBranchLabel?: boolean;
+}): void;
+export declare function allocateTaskWorktrees(opts: SddParallelRunOptions, state: SddWorktreeState, tasks: TaskNode[]): Promise<void>;
+export declare function resolveTaskWorktrees(opts: SddParallelRunOptions, state: SddWorktreeState, tasks: TaskNode[]): Promise<void>;
+export declare function integrateTaskWorktree(params: {
+    opts: SddParallelRunOptions;
+    state: SddWorktreeState;
+    task: TaskNode;
+    result?: TaskResult | undefined;
+    runId: string;
+    emit: (event: any, payload: any) => void;
+    abortRun: (reason: string) => void;
+}): Promise<{
+    ok: boolean;
+    conflictFiles?: string[];
+    reason?: string;
+    fatal?: boolean;
+}>;
+//# sourceMappingURL=sdd-worktree-integration.d.ts.map

package/dist/spec-builder.d.ts

@@ -76,6 +76,11 @@ export declare class AISpecBuilder {
      * executing → done
      */
     approve(): AISpecPhase;
+    /**
+     * Rewind the session to an earlier phase (e.g. rejecting plan to re-specify,
+     * or moving from spec review back to questioning).
+     */
+    rewindTo(targetPhase: AISpecPhase): AISpecPhase;
     /**
      * Set the implementation plan text.
      */

package/dist/vibe-protocol-wiring.d.ts

@@ -0,0 +1,10 @@
+import type { AgentPipelines } from '@wrongstack/core/agent';
+export declare const VIBE_PROTOCOL_META_KEY = "vibeProtocol";
+/**
+ * Installs the VIBE protocol on Agent pipelines. CLI/TUI (lifecycle-plugins)
+ * and standalone WebUI (createAgentServices) both call this so a tagged user
+ * turn receives the synthesized spec and coder contract before the model runs;
+ * the first final text response is then audited and receives the report.
+ */
+export declare function installVibeProtocol(pipelines: AgentPipelines): void;
+//# sourceMappingURL=vibe-protocol-wiring.d.ts.map

package/dist/vibe-protocol.d.ts

@@ -0,0 +1,80 @@
+/**
+ * SDD — VIBE Three-Stage Verification Protocol.
+ *
+ * Implements the Three-Stage Verification Protocol (Spec-Synthesizer -> Coder -> Auditor)
+ * designed to transform chaotic, incomplete, or ambiguous user prompts into verified,
+ * regression-free specifications and code.
+ */
+export interface VibeScopeBoundaries {
+    included: string[];
+    excluded: string[];
+}
+export interface VibeSpecSynthesizerResult {
+    /** High-level core intent crystallized from the chaotic prompt. */
+    coreIntent: string;
+    /** Inferred assumptions and sensible defaults to fill gaps. */
+    sensibleDefaults: string[];
+    /** Testable Given-When-Then or checklist items. */
+    acceptanceCriteria: string[];
+    /** Strict boundaries to prevent over-engineering. */
+    scopeBoundaries: VibeScopeBoundaries;
+    /** Formatted Markdown spec contract. */
+    formattedSpecMarkdown: string;
+}
+export interface VibeCoderContract {
+    /** Summary of the spec to be implemented. */
+    specSummary: string;
+    /** Actionable developer instructions derived strictly from the synthesized spec. */
+    instructions: string[];
+    /** Target files or modules affected. */
+    targetFiles: string[];
+    /** Acceptance criteria checklist that the coder must satisfy. */
+    acceptanceChecklist: string[];
+}
+export interface VibeAuditCheck {
+    id: string;
+    name: string;
+    passed: boolean;
+    details: string;
+}
+export interface VibeAuditVerdict {
+    verdict: 'PASS' | 'REJECT';
+    score: number;
+    checks: VibeAuditCheck[];
+    reworkDirectives?: string[];
+    summary: string;
+}
+export interface VibeVerificationReport {
+    isVibeMode: boolean;
+    stage: 'synthesizer' | 'coder' | 'auditor' | 'passed';
+    synthesizer: VibeSpecSynthesizerResult;
+    coder: VibeCoderContract;
+    audit: VibeAuditVerdict;
+    markdown: string;
+}
+/**
+ * Policy sentences are not code artifacts. Only identifier-like exclusions
+ * (packages, files, symbols) are safe to substring-match in coder output.
+ */
+export declare function isIdentifierLikeExclusion(excluded: string): boolean;
+/**
+ * 1. Spec-Synthesizer: Transforms unstructured, chaotic vibe prompt into a formal spec.
+ */
+export declare function synthesizeVibeSpec(rawPrompt: string, projectContext?: string): VibeSpecSynthesizerResult;
+/**
+ * 2. Coder Stage: Generates coder contract strictly from the synthesized spec.
+ */
+export declare function buildCoderContract(spec: VibeSpecSynthesizerResult, targetFiles?: string[]): VibeCoderContract;
+/**
+ * 3. Auditor Stage: Cross-checks raw vibe vs synthesized spec vs coder output.
+ */
+export declare function auditVibeExecution(input: {
+    rawPrompt?: string;
+    spec: VibeSpecSynthesizerResult;
+    coderOutput: string;
+}): VibeAuditVerdict;
+/**
+ * Formats a comprehensive 3-stage Markdown report.
+ */
+export declare function formatVibeReport(rawPrompt: string, spec: VibeSpecSynthesizerResult, coder: VibeCoderContract, audit: VibeAuditVerdict): string;
+//# sourceMappingURL=vibe-protocol.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/sdd",
-  "version": "0.306.4",
+  "version": "0.307.1",
   "license": "MIT",
   "description": "WrongStack Spec-Driven Development engine — standalone package extracted from @wrongstack/core. Task graph generation, tracking, execution, lifecycle management, and AI-driven spec building for SDD workflows.",
   "repository": {
@@ -27,12 +27,12 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@wrongstack/kanban": "0.306.4",
-    "@wrongstack/core": "0.306.4",
-    "@wrongstack/requirement-intake": "0.306.4"
+    "@wrongstack/requirement-intake": "0.307.1",
+    "@wrongstack/kanban": "0.307.1",
+    "@wrongstack/core": "0.307.1"
   },
   "devDependencies": {
-    "@types/node": "^26.1.2",
+    "@types/node": "^26.2.0",
     "typescript": "^7.0.2"
   },
   "publishConfig": {