fix(mcp): route product feedback prompts to packet

published/current/fpf-index/snapshot.json

@@ -1,8 +1,8 @@
 {
   "sourceHash": "sha256:500fcc0babd0db1184a4cb5b4487188af4f54911ae3ec99943d5902bb6229a50",
   "sourcePath": "published/current/FPF-Spec.md",
-  "builtAt": "2026-05-13T08:00:45.022Z",
-  "compilerFingerprint": "sha256:64da4d22faf54820c33710eafe9cebac7012ecdda4ae9d2d99bb5ec4fd7f4de7",
+  "builtAt": "2026-05-14T14:09:51.168Z",
+  "compilerFingerprint": "sha256:9cd395da915eb3ce5276fa51b3189840434a9bb6294035d08fa38b9881e95fc5",
   "compilerMode": "local_vectorless",
   "indexRoots": [
     "heading:first-principles-framework-fpf-core-conceptual-specification:1",
@@ -1119120,6 +1119120,51 @@
       "routeId": "route:project-alignment",
       "routeScore": 88
     },
+    {
+      "name": "product-role-feedback",
+      "allOf": [
+        [
+          "product maintainer",
+          "product feedback",
+          "product-role feedback",
+          "product role feedback",
+          "role feedback",
+          "role-feedback",
+          "dogfood"
+        ]
+      ],
+      "anyOf": [
+        [
+          "adoption improvement",
+          "live product smoke",
+          "discussion-ready",
+          "discussion ready",
+          "severity",
+          "validation path",
+          "work packet",
+          "bounded context",
+          "whole spec",
+          "whole fpf",
+          "full spec",
+          "full fpf",
+          "without pasting",
+          "do not paste",
+          "instead of pasting"
+        ]
+      ],
+      "seedNodeIds": [
+        "E.12",
+        "A.1.1",
+        "A.15",
+        "A.2.2",
+        "A.2.3"
+      ],
+      "seedScore": 20,
+      "seedOrigin": "route_expansion",
+      "initialNodeIds": [],
+      "routeId": "route:project-alignment",
+      "routeScore": 92
+    },
     {
       "name": "vocabulary-alignment",
       "allOf": [

published/current/manifest.json

@@ -1,12 +1,12 @@
 {
   "channel": "latest-published",
   "sourceHash": "sha256:500fcc0babd0db1184a4cb5b4487188af4f54911ae3ec99943d5902bb6229a50",
-  "compilerFingerprint": "sha256:64da4d22faf54820c33710eafe9cebac7012ecdda4ae9d2d99bb5ec4fd7f4de7",
+  "compilerFingerprint": "sha256:9cd395da915eb3ce5276fa51b3189840434a9bb6294035d08fa38b9881e95fc5",
   "upstreamRef": "ee40821c9c49c642dfedb18d6915388dbec4e7df",
   "upstreamRepoUrl": "https://github.com/ailev/FPF",
   "upstreamCommittedAt": "2026-05-12T16:57:41Z",
   "specPath": "published/current/FPF-Spec.md",
   "snapshotPath": "published/current/fpf-index/snapshot.json",
   "specBytes": 6566931,
-  "publishedAt": "2026-05-13T08:00:55.400Z"
+  "publishedAt": "2026-05-14T14:09:56.488Z"
 }

src/runtime/answer-projector.ts

@@ -3,6 +3,7 @@ import {
   getPartCDraftsByCluster,
   selectBestAnchors,
 } from './compiler.js';
+import { hasProductRoleFeedbackIntent } from './route-intent-signals.js';
 import {
   unique,
 } from './text.js';
@@ -94,12 +95,19 @@ export function buildRouteAnswer(
   rebuilt: boolean,
 ): QueryResult {
   const route = snapshot.routeGraph.nodes[routeNodeId]!;
+  const productRoleFeedbackPacket = isProductRoleFeedbackPacket(routeNodeId, question);
+  const supplementalIds = productRoleFeedbackPacket
+    ? ['E.12', 'A.1.1', 'A.15', 'A.2.2', 'A.2.3'].filter(
+        (id) => Boolean(snapshot.compiledNodes[id]),
+      )
+    : [];
   // Include routeSurfaces alongside the ordered/optional/landing lists.
   // Some routes (e.g. boundary-unpacking-claim-routing) only declare
   // surfaces; without this fallback the structured `ids` response would
   // be just the route ID, hiding the patterns the answer prose names.
   const ids = unique([
     routeNodeId,
+    ...supplementalIds,
     ...route.orderedIds,
     ...route.optionalIds,
     ...route.landingIds,
@@ -115,20 +123,29 @@ export function buildRouteAnswer(
     route.firstHonestBurden
       ? `First honest burden: ${route.firstHonestBurden}.`
       : 'Choose this route only when the stated burden matches the present problem.',
+    ...(productRoleFeedbackPacket
+      ? [
+          'Use the product-role feedback packet: E.12 plus A.1.1, A.15, A.2.2, and A.2.3 before escalating to broader spec-writing guidance.',
+          'Do not paste the whole FPF, and do not load E.8/E.19 unless the feedback is actually about writing or revising FPF pattern text.',
+        ]
+      : []),
     ...(route.constraints ?? []),
   ];
   const answer = [
     `${route.id} (${route.name}) is the matched first-practical route.`,
     route.firstHonestBurden ? `Burden: ${route.firstHonestBurden}.` : '',
+    productRoleFeedbackPacket
+      ? `Product-role feedback packet IDs: ${supplementalIds.join(', ')}.`
+      : '',
     route.orderedIds.length > 0
       ? `Ordered entry IDs: ${route.orderedIds.join(' -> ')}.`
       : '',
     route.optionalIds.length > 0
       ? `Conditional additions: ${route.optionalIds.join(', ')}.`
       : '',
     route.landingIds.length > 0 ? `Landing surface: ${route.landingIds.join(', ')}.` : '',
-    `Acceptance check: ${routeAcceptanceCheck(routeNodeId, route)}.`,
-    `Next move: ${routeNextMove(routeNodeId, route)}.`,
+    `Acceptance check: ${routeAcceptanceCheck(routeNodeId, route, question)}.`,
+    `Next move: ${routeNextMove(routeNodeId, route, question)}.`,
     route.routeSurfaces.length > 0
       ? `Route-bearing surfaces: ${route.routeSurfaces.join(', ')}.`
       : '',
@@ -179,7 +196,11 @@ export function buildRouteAnswer(
 function routeAcceptanceCheck(
   routeNodeId: string,
   route: Snapshot['routeGraph']['nodes'][string],
+  question: string,
 ): string {
+  if (isProductRoleFeedbackPacket(routeNodeId, question)) {
+    return 'the role/job can be replayed by another person, the feedback points at exact evidence, and the output lands as one focused PR, issue, discussion, or no-new-feedback checkpoint';
+  }
   switch (routeNodeId) {
     case 'route:project-alignment':
       return 'a shared kickoff packet names the bounded context, actor roles, role/method/work split, first work-plan item, evidence to collect, and UTS-ready terms';
@@ -197,7 +218,11 @@ function routeAcceptanceCheck(
 function routeNextMove(
   routeNodeId: string,
   route: Snapshot['routeGraph']['nodes'][string],
+  question: string,
 ): string {
+  if (isProductRoleFeedbackPacket(routeNodeId, question)) {
+    return 'name the persona/job and surface first, use E.12 with A.1.1, A.15, A.2.2, and A.2.3 to capture one adoption friction, then stop at one proposed improvement with severity and validation path';
+  }
   switch (routeNodeId) {
     case 'route:project-alignment':
       return 'read A.1.1 and A.15 first, draft the kickoff worksheet, then add A.15.2/A.15.3 only when the plan/run split must be made explicit';
@@ -212,6 +237,10 @@ function routeNextMove(
   }
 }
 
+function isProductRoleFeedbackPacket(routeNodeId: string, question: string): boolean {
+  return routeNodeId === 'route:project-alignment' && hasProductRoleFeedbackIntent(question);
+}
+
 export function buildPatternAnswer(
   question: string,
   mode: AnswerMode,

src/runtime/compiler.ts

@@ -35,6 +35,8 @@ import {
   AGENT_WORKFLOW_JOB_SIGNALS,
   BOUNDARY_BURDEN_SIGNALS,
   BOUNDARY_REVIEW_RULE_JOB_SIGNALS,
+  PRODUCT_ROLE_FEEDBACK_OUTPUT_SIGNALS,
+  PRODUCT_ROLE_FEEDBACK_ROLE_SIGNALS,
 } from './route-intent-signals.js';
 import { buildValidation } from './validation-runner.js';
 import type {
@@ -250,6 +252,20 @@ function buildHeuristicSeedRules(
       routeId: alignmentRoute.id,
       routeScore: 88,
     });
+    const productRoleFeedbackNodeIds = ['E.12', 'A.1.1', 'A.15', 'A.2.2', 'A.2.3'].filter(
+      (id) => id in patternNodes || id in routeNodes,
+    );
+    rules.push({
+      name: 'product-role-feedback',
+      allOf: [[...PRODUCT_ROLE_FEEDBACK_ROLE_SIGNALS]],
+      anyOf: [[...PRODUCT_ROLE_FEEDBACK_OUTPUT_SIGNALS, ...AGENT_WORKFLOW_BOUNDED_RETRIEVAL_SIGNALS]],
+      seedNodeIds: productRoleFeedbackNodeIds,
+      seedScore: 20,
+      seedOrigin: 'route_expansion',
+      initialNodeIds: [],
+      routeId: alignmentRoute.id,
+      routeScore: 92,
+    });
     rules.push({
       name: 'vocabulary-alignment',
       allOf: [['vocabulary']],

src/runtime/route-intent-signals.ts

@@ -68,6 +68,25 @@ export const AGENT_WORKFLOW_BOUNDED_RETRIEVAL_SIGNALS = [
   'instead of pasting',
 ] as const;
 
+export const PRODUCT_ROLE_FEEDBACK_ROLE_SIGNALS = [
+  'product maintainer',
+  'product feedback',
+  'product-role feedback',
+  'product role feedback',
+  'role feedback',
+  'role-feedback',
+  'dogfood',
+] as const;
+
+export const PRODUCT_ROLE_FEEDBACK_OUTPUT_SIGNALS = [
+  'adoption improvement',
+  'live product smoke',
+  'discussion-ready',
+  'discussion ready',
+  'severity',
+  'validation path',
+] as const;
+
 export const WRITING_OR_REVIEWING_PATTERN_SIGNALS = [
   'spec writer',
   'spec writing',
@@ -79,3 +98,18 @@ export const WRITING_OR_REVIEWING_PATTERN_SIGNALS = [
 export function hasBoundaryReviewNegation(normalizedQuestion: string): boolean {
   return BOUNDARY_REVIEW_NEGATIONS.some((phrase) => normalizedQuestion.includes(phrase));
 }
+
+export function hasProductRoleFeedbackIntent(question: string): boolean {
+  const normalizedQuestion = question.toLowerCase();
+  const hasRoleSignal = PRODUCT_ROLE_FEEDBACK_ROLE_SIGNALS.some((phrase) =>
+    normalizedQuestion.includes(phrase),
+  );
+  const hasQualifyingSignal =
+    PRODUCT_ROLE_FEEDBACK_OUTPUT_SIGNALS.some((phrase) =>
+      normalizedQuestion.includes(phrase),
+    ) ||
+    AGENT_WORKFLOW_BOUNDED_RETRIEVAL_SIGNALS.some((phrase) =>
+      normalizedQuestion.includes(phrase),
+    );
+  return hasRoleSignal && hasQualifyingSignal;
+}

tests/fpf-spec-runtime.test.ts

@@ -210,6 +210,58 @@ describe('FpfRuntime', () => {
     expect(agentWorkflow.answer.length).toBeGreaterThan(0);
     expect(agentWorkflow.citations.length).toBeGreaterThan(0);
 
+    const productMaintainer = await runtime.query(
+      'As a product maintainer, turn live product smoke evidence plus recurring role-feedback discussions into one adoption improvement, severity, and validation path without reading or pasting the full FPF.',
+      'compact',
+    );
+    if (routeIds.has('route:project-alignment')) {
+      expect(productMaintainer.status).toBe('ok');
+      expect(productMaintainer.ids).toEqual(
+        expect.arrayContaining([
+          'route:project-alignment',
+          'E.12',
+          'A.1.1',
+          'A.15',
+          'A.2.2',
+          'A.2.3',
+        ]),
+      );
+      expect(productMaintainer.answer).toContain('Product-role feedback packet IDs');
+    } else {
+      expect(['ok', 'ambiguous']).toContain(productMaintainer.status);
+      expect(productMaintainer.ids.every((id) => !id.startsWith('route:'))).toBe(true);
+    }
+    expect(productMaintainer.answer.length).toBeGreaterThan(0);
+    expect(productMaintainer.citations.length).toBeGreaterThan(0);
+
+    const boundedProductMaintainer = await runtime.query(
+      'As a product maintainer, build a work packet without pasting the whole FPF.',
+      'compact',
+    );
+    if (routeIds.has('route:project-alignment')) {
+      expect(boundedProductMaintainer.status).toBe('ok');
+      expect(boundedProductMaintainer.ids).toEqual(
+        expect.arrayContaining([
+          'route:project-alignment',
+          'E.12',
+          'A.1.1',
+          'A.15',
+          'A.2.2',
+          'A.2.3',
+        ]),
+      );
+      expect(boundedProductMaintainer.answer).toContain(
+        'Product-role feedback packet IDs',
+      );
+    } else {
+      expect(['ok', 'ambiguous']).toContain(boundedProductMaintainer.status);
+      expect(
+        boundedProductMaintainer.ids.every((id) => !id.startsWith('route:')),
+      ).toBe(true);
+    }
+    expect(boundedProductMaintainer.answer.length).toBeGreaterThan(0);
+    expect(boundedProductMaintainer.citations.length).toBeGreaterThan(0);
+
     const unavailableSynthesizer = new FpfRuntime({
       artifactDir: resolve(tempRoot, 'deterministic-artifacts'),
       sourcePath,

tests/mcp-server.test.ts

@@ -467,6 +467,68 @@ describe('direct MCP server', () => {
         true,
       );
     }
+
+    const productMaintainerQuery = await harness.request('tools/call', {
+      name: 'query_fpf_spec',
+      arguments: {
+        mode: 'compact',
+        question:
+          'As a product maintainer, turn live product smoke evidence plus recurring role-feedback discussions into one adoption improvement, severity, and validation path without reading or pasting the full FPF.',
+      },
+    });
+    const productMaintainerPayload = asToolPayload(productMaintainerQuery);
+    expect(productMaintainerPayload.status).toBe('ok');
+    if (routeIds.has('route:project-alignment')) {
+      expect(productMaintainerPayload.ids).toEqual(
+        expect.arrayContaining([
+          'route:project-alignment',
+          'E.12',
+          'A.1.1',
+          'A.15',
+          'A.2.2',
+          'A.2.3',
+        ]),
+      );
+      expect(productMaintainerPayload.answer).toContain('Product-role feedback packet IDs');
+    } else {
+      expect((productMaintainerPayload.ids as string[]).every((id) => !id.startsWith('route:'))).toBe(
+        true,
+      );
+    }
+
+    const boundedProductMaintainerQuery = await harness.request('tools/call', {
+      name: 'query_fpf_spec',
+      arguments: {
+        mode: 'compact',
+        question:
+          'As a product maintainer, build a work packet without pasting the whole FPF.',
+      },
+    });
+    const boundedProductMaintainerPayload = asToolPayload(
+      boundedProductMaintainerQuery,
+    );
+    expect(boundedProductMaintainerPayload.status).toBe('ok');
+    if (routeIds.has('route:project-alignment')) {
+      expect(boundedProductMaintainerPayload.ids).toEqual(
+        expect.arrayContaining([
+          'route:project-alignment',
+          'E.12',
+          'A.1.1',
+          'A.15',
+          'A.2.2',
+          'A.2.3',
+        ]),
+      );
+      expect(boundedProductMaintainerPayload.answer).toContain(
+        'Product-role feedback packet IDs',
+      );
+    } else {
+      expect(
+        (boundedProductMaintainerPayload.ids as string[]).every(
+          (id) => !id.startsWith('route:'),
+        ),
+      ).toBe(true);
+    }
   });
 
   it('defaults to public tools when FPF_MCP_SURFACE is unset', async () => {