@aexol/spectral 0.7.7 → 0.8.0

package/dist/extensions/spectral-vision-fallback.js

@@ -0,0 +1,225 @@
+/**
+ * Spectral Vision Extension
+ *
+ * Automatically switches to a vision-capable model for image processing
+ * when images are attached. This allows non-vision models to "see" images
+ * and saves main agent context by using a potentially smaller/cheaper
+ * vision model for image understanding.
+ *
+ * Logic:
+ *   - ALWAYS intercepts images (even when main model supports vision),
+ *     replacing them with text descriptions.
+ *   - Prefers the admin-configured default vision model (isVisionDefault
+ *     flag from backend via SettingsManager) for image descriptions.
+ *   - Falls back to the main model for vision if no admin default is
+ *     configured and the main model supports images.
+ *   - If neither is available, falls back to the first available
+ *     vision-capable model by provider priority.
+ *
+ * Hooks into the `context` event to intercept ALL images before they reach
+ * the LLM (covers user-attached images and tool-result images alike).
+ */
+import { streamSimple } from "../sdk/ai/index.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Check if the SettingsManager has an admin-configured default vision model
+ * with working auth. Returns the model if found and auth-ready, or undefined.
+ */
+function getAdminVisionModel(ctx) {
+    const settings = ctx.settingsManager;
+    if (!settings)
+        return undefined;
+    const defaultVisionProvider = settings.getDefaultVisionProvider();
+    const defaultVisionModel = settings.getDefaultVisionModel();
+    if (!defaultVisionProvider || !defaultVisionModel)
+        return undefined;
+    const allModels = ctx.modelRegistry.getAll();
+    const match = allModels.find((m) => m.provider === defaultVisionProvider && m.id === defaultVisionModel);
+    if (!match || !match.input.includes("image"))
+        return undefined;
+    if (!ctx.modelRegistry.hasConfiguredAuth(match))
+        return undefined;
+    return match;
+}
+/**
+ * Resolve the best vision model to use for image descriptions.
+ *
+ * Priority:
+ *   1. Admin-configured default vision model (isVisionDefault from backend)
+ *   2. Current main model if it supports images
+ *   3. Best available vision model by provider priority
+ *   4. First available vision model
+ */
+function resolveVisionModel(ctx) {
+    // 1. Admin-configured default vision model (always preferred)
+    const adminModel = getAdminVisionModel(ctx);
+    if (adminModel) {
+        process.stderr.write(`[spectral-vision] Using admin-configured default: ${adminModel.provider}/${adminModel.id}\n`);
+        return adminModel;
+    }
+    // 2. Current main model if it supports images
+    const currentModel = ctx.model;
+    if (currentModel?.input.includes("image") && ctx.modelRegistry.hasConfiguredAuth(currentModel)) {
+        process.stderr.write(`[spectral-vision] Using main model for vision: ${currentModel.provider}/${currentModel.id}\n`);
+        return currentModel;
+    }
+    // 3. Fall back to best available vision model by provider priority
+    const allModels = ctx.modelRegistry.getAll();
+    const visionModels = allModels.filter((m) => m.input.includes("image") && ctx.modelRegistry.hasConfiguredAuth(m));
+    if (visionModels.length === 0)
+        return undefined;
+    const providerPriority = ["anthropic", "openai", "google", "openrouter"];
+    for (const provider of providerPriority) {
+        const match = visionModels.find((m) => m.provider === provider);
+        if (match) {
+            process.stderr.write(`[spectral-vision] Using fallback vision model: ${match.provider}/${match.id}\n`);
+            return match;
+        }
+    }
+    // 4. First available vision model
+    const fallback = visionModels[0];
+    process.stderr.write(`[spectral-vision] Using first available vision model: ${fallback.provider}/${fallback.id}\n`);
+    return fallback;
+}
+/** Check if any content block in an array is an image */
+function hasImageContent(content) {
+    return Array.isArray(content) && content.some((c) => c?.type === "image");
+}
+/** Count images in a message */
+function countImages(msg) {
+    if (!Array.isArray(msg.content))
+        return 0;
+    return msg.content.filter((c) => c.type === "image").length;
+}
+// ---------------------------------------------------------------------------
+// Core: call vision model to describe images
+// ---------------------------------------------------------------------------
+async function describeImages(visionModel, content, contextText, ctx) {
+    const userContent = [
+        {
+            type: "text",
+            text: `Please describe the following image(s). ` +
+                (contextText ? `Context: ${contextText}. ` : "") +
+                "Focus on what is visually visible — text content, UI elements, diagrams, " +
+                "code structure, layout, colors, etc. Be concise but thorough. " +
+                "If multiple images are provided, describe each one separately with a heading.",
+        },
+    ];
+    const textPrefixBlocks = [];
+    let imageCount = 0;
+    for (const block of content) {
+        if (block.type === "image") {
+            userContent.push(block);
+            imageCount++;
+        }
+        else if (block.type === "text") {
+            textPrefixBlocks.push(block);
+        }
+    }
+    if (imageCount === 0)
+        return content;
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(visionModel);
+    if (!auth.ok) {
+        process.stderr.write(`[spectral-vision] No API key for vision model ${visionModel.provider}/${visionModel.id}\n`);
+        return content;
+    }
+    try {
+        const result = await streamSimple(visionModel, {
+            systemPrompt: "You are an image description assistant. Describe images accurately and concisely.",
+            messages: [{ role: "user", content: userContent, timestamp: Date.now() }],
+            tools: [],
+        }, {
+            apiKey: auth.apiKey,
+            headers: auth.headers,
+        });
+        let description = "";
+        for await (const event of result) {
+            if (event.type === "text_delta") {
+                description += event.delta;
+            }
+        }
+        const textNote = description.trim()
+            ? `[Image description from ${visionModel.provider}/${visionModel.id} (${imageCount} image(s)):\n${description}\n]`
+            : `[${imageCount} image(s) — vision model returned empty description]`;
+        // Notify the frontend that the vision extension analyzed the image(s)
+        try {
+            ctx.ui.notify(`[spectral-vision] Analyzed ${imageCount} image(s) with ${visionModel.provider}/${visionModel.id}`, "info");
+        }
+        catch {
+            // UI context may not be available in headless modes
+        }
+        return [
+            ...textPrefixBlocks,
+            { type: "text", text: textNote },
+        ];
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[spectral-vision] Vision call failed: ${msg}\n`);
+        // Notify frontend about the failure
+        try {
+            ctx.ui.notify(`[spectral-vision] Failed to analyze ${imageCount} image(s): ${msg}`, "warning");
+        }
+        catch {
+            // UI context may not be available in headless modes
+        }
+        return [
+            ...textPrefixBlocks,
+            {
+                type: "text",
+                text: `[${imageCount} image(s) omitted — vision fallback failed: ${msg}]`,
+            },
+        ];
+    }
+}
+// ---------------------------------------------------------------------------
+// Extension entry point
+// ---------------------------------------------------------------------------
+export default function spectralVisionExtension(pi) {
+    let visionModel;
+    pi.on("session_start", (_event, ctx) => {
+        visionModel = resolveVisionModel(ctx);
+        if (visionModel) {
+            process.stderr.write(`[spectral-vision] Ready — using ${visionModel.provider}/${visionModel.id} for image descriptions.\n`);
+        }
+        else {
+            process.stderr.write("[spectral-vision] No vision model with auth configured. Image description disabled.\n");
+        }
+    });
+    pi.on("context", async (event, ctx) => {
+        const messages = event.messages;
+        // Check if any message contains images
+        let totalImages = 0;
+        for (const msg of messages) {
+            totalImages += countImages(msg);
+        }
+        if (totalImages === 0)
+            return;
+        // Re-resolve vision model each time images are encountered.
+        // This ensures automatic switching to the admin-configured default
+        // vision model even when the main model supports vision.
+        visionModel = resolveVisionModel(ctx);
+        if (!visionModel) {
+            process.stderr.write("[spectral-vision] No vision model available, images will be omitted\n");
+            return;
+        }
+        process.stderr.write(`[spectral-vision] Describing ${totalImages} image(s) with ${visionModel.provider}/${visionModel.id}...\n`);
+        // Process each message
+        const processed = await Promise.all(messages.map(async (msg) => {
+            if (msg.role !== "user" || !Array.isArray(msg.content) || !hasImageContent(msg.content)) {
+                return msg;
+            }
+            // Extract context from preceding text blocks
+            const textBlocks = msg.content
+                .filter((c) => c.type === "text")
+                .map((c) => c.text)
+                .join(" ");
+            const contextText = textBlocks.substring(0, 500); // limit context
+            const described = await describeImages(visionModel, msg.content, contextText, ctx);
+            return { ...msg, content: described };
+        }));
+        return { messages: processed };
+    });
+}

package/dist/mcp/agent-dir.js

@@ -3,7 +3,7 @@ import { join, resolve } from "node:path";
 export function getAgentDir() {
     const configured = process.env.PI_CODING_AGENT_DIR?.trim();
     if (!configured) {
-        return join(homedir(), ".pi", "agent");
+        return join(homedir(), ".spectral", "agent");
     }
     if (configured === "~") {
         return homedir();

package/dist/mcp/config.js

@@ -5,7 +5,7 @@ import { dirname, join, resolve } from "node:path";
 import { getAgentPath } from "./agent-dir.js";
 const GENERIC_GLOBAL_CONFIG_PATH = join(homedir(), ".config", "mcp", "mcp.json");
 const PROJECT_CONFIG_NAME = ".mcp.json";
-const PROJECT_PI_CONFIG_NAME = ".pi/mcp.json";
+const PROJECT_MCP_CONFIG_NAME = ".spectral/mcp.json";
 const REPOPROMPT_BINARY_CANDIDATES = [
     join(homedir(), "RepoPrompt", "repoprompt_cli"),
     "/Applications/Repo Prompt.app/Contents/MacOS/repoprompt-mcp",
@@ -32,7 +32,7 @@ export function getProjectConfigPath(cwd = process.cwd()) {
     return resolve(cwd, PROJECT_CONFIG_NAME);
 }
 export function getProjectPiConfigPath(cwd = process.cwd()) {
-    return resolve(cwd, PROJECT_PI_CONFIG_NAME);
+    return resolve(cwd, PROJECT_MCP_CONFIG_NAME);
 }
 export function getConfigDiscoveryPaths(overridePath) {
     return getConfigSources(overridePath).map((source) => ({
@@ -368,7 +368,7 @@ function findProjectRoot(cwd = process.cwd()) {
         if (existsSync(join(current, ".git"))
             || existsSync(join(current, "package.json"))
             || existsSync(join(current, PROJECT_CONFIG_NAME))
-            || existsSync(join(current, ".pi"))) {
+            || existsSync(join(current, ".spectral"))) {
             return current;
         }
         const parent = dirname(current);

package/dist/mcp/sampling-handler.js

@@ -1,4 +1,4 @@
-import { complete } from "../pi/ai/index.js";
+import { complete } from "../sdk/ai/index.js";
 import { truncateAtWord } from "./utils.js";
 import { CreateMessageRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 export function registerSamplingHandler(client, options) {

package/dist/mcp/server-manager.js

@@ -96,6 +96,8 @@ export class McpServerManager {
             }
             // Check for UnauthorizedError — server requires OAuth.
             // This can fire from createHttpTransport probe or client.connect.
+            // transport may be undefined if createHttpTransport threw during the probe
+            // before returning a transport; close() handles this safely.
             if (error instanceof UnauthorizedError && supportsOAuth(definition)) {
                 return {
                     client,
@@ -239,7 +241,9 @@ export class McpServerManager {
         connection.status = "closed";
         this.connections.delete(name);
         await connection.client.close().catch(() => { });
-        await connection.transport.close().catch(() => { });
+        if (connection.transport) {
+            await connection.transport.close().catch(() => { });
+        }
     }
     async closeAll() {
         const names = [...this.connections.keys()];

package/dist/memory/commands/status.js

@@ -1,4 +1,4 @@
-import { SettingsManager } from "../../pi/coding-agent/index.js";
+import { SettingsManager } from "../../sdk/coding-agent/index.js";
 import { getMemoryState, rawTokensSinceLastBound, rawTokensSinceLastCompaction, } from "../branch.js";
 import { observationPoolTokens as estimateObservationPoolTokens } from "../compaction.js";
 import { countByRelevance, formatRelevanceHistogram } from "../relevance.js";
@@ -39,14 +39,14 @@ export function registerStatusCommand(pi, runtime) {
             const pObsLabel = pendingObsCount === 1 ? "observation" : "observations";
             const passiveLines = runtime.config.passive === true
                 ? [
-                    "── Mode ──",
+                    "### Mode",
                     "Passive: proactive observation and compaction triggers disabled; compaction hook remains active",
                     "",
                 ]
                 : [];
             const activityLines = runtime.config.passive === true
                 ? [
-                    "── Activity ──",
+                    "### Activity",
                     `Observation trigger: passive (~${sinceBound.toLocaleString()} / ${obsThreshold.toLocaleString()} tokens, ${obsPct}%)`,
                     "  → proactive observation is disabled; manual/Pi compaction can still run sync catch-up observation",
                     `Compaction trigger:  passive (~${sinceCompaction.toLocaleString()} / ${compThreshold.toLocaleString()} tokens, ${compPct}%)`,
@@ -56,7 +56,7 @@ export function registerStatusCommand(pi, runtime) {
                     `    distilled from them and redundant observations are pruned away`,
                 ]
                 : [
-                    "── Activity ──",
+                    "### Activity",
                     `Next observation: ~${sinceBound.toLocaleString()} / ${obsThreshold.toLocaleString()} tokens (${obsPct}%)`,
                     `  → at ${obsThreshold.toLocaleString()} tokens, recent conversation is compressed into new observations`,
                     `Next compaction:  ~${sinceCompaction.toLocaleString()} / ${compThreshold.toLocaleString()} tokens (${compPct}%)`,
@@ -68,7 +68,7 @@ export function registerStatusCommand(pi, runtime) {
                 ];
             const lines = [
                 ...passiveLines,
-                "── Memory ──",
+                "### Memory",
                 `Reflections:   ~${committedRefsTokens.toLocaleString()} tokens (${committedRefsCount} ${refLabel})      — durable insights`,
                 `Observations:`,
                 `  committed    ~${committedObsTokens.toLocaleString()} tokens (${committedObsCount} ${cObsLabel}) — folded into last compaction`,
@@ -79,7 +79,7 @@ export function registerStatusCommand(pi, runtime) {
             ];
             if (runtime.observerInFlight || runtime.compactInFlight) {
                 lines.push("");
-                lines.push("── In flight ──");
+                lines.push("### In Flight");
                 if (runtime.observerInFlight)
                     lines.push("Observer: running");
                 if (runtime.compactInFlight)

package/dist/memory/commands/view.js

@@ -1,8 +1,8 @@
 import { getMemoryState } from "../branch.js";
-import { observationPoolTokens as estimateObservationPoolTokens } from "../compaction.js";
+import { observationPoolTokens as estimateObservationPoolTokens, observationsToMarkdownList, reflectionsToMarkdownList, } from "../compaction.js";
 import { countByRelevance, formatRelevanceHistogram } from "../relevance.js";
 import { estimateStringTokens } from "../tokens.js";
-import { reflectionContent, reflectionToPromptLine } from "../types.js";
+import { reflectionContent } from "../types.js";
 export function registerViewCommand(pi, runtime) {
     pi.registerCommand("om-view", {
         description: "Print observational memory details (reflections + observations)",
@@ -22,39 +22,41 @@ export function registerViewCommand(pi, runtime) {
             const totalTokens = committedRefTokens + totalObsTokens;
             const relevanceHistogram = countByRelevance([...committedObs, ...pendingObs]);
             const plural = (n, singular, plural) => (n === 1 ? singular : plural);
-            const renderObs = (r) => `[${r.id}] ${r.timestamp} [${r.relevance}] ${r.content}`;
             const sections = [];
-            sections.push(`Memory: ${committedRefCount} ${plural(committedRefCount, "reflection", "reflections")} · ` +
+            sections.push(`## Memory Overview\n\n` +
+                `${committedRefCount} ${plural(committedRefCount, "reflection", "reflections")} · ` +
                 `${totalObsCount} ${plural(totalObsCount, "observation", "observations")} ` +
                 `(${committedObsCount} committed, ${pendingObsCount} pending) · ` +
                 `~${totalTokens.toLocaleString()} tokens · ` +
                 `relevance ${formatRelevanceHistogram(relevanceHistogram)}`);
+            sections.push(`## Reflections (${committedRefCount} ${plural(committedRefCount, "entry", "entries")}, ~${committedRefTokens.toLocaleString()} tokens)`);
             sections.push("");
-            sections.push(`── Reflections (${committedRefCount} ${plural(committedRefCount, "entry", "entries")}, ~${committedRefTokens.toLocaleString()} tokens) ──`);
             if (committedRefItems.length > 0) {
-                sections.push(committedRefItems.map(reflectionToPromptLine).join("\n\n"));
+                sections.push(reflectionsToMarkdownList(committedRefItems));
             }
             else {
-                sections.push("(none)");
+                sections.push("*(none)*");
             }
             sections.push("");
-            sections.push(`── Observations — committed (${committedObsCount} ${plural(committedObsCount, "observation", "observations")}, ~${committedObsTokens.toLocaleString()} tokens) ──`);
+            sections.push(`## Observations (committed: ${committedObsCount} ${plural(committedObsCount, "observation", "observations")}, ~${committedObsTokens.toLocaleString()} tokens)`);
+            sections.push("");
             if (committedObs.length > 0) {
-                sections.push(committedObs.map(renderObs).join("\n"));
+                sections.push(observationsToMarkdownList(committedObs));
             }
             else {
-                sections.push("(none)");
+                sections.push("*(none)*");
             }
             sections.push("");
-            sections.push(`── Observations — pending (${pendingObsCount} ${plural(pendingObsCount, "observation", "observations")}, ~${pendingObsTokens.toLocaleString()} tokens) ──`);
+            sections.push(`## Observations (pending: ${pendingObsCount} ${plural(pendingObsCount, "observation", "observations")}, ~${pendingObsTokens.toLocaleString()} tokens)`);
+            sections.push("");
             if (pendingObs.length > 0) {
-                sections.push(pendingObs.map(renderObs).join("\n"));
+                sections.push(observationsToMarkdownList(pendingObs));
             }
             else {
-                sections.push("(none)");
+                sections.push("*(none)*");
             }
             sections.push("");
-            sections.push("Tip: use /tree to browse the raw messages still live in the session.");
+            sections.push("*Tip: use /tree to browse the raw messages still live in the session.*");
             ctx.ui.notify(sections.join("\n"), "info");
         },
     });

package/dist/memory/compaction.js

@@ -1,5 +1,5 @@
-import { agentLoop } from "../pi/agent-core/index.js";
-import { Type } from "../pi/ai/index.js";
+import { agentLoop } from "../sdk/agent-core/index.js";
+import { Type } from "../sdk/ai/index.js";
 import { debugLog, isDebugLogEnabled } from "./debug-log.js";
 import { hashId } from "./ids.js";
 import { AGENT_LOOP_MAX_TOKENS, boundedMaxTokens } from "./model-budget.js";
@@ -798,16 +798,44 @@ export async function runPruner(args, reflections, observations, budgetTokens, o
     });
     return result;
 }
+/**
+ * Format an observation for Markdown-safe display.
+ * Wraps the ID in backticks so it renders as inline code in Markdown
+ * rather than being misinterpreted as a link reference.
+ */
+export function observationToMarkdown(record) {
+    return `[\`${record.id}\`] ${record.timestamp} [${record.relevance}] ${record.content}`;
+}
+/**
+ * Format a reflection for Markdown-safe display.
+ * Wraps the ID in backticks so it renders as inline code in Markdown.
+ */
+export function reflectionToMarkdown(reflection) {
+    if (typeof reflection === "string")
+        return reflection;
+    return `[\`${reflection.id}\`] ${reflection.content}`;
+}
+/**
+ * Format observations as a Markdown bullet list for display.
+ */
+export function observationsToMarkdownList(observations) {
+    return observations.map((o) => `- ${observationToMarkdown(o)}`).join("\n");
+}
+/**
+ * Format reflections as a Markdown bullet list for display.
+ */
+export function reflectionsToMarkdownList(reflections) {
+    return reflections.map((r) => `- ${reflectionToMarkdown(r)}`).join("\n");
+}
 export function renderSummary(reflections, observations) {
     if (reflections.length === 0 && observations.length === 0)
         return "";
     const parts = [CONTEXT_USAGE_INSTRUCTIONS];
     if (reflections.length > 0) {
-        parts.push(`## Reflections\n${reflections.map(reflectionToPromptLine).join("\n")}`);
+        parts.push(`## Reflections\n${reflectionsToMarkdownList(reflections)}`);
     }
     if (observations.length > 0) {
-        const body = observationsToPromptLines(observations).join("\n");
-        parts.push(`## Observations\n${body}`);
+        parts.push(`## Observations\n${observationsToMarkdownList(observations)}`);
     }
     return parts.join("\n\n");
 }

package/dist/memory/config.js

@@ -1,10 +1,10 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { getAgentDir } from "../pi/coding-agent/index.js";
+import { getAgentDir } from "../sdk/coding-agent/index.js";
 export const DEFAULTS = {
     observationThresholdTokens: 1_000,
     compactionThresholdTokens: 50_000,
-    reflectionThresholdTokens: 30_000,
+    reflectionThresholdTokens: 10_000,
     passive: false,
     debugLog: false,
     observerMaxChunkTokens: 30_000,
@@ -72,7 +72,7 @@ function readNamespacedConfig(path) {
 }
 export function loadConfig(cwd, env = process.env) {
     const globalPath = join(getAgentDir(), "settings.json");
-    const projectPath = join(cwd, ".pi", "settings.json");
+    const projectPath = join(cwd, ".spectral", "settings.json");
     return {
         ...DEFAULTS,
         ...readNamespacedConfig(globalPath),

package/dist/memory/debug-log.js

@@ -1,7 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { existsSync, mkdirSync, renameSync, statSync, unlinkSync, appendFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { getAgentDir } from "../pi/coding-agent/index.js";
+import { getAgentDir } from "../sdk/coding-agent/index.js";
 export const DEBUG_LOG_MAX_BYTES = 10 * 1024 * 1024;
 export const DEBUG_LOG_RELATIVE_PATH = join("observational-memory", "debug.ndjson");
 const storage = new AsyncLocalStorage();

package/dist/memory/observer.js

@@ -1,5 +1,5 @@
-import { agentLoop } from "../pi/agent-core/index.js";
-import { Type } from "../pi/ai/index.js";
+import { agentLoop } from "../sdk/agent-core/index.js";
+import { Type } from "../sdk/ai/index.js";
 import { hashId } from "./ids.js";
 import { AGENT_LOOP_MAX_TOKENS, boundedMaxTokens } from "./model-budget.js";
 import { OBSERVER_SYSTEM } from "./prompts.js";

package/dist/memory/prompts.js

@@ -92,7 +92,7 @@ Your job is to compress a chunk of recent conversation into timestamped, rated o
 
 You receive:
 - Current reflections (long-lived facts already crystallized).
-- Current observations (already-recorded observations, each shown as "[id] YYYY-MM-DD HH:MM [relevance] content").
+- Current observations (already-recorded observations, each shown as "[\`id\`] YYYY-MM-DD HH:MM [relevance] content").
 - A new chunk of conversation with source entry labels and inline message timestamps. Each source block starts with "[Source entry id: <id>]" followed by content formatted as "[User @ YYYY-MM-DD HH:MM]:", "[Assistant @ ...]:", "[Tool result for <name> @ ...]:", custom messages, or branch summaries.
 - A current local time fallback for observations that have no obvious message timestamp.
 
@@ -141,7 +141,7 @@ Your task is different from the observer's: you are not recording events, you ar
 
 You receive:
 - Current reflections (already-crystallized long-lived facts, one per line). Newer reflections may begin with a bracketed id handle; treat that id as recall metadata, not as part of the reflection prose.
-- Current observations (timestamped, relevance-tagged events accumulated over many turns). Each is shown as "[id] YYYY-MM-DD HH:MM [relevance] content".
+- Current observations (timestamped, relevance-tagged events accumulated over many turns). Each is shown as "[\`id\`] YYYY-MM-DD HH:MM [relevance] content".
 
 How you work:
 1. Read current reflections and observations to understand what is already crystallized and what new signal exists in the pool.
@@ -198,7 +198,7 @@ ${RELEVANCE_RUBRIC}
 
 You receive:
 - Current reflections (long-lived facts; they survive regardless — treat them as already captured). Newer reflections may begin with a bracketed id handle; treat that id as recall metadata, not as part of the reflection prose.
-- Current observations (timestamped, relevance-tagged events to prune). Each is shown as "[id] YYYY-MM-DD HH:MM [relevance] [coverage: tag] content", where id is the 12-character hex handle you reference when dropping.
+- Current observations (timestamped, relevance-tagged events to prune). Each is shown as "[\`id\`] YYYY-MM-DD HH:MM [relevance] [coverage: tag] content", where id is the 12-character hex handle you reference when dropping.
 - A pressure line stating pool size, target, tokens still to cut, and the current pass strategy.
 
 Coverage tags are pruning signals derived from current provenance-backed reflection support ids. They are strong evidence, not blind commands:
@@ -279,8 +279,8 @@ export function buildPrunerPassGuidance(pass, maxPasses) {
 }
 export const CONTEXT_USAGE_INSTRUCTIONS = `These are condensed memories from earlier in this session.
 
-- Reflections: stable, long-lived facts about the user, project, decisions, and constraints. New reflection lines may include ids in brackets.
-- Observations: timestamped events from the conversation history, in chronological order. Observation lines include ids in brackets.
+- Reflections: stable, long-lived facts about the user, project, decisions, and constraints. New reflection lines may include ids in brackets wrapped in backticks.
+- Observations: timestamped events from the conversation history, in chronological order. Observation lines include ids in brackets wrapped in backticks.
 
 Treat these as past records. When entries conflict, the most recent observation reflects the latest known state. Work that prior observations describe as completed should not be redone unless the user explicitly asks to revisit it.
 

package/dist/memory/tokens.js

@@ -1,4 +1,4 @@
-import { estimateTokens as estimateMessageTokens } from "../pi/coding-agent/index.js";
+import { estimateTokens as estimateMessageTokens } from "../sdk/coding-agent/index.js";
 export function estimateStringTokens(text) {
     return Math.ceil(text.length / 4);
 }

package/dist/memory/tools/read-project-observations.js

@@ -1,5 +1,5 @@
-import { Type } from "../../pi/ai/index.js";
-import { defineTool } from "../../pi/coding-agent/index.js";
+import { Type } from "../../sdk/ai/index.js";
+import { defineTool } from "../../sdk/coding-agent/index.js";
 import { getProjectObsStore } from "../project-observations-store.js";
 export const READ_PROJECT_OBSERVATIONS_TOOL_NAME = "read_project_observations";
 export const readProjectObservationsTool = defineTool({

package/dist/memory/tools/recall-observation.js

@@ -1,5 +1,5 @@
-import { Type } from "../../pi/ai/index.js";
-import { defineTool } from "../../pi/coding-agent/index.js";
+import { Type } from "../../sdk/ai/index.js";
+import { defineTool } from "../../sdk/coding-agent/index.js";
 import { recallMemorySources, } from "../branch.js";
 import { renderRecallSourceEntries, renderRecallSourceEntry } from "../serialize.js";
 import { estimateEntryTokens } from "../tokens.js";
@@ -181,10 +181,10 @@ function friendlySourceUnavailableMessage(match) {
     return `Observation ${match.observation.id} has source entries associated, but some are unavailable on the current branch or are not source-renderable.${missing}${nonSource}`;
 }
 function reflectionLineText(reflection) {
-    return `[${reflection.id}] ${reflection.content}`;
+    return `[\`${reflection.id}\`] ${reflection.content}`;
 }
 function observationLineText(observation) {
-    return `[${observation.id}] ${observation.timestamp} [${observation.relevance}] ${observation.content}`;
+    return `[\`${observation.id}\`] ${observation.timestamp} [${observation.relevance}] ${observation.content}`;
 }
 function renderObservationOnlyTextFromResult(result) {
     const sections = [];