@pencil-agent/nano-pencil 1.13.7 → 1.13.8

package/dist/build-meta.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.13.7",
-  "commitHash": "9b46faa",
+  "version": "1.13.8",
+  "commitHash": "66ecf7f",
   "branch": "main",
-  "builtAt": "2026-04-25T14:10:25.443Z"
+  "builtAt": "2026-04-26T15:41:55.811Z"
 }

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, tool_trace→eval_tool_traces with PGRST204 legacy-schema fallback, memory_recalls→eval_memory_recalls batch INSERT, 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/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 with legacy-schema fallback, 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 with legacy-schema fallback, 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) {
@@ -339,6 +392,23 @@ function parsePostgrestErrorCode(rawBody) {
         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, };

package/dist/extensions/defaults/sal/index.js

@@ -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 { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -49,7 +49,9 @@ function loadBuildMeta() {
 }
 const BUILD_META = loadBuildMeta();
 const NOSAL_FLAG = "nosal";
+const SAL_AB_FLAG = "sal-ab";
 const SAL_REBUILD_FLAG = "sal-rebuild-terrain";
+const SAL_AB_ENV = "NANOPENCIL_SAL_AB";
 const SAL_CONTEXT_BUDGET_TOKENS = 800;
 const APPROX_TOKENS_PER_CHAR = 0.25;
 const EVAL_ENABLED_ENV = "NANOPENCIL_EVAL_ENABLED";
@@ -70,6 +72,10 @@ function resolveStaleCleanupEnabled(envValue, credentials) {
     return credentials?.cleanup_stale_runs === true;
 }
 function isTruthy(value) {
+    if (value === true)
+        return true;
+    if (typeof value !== "string")
+        return false;
     if (!value)
         return false;
     return ["1", "true", "yes", "on"].includes(value.toLowerCase());
@@ -411,6 +417,9 @@ function resolveEvalVariant(runtime, salEnabled) {
         return runtime.evalVariantOverride;
     return salEnabled ? "sal" : "control";
 }
+function resolveSalAbEnabled(flagValue) {
+    return isTruthy(flagValue) || isTruthy(process.env[SAL_AB_ENV]);
+}
 async function emitEval(runtime, eventType, salEnabled, payload) {
     if (!runtime.evalEnabled)
         return;
@@ -422,6 +431,27 @@ async function emitEval(runtime, eventType, salEnabled, payload) {
         console.error("[sal][eval] failed to emit event:", err.message);
     }
 }
+async function evalBestEffort(label, work, timeoutMs = 6000) {
+    let timer;
+    try {
+        await Promise.race([
+            work,
+            new Promise((resolve) => {
+                timer = setTimeout(() => {
+                    console.error(`[sal][eval] ${label} timed out; continuing session shutdown`);
+                    resolve();
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    catch (err) {
+        console.error(`[sal][eval] ${label} failed:`, err.message);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 /**
  * Fire-and-forget PATCH to mark stale "running" eval runs as "abandoned".
  * Uses raw HTTP so it stays independent of the EvalSink batching pipeline.
@@ -485,6 +515,11 @@ export default async function salExtension(api) {
         description: "Disable Structural Anchor Localization (SAL) - fall back to baseline memory mode",
         default: false,
     });
+    api.registerFlag(SAL_AB_FLAG, {
+        type: "boolean",
+        description: "Enable SAL A/B experiment sidecar files under .memory-experiments",
+        default: false,
+    });
     api.registerFlag(SAL_REBUILD_FLAG, {
         type: "boolean",
         description: "Force SAL terrain index rebuild on next localization pass",
@@ -568,6 +603,7 @@ export default async function salExtension(api) {
         pendingRebuild: false,
     };
     const isEnabled = () => !api.getFlag(NOSAL_FLAG);
+    const isSalAbEnabled = () => resolveSalAbEnabled(api.getFlag(SAL_AB_FLAG));
     api.registerCommand("sal:coverage", {
         description: "Report DIP P3 coverage for SAL prerequisite gating. Usage: /sal:coverage [module1 module2 ...]",
         handler: async (args, ctx) => {
@@ -679,6 +715,7 @@ export default async function salExtension(api) {
             const lines = [
                 "[SAL Status]",
                 `  SAL: ${flagOn ? "ON (default)" : "OFF (--nosal)"}`,
+                `  SAL A/B sidecar: ${isSalAbEnabled() ? "ON (--sal-ab)" : "OFF"}`,
                 `  eval: ${runtime.evalEnabled ? "ON" : "OFF"}`,
                 `  adapter: ${runtime.evalAdapter ?? "(inferred at sink creation)"}`,
                 `  endpoint: ${endpointDisplay}`,
@@ -687,7 +724,7 @@ export default async function salExtension(api) {
                 `  weightsSource: ${runtime.weightsSource}`,
                 `  snapshotGeneratedAt: ${snapshot ? new Date(snapshot.generatedAt).toISOString() : "(not built)"}`,
                 `  nodes: ${snapshot?.nodes.length ?? 0}`,
-                `  sidecarDir: ${runtime.sidecarDir}`,
+                `  sidecarDir: ${isSalAbEnabled() ? runtime.sidecarDir : "(disabled; use --sal-ab)"}`,
             ];
             ctx.ui.notify(lines.join("\n"), "info");
         },
@@ -837,7 +874,7 @@ export default async function salExtension(api) {
         // Emit tool usage trace for self-awareness analytics.
         // Always emit a bounded summary, including no-tool turns.
         await emitEval(runtime, "tool_trace", isEnabled(), buildToolTracePayload(runtime.turn, turnDuration));
-        if (actionRes) {
+        if (isSalAbEnabled() && actionRes) {
             persistTurnRecord(runtime, taskRes, actionRes);
         }
         runtime.turn = {
@@ -879,8 +916,8 @@ export default async function salExtension(api) {
             turn_count: runtime.turnCounter,
             total_duration_ms: Math.max(0, Date.now() - runtime.evalStartedAtMs),
         });
-        await runtime.evalSink.flush();
-        await runtime.evalSink.close();
+        await evalBestEffort("flush", runtime.evalSink.flush());
+        await evalBestEffort("close", runtime.evalSink.close());
     });
     // ------------------------------------------------------------------
     // Strategy A: Emergency flush on abnormal exit.
@@ -898,7 +935,7 @@ export default async function salExtension(api) {
             turn_count: runtime.turnCounter,
             total_duration_ms: Math.max(0, Date.now() - runtime.evalStartedAtMs),
         })
-            .then(() => runtime.evalSink.flush())
+            .then(() => evalBestEffort("emergency flush", runtime.evalSink.flush()))
             .catch(() => { });
     };
     process.on("beforeExit", emergencyFlush);
@@ -946,4 +983,4 @@ export default async function salExtension(api) {
         });
     });
 }
-export { SAL_DEFAULT_WEIGHTS, buildToolTracePayload, inferIntent, normalizeExperimentId, resolveSalSidecarDir, resolveStaleCleanupEnabled, };
+export { SAL_DEFAULT_WEIGHTS, buildToolTracePayload, inferIntent, normalizeExperimentId, resolveSalSidecarDir, resolveSalAbEnabled, resolveStaleCleanupEnabled, };

package/dist/extensions/defaults/team/CLAUDE.md

@@ -3,11 +3,15 @@
 > P2 | Parent: ../CLAUDE.md
 
 Member List
-- index.ts: AgentTeam extension entry, /team:/team:spawn/:send/:status/:stop/:terminate/:approve/:mode commands, TEAM_MESSAGE_TYPE renderer
-- team-types.ts: TeammateRole/TeammateMode/TeammateStatus/TeammateIdentity/TeammateMessage/PersistedTeammate/TeamSpawnSpec/TeamSendResult types
+- index.ts: AgentTeam extension entry, /team:/team:spawn/:preset/:send/:status/:progress/:psyche/:dashboard/:stop/:terminate/:approve/:mode commands, TEAM_MESSAGE_TYPE renderer, footer/widget updates
+- team-types.ts: TeammateRole/TeammateMode/TeammateStatus/HarnessState/PsycheWeights/TeammateIdentity/TeammateMessage/PersistedTeammate/TeamSpawnSpec/TeamSendResult types
 - team-state-store.ts: TeamStateStore class - durable teammate persistence via JSON files in <agentDir>/teams/
-- team-parser.ts: Team command parser - parseTeamCommand/buildTeamHelp for /team:* subcommands
-- team-runtime.ts: TeamRuntime class - teammate registry, lifecycle, mailbox + permission + transcript wiring; uses SubAgentRuntime for agent spawning
+- team-parser.ts: Team command parser - parseTeamCommand/buildTeamHelp for /team:* subcommands, preset/progress/psyche/dashboard parsing, --harness spawn flag
+- team-runtime.ts: TeamRuntime class - teammate registry, lifecycle, harness/psyche prompt injection, harness implementer execute default, mailbox + permission + transcript wiring; uses SubAgentRuntime for agent spawning
+- team-psyche.ts: Psyche prompt layer - phase/role/soul weighted Id/Ego/Superego prompt construction
+- team-harness.ts: Harness protocol helpers - harness file defaults, phase instructions, context file selection, feature-list validation, git checkpoint/revert, phase progression
+- team-presets.ts: Preset definitions and executor - solo/duo/squad teammate spawning and optional solo autostart
+- team-dashboard.ts: Text dashboard/status rendering - card layout, psyche/progress bars, footer status summary
 - team-permissions.ts: PermissionStore - pending permission request queue, approve/deny, path allowlists (B.4)
 - team-mailbox.ts: TeamMailbox - typed in-memory append-only message log for leader↔teammate (B.3)
 - team-transcript.ts: TeamTranscriptWriter - per-teammate JSONL transcripts under <storageDir>/transcripts/ (B.7)
@@ -32,9 +36,13 @@ This extension implements the Phase B "true AgentTeam" per the refactor plan:
 | Command | Description |
 |---------|-------------|
 | `/team` | List all teammates |
-| `/team:spawn <role> [--name <id>]` | Create a persistent teammate |
+| `/team:spawn <role> [--name <id>] [--harness]` | Create a persistent teammate |
+| `/team:preset <solo\|duo\|squad> <task>` | Create teammates from a preset |
 | `/team:send <name> <message>` | Send message to a teammate |
 | `/team:status [<name>]` | Show team or teammate status |
+| `/team:progress [<name>]` | Show harness progress |
+| `/team:psyche [<name>]` | Show psyche weights |
+| `/team:dashboard` | Toggle the text dashboard widget |
 | `/team:stop <name>` | Stop teammate's current turn |
 | `/team:terminate <name>` | Destroy a teammate |
 | `/team:approve <request-id>` | Approve a permission request (TODO) |
@@ -46,6 +54,7 @@ This extension implements the Phase B "true AgentTeam" per the refactor plan:
 - `reviewer`: Read-only review/audit
 - `implementer`: Sandboxed write in isolated worktree
 - `planner`: Read-only plan production
+- `verifier`: Read-only strict verification/review
 - `generic`: Read-only by default
 
 ## Modes

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

@@ -1,14 +1,18 @@
 /**
- * [WHO]: AgentTeam extension, registers /team commands for persistent teammates
- * [FROM]: Depends on @pencil-agent/tui, core/extensions/types, ./team-runtime, ./team-parser, ./team-types
+ * [WHO]: AgentTeam extension, registers /team commands for persistent teammates, harness status, psyche status, dashboard widget
+ * [FROM]: Depends on @pencil-agent/tui, core/extensions/types, ./team-runtime, ./team-parser, ./team-types, ./team-harness, ./team-presets, ./team-dashboard
  * [TO]: Consumed by builtin-extensions.ts as default extension
  * [HERE]: extensions/defaults/team/index.ts - AgentTeam extension entry point
  *
  * Commands:
  *   /team                      - List teammates
- *   /team:spawn <role> [--name <id>] - Create teammate
+ *   /team:spawn <role> [--name <id>] [--harness] - Create teammate
+ *   /team:preset <solo|duo|squad> <task> - Create preset team
  *   /team:send <name> <message>      - Send message to teammate
  *   /team:status [<name>]            - Show status
+ *   /team:progress [<name>]          - Show harness progress
+ *   /team:psyche [<name>]            - Show psyche weights
+ *   /team:dashboard                  - Toggle dashboard widget
  *   /team:stop <name>                - Stop teammate turn
  *   /team:terminate <name>           - Destroy teammate
  *   /team:approve <request-id>       - Approve permission request