@gramatr/client 0.6.20 → 0.6.21

package/core/routing.ts

@@ -47,6 +47,27 @@ export async function routePrompt(options: {
   };
 }
 
+/**
+ * Fetch Packet 2 enrichment (reverse engineering + ISC scaffold).
+ * Called automatically by the prompt enricher hook when packet_2_status is "pending".
+ * Brief timeout — enrichment is usually pre-computed by the time we ask.
+ */
+export async function fetchEnrichment(enrichmentId: string, timeoutMs: number = 2000): Promise<Record<string, unknown> | null> {
+  try {
+    const result = await callMcpToolDetailed<Record<string, unknown>>(
+      'gramatr_get_enrichment',
+      { enrichment_id: enrichmentId, timeout_ms: timeoutMs },
+      timeoutMs + 1000, // HTTP timeout slightly longer than server timeout
+    );
+    if (result.data && result.data.status === 'ready') {
+      return result.data;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 export function describeRoutingFailure(error: MctToolCallError): {
   title: string;
   detail: string;

package/hooks/gramatr-prompt-enricher.hook.ts

@@ -25,6 +25,7 @@ import { getGitContext } from './lib/gmtr-hook-utils.ts';
 import {
   persistClassificationResult,
   routePrompt,
+  fetchEnrichment,
   shouldSkipPromptRouting,
 } from '../core/routing.ts';
 import type { RouteResponse } from '../core/types.ts';
@@ -155,7 +156,7 @@ function formatFailureWarning(failure: RouterFailure): string {
 
 // ── Format Intelligence Block ──
 
-function formatIntelligence(data: RouteResponse): string {
+function formatIntelligence(data: RouteResponse, enrichment?: Record<string, unknown> | null): string {
   const c = data.classification || {};
   const ts = data.token_savings || {};
   const es = data.execution_summary || {};
@@ -450,6 +451,14 @@ function formatIntelligence(data: RouteResponse): string {
     }
   }
 
+  // Enrichment status — tell agent what happened with Packet 2
+  if (enrichment) {
+    // Enrichment was auto-fetched and merged — ISC scaffold + RE already in the output above
+  } else if (data.packet_2_status === 'pending' && data.enrichment_id) {
+    lines.push('');
+    lines.push(`Packet 2 (reverse engineering + ISC scaffold) is still generating. If needed, call gramatr_get_enrichment with enrichment_id="${data.enrichment_id}".`);
+  }
+
   return lines.join('\n');
 }
 
@@ -580,6 +589,29 @@ async function main() {
     lastFailure = null;
   }
 
+  // Auto-fetch Packet 2 enrichment if pending (reverse engineering + ISC scaffold)
+  // Brief wait — enrichment is usually pre-computed by the time Packet 1 returns.
+  // If it's not ready in 2s, inject what we have and tell the agent how to get it later.
+  let enrichment: Record<string, unknown> | null = null;
+  if (result && (result as any).packet_2_status === 'pending' && (result as any).enrichment_id) {
+    try {
+      enrichment = await fetchEnrichment((result as any).enrichment_id, 2000);
+      if (enrichment) {
+        // Merge enrichment into the classification so the existing formatting logic picks it up
+        const c = (result as any).classification;
+        if (c && enrichment.reverse_engineering) {
+          c.reverse_engineering = enrichment.reverse_engineering;
+        }
+        if (c && enrichment.isc_scaffold) {
+          c.isc_scaffold = enrichment.isc_scaffold;
+        }
+        if (enrichment.constraints_extracted) {
+          c.constraints_extracted = enrichment.constraints_extracted;
+        }
+      }
+    } catch { /* non-blocking — Packet 1 still delivers */ }
+  }
+
   // Emit status to stderr
   emitStatus(result, elapsed);
 
@@ -660,7 +692,7 @@ async function main() {
   }
 
   // Format and inject
-  const context = formatIntelligence(result);
+  const context = formatIntelligence(result, enrichment);
 
   console.log(
     JSON.stringify({

package/hooks/session-start.hook.ts

@@ -482,8 +482,15 @@ async function main(): Promise<void> {
 
     // Opportunistic npm version check — prints a notification to stderr if a
     // newer gramatr is published. Never blocks or crashes the session start.
+    // Also injects context to stdout so Claude can proactively inform the user.
     try {
-      await runVersionCheckAndNotify(VERSION);
+      const versionResult = await runVersionCheckAndNotify(VERSION);
+      if (versionResult?.isOutdated) {
+        emitStdout(`gramatr update available: v${versionResult.installedVersion} → v${versionResult.latestVersion}. ` +
+          `Inform the user that a gramatr update is available and recommend they exit Claude Code (/exit) ` +
+          `then run \`npx gramatr@latest install claude-code\` followed by \`claude --resume\` to get the latest features. ` +
+          `Hooks are loaded at session start so a restart is required for new hook code to take effect.`);
+      }
     } catch {
       // Silent — version check is strictly optional.
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gramatr/client",
-  "version": "0.6.20",
+  "version": "0.6.21",
   "publishConfig": {
     "access": "public"
   },