pi-vcc 0.4.0

package/src/extract/commits.ts

@@ -0,0 +1,69 @@
+import type { NormalizedBlock } from "../types";
+
+interface CommitInfo {
+  hash?: string;
+  message: string;
+}
+
+const COMMIT_MSG_RE = /git\s+commit[^\n]*?-m\s+(?:"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)'|\$?'((?:[^'\\]|\\.)*)')/;
+// Match short hash from git output: "[branch hash]" or "main hash" or 7-12 hex
+const HASH_RE = /\b([0-9a-f]{7,12})\b/;
+
+const firstLineOf = (text: string): string => {
+  const line = text.split(/\\n|\n/)[0] ?? "";
+  return line.trim();
+};
+
+const cleanMessage = (msg: string): string =>
+  msg.replace(/\\"/g, '"').replace(/\\'/g, "'").trim();
+
+/**
+ * Extract git commits from bash tool calls (`git commit -m "..."`) and pair
+ * with hash from the immediately following tool_result.
+ */
+export const extractCommits = (blocks: NormalizedBlock[]): CommitInfo[] => {
+  const commits: CommitInfo[] = [];
+
+  for (let i = 0; i < blocks.length; i++) {
+    const b = blocks[i];
+    if (b.kind !== "tool_call" || b.name !== "bash") continue;
+    const cmd = typeof b.args.command === "string" ? b.args.command : "";
+    if (!/\bgit\s+commit\b/.test(cmd)) continue;
+    const m = cmd.match(COMMIT_MSG_RE);
+    if (!m) continue;
+    const message = firstLineOf(cleanMessage(m[1] ?? m[2] ?? m[3] ?? ""));
+    if (!message) continue;
+
+    let hash: string | undefined;
+    // Look at next tool_result for hash
+    for (let j = i + 1; j < Math.min(blocks.length, i + 3); j++) {
+      const r = blocks[j];
+      if (r.kind !== "tool_result") continue;
+      // Common git commit output: `[branch <hash>] message` or `<branch> <hash>..<hash>`
+      const bracket = r.text.match(/\[\S+\s+([0-9a-f]{7,12})\]/);
+      if (bracket) { hash = bracket[1]; break; }
+      const range = r.text.match(/\b([0-9a-f]{7,12})\.\.([0-9a-f]{7,12})\b/);
+      if (range) { hash = range[2]; break; }
+      const plain = r.text.match(HASH_RE);
+      if (plain) { hash = plain[1]; break; }
+    }
+
+    // Dedup by message+hash
+    const key = `${hash ?? ""}::${message}`;
+    if (!commits.some((c) => `${c.hash ?? ""}::${c.message}` === key)) {
+      commits.push({ hash, message });
+    }
+  }
+
+  return commits;
+};
+
+export const formatCommits = (commits: CommitInfo[], limit = 8): string[] => {
+  const lines: string[] = [];
+  const items = commits.slice(-limit); // keep most recent
+  for (const c of items) {
+    const prefix = c.hash ? `${c.hash}: ` : "";
+    lines.push(`${prefix}${c.message}`);
+  }
+  return lines;
+};

package/src/extract/files.ts

@@ -0,0 +1,80 @@
+import type { FileOps, NormalizedBlock } from "../types";
+import { extractPath } from "../core/tool-args";
+
+interface FileActivity {
+  read: Set<string>;
+  modified: Set<string>;
+  created: Set<string>;
+}
+
+const FILE_READ_TOOLS = new Set([
+  "Read", "read_file", "View",
+]);
+
+const FILE_WRITE_TOOLS = new Set([
+  "Edit", "Write", "edit", "write", "edit_file", "write_file",
+  "MultiEdit",
+]);
+
+const FILE_CREATE_TOOLS = new Set([
+  "Write", "write", "write_file",
+]);
+
+/**
+ * Find the longest common directory prefix among absolute paths.
+ * Returns "" if fewer than 2 absolute paths or no meaningful common prefix.
+ */
+const longestCommonDirPrefix = (paths: string[]): string => {
+  const abs = paths.filter((p) => p.startsWith("/"));
+  if (abs.length < 2) return "";
+  const split = abs.map((p) => p.split("/"));
+  const min = Math.min(...split.map((s) => s.length));
+  let i = 0;
+  while (i < min - 1) {
+    const seg = split[0][i];
+    if (!split.every((s) => s[i] === seg)) break;
+    i++;
+  }
+  if (i < 2) return ""; // require at least /a/b common
+  return split[0].slice(0, i).join("/") + "/";
+};
+
+const trimPaths = (set: Set<string>, prefix: string): Set<string> => {
+  if (!prefix) return set;
+  const out = new Set<string>();
+  for (const p of set) {
+    out.add(p.startsWith(prefix) ? p.slice(prefix.length) : p);
+  }
+  return out;
+};
+
+export const extractFiles = (
+  blocks: NormalizedBlock[],
+  fileOps?: FileOps,
+): FileActivity => {
+  const act: FileActivity = {
+    read: new Set(fileOps?.readFiles ?? []),
+    modified: new Set(fileOps?.modifiedFiles ?? []),
+    created: new Set(fileOps?.createdFiles ?? []),
+  };
+
+  for (const b of blocks) {
+    if (b.kind !== "tool_call") continue;
+    const p = extractPath(b.args);
+    if (!p) continue;
+
+    if (FILE_READ_TOOLS.has(b.name)) act.read.add(p);
+    if (FILE_WRITE_TOOLS.has(b.name)) act.modified.add(p);
+    if (FILE_CREATE_TOOLS.has(b.name)) act.created.add(p);
+  }
+
+  const all = [...act.read, ...act.modified, ...act.created];
+  const prefix = longestCommonDirPrefix(all);
+  if (prefix) {
+    act.read = trimPaths(act.read, prefix);
+    act.modified = trimPaths(act.modified, prefix);
+    act.created = trimPaths(act.created, prefix);
+  }
+
+  return act;
+};

package/src/extract/goals.ts

@@ -0,0 +1,79 @@
+import type { NormalizedBlock } from "../types";
+import { nonEmptyLines, clip } from "../core/content";
+import { collapseSkillLines } from "../core/skill-collapse";
+
+const SCOPE_CHANGE_RE =
+  /\b(instead|actually|change of plan|forget that|new task|switch to|now I want|pivot|let'?s do|stop .* and)\b/i;
+
+const TASK_RE =
+  /\b(fix|implement|add|create|build|refactor|debug|investigate|update|remove|delete|migrate|deploy|test|write|set up)\b/i;
+
+const NOISE_SHORT_RE = /^(ok|yes|no|sure|yeah|yep|go|hi|hey|thx|thanks|ok\b.*|y|n|k)\s*[.!?]*$/i;
+
+// Reject lines that are clearly not user goals (pasted output, code, paths, tool dumps)
+// or meta-prompt boilerplate (command templates like `/issues` that start with "For each issue:"
+// followed by numbered "Read the issue in full..." steps).
+const NON_GOAL_RE =
+  /^\s*[\[│├└─╭╰]|```|^\s*(=[A-Z]+\(|function |const |let |var |import |export |class )|^(https?:|file:|\/[A-Za-z])|\\n|^\s*For each\b|\bin full\b[^\n]*\b(comments|issue|issues|PRs?|linked)\b/;
+
+// Signals that the rest of the user message is a command template (e.g. /issues),
+// in which case we should stop collecting goals at the signal line.
+const TEMPLATE_SIGNAL_RE =
+  /^\s*(For each\b|Do NOT implement\b|Analyze and propose\b|If Task\/context\b|Output:\s*$)/i;
+
+const truncateAtTemplate = (lines: string[]): string[] => {
+  const idx = lines.findIndex((l) => TEMPLATE_SIGNAL_RE.test(l));
+  return idx >= 0 ? lines.slice(0, idx) : lines;
+};
+
+const stripLeadingBullet = (line: string): string =>
+  line.replace(/^\s*(?:[-*+]|\d+\.)\s+/, "").trim();
+
+const MAX_GOAL_CHARS = 200;
+
+const isSubstantiveGoal = (text: string): boolean => {
+  const t = text.trim();
+  if (t.length <= 5) return false;
+  if (t.length > MAX_GOAL_CHARS) return false;
+  if (NOISE_SHORT_RE.test(t)) return false;
+  if (NON_GOAL_RE.test(t)) return false;
+  return true;
+};
+
+// Test scope-change / task intent only on the leading portion of a user block
+// so that pasted outputs below the actual instruction do not trigger matches.
+const LEADING_CHARS = 200;
+
+export const extractGoals = (blocks: NormalizedBlock[]): string[] => {
+  const goals: string[] = [];
+  let latestScopeChange: string[] | null = null;
+
+  for (const b of blocks) {
+    if (b.kind !== "user") continue;
+    const rawLines = nonEmptyLines(b.text);
+    const truncated = truncateAtTemplate(rawLines);
+    const lines = collapseSkillLines(truncated.filter(isSubstantiveGoal))
+      .map(stripLeadingBullet)
+      .filter((l) => l.length > 5);
+    if (lines.length === 0) continue;
+
+    if (goals.length === 0) {
+      goals.push(...lines.slice(0, 6));
+      continue;
+    }
+
+    const leading = b.text.slice(0, LEADING_CHARS);
+    if (SCOPE_CHANGE_RE.test(leading)) {
+      latestScopeChange = lines.slice(0, 3).map((l) => clip(l, MAX_GOAL_CHARS));
+    } else if (TASK_RE.test(leading) && lines[0].length > 15) {
+      latestScopeChange = lines.slice(0, 2).map((l) => clip(l, MAX_GOAL_CHARS));
+    }
+  }
+
+  // Only emit the [Scope change] marker when we actually captured bullets.
+  if (latestScopeChange && latestScopeChange.length > 0) {
+    goals.push("[Scope change]", ...latestScopeChange);
+  }
+
+  return goals.slice(0, 8);
+};

package/src/extract/preferences.ts

@@ -0,0 +1,55 @@
+import type { NormalizedBlock } from "../types";
+import { clip, nonEmptyLines } from "../core/content";
+
+// Tightened patterns: require a clear preference construction, not bare keywords.
+const PREF_PATTERNS = [
+  /\bprefer(?:s|red|ring)?\s+\w/i,
+  /\bdon'?t want\b/i,
+  /\balways (?:use|do|run|prefer|keep|make|format|write|add|set|put|prefix|start|include|append)\b/i,
+  /\bnever (?:use|do|run|push|commit|write|ignore|add|set|put|remove|delete|include|deploy)\b/i,
+  /\bplease (?:use|avoid|keep|make|don'?t|do not|format|write)\b/i,
+  /\b(?:style|format|language|naming)\s*[:=]\s*\S/i,
+];
+
+export const extractPreferences = (blocks: NormalizedBlock[]): string[] => {
+  const prefs: string[] = [];
+  const seen = new Set<string>();
+
+  for (const b of blocks) {
+    if (b.kind !== "user") continue;
+
+    let perBlock = 0;
+    for (const line of nonEmptyLines(b.text)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.length < 5) continue;
+      if (trimmed.length > 200) continue;
+      // Reject questions.
+      if (trimmed.endsWith("?") || trimmed.includes("?...")) continue;
+      if (!PREF_PATTERNS.some((p) => p.test(trimmed))) continue;
+
+      const clipped = clip(trimmed, 200);
+      const key = clipped.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      prefs.push(clipped);
+
+      // Cap per user block to avoid pasting long rule lists as many prefs.
+      if (++perBlock >= 1) break;
+    }
+  }
+
+  return prefs.slice(0, 10);
+};
+
+/**
+ * Remove preferences that duplicate goals (case-insensitive, trimmed).
+ * Called by `buildSections` so that the two sections do not overlap.
+ */
+export const dedupPreferencesAgainstGoals = (
+  prefs: string[],
+  goals: string[],
+): string[] => {
+  const norm = (s: string) => s.trim().toLowerCase();
+  const goalSet = new Set(goals.map(norm));
+  return prefs.filter((p) => !goalSet.has(norm(p)));
+};

package/src/extract/references.ts

@@ -0,0 +1,214 @@
+import type { NormalizedBlock } from "../types";
+
+export interface ReferenceExtract {
+  urls: string[];
+  githubRefs: string[];
+  versions: string[];
+  branches: string[];
+  commitRefs: string[];
+}
+
+export interface ReferencesOptions {
+  enabled?: boolean;
+  /** Extra URL regex strings (compiled and applied alongside built-in). */
+  extraUrlPatterns?: string[];
+  /** Extra GitHub ref regex strings (full match added to githubRefs). */
+  extraGithubRefPatterns?: string[];
+  /** Extra version regex strings (capture group 1 or full match). */
+  extraVersionPatterns?: string[];
+  /** Extra branch regex strings (full match added to branches). */
+  extraBranchPatterns?: string[];
+}
+
+// ── Regex patterns ──
+
+// URLs: http:// or https:// followed by non-whitespace, strip trailing punctuation
+const URL_RE = /https?:\/\/\S+/g;
+const TRAILING_PUNCT_RE = /[.,;:!?)\]}>]+$/;
+
+// GitHub refs
+const BARE_ISSUE_RE = /#(\d+)/g;
+const PR_REF_RE = /\b(PR|pr)\s*#(\d+)/g;
+const OWNER_REPO_RE = /\b([a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?)\/([a-zA-Z0-9_.-]+)\b/g;
+// Filter: owner must be 2+ chars, repo must be 2+ chars, and not look like a file path
+const REPO_FILTER = (owner: string, repo: string): boolean => {
+  if (owner.length < 2 || repo.length < 2) return false;
+  if (/^\./.test(repo)) return false;
+  const skipOwners = new Set(["src", "lib", "dist", "build", "test", "tests", "pkg", "cmd", "web", "app", "docs", "scripts", "assets", "public", "static", "vendor"]);
+  if (skipOwners.has(owner.toLowerCase())) return false;
+  return true;
+};
+
+// Versions: v1.2.3 or bare 1.2.3 (but NOT IP octets)
+const VERSION_RE = /\b(v?\d+\.\d+\.\d+)\b/g;
+const isIPContext = (text: string, index: number): boolean => {
+  const before = text.slice(Math.max(0, index - 20), index);
+  const after = text.slice(index, Math.min(text.length, index + 30));
+  if (/\d+\.\d+\.\d+\.\d+/.test(after)) return true;
+  if (/\d+\.\d+\.\d+\.\d+/.test(before + after.slice(0, 15))) return true;
+  return false;
+};
+
+// Branches: feat/xxx, fix/xxx, etc.
+const BRANCH_RE = /\b(?:feat|fix|hotfix|release|chore|refactor|docs|test)\/[\w-]+\b/g;
+
+// Commit refs: 7-12 hex chars (only in user/assistant blocks)
+const COMMIT_REF_RE = /\b([0-9a-f]{7,12})\b/g;
+const isLikelyHexHash = (s: string): boolean => /[a-f]/i.test(s);
+
+// ── Limits ──
+const URL_LIMIT = 10;
+const GITHUB_REF_LIMIT = 8;
+const VERSION_LIMIT = 5;
+const BRANCH_LIMIT = 5;
+const COMMIT_REF_LIMIT = 5;
+
+// ── Helpers ──
+
+const cleanUrl = (raw: string): string => raw.replace(TRAILING_PUNCT_RE, "");
+
+const collectTextFromBlocks = (blocks: NormalizedBlock[]): string[] => {
+  const texts: string[] = [];
+  for (const b of blocks) {
+    if (b.kind === "user" || b.kind === "assistant") {
+      texts.push(b.text);
+    }
+  }
+  return texts;
+};
+
+/** Compile an array of regex strings into RegExp objects (global). */
+const compilePatterns = (patterns: string[] | undefined): RegExp[] => {
+  if (!patterns || patterns.length === 0) return [];
+  return patterns.map((p) => {
+    try { return new RegExp(p, "g"); } catch { return null; }
+  }).filter((r): r is RegExp => r !== null);
+};
+
+// ── Extraction ──
+
+export const extractReferences = (blocks: NormalizedBlock[], options?: ReferencesOptions): ReferenceExtract => {
+  if (options?.enabled === false) {
+    return { urls: [], githubRefs: [], versions: [], branches: [], commitRefs: [] };
+  }
+
+  const urls = new Set<string>();
+  const githubRefs = new Set<string>();
+  const versions = new Set<string>();
+  const branches = new Set<string>();
+  const commitRefs = new Set<string>();
+
+  const extraUrlRes = compilePatterns(options?.extraUrlPatterns);
+  const extraGhRefRes = compilePatterns(options?.extraGithubRefPatterns);
+  const extraVersionRes = compilePatterns(options?.extraVersionPatterns);
+  const extraBranchRes = compilePatterns(options?.extraBranchPatterns);
+
+  const texts = collectTextFromBlocks(blocks);
+
+  for (const text of texts) {
+    // ── URLs ──
+    if (urls.size < URL_LIMIT) {
+      for (const m of text.matchAll(URL_RE)) {
+        const cleaned = cleanUrl(m[0]);
+        if (cleaned && urls.size < URL_LIMIT) urls.add(cleaned);
+      }
+      // Extra URL patterns
+      for (const re of extraUrlRes) {
+        for (const m of text.matchAll(re)) {
+          const val = m[1] ?? m[0];
+          const cleaned = cleanUrl(val);
+          if (cleaned && urls.size < URL_LIMIT) urls.add(cleaned);
+        }
+      }
+    }
+
+    // ── GitHub refs ──
+    if (githubRefs.size < GITHUB_REF_LIMIT) {
+      // Built-in: bare issue numbers
+      for (const m of text.matchAll(BARE_ISSUE_RE)) {
+        const ref = `#${m[1]}`;
+        if (githubRefs.size < GITHUB_REF_LIMIT) githubRefs.add(ref);
+      }
+      // Built-in: PR references
+      for (const m of text.matchAll(PR_REF_RE)) {
+        const ref = `${m[1]} #${m[2]}`;
+        if (githubRefs.size < GITHUB_REF_LIMIT) githubRefs.add(ref);
+      }
+      // Built-in: owner/repo
+      for (const m of text.matchAll(OWNER_REPO_RE)) {
+        if (REPO_FILTER(m[1], m[2])) {
+          const ref = `${m[1]}/${m[2]}`;
+          if (githubRefs.size < GITHUB_REF_LIMIT) githubRefs.add(ref);
+        }
+      }
+      // Built-in: GitHub URLs → owner/repo#issue
+      for (const m of text.matchAll(/https?:\/\/github\.com\/([a-zA-Z0-9-]+)\/([a-zA-Z0-9_.-]+)\/(?:issues|pull)\/(\d+)/g)) {
+        const ref = `${m[1]}/${m[2]}#${m[3]}`;
+        if (githubRefs.size < GITHUB_REF_LIMIT) githubRefs.add(ref);
+      }
+      // Extra GitHub ref patterns (full match)
+      for (const re of extraGhRefRes) {
+        for (const m of text.matchAll(re)) {
+          const val = m[1] ?? m[0];
+          if (githubRefs.size < GITHUB_REF_LIMIT) githubRefs.add(val);
+        }
+      }
+    }
+
+    // ── Versions ──
+    if (versions.size < VERSION_LIMIT) {
+      for (const m of text.matchAll(VERSION_RE)) {
+        if (!isIPContext(text, m.index ?? 0)) {
+          if (versions.size < VERSION_LIMIT) versions.add(m[1]);
+        }
+      }
+      // Extra version patterns
+      for (const re of extraVersionRes) {
+        for (const m of text.matchAll(re)) {
+          const val = m[1] ?? m[0];
+          if (versions.size < VERSION_LIMIT) versions.add(val);
+        }
+      }
+    }
+
+    // ── Branches ──
+    if (branches.size < BRANCH_LIMIT) {
+      for (const m of text.matchAll(BRANCH_RE)) {
+        if (branches.size < BRANCH_LIMIT) branches.add(m[0]);
+      }
+      // Extra branch patterns
+      for (const re of extraBranchRes) {
+        for (const m of text.matchAll(re)) {
+          if (branches.size < BRANCH_LIMIT) branches.add(m[0]);
+        }
+      }
+    }
+
+    // ── Commit refs ──
+    if (commitRefs.size < COMMIT_REF_LIMIT) {
+      for (const m of text.matchAll(COMMIT_REF_RE)) {
+        if (isLikelyHexHash(m[1])) {
+          if (commitRefs.size < COMMIT_REF_LIMIT) commitRefs.add(m[1]);
+        }
+      }
+    }
+  }
+
+  return {
+    urls: [...urls].slice(0, URL_LIMIT),
+    githubRefs: [...githubRefs].slice(0, GITHUB_REF_LIMIT),
+    versions: [...versions].slice(0, VERSION_LIMIT),
+    branches: [...branches].slice(0, BRANCH_LIMIT),
+    commitRefs: [...commitRefs].slice(0, COMMIT_REF_LIMIT),
+  };
+};
+
+export const formatReferences = (refs: ReferenceExtract): string[] => {
+  const lines: string[] = [];
+  if (refs.urls.length > 0) lines.push(`URL: ${refs.urls.join(", ")}`);
+  if (refs.githubRefs.length > 0) lines.push(`GitHub: ${refs.githubRefs.join(", ")}`);
+  if (refs.versions.length > 0) lines.push(`Version: ${refs.versions.join(", ")}`);
+  if (refs.branches.length > 0) lines.push(`Branch: ${refs.branches.join(", ")}`);
+  if (refs.commitRefs.length > 0) lines.push(`CommitRef: ${refs.commitRefs.join(", ")}`);
+  return lines;
+};

package/src/extract/signals.ts

@@ -0,0 +1,145 @@
+import type { NormalizedBlock } from "../types";
+import { clip, nonEmptyLines } from "../core/content";
+
+export interface SignalsOptions {
+  enabled?: boolean;
+  /** Extra constraint regex strings (applied alongside built-in). */
+  extraConstraintPatterns?: string[];
+  /** Extra decision regex strings (applied alongside built-in). */
+  extraDecisionPatterns?: string[];
+  /** Extra status keywords (added to built-in DONE|TODO|WIP|blocked|resolved). */
+  extraStatusKeywords?: string[];
+}
+
+// ─── Pattern definitions ────────────────────────────────────────────
+
+const CONSTRAINT_RE =
+  /\b(don'?t|must not|cannot|forbidden|disallowed|off[- ]limits|out of scope|excluded|do not)\b/i;
+
+const DECISION_RE =
+  /\b(decided|let'?s use|going with|chose|we'?ll use)\b/i;
+
+const DEFAULT_STATUS_KEYWORDS = ["DONE", "TODO", "WIP", "blocked", "resolved"];
+
+// Build a regex that matches a status keyword at start of line or after [.!?;:\-—]
+const buildStatusPattern = (line: string, extraKeywords?: string[]): boolean => {
+  const keywords = extraKeywords && extraKeywords.length > 0
+    ? [...DEFAULT_STATUS_KEYWORDS, ...extraKeywords]
+    : DEFAULT_STATUS_KEYWORDS;
+  for (const kw of keywords) {
+    const re = new RegExp(`(?:^|[.!?;:\\-—])\\s*${kw}\\b`, "i");
+    if (re.test(line)) return true;
+  }
+  return false;
+};
+
+/** Compile an array of regex strings into RegExp objects. */
+const compilePatterns = (patterns: string[] | undefined): RegExp[] => {
+  if (!patterns || patterns.length === 0) return [];
+  return patterns.map((p) => {
+    try { return new RegExp(p, "i"); } catch { return null; }
+  }).filter((r): r is RegExp => r !== null);
+};
+
+// ─── Types ──────────────────────────────────────────────────────────
+
+export interface SignalExtract {
+  constraints: string[];
+  decisions: string[];
+  statuses: string[];
+}
+
+// ─── Extractor ──────────────────────────────────────────────────────
+
+const MIN_LINE_LENGTH = 15;
+const MAX_LINE_LENGTH = 200;
+const CAP_CONSTRAINTS = 5;
+const CAP_DECISIONS = 5;
+const CAP_STATUSES = 5;
+
+export const extractSignals = (blocks: NormalizedBlock[], options?: SignalsOptions): SignalExtract => {
+  if (options?.enabled === false) {
+    return { constraints: [], decisions: [], statuses: [] };
+  }
+
+  const extraConstraintRes = compilePatterns(options?.extraConstraintPatterns);
+  const extraDecisionRes = compilePatterns(options?.extraDecisionPatterns);
+
+  const constraints: string[] = [];
+  const decisions: string[] = [];
+  const statuses: string[] = [];
+
+  const seenConstraints = new Set<string>();
+  const seenDecisions = new Set<string>();
+  const seenStatuses = new Set<string>();
+
+  for (const b of blocks) {
+    if (b.kind !== "user" && b.kind !== "assistant") continue;
+    const isUser = b.kind === "user";
+
+    for (const line of nonEmptyLines(b.text)) {
+      const trimmed = line.trim();
+      if (trimmed.length < MIN_LINE_LENGTH) continue;
+      if (trimmed.length > 500) continue;
+      if (trimmed.endsWith("?")) continue;
+
+      // ── Constraints (user only) ────────────────────────────────
+      if (isUser && constraints.length < CAP_CONSTRAINTS) {
+        let matched = CONSTRAINT_RE.test(trimmed);
+        if (!matched) {
+          for (const re of extraConstraintRes) {
+            if (re.test(trimmed)) { matched = true; break; }
+          }
+        }
+        if (matched) {
+          const clipped = clip(trimmed, MAX_LINE_LENGTH);
+          const key = clipped.toLowerCase();
+          if (!seenConstraints.has(key)) {
+            seenConstraints.add(key);
+            constraints.push(clipped);
+          }
+        }
+      }
+
+      // ── Decisions (user only) ──────────────────────────────────
+      if (isUser && decisions.length < CAP_DECISIONS) {
+        let matched = DECISION_RE.test(trimmed);
+        if (!matched) {
+          for (const re of extraDecisionRes) {
+            if (re.test(trimmed)) { matched = true; break; }
+          }
+        }
+        if (matched) {
+          const clipped = clip(trimmed, MAX_LINE_LENGTH);
+          const key = clipped.toLowerCase();
+          if (!seenDecisions.has(key)) {
+            seenDecisions.add(key);
+            decisions.push(clipped);
+          }
+        }
+      }
+
+      // ── Statuses (user + assistant) ────────────────────────────
+      if (statuses.length < CAP_STATUSES && buildStatusPattern(trimmed, options?.extraStatusKeywords)) {
+        const clipped = clip(trimmed, MAX_LINE_LENGTH);
+        const key = clipped.toLowerCase();
+        if (!seenStatuses.has(key)) {
+          seenStatuses.add(key);
+          statuses.push(clipped);
+        }
+      }
+    }
+  }
+
+  return { constraints, decisions, statuses };
+};
+
+// ─── Formatter ──────────────────────────────────────────────────────
+
+export const formatSignals = (signals: SignalExtract): string[] => {
+  const lines: string[] = [];
+  for (const c of signals.constraints) lines.push(`Constraint: ${c}`);
+  for (const d of signals.decisions) lines.push(`Decision: ${d}`);
+  for (const s of signals.statuses) lines.push(`Status: ${s}`);
+  return lines;
+};