fix(architect): install fix & guard native plan verbosity parsing

Author: mmethodz

extensions/vscode/package-lock.json

@@ -444,6 +444,6 @@
     "dompurify": "^3.4.0",
     "markdown-it": "^14.1.1",
     "mermaid": "^11.12.0",
-    "@dreamgraph/token-economy": "12.4.0"
+    "@dreamgraph/token-economy": "file:../../packages/token-economy"
   }
 }

extensions/vscode/package.json

@@ -690,10 +690,16 @@ function classifySlice(title: string): { category: "phase" | "slice"; sortId: st
   if (phaseMatch) {
     return { category: "phase", sortId: `phase-${phaseMatch[1]}` };
   }
-  const sliceMatch = title.match(/^Slice\s+([A-Za-z0-9]+)[.:]?\s*(.*)$/i);
-  if (sliceMatch) {
-    const ordinal = sliceMatch[1].toLowerCase();
-    const titleSlug = slugifySliceSegment(sliceMatch[2] ?? "");
+  const numericSliceMatch = title.match(/^Slice\s+(\d+)[.:]?\s*(.*)$/i);
+  if (numericSliceMatch) {
+    const ordinal = numericSliceMatch[1].toLowerCase();
+    const titleSlug = slugifySliceSegment(numericSliceMatch[2] ?? "");
+    return { category: "slice", sortId: titleSlug ? `slice-${ordinal}-${titleSlug}` : `slice-${ordinal}` };
+  }
+  const letterSliceMatch = title.match(/^Slice\s+([A-Z])(?:[.:]|\s+[—-])\s*(.*)$/i);
+  if (letterSliceMatch) {
+    const ordinal = letterSliceMatch[1].toLowerCase();
+    const titleSlug = slugifySliceSegment(letterSliceMatch[2] ?? "");
     return { category: "slice", sortId: titleSlug ? `slice-${ordinal}-${titleSlug}` : `slice-${ordinal}` };
   }
   return null;

src/architect/plan-registry.ts

@@ -1556,7 +1556,9 @@ function buildCreatedPlanLog(planId: string, title: string, timestamp: string):
 }
 
 function isArchitectRuntimeIdentityQuestion(message: string): boolean {
-  return /\b(model|provider|adapter|runtime|route|session)\b/i.test(message);
+  const compact = message.replace(/\s+/g, " ").trim();
+  if (!compact.endsWith("?")) return false;
+  return /\b(what|which|who)\b.*\b(model|provider|adapter|runtime|route|session)\b/i.test(compact);
 }
 
 function shouldApplyPlanChatUpdate(message: string, plan: ArchitectPlanProjection | null): boolean {
@@ -1576,11 +1578,101 @@ function normalizePlanChatUpdateContent(message: string): string {
     .slice(0, 24_000);
 }
 
+function splitMarkdownTableRow(line: string): string[] {
+  return line
+    .trim()
+    .replace(/^\|/, "")
+    .replace(/\|$/, "")
+    .split("|")
+    .map((cell) => cell.trim());
+}
+
+function isMarkdownTableDivider(line: string): boolean {
+  return /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/.test(line);
+}
+
+function normalizeSliceTitle(sliceCell: string, changeCell: string): string {
+  const cleanSlice = sliceCell.replace(/^slice\s+/i, "").trim();
+  const ordinal = cleanSlice || "1";
+  const firstSentence = changeCell
+    .replace(/`([^`]+)`/g, "$1")
+    .split(/[.!?]/)[0]
+    ?.replace(/\s+/g, " ")
+    .trim();
+  const title = firstSentence && firstSentence.length > 0 ? firstSentence.slice(0, 80) : "Implementation Work";
+  return `Slice ${ordinal} - ${title}`;
+}
+
+function normalizeArchitectNativePlanMarkdown(markdown: string): string {
+  const lines = markdown.split("\n");
+  const nextLines: string[] = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const headingMatch = lines[index].match(/^(##\s+)(\d+\.\s+)?Planned Slices\s*$/i);
+    if (!headingMatch) {
+      nextLines.push(lines[index]);
+      continue;
+    }
+
+    nextLines.push(`${headingMatch[1]}${headingMatch[2] ?? ""}Implementation Slices`);
+    index += 1;
+    const sectionLines: string[] = [];
+    while (index < lines.length && !/^##\s+/.test(lines[index])) {
+      sectionLines.push(lines[index]);
+      index += 1;
+    }
+    index -= 1;
+
+    const tableHeaderIndex = sectionLines.findIndex((line) => /^\s*\|\s*Slice\s*\|/i.test(line));
+    if (tableHeaderIndex < 0 || tableHeaderIndex + 1 >= sectionLines.length || !isMarkdownTableDivider(sectionLines[tableHeaderIndex + 1])) {
+      nextLines.push(...sectionLines);
+      continue;
+    }
+
+    nextLines.push(...sectionLines.slice(0, tableHeaderIndex));
+    const headers = splitMarkdownTableRow(sectionLines[tableHeaderIndex]).map((cell) => cell.toLowerCase());
+    const sliceIndex = headers.indexOf("slice");
+    const changeIndex = headers.indexOf("change");
+    const providerIndex = headers.findIndex((cell) => cell.includes("provider") || cell.includes("adapter"));
+    const filesIndex = headers.indexOf("files");
+    const verificationIndex = headers.indexOf("verification");
+
+    for (let tableIndex = tableHeaderIndex + 2; tableIndex < sectionLines.length; tableIndex += 1) {
+      const line = sectionLines[tableIndex];
+      if (!/^\s*\|/.test(line)) {
+        if (line.trim()) nextLines.push(line);
+        continue;
+      }
+      const cells = splitMarkdownTableRow(line);
+      const sliceCell = sliceIndex >= 0 ? cells[sliceIndex] ?? "" : "";
+      const changeCell = changeIndex >= 0 ? cells[changeIndex] ?? "" : "";
+      if (!sliceCell || !changeCell) continue;
+
+      nextLines.push("");
+      nextLines.push(`### ${normalizeSliceTitle(sliceCell, changeCell)}`);
+      nextLines.push("");
+      nextLines.push(changeCell);
+      if (providerIndex >= 0 && cells[providerIndex]) {
+        nextLines.push("");
+        nextLines.push(`Provider/adapter specifics: ${cells[providerIndex]}`);
+      }
+      if (filesIndex >= 0 && cells[filesIndex]) {
+        nextLines.push("");
+        nextLines.push(`Files: ${cells[filesIndex]}`);
+      }
+      if (verificationIndex >= 0 && cells[verificationIndex]) {
+        nextLines.push("");
+        nextLines.push(`Verification: ${cells[verificationIndex]}`);
+      }
+    }
+  }
+  return nextLines.join("\n");
+}
+
 function applyPlanChatUpdateToMarkdown(markdown: string, content: string, timestamp: string): { markdown: string; mode: ArchitectPlanChatUpdateResult["update_mode"]; sectionTitle: string } {
   const placeholder = "Describe the goal for this Architect plan.";
   if (markdown.includes(placeholder)) {
     return {
-      markdown: markdown.replace(placeholder, content),
+      markdown: normalizeArchitectNativePlanMarkdown(markdown.replace(placeholder, content)),
       mode: "replace_goal_placeholder",
       sectionTitle: "0. Goal",
     };
@@ -1597,7 +1689,7 @@ function applyPlanChatUpdateToMarkdown(markdown: string, content: string, timest
     content,
     "",
   ].join("\n");
-  return { markdown: nextMarkdown, mode: "append_chat_update", sectionTitle };
+  return { markdown: normalizeArchitectNativePlanMarkdown(nextMarkdown), mode: "append_chat_update", sectionTitle };
 }
 
 async function applyPlanChatUpdate(

src/architect/routes.ts

@@ -1148,6 +1148,72 @@ describe("standalone Architect route hardening", () => {
     }
   });
 
+  it("normalizes chat-authored slice tables into native implementation slice headings", async () => {
+    const tempRoot = await mkdtemp(join(tmpdir(), "dreamgraph-plan-slice-table-"));
+    const plansDir = join(tempRoot, "plans");
+    const dataDir = join(tempRoot, "data");
+    const scopeSpy = vi.spyOn(lifecycle, "getActiveScope").mockReturnValue({
+      instanceId: "test",
+      projectRoot: tempRoot,
+      plansRoot: plansDir,
+      dataDir,
+      unsafeMode: false,
+      source: "test",
+    });
+
+    try {
+      await mkdir(plansDir, { recursive: true });
+      await mkdir(dataDir, { recursive: true });
+
+      await withArchitectServer(async (baseUrl) => {
+        const createdResponse = await fetch(`${baseUrl}/api/architect/v1/plans`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ title: "Slice Table Plan" }),
+        });
+        expect(createdResponse.status).toBe(201);
+        const created = await createdResponse.json() as Record<string, unknown>;
+        const createdResult = created.result as Record<string, unknown>;
+        const planId = String(createdResult.plan_id);
+
+        await expectJsonOk(await fetch(`${baseUrl}/api/architect/v1/chat`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            planId,
+            adapter: "codex-cli",
+            provider: "none",
+            model: "gpt-5.4",
+            mode: "autonomous",
+            message: [
+              "this plan should include implementation slices",
+              "",
+              "## 3. Planned Slices",
+              "",
+              "| Slice | Change | Provider/adapter specifics | Files | Verification |",
+              "| --- | --- | --- | --- | --- |",
+              "| 1 | Build the parser contract. | Applies to every route. | `src/architect/routes.ts` | Registry reports Slice 1. |",
+              "| 2 | Add regression coverage. | Test-only. | `tests/standalone-architect-routes.test.ts` | Test passes. |",
+            ].join("\n"),
+          }),
+        }));
+
+        const markdown = await readFile(join(plansDir, `${planId}.md`), "utf-8");
+        expect(markdown).toContain("## 3. Implementation Slices");
+        expect(markdown).toContain("### Slice 1 - Build the parser contract");
+        expect(markdown).toContain("### Slice 2 - Add regression coverage");
+        expect(markdown).not.toContain("| Slice | Change |");
+
+        const projected = await expectJsonOk(await fetch(`${baseUrl}/api/architect/v1/plans/${planId}`));
+        const plan = projected.plan as { registry?: { summary?: { slice_count?: number } } };
+        expect(plan.registry?.summary?.slice_count).toBe(2);
+      });
+    } finally {
+      scopeSpy.mockRestore();
+      await rm(tempRoot, { recursive: true, force: true });
+    }
+  });
+
   it("rejects GET chat prompts and supports POST SSE chat responses", async () => {
     await withArchitectServer(async (baseUrl) => {
       const rejected = await fetch(`${baseUrl}/api/architect/v1/chat?message=must-not-travel-in-url`);