@gramatr/client 0.6.19 → 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

@@ -20,15 +20,22 @@
  * - Token savings metadata
  */
 
-import { readFileSync } from 'fs';
+import { readFileSync, appendFileSync } from 'fs';
 import { getGitContext } from './lib/gmtr-hook-utils.ts';
 import {
   persistClassificationResult,
   routePrompt,
+  fetchEnrichment,
   shouldSkipPromptRouting,
 } from '../core/routing.ts';
 import type { RouteResponse } from '../core/types.ts';
 
+// ── Turn Tracking (Issue #594) ──
+// Module-level counter incremented per prompt in this process.
+// Reset on process restart (acceptable — session-end flushes).
+let turnCounter = 0;
+const TURNS_JSONL_PATH = '/tmp/gramatr-turns.jsonl';
+
 // ── Types ──
 
 interface HookInput {
@@ -149,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 || {};
@@ -337,6 +344,10 @@ function formatIntelligence(data: RouteResponse): string {
   lines.push('The ISC prefix is REQUIRED — it signals to the user that GMTR intelligence is driving the criteria.');
   lines.push('This is a HARD GATE — do NOT proceed to any work until TaskCreate calls are complete.');
 
+  // ── grā identity — server-generated content marker ──
+  lines.push('');
+  lines.push('When presenting gramatr intelligence (ISC scaffolds, search results, agent recommendations, summaries), prefix with **grā:** in bold. This distinguishes server-pre-computed content from your own reasoning. Example: "**grā:** ISC scaffold suggests 6 criteria for this migration task."');
+
   // ── Effort-level-scaled format ──
   if (effort === 'instant') {
     lines.push('');
@@ -440,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');
 }
 
@@ -570,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);
 
@@ -614,6 +656,23 @@ async function main() {
 
   persistLastClassification(prompt, session_id, result, downstreamModel);
 
+  // Accumulate turn data for batch flush at session end (Issue #594)
+  try {
+    const cl = result?.classification || {};
+    const es = result?.execution_summary || {};
+    const turnData = {
+      turn_number: turnCounter++,
+      timestamp: new Date().toISOString(),
+      prompt: prompt.substring(0, 500),
+      effort_level: cl.effort_level || null,
+      intent_type: cl.intent_type || null,
+      confidence: cl.confidence || null,
+      memory_tier: cl.memory_tier || null,
+      classifier_model: es.classifier_model || null,
+    };
+    appendFileSync(TURNS_JSONL_PATH, JSON.stringify(turnData) + '\n');
+  } catch { /* never block the hook */ }
+
   // If no result — DO NOT silently pass through. Tell the user what's broken.
   if (!result || !result.classification) {
     if (lastFailure) {
@@ -633,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-end.hook.ts

@@ -11,7 +11,7 @@
  * ZERO external CLI dependencies — no jq, sed, curl, awk.
  */
 
-import { writeFileSync } from 'fs';
+import { writeFileSync, readFileSync, existsSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import {
   readHookInput,
@@ -129,6 +129,32 @@ async function main(): Promise<void> {
         log('');
         log('Saving session state to gramatr...');
 
+        // ── Flush accumulated turns to server (Issue #594) ──
+        try {
+          const turnsFile = '/tmp/gramatr-turns.jsonl';
+          if (existsSync(turnsFile)) {
+            const lines = readFileSync(turnsFile, 'utf8').trim().split('\n').filter(Boolean);
+            const turns = lines.map(line => JSON.parse(line));
+            if (turns.length > 0) {
+              log(`  Flushing ${turns.length} turns to gramatr...`);
+              const interactionId = config?.current_session?.interaction_id || '';
+              const flushResult = await callMcpToolRaw('gramatr_batch_save_turns', {
+                session_id: sessionEntityId || sessionId,
+                project_id: projectId,
+                turns,
+              });
+              if (flushResult && flushResult.includes('"turns_saved"')) {
+                log(`  Turns flushed successfully`);
+              } else {
+                log('  Turn flush uncertain (server may be unavailable)');
+              }
+            }
+            unlinkSync(turnsFile);
+          }
+        } catch {
+          log('  Turn flush failed (non-critical)');
+        }
+
         // Session lifecycle only — gramatr_session_end records git summary on the session entity.
         // Handoffs are saved by the AGENT in the LEARN phase via gramatr_save_handoff (HARD GATE).
         // The hook does NOT save handoffs — it lacks conversation context.

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.19",
+  "version": "0.6.21",
   "publishConfig": {
     "access": "public"
   },