@pencil-agent/nano-pencil 1.13.6 → 1.13.8

package/dist/build-meta.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.13.6",
-  "commitHash": "d5ae966",
+  "version": "1.13.8",
+  "commitHash": "66ecf7f",
   "branch": "main",
-  "builtAt": "2026-04-23T04:35:24.822Z"
+  "builtAt": "2026-04-26T15:41:55.811Z"
 }

package/dist/core/model-registry.js

@@ -207,8 +207,9 @@ export class ModelRegistry {
             // Keep built-in models even if custom models failed to load
         }
         const builtInModels = this.useOnlyCustomModels
-            ? this.loadBuiltInModels(overrides, modelOverrides, new Set(["openrouter"]), {
+            ? this.loadBuiltInModels(overrides, modelOverrides, new Set(["openrouter", "zai"]), {
                 openrouter: new Set(NANOPENCIL_OPENROUTER_BUILTIN_MODEL_IDS),
+                // zai not specified = load all zai models
             })
             : this.loadBuiltInModels(overrides, modelOverrides);
         let combined = this.mergeCustomModels(builtInModels, customModels);

package/dist/core/runtime/agent-session.js

@@ -1183,8 +1183,22 @@ export class AgentSession {
         this.agent.setModel(model);
         this.sessionManager.appendModelChange(model.provider, model.id);
         this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
-        // Re-clamp thinking level for new model's capabilities
-        this.setThinkingLevel(this.thinkingLevel);
+        // Auto-select thinking level based on model capabilities
+        const currentLevel = this.thinkingLevel;
+        let newLevel;
+        if (!model.reasoning) {
+            // Model doesn't support thinking, force off
+            newLevel = "off";
+        }
+        else if (currentLevel === "off") {
+            // Model supports thinking but current level is off, default to medium
+            newLevel = "medium";
+        }
+        else {
+            // Keep current level but clamp to new model's capabilities
+            newLevel = currentLevel;
+        }
+        this.setThinkingLevel(newLevel);
         await this._emitModelSelect(model, previousModel, "set");
     }
     /**
@@ -1290,8 +1304,19 @@ export class AgentSession {
         this.agent.setModel(nextModel);
         this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
         this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
-        // Re-clamp thinking level for new model's capabilities
-        this.setThinkingLevel(this.thinkingLevel);
+        // Auto-select thinking level based on model capabilities
+        const currentLevel = this.thinkingLevel;
+        let newLevel;
+        if (!nextModel.reasoning) {
+            newLevel = "off";
+        }
+        else if (currentLevel === "off") {
+            newLevel = "medium";
+        }
+        else {
+            newLevel = currentLevel;
+        }
+        this.setThinkingLevel(newLevel);
         await this._emitModelSelect(nextModel, currentModel, "cycle");
         return {
             model: nextModel,

package/dist/core/sub-agent/sub-agent-backend.js

@@ -5,6 +5,8 @@
  * [HERE]: core/sub-agent/sub-agent-backend.ts - in-process SubAgent implementation
  */
 import { createAgentSession } from "../runtime/sdk.js";
+import { readFile } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
 /**
  * In-process SubAgent backend.
  * Wraps createAgentSession() to run SubAgent in the same process.
@@ -12,6 +14,7 @@ import { createAgentSession } from "../runtime/sdk.js";
 export class InProcessSubAgentBackend {
     async spawn(spec) {
         const id = crypto.randomUUID();
+        const prompt = await buildPromptWithContextFiles(spec);
         // Create an internal AbortController that can be triggered by external signal or timeout
         const internalAbortController = new AbortController();
         // Forward external signal abort to internal controller
@@ -56,7 +59,7 @@ export class InProcessSubAgentBackend {
         // Start the prompt
         const promptPromise = (async () => {
             try {
-                await session.prompt(spec.prompt, {
+                await session.prompt(prompt, {
                     images: spec.images,
                 });
                 status = "done";
@@ -87,6 +90,18 @@ export class InProcessSubAgentBackend {
                 }
             }
             finally {
+                if (spec.exitHook && result) {
+                    try {
+                        await spec.exitHook(result);
+                    }
+                    catch (error) {
+                        status = "error";
+                        result = {
+                            success: false,
+                            error: `exitHook failed: ${error instanceof Error ? error.message : String(error)}`,
+                        };
+                    }
+                }
                 if (timeoutId !== undefined) {
                     clearTimeout(timeoutId);
                 }
@@ -117,3 +132,26 @@ export class InProcessSubAgentBackend {
         };
     }
 }
+async function buildPromptWithContextFiles(spec) {
+    if (!spec.contextFiles?.length) {
+        return spec.prompt;
+    }
+    const chunks = [];
+    for (const filePath of spec.contextFiles) {
+        const absolutePath = isAbsolute(filePath) ? filePath : resolve(spec.cwd, filePath);
+        try {
+            const content = await readFile(absolutePath, "utf8");
+            chunks.push(`### ${filePath}\n\`\`\`\n${content}\n\`\`\``);
+        }
+        catch (error) {
+            chunks.push(`### ${filePath}\n(unavailable: ${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    return [
+        "The following files are injected as current task context. Treat them as read-only context unless the task instructions explicitly allow updates.",
+        "",
+        ...chunks,
+        "",
+        spec.prompt,
+    ].join("\n");
+}

package/dist/core/sub-agent/sub-agent-types.d.ts

@@ -25,6 +25,10 @@ export interface SubAgentSpec {
     images?: ImageContent[];
     /** Model to use (reuses main session's model and auth) */
     model?: Model<any>;
+    /** Files to inject into the initial prompt as read-only context */
+    contextFiles?: string[];
+    /** Optional callback invoked after the run result is available */
+    exitHook?: (result: SubAgentResult) => Promise<void> | void;
 }
 /**
  * Result from a completed SubAgent run.

package/dist/extensions/defaults/AGENT.md

@@ -37,14 +37,14 @@ loop/scheduler-controller.ts: SchedulerController - in-memory recurring task sto
 loop/scheduler-parser.ts: Loop command parsing with flags/subcommands, parseSchedulerCommand/parseDurationSpec/buildSchedulerHelp, --name/--max/--quiet
 loop/scheduler-types.ts: Scheduled loop types, LoopPayloadKind/ScheduledLoopTask/LoopStartSpec/ParsedSchedulerCommand
 loop/README.md: Loop extension documentation - recurring scheduler usage and flags
-sal/index.ts: SAL extension entry, enabled by default, registers --nosal/--sal-rebuild-terrain flags, /sal:coverage /sal:status /sal:setup commands, before_agent_start/tool_execution_start/agent_end hooks; /sal:setup writes ~/.memory-experiments/credentials.json with adapter inference (insforge/jsonl/noop); publishes structuralAnchor via core/runtime/turn-context (no SAL-specific globals); emits run_start/turn_anchor/run_end eval events through pluggable EvalSink; runtime no-op when --nosal is set
+sal/index.ts: SAL extension entry, enabled by default, registers --nosal/--sal-ab/--sal-rebuild-terrain flags, /sal:coverage /sal:status /sal:setup commands, before_agent_start/tool_execution_start/agent_end hooks; /sal:setup writes ~/.memory-experiments/credentials.json with adapter inference (insforge/jsonl/noop); publishes structuralAnchor via core/runtime/turn-context (no SAL-specific globals); emits run_start/turn_anchor/run_end eval events through pluggable EvalSink with best-effort shutdown flushing; writes local .memory-experiments sidecar anchors only when --sal-ab or NANOPENCIL_SAL_AB=1 is enabled; runtime no-op when --nosal is set
 sal/terrain.ts: TerrainSnapshot/TerrainNode/TerrainEdge model, buildTerrainIndex(), checkDipCoverage(), isSnapshotStale(), moduleIdForPath(), parses P2 AGENT.md and P3 file headers
 sal/anchors.ts: StructuralAnchor/AnchorResolution model, locateTask(), locateAction(), evidence-driven scoring with tunable SalWeights, CJK bigram tokenization
 sal/weights.ts: SalWeights interface, SAL_DEFAULT_WEIGHTS, loadSalWeights() reads sal-config.json from workspace or .memory-experiments/sal/
 sal/eval/index.ts: createEvalSink() factory + barrel re-exports; adapter selection via options.adapter or endpoint scheme inference (http(s)→insforge, file://|/|./|../→jsonl, missing→noop); ONLY entry point SAL imports from
 sal/eval/types.ts: EvalSink interface, EvalEventEnvelope/EvalEventType (run_start/run_end/turn_anchor), EvalAdapterId ("insforge"|"jsonl"|"noop"), CreateEvalSinkOptions, createEvalEvent factory; zero-dependency type surface
 sal/eval/noop-sink.ts: noopSink — silent EvalSink used when eval disabled or no adapter configured
-sal/eval/insforge-sink.ts: InsForgeEvalSink — PostgREST adapter, routes run_start→eval_runs INSERT (merge-duplicates), turn_anchor→eval_turns + eval_sal_anchors×2, run_end→eval_runs PATCH; allowSelfSigned TLS option, batching with default 2000ms interval
+sal/eval/insforge-sink.ts: InsForgeEvalSink — PostgREST adapter, routes run_start→eval_runs INSERT (merge-duplicates) with legacy-schema fallback, writes turn_anchor/tool_trace/memory_recalls/run_end only after parent run confirmation, tool_trace→eval_tool_traces with PGRST204 fallback, memory_recalls→eval_memory_recalls batch INSERT, run_end→eval_runs PATCH; allowSelfSigned TLS option logs only in development runtime, batching with default 2000ms interval
 sal/eval/jsonl-sink.ts: JsonlEvalSink — append-only filesystem adapter, one JSON object per line, accepts file:// URLs or plain paths, auto-creates parent dir, batched writes
 sal/README.md: SAL extension usage, sidecar output layout, weights override, pluggability contract
 team/index.ts: AgentTeam extension entry, /team:/team:spawn/:send/:status/:stop/:terminate/:approve/:mode commands, TEAM_MESSAGE_TYPE renderer

package/dist/extensions/defaults/CLAUDE.md

@@ -47,7 +47,7 @@ sal/terrain.ts: TerrainSnapshot/TerrainNode/TerrainEdge model, async buildTerrai
 sal/anchors.ts: StructuralAnchor/AnchorResolution model, locateTask(), locateAction(), evidence-driven scoring with tunable SalWeights, CJK bigram tokenization
 sal/weights.ts: SalWeights interface, SAL_DEFAULT_WEIGHTS, loadSalWeights() reads sal-config.json from workspace or .memory-experiments/sal/
 sal/eval/index.ts: createEvalSink() factory + barrel re-exports; adapter selection via options.adapter or endpoint scheme inference (http(s)→insforge, file://|/|./|../→jsonl, missing→noop); ONLY entry point SAL imports from
-sal/eval/types.ts: EvalSink interface, EvalEventEnvelope/EvalEventType (run_start/run_end/turn_anchor/memory_recalls), EvalAdapterId ("insforge"|"jsonl"|"noop"), CreateEvalSinkOptions, createEvalEvent factory; zero-dependency type surface
+sal/eval/types.ts: EvalSink interface, EvalEventEnvelope/EvalEventType (run_start/run_end/turn_anchor/memory_recalls/tool_trace), EvalAdapterId ("insforge"|"jsonl"|"noop"), CreateEvalSinkOptions, createEvalEvent factory; zero-dependency type surface
 sal/eval/noop-sink.ts: noopSink — silent EvalSink used when eval disabled or no adapter configured
 sal/eval/insforge-sink.ts: InsForgeEvalSink — PostgREST adapter, routes run_start→eval_runs INSERT (merge-duplicates), turn_anchor→eval_turns + eval_sal_anchors×2, tool_trace→eval_tool_traces bounded per-turn summaries (including no-tool turns and truncation counters), memory_recalls→eval_memory_recalls batch INSERT, run_end→eval_runs PATCH; allowSelfSigned TLS option, batching with default 2000ms interval
 sal/eval/jsonl-sink.ts: JsonlEvalSink — append-only filesystem adapter, one JSON object per line, accepts file:// URLs or plain paths, auto-creates parent dir, batched writes

package/dist/extensions/defaults/sal/README.md

@@ -14,11 +14,14 @@ SAL is **enabled by default** on every nanoPencil session.
 # SAL active (default)
 pencil -p "your prompt"
 
+# SAL active with local A/B sidecar artifacts
+pencil --sal-ab -p "your prompt"
+
 # SAL disabled — baseline memory mode
 pencil --nosal -p "your prompt"
 ```
 
-When `--nosal` is set, all hooks return early and zero work is performed.
+When `--nosal` is set, all hooks return early and zero work is performed. When SAL is active without `--sal-ab`, it can still emit configured eval data to InsForge, but it does not create local `.memory-experiments` sidecar files.
 
 ## Terminal compatibility (Warp, block UIs)
 
@@ -33,7 +36,7 @@ SAL builds a **terrain snapshot** of the workspace (walk + read DIP headers). Th
 
 ## Sidecar output
 
-When enabled, every turn writes a JSON record to:
+Local sidecar output is disabled by default. Enable it only for explicit SAL A/B experiments with `--sal-ab` or `NANOPENCIL_SAL_AB=1`. In that mode, every grounded turn writes a JSON record to:
 
 ```
 <workspace>/.memory-experiments/sal/anchors/turn-<timestamp>.json

package/dist/extensions/defaults/sal/eval/insforge-sink.d.ts

@@ -2,7 +2,7 @@
  * [WHO]: Provides InsForgeEvalSink (PostgREST-backed adapter)
  * [FROM]: Depends on node:https, node:http, node:url; ./types.js for EvalSink/EvalEventEnvelope/CreateEvalSinkOptions
  * [TO]: Constructed by eval/index.ts factory when adapter resolves to "insforge"
- * [HERE]: extensions/defaults/sal/eval/insforge-sink.ts - InsForge-specific routing: run_start→eval_runs INSERT (merge-duplicates, includes pencil_version), turn_anchor→eval_turns + eval_sal_anchors×2, tool_trace→eval_tool_traces, memory_recalls→eval_memory_recalls, run_end→eval_runs PATCH
+ * [HERE]: extensions/defaults/sal/eval/insforge-sink.ts - InsForge-specific routing: run_start→eval_runs INSERT (merge-duplicates, includes pencil_version with legacy fallback), turn_anchor→eval_turns + eval_sal_anchors×2 only after parent run confirmation, tool_trace→eval_tool_traces with legacy-schema fallback, memory_recalls→eval_memory_recalls, run_end→eval_runs PATCH
  *
  * Pluggable: nothing in this file may be imported from outside the eval/ directory.
  * To add a new backend, write a sibling file with the same EvalSink interface.
@@ -18,6 +18,8 @@ export declare class InsForgeEvalSink implements EvalSink {
     private flushTimer;
     private flushInFlight;
     private closed;
+    private confirmedRuns;
+    private failedRuns;
     constructor(options: CreateEvalSinkOptions);
     sendEvent(event: EvalEventEnvelope): Promise<void>;
     flush(): Promise<void>;
@@ -26,6 +28,7 @@ export declare class InsForgeEvalSink implements EvalSink {
     private scheduleFlush;
     private routeEvent;
     private handleRunStart;
+    private ensureRunExists;
     private handleTurnAnchor;
     private handleRunEnd;
     private handleMemoryRecalls;

package/dist/extensions/defaults/sal/eval/insforge-sink.js

@@ -2,14 +2,15 @@
  * [WHO]: Provides InsForgeEvalSink (PostgREST-backed adapter)
  * [FROM]: Depends on node:https, node:http, node:url; ./types.js for EvalSink/EvalEventEnvelope/CreateEvalSinkOptions
  * [TO]: Constructed by eval/index.ts factory when adapter resolves to "insforge"
- * [HERE]: extensions/defaults/sal/eval/insforge-sink.ts - InsForge-specific routing: run_start→eval_runs INSERT (merge-duplicates, includes pencil_version), turn_anchor→eval_turns + eval_sal_anchors×2, tool_trace→eval_tool_traces, memory_recalls→eval_memory_recalls, run_end→eval_runs PATCH
+ * [HERE]: extensions/defaults/sal/eval/insforge-sink.ts - InsForge-specific routing: run_start→eval_runs INSERT (merge-duplicates, includes pencil_version with legacy fallback), turn_anchor→eval_turns + eval_sal_anchors×2 only after parent run confirmation, tool_trace→eval_tool_traces with legacy-schema fallback, memory_recalls→eval_memory_recalls, run_end→eval_runs PATCH
  *
  * Pluggable: nothing in this file may be imported from outside the eval/ directory.
  * To add a new backend, write a sibling file with the same EvalSink interface.
  */
-import { request } from "node:https";
 import { request as httpRequest } from "node:http";
+import { request } from "node:https";
 import { URL } from "node:url";
+import { fileURLToPath } from "node:url";
 export class InsForgeEvalSink {
     enabled = true;
     base;
@@ -20,11 +21,13 @@ export class InsForgeEvalSink {
     flushTimer;
     flushInFlight;
     closed = false;
+    confirmedRuns = new Set();
+    failedRuns = new Set();
     constructor(options) {
         this.base = options.endpoint.replace(/\/+$/, "");
         this.batchIntervalMs = options.batchIntervalMs ?? 2000;
         this.allowSelfSigned = options.allowSelfSigned ?? false;
-        if (this.allowSelfSigned) {
+        if (this.allowSelfSigned && isDevelopmentRuntime()) {
             console.warn("[sal][eval] TLS certificate verification disabled (allowSelfSigned=true)");
         }
         const h = {
@@ -51,13 +54,16 @@ export class InsForgeEvalSink {
     }
     async flush() {
         if (this.flushInFlight) {
-            await this.flushInFlight;
+            await this.flushInFlight.catch(() => { });
             return;
         }
         this.flushInFlight = this.doFlush();
         try {
             await this.flushInFlight;
         }
+        catch (err) {
+            console.error("[sal][eval] flush failed:", err.message);
+        }
         finally {
             this.flushInFlight = undefined;
         }
@@ -78,7 +84,9 @@ export class InsForgeEvalSink {
     }
     async close() {
         this.closed = true;
-        await this.flush();
+        await this.flush().catch((err) => {
+            console.error("[sal][eval] close flush failed:", err.message);
+        });
     }
     scheduleFlush() {
         if (this.flushTimer)
@@ -98,16 +106,20 @@ export class InsForgeEvalSink {
                     await this.handleRunStart(event);
                     break;
                 case "turn_anchor":
-                    await this.handleTurnAnchor(event);
+                    if (await this.ensureRunExists(event))
+                        await this.handleTurnAnchor(event);
                     break;
                 case "memory_recalls":
-                    await this.handleMemoryRecalls(event);
+                    if (await this.ensureRunExists(event))
+                        await this.handleMemoryRecalls(event);
                     break;
                 case "tool_trace":
-                    await this.handleToolTrace(event);
+                    if (await this.ensureRunExists(event))
+                        await this.handleToolTrace(event);
                     break;
                 case "run_end":
-                    await this.handleRunEnd(event);
+                    if (await this.ensureRunExists(event))
+                        await this.handleRunEnd(event);
                     break;
             }
         }
@@ -118,20 +130,61 @@ export class InsForgeEvalSink {
     // INSERT into eval_runs (merge-duplicates so a later run_start can update model)
     async handleRunStart(ev) {
         const p = ev.payload;
-        await this.postJson(`${this.base}/api/database/records/eval_runs`, [{
-                run_id: ev.run_id,
-                variant: ev.variant,
-                status: "running",
-                task_description: strOrNull(p.task_description),
-                task_file: strOrNull(p.task_file),
-                model: strOrNull(p.model),
-                thinking: p.thinking === true,
-                pencil_version: strOrNull(p.pencil_version),
-                commit_hash: strOrNull(p.commit, "unknown"),
-                branch_name: strOrNull(p.branch, "unknown"),
-                workspace_root: strOrNull(p.workspace_root),
-                started_at: ev.ts,
-            }], { prefer: "resolution=merge-duplicates" });
+        const row = {
+            run_id: ev.run_id,
+            variant: ev.variant,
+            status: "running",
+            task_description: strOrNull(p.task_description),
+            task_file: strOrNull(p.task_file),
+            model: strOrNull(p.model),
+            thinking: p.thinking === true,
+            pencil_version: strOrNull(p.pencil_version),
+            commit_hash: strOrNull(p.commit, "unknown"),
+            branch_name: strOrNull(p.branch, "unknown"),
+            workspace_root: strOrNull(p.workspace_root),
+            started_at: ev.ts,
+        };
+        const url = `${this.base}/api/database/records/eval_runs`;
+        const result = await this.postJson(url, [row], {
+            prefer: "resolution=merge-duplicates",
+            quietErrorCodes: ["PGRST204"],
+        });
+        if (result.ok) {
+            this.confirmedRuns.add(ev.run_id);
+            this.failedRuns.delete(ev.run_id);
+            return;
+        }
+        const fallback = await this.postJson(url, [toLegacyRunStartRow(row)], {
+            prefer: "resolution=merge-duplicates",
+        });
+        if (fallback.ok) {
+            this.confirmedRuns.add(ev.run_id);
+            this.failedRuns.delete(ev.run_id);
+            return;
+        }
+        this.failedRuns.add(ev.run_id);
+    }
+    async ensureRunExists(ev) {
+        if (this.confirmedRuns.has(ev.run_id))
+            return true;
+        if (!this.failedRuns.has(ev.run_id)) {
+            await this.handleRunStart({
+                ...ev,
+                event_type: "run_start",
+                payload: {
+                    task_description: strOrNull(ev.payload.prompt_summary),
+                    model: strOrNull(ev.metadata?.model) ?? "unknown",
+                    thinking: false,
+                    commit: "unknown",
+                    branch: "unknown",
+                    workspace_root: strOrNull(ev.metadata?.workspace_root),
+                },
+            });
+            if (this.confirmedRuns.has(ev.run_id))
+                return true;
+        }
+        console.error(`[sal][eval] skipping ${ev.event_type}: eval_runs row is not available for run_id=${ev.run_id}`);
+        return false;
     }
     // INSERT into eval_turns + eval_sal_anchors (task + action)
     async handleTurnAnchor(ev) {
@@ -222,25 +275,33 @@ export class InsForgeEvalSink {
     async handleToolTrace(ev) {
         const p = ev.payload;
         const taskSignals = p.task_signals;
-        await this.postJson(`${this.base}/api/database/records/eval_tool_traces`, [{
-                run_id: ev.run_id,
-                turn_id: String(p.turn_id ?? 0),
-                event_id: ev.event_id,
-                tool_calls: p.tool_calls ? JSON.stringify(p.tool_calls) : null,
-                tool_sequence: p.tool_sequence ? JSON.stringify(p.tool_sequence) : null,
-                intent: strOrNull(taskSignals?.intent),
-                prompt_length: String(taskSignals?.prompt_length ?? 0),
-                has_error_trace: String(taskSignals?.has_error_trace === true),
-                has_file_reference: String(taskSignals?.has_file_reference === true),
-                has_tool_usage: String(p.has_tool_usage === true),
-                total_tool_calls: String(p.total_tool_calls ?? 0),
-                total_errors: String(p.total_errors ?? 0),
-                completed_tool_calls: String(p.completed_tool_calls ?? 0),
-                truncated_tool_calls: String(p.truncated_tool_calls ?? 0),
-                truncated_tool_summary: String(p.truncated_tool_summary ?? 0),
-                duration_ms: String(p.duration_ms ?? 0),
-                recorded_at: ev.ts,
-            }], { prefer: "resolution=ignore-duplicates" });
+        const row = {
+            run_id: ev.run_id,
+            turn_id: String(p.turn_id ?? 0),
+            event_id: ev.event_id,
+            tool_calls: p.tool_calls ? JSON.stringify(p.tool_calls) : null,
+            tool_sequence: p.tool_sequence ? JSON.stringify(p.tool_sequence) : null,
+            intent: strOrNull(taskSignals?.intent),
+            prompt_length: String(taskSignals?.prompt_length ?? 0),
+            has_error_trace: String(taskSignals?.has_error_trace === true),
+            has_file_reference: String(taskSignals?.has_file_reference === true),
+            has_tool_usage: String(p.has_tool_usage === true),
+            total_tool_calls: String(p.total_tool_calls ?? 0),
+            total_errors: String(p.total_errors ?? 0),
+            completed_tool_calls: String(p.completed_tool_calls ?? 0),
+            truncated_tool_calls: String(p.truncated_tool_calls ?? 0),
+            truncated_tool_summary: String(p.truncated_tool_summary ?? 0),
+            duration_ms: String(p.duration_ms ?? 0),
+            recorded_at: ev.ts,
+        };
+        const url = `${this.base}/api/database/records/eval_tool_traces`;
+        const result = await this.postJson(url, [row], {
+            prefer: "resolution=ignore-duplicates",
+            quietErrorCodes: ["PGRST204"],
+        });
+        if (!result.ok && result.errorCode === "PGRST204") {
+            await this.postJson(url, [toLegacyToolTraceRow(row)], { prefer: "resolution=ignore-duplicates" });
+        }
     }
     // ------------------------------------------------------------------
     // HTTP helpers
@@ -249,12 +310,12 @@ export class InsForgeEvalSink {
         const extraHeaders = {};
         if (extra?.prefer)
             extraHeaders["Prefer"] = extra.prefer;
-        return this.httpJson("POST", url, body, extraHeaders);
+        return this.httpJson("POST", url, body, extraHeaders, extra?.quietErrorCodes);
     }
     patchJson(url, body) {
         return this.httpJson("PATCH", url, body, {});
     }
-    httpJson(method, url, body, extraHeaders) {
+    httpJson(method, url, body, extraHeaders, quietErrorCodes = []) {
         return new Promise((resolve) => {
             const payload = JSON.stringify(body);
             let parsed;
@@ -263,7 +324,7 @@ export class InsForgeEvalSink {
             }
             catch {
                 console.error(`[sal][eval] invalid URL: ${url}`);
-                resolve(false);
+                resolve({ ok: false });
                 return;
             }
             const isHttps = parsed.protocol === "https:";
@@ -287,20 +348,21 @@ export class InsForgeEvalSink {
                 res.on("data", (chunk) => { rawBody += chunk; });
                 res.on("end", () => {
                     const ok = res.statusCode !== undefined && res.statusCode < 300;
-                    if (!ok) {
+                    const errorCode = parsePostgrestErrorCode(rawBody);
+                    if (!ok && !quietErrorCodes.includes(errorCode ?? "")) {
                         console.error(`[sal][eval] HTTP ${res.statusCode} ${method} ${parsed.pathname} — ${rawBody.slice(0, 300)}`);
                     }
-                    resolve(ok);
+                    resolve({ ok, statusCode: res.statusCode, body: rawBody, errorCode });
                 });
             });
             req.on("error", (err) => {
                 console.error(`[sal][eval] network error → ${parsed.hostname}: ${err.message}`);
-                resolve(false);
+                resolve({ ok: false });
             });
             req.on("timeout", () => {
                 console.error(`[sal][eval] timeout ${method} ${parsed.pathname}`);
                 req.destroy();
-                resolve(false);
+                resolve({ ok: false });
             });
             req.write(payload);
             req.end();
@@ -321,3 +383,33 @@ function numOrNull(v) {
     const n = Number(v);
     return isNaN(n) ? null : n;
 }
+function parsePostgrestErrorCode(rawBody) {
+    try {
+        const parsed = JSON.parse(rawBody);
+        return typeof parsed?.code === "string" ? parsed.code : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isDevelopmentRuntime() {
+    if (process.env.NODE_ENV === "development")
+        return true;
+    if (process.env.NODE_ENV === "production")
+        return false;
+    try {
+        const currentFile = fileURLToPath(import.meta.url).replace(/\\/g, "/");
+        return !currentFile.includes("/dist/");
+    }
+    catch {
+        return false;
+    }
+}
+function toLegacyRunStartRow(row) {
+    const { pencil_version: _pencilVersion, commit_hash: _commitHash, branch_name: _branchName, workspace_root: _workspaceRoot, ...legacyRow } = row;
+    return legacyRow;
+}
+function toLegacyToolTraceRow(row) {
+    const { has_tool_usage: _hasToolUsage, completed_tool_calls: _completedToolCalls, truncated_tool_calls: _truncatedToolCalls, truncated_tool_summary: _truncatedToolSummary, ...legacyRow } = row;
+    return legacyRow;
+}

package/dist/extensions/defaults/sal/index.d.ts

@@ -1,8 +1,8 @@
 /**
- * [WHO]: SAL extension entry - enabled by default, registers --nosal/--sal-rebuild-terrain flags, /sal:coverage /sal:status /sal:setup commands, before_agent_start/tool_execution_start/tool_execution_end/agent_end hooks; runtime no-op when --nosal is set
+ * [WHO]: SAL extension entry - enabled by default, registers --nosal/--sal-ab/--sal-rebuild-terrain flags, /sal:coverage /sal:status /sal:setup commands, before_agent_start/tool_execution_start/tool_execution_end/agent_end hooks; runtime no-op when --nosal is set
  * [FROM]: Depends on core/extensions/types.ts (ToolExecutionStartEvent, ToolExecutionEndEvent), core/runtime/turn-context.ts (publishes structuralAnchor), extensions/defaults/sal/terrain.ts, anchors.ts, weights.ts, eval/index.ts (pluggable adapters)
  * [TO]: Loaded by builtin-extensions.ts as a default extension entry point
- * [HERE]: extensions/defaults/sal/index.ts - pluggable Structural Anchor Localization (SAL) extension; emits run_start/turn_anchor/tool_trace/run_end eval events; tool_trace captures per-turn tool usage profile (call counts, sequences, intent, errors) for self-awareness analytics
+ * [HERE]: extensions/defaults/sal/index.ts - pluggable Structural Anchor Localization (SAL) extension; emits run_start/turn_anchor/tool_trace/run_end eval events with best-effort flush/close isolation; tool_trace captures per-turn tool usage profile (call counts, sequences, intent, errors) for self-awareness analytics
  */
 import { type EvalAdapterId } from "./eval/index.js";
 import type { ExtensionAPI } from "../../../core/extensions/types.js";
@@ -42,5 +42,6 @@ declare function resolveSalSidecarDir(workspaceRoot: string, experimentId?: stri
 type TaskIntent = "fix" | "feat" | "refactor" | "explain" | "explore" | "unknown";
 declare function inferIntent(prompt: string): TaskIntent;
 declare function buildToolTracePayload(turn: TurnState, turnDuration: number): Record<string, unknown>;
+declare function resolveSalAbEnabled(flagValue: unknown): boolean;
 export default function salExtension(api: ExtensionAPI): Promise<void>;
-export { SAL_DEFAULT_WEIGHTS, buildToolTracePayload, inferIntent, normalizeExperimentId, resolveSalSidecarDir, resolveStaleCleanupEnabled, };
+export { SAL_DEFAULT_WEIGHTS, buildToolTracePayload, inferIntent, normalizeExperimentId, resolveSalSidecarDir, resolveSalAbEnabled, resolveStaleCleanupEnabled, };