@pencil-agent/nano-pencil 1.13.9 → 1.13.10

package/dist/build-meta.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.13.9",
-  "commitHash": "593bf56",
+  "version": "1.13.10",
+  "commitHash": "027d681",
   "branch": "main",
-  "builtAt": "2026-04-26T17:04:12.832Z"
+  "builtAt": "2026-04-27T10:15:14.235Z"
 }

package/dist/builtin-extensions.js

@@ -20,6 +20,7 @@ const BUNDLED_PRESENCE_EXTENSION = join(__dirname, "extensions", "defaults", "pr
 const BUNDLED_INTERVIEW_EXTENSION = join(__dirname, "extensions", "defaults", "interview", "index.js");
 const BUNDLED_LOOP_EXTENSION = join(__dirname, "extensions", "defaults", "loop", "index.js");
 const BUNDLED_PLAN_EXTENSION = join(__dirname, "extensions", "defaults", "plan", "index.js");
+const BUNDLED_DIAGNOSTICS_EXTENSION = join(__dirname, "extensions", "defaults", "diagnostics", "index.js");
 const BUNDLED_SAL_EXTENSION = join(__dirname, "extensions", "defaults", "sal", "index.js");
 const BUNDLED_GRUB_EXTENSION = join(__dirname, "extensions", "defaults", "grub", "index.js");
 const BUNDLED_SUBAGENT_EXTENSION = join(__dirname, "extensions", "defaults", "subagent", "index.js");
@@ -68,6 +69,17 @@ function findPackageRoot(startDir) {
  */
 export function getBuiltinExtensionPaths() {
     const paths = [];
+    // === Diagnostics extension (extension-owned issue buffer and reporting) ===
+    // Loaded first so it can subscribe to diagnostic:event before producer
+    // extensions such as SAL publish background failures.
+    if (existsSync(BUNDLED_DIAGNOSTICS_EXTENSION)) {
+        paths.push(BUNDLED_DIAGNOSTICS_EXTENSION);
+    }
+    else {
+        const diagnosticsTs = join(__dirname, "extensions", "defaults", "diagnostics", "index.ts");
+        if (existsSync(diagnosticsTs))
+            paths.push(diagnosticsTs);
+    }
     // === SAL extension (Structural Anchor Localization, default-on, experimental) ===
     // Loaded ahead of NanoMem because turn-context producers must publish before
     // turn-context consumers read. SAL is a producer of structuralAnchor; NanoMem

package/dist/core/runtime/pencil-agent.d.ts

@@ -6,6 +6,7 @@
  */
 import { type SDKLogger } from "./sdk.js";
 import { type AgentSessionEvent } from "./agent-session.js";
+import type { Api } from "@pencil-agent/ai";
 import type { ThinkingLevel } from "@pencil-agent/agent-core";
 /**
  * Simplified options for PencilAgent wrapper.
@@ -13,10 +14,21 @@ import type { ThinkingLevel } from "@pencil-agent/agent-core";
 export interface PencilAgentOptions {
     /** API key for the provider. If omitted, uses environment variable. */
     apiKey?: string;
-    /** Provider name: 'anthropic', 'openai', 'google', etc. */
+    /** Provider name: 'anthropic', 'openai', 'google', or any custom provider in models.json. */
     provider?: string;
     /** Model ID: 'claude-4-5-20250920', 'gpt-4o', etc. */
     model?: string;
+    /**
+     * Optional base URL when registering a custom provider on the fly.
+     * Required when `provider` + `model` is not already defined in
+     * ~/.nanopencil/agent/models.json. Ignored when the model is found.
+     */
+    baseUrl?: string;
+    /**
+     * Optional API protocol for the dynamically-registered provider.
+     * Defaults to "openai-completions". Ignored when the model is found.
+     */
+    api?: Api;
     /** Thinking level: 'off' | 'low' | 'medium' | 'high' */
     thinkingLevel?: ThinkingLevel;
     /** Working directory. Default: process.cwd() */
@@ -69,6 +81,21 @@ export declare class PencilAgent {
      * Must be called before run/chat.
      */
     init(): Promise<void>;
+    /**
+     * Resolve constructor-provided provider/model into a Model<any>.
+     *
+     * Lookup order:
+     *   1. Existing entry in modelRegistry (e.g. ~/.nanopencil/agent/models.json
+     *      already declares this provider/model — common case for users who ran
+     *      /sal:setup or hand-edited models.json).
+     *   2. Dynamic registration when caller supplied baseUrl + apiKey — lets a
+     *      one-line constructor call wire up a brand-new OpenAI-compatible
+     *      endpoint without touching disk.
+     *   3. Otherwise return undefined and let createAgentSession fall back to
+     *      findInitialModel() (built-in default). The logger surfaces a warning
+     *      in this case so the caller knows their args were not honoured.
+     */
+    private resolveRequestedModel;
     /**
      * Handle session events - collects text for run()
      */

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

@@ -63,6 +63,10 @@ export class PencilAgent {
                 key: this.options.apiKey,
             });
         }
+        // Resolve user-specified provider/model into a Model<any> for createAgentSession.
+        // Without this, createAgentSession falls back to findInitialModel() which
+        // picks the first available built-in — silently ignoring constructor args.
+        const resolvedModel = this.resolveRequestedModel(modelRegistry);
         // Resolve tools
         let tools = undefined;
         if (this.options.tools && this.options.tools.length > 0) {
@@ -73,6 +77,7 @@ export class PencilAgent {
         // Create session
         this.sessionResult = await createAgentSession({
             cwd: this.cwd,
+            model: resolvedModel,
             thinkingLevel: this.options.thinkingLevel,
             tools,
             authStorage,
@@ -94,6 +99,57 @@ export class PencilAgent {
         this.session.subscribe(this.handleEvent.bind(this));
         this.initialized = true;
     }
+    /**
+     * Resolve constructor-provided provider/model into a Model<any>.
+     *
+     * Lookup order:
+     *   1. Existing entry in modelRegistry (e.g. ~/.nanopencil/agent/models.json
+     *      already declares this provider/model — common case for users who ran
+     *      /sal:setup or hand-edited models.json).
+     *   2. Dynamic registration when caller supplied baseUrl + apiKey — lets a
+     *      one-line constructor call wire up a brand-new OpenAI-compatible
+     *      endpoint without touching disk.
+     *   3. Otherwise return undefined and let createAgentSession fall back to
+     *      findInitialModel() (built-in default). The logger surfaces a warning
+     *      in this case so the caller knows their args were not honoured.
+     */
+    resolveRequestedModel(registry) {
+        const provider = this.options.provider;
+        const modelId = this.options.model;
+        if (!provider || !modelId)
+            return undefined;
+        const existing = registry.find(provider, modelId);
+        if (existing)
+            return existing;
+        if (this.options.baseUrl) {
+            try {
+                registry.registerProvider(provider, {
+                    api: this.options.api ?? "openai-completions",
+                    baseUrl: this.options.baseUrl,
+                    apiKey: this.options.apiKey,
+                    models: [{
+                            id: modelId,
+                            name: modelId,
+                            reasoning: false,
+                            input: ["text"],
+                            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                            contextWindow: 128_000,
+                            maxTokens: 8192,
+                        }],
+                });
+                const registered = registry.find(provider, modelId);
+                if (registered)
+                    return registered;
+            }
+            catch (err) {
+                this.logger.warn(`[PencilAgent] dynamic provider registration failed for ${provider}/${modelId}: ${err.message}`);
+            }
+        }
+        this.logger.warn(`[PencilAgent] model ${provider}/${modelId} not found in registry. ` +
+            `Either add it to ~/.nanopencil/agent/models.json or pass { baseUrl, apiKey } to register it dynamically. ` +
+            `Falling back to default model selection.`);
+        return undefined;
+    }
     /**
      * Handle session events - collects text for run()
      */

package/dist/extensions/defaults/AGENT.md

@@ -3,6 +3,11 @@
 > P2 | Parent: ../AGENT.md
 
 Member List
+diagnostics/index.ts: Diagnostics extension entry, subscribes to diagnostic:event, buffers session-local diagnostic records, prompts only after threshold at agent_end, registers /report-issue
+diagnostics/types.ts: Diagnostic event/report type contract and diagnostic:event channel name
+diagnostics/diagnostic-buffer.ts: DiagnosticBuffer, event coercion, fingerprint dedupe, prompt gating
+diagnostics/reporter.ts: User-approved InsForge pencil_issue_events reporter, configured via NANOPENCIL_ISSUE_* env vars
+diagnostics/redaction.ts: Diagnostic message normalization and secret/path redaction helpers
 link-world/index.ts: Internet access extension, provides internet-search Skill after setup
 mcp/index.ts: MCP protocol integration extension, MCP guidance resources
 presence/index.ts: AI-driven opening + idle presence lines, uses NanoMemEngine episodes/preferences/lessons + git/cwd snapshot, injects latest line into agent systemPrompt every turn for main-conversation perception, 30s debounce + idle in-flight lock, configurable via settings.presence.enabled, PRESENCE_MESSAGE_TYPE renderer
@@ -37,12 +42,12 @@ 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-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/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; publishes SAL eval background failures to diagnostic:event; 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/types.ts: EvalSink interface, EvalEventEnvelope/EvalEventType (run_start/run_end/turn_anchor), EvalAdapterId ("insforge"|"jsonl"|"noop"), CreateEvalSinkOptions with optional onDiagnostic callback, 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) 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

package/dist/extensions/defaults/diagnostics/diagnostic-buffer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * [WHO]: DiagnosticBuffer, coerceDiagnosticEvent()
+ * [FROM]: Depends on ./types.js and ./redaction.js for event schema and privacy normalization
+ * [TO]: Consumed by extensions/defaults/diagnostics/index.ts
+ * [HERE]: extensions/defaults/diagnostics/diagnostic-buffer.ts - session-local dedupe and prompt gating state
+ */
+import { type DiagnosticEvent, type DiagnosticRecord } from "./types.js";
+export declare class DiagnosticBuffer {
+    private records;
+    add(event: DiagnosticEvent): DiagnosticRecord;
+    all(): DiagnosticRecord[];
+    last(): DiagnosticRecord | undefined;
+    findPromptCandidate(): DiagnosticRecord | undefined;
+    findUnreported(): DiagnosticRecord[];
+    markPrompted(fingerprint: string): void;
+    markReported(fingerprint: string): void;
+    private trim;
+}
+export declare function coerceDiagnosticEvent(value: unknown): DiagnosticEvent | undefined;

package/dist/extensions/defaults/diagnostics/diagnostic-buffer.js

@@ -0,0 +1,125 @@
+/**
+ * [WHO]: DiagnosticBuffer, coerceDiagnosticEvent()
+ * [FROM]: Depends on ./types.js and ./redaction.js for event schema and privacy normalization
+ * [TO]: Consumed by extensions/defaults/diagnostics/index.ts
+ * [HERE]: extensions/defaults/diagnostics/diagnostic-buffer.ts - session-local dedupe and prompt gating state
+ */
+import { normalizeDiagnosticMessage, sanitizeDiagnosticValue } from "./redaction.js";
+const MAX_RECORDS = 100;
+export class DiagnosticBuffer {
+    records = new Map();
+    add(event) {
+        const now = event.created_at ?? new Date().toISOString();
+        const sanitized = {
+            source: event.source,
+            severity: event.severity,
+            category: event.category,
+            message: normalizeDiagnosticMessage(event.message),
+            detail: sanitizeDiagnosticValue(event.detail),
+            context: sanitizeDiagnosticValue(event.context),
+            created_at: now,
+        };
+        const fingerprint = event.fingerprint ?? buildFingerprint(sanitized);
+        const existing = this.records.get(fingerprint);
+        if (existing) {
+            existing.last_seen_at = now;
+            existing.occurrence_count += 1;
+            existing.severity = maxSeverity(existing.severity, sanitized.severity);
+            existing.detail = sanitized.detail;
+            existing.context = { ...(existing.context ?? {}), ...(sanitized.context ?? {}) };
+            // New occurrences invalidate a prior auto-report so the next
+            // agent_end batch uploads the updated count.
+            existing.reported = false;
+            return existing;
+        }
+        const record = {
+            ...sanitized,
+            fingerprint,
+            first_seen_at: now,
+            last_seen_at: now,
+            occurrence_count: 1,
+            prompted: false,
+            reported: false,
+        };
+        this.records.set(fingerprint, record);
+        this.trim();
+        return record;
+    }
+    all() {
+        return Array.from(this.records.values()).sort((a, b) => b.last_seen_at.localeCompare(a.last_seen_at));
+    }
+    last() {
+        return this.all()[0];
+    }
+    findPromptCandidate() {
+        return this.all().find((record) => !record.prompted && shouldPrompt(record));
+    }
+    findUnreported() {
+        return this.all().filter((record) => !record.reported);
+    }
+    markPrompted(fingerprint) {
+        const record = this.records.get(fingerprint);
+        if (record)
+            record.prompted = true;
+    }
+    markReported(fingerprint) {
+        const record = this.records.get(fingerprint);
+        if (record)
+            record.reported = true;
+    }
+    trim() {
+        if (this.records.size <= MAX_RECORDS)
+            return;
+        const sorted = this.all();
+        for (const record of sorted.slice(MAX_RECORDS)) {
+            this.records.delete(record.fingerprint);
+        }
+    }
+}
+export function coerceDiagnosticEvent(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const input = value;
+    const source = typeof input.source === "string" ? input.source : undefined;
+    const severity = isSeverity(input.severity) ? input.severity : undefined;
+    const category = isCategory(input.category) ? input.category : "unknown";
+    const message = typeof input.message === "string" ? input.message : undefined;
+    if (!source || !severity || !message)
+        return undefined;
+    return {
+        source,
+        severity,
+        category,
+        message,
+        detail: input.detail,
+        fingerprint: typeof input.fingerprint === "string" ? input.fingerprint : undefined,
+        context: input.context && typeof input.context === "object" ? input.context : undefined,
+        created_at: typeof input.created_at === "string" ? input.created_at : undefined,
+    };
+}
+function shouldPrompt(record) {
+    if (record.severity === "error")
+        return record.occurrence_count >= 3;
+    if (record.severity === "warning")
+        return record.occurrence_count >= 5 || record.category === "fallback";
+    return false;
+}
+function buildFingerprint(event) {
+    return `${event.source}:${event.category}:${normalizeDiagnosticMessage(event.message).toLowerCase()}`;
+}
+function isSeverity(value) {
+    return value === "debug" || value === "info" || value === "warning" || value === "error";
+}
+function isCategory(value) {
+    return (value === "network" ||
+        value === "fallback" ||
+        value === "persistence" ||
+        value === "config" ||
+        value === "extension_timeout" ||
+        value === "schema" ||
+        value === "unknown");
+}
+function maxSeverity(a, b) {
+    const rank = { debug: 0, info: 1, warning: 2, error: 3 };
+    return rank[b] > rank[a] ? b : a;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * [WHO]: diagnosticsExtension - diagnostic:event listener, /report-issue command, silent auto-upload on agent_end
+ * [FROM]: Depends on core/extensions/types, @pencil-agent/tui, ./diagnostic-buffer, ./reporter, ./types
+ * [TO]: Auto-loaded by builtin-extensions.ts as a default extension before diagnostic producers
+ * [HERE]: extensions/defaults/diagnostics/index.ts - extension-owned diagnostic buffer; background failures auto-upload silently at agent_end, /report-issue stays for explicit user-initiated bundles
+ */
+import type { ExtensionAPI } from "../../../core/extensions/types.js";
+export default function diagnosticsExtension(api: ExtensionAPI): Promise<void>;

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

@@ -0,0 +1,101 @@
+/**
+ * [WHO]: diagnosticsExtension - diagnostic:event listener, /report-issue command, silent auto-upload on agent_end
+ * [FROM]: Depends on core/extensions/types, @pencil-agent/tui, ./diagnostic-buffer, ./reporter, ./types
+ * [TO]: Auto-loaded by builtin-extensions.ts as a default extension before diagnostic producers
+ * [HERE]: extensions/defaults/diagnostics/index.ts - extension-owned diagnostic buffer; background failures auto-upload silently at agent_end, /report-issue stays for explicit user-initiated bundles
+ */
+import { Box, Container, Spacer, Text } from "@pencil-agent/tui";
+import { subscribeDiagnostics } from "../../../utils/diagnostics.js";
+import { coerceDiagnosticEvent, DiagnosticBuffer } from "./diagnostic-buffer.js";
+import { reportDiagnostics } from "./reporter.js";
+import { DIAGNOSTIC_EVENT_CHANNEL } from "./types.js";
+const MESSAGE_TYPE = "diagnostics";
+export default async function diagnosticsExtension(api) {
+    const buffer = new DiagnosticBuffer();
+    api.registerMessageRenderer(MESSAGE_TYPE, (message, _options, theme) => {
+        const text = typeof message.content === "string" ? message.content : JSON.stringify(message.content, null, 2);
+        const box = new Box(1, 1, (v) => theme.bg("customMessageBg", v));
+        box.addChild(new Text(theme.fg("dim", text), 0, 0));
+        const container = new Container();
+        container.addChild(new Spacer(1));
+        container.addChild(box);
+        return container;
+    });
+    // Legacy path: producers that still call api.events.emit("diagnostic:event", ...)
+    api.events.on(DIAGNOSTIC_EVENT_CHANNEL, (payload) => {
+        const event = coerceDiagnosticEvent(payload);
+        if (!event)
+            return;
+        buffer.add(event);
+    });
+    // Canonical path: producers (including deep utilities without api access)
+    // using utils/diagnostics.ts → reportDiagnostic(...). The shared Symbol.for
+    // slot also relays mem-core (separate package) events here.
+    subscribeDiagnostics((event) => {
+        const coerced = coerceDiagnosticEvent(event);
+        if (coerced)
+            buffer.add(coerced);
+    });
+    api.on("agent_end", async (_event, ctx) => {
+        // Background subsystem failures (SAL eval, mem-core, presence, etc.)
+        // auto-upload silently — they did not interrupt the user, so prompting
+        // for permission would be reverse-value. /report-issue stays available
+        // for the user to bundle records manually (info/debug included).
+        const unreported = buffer.findUnreported();
+        if (unreported.length === 0)
+            return;
+        // pencil_issue_events is for actionable issues. info/debug telemetry
+        // (e.g. Soul evolution success notes) shows up in dev console via the
+        // bus but should not pollute the issue table. Mark them reported so
+        // they don't accumulate forever.
+        const uploadable = unreported.filter((r) => r.severity === "warning" || r.severity === "error");
+        const skipped = unreported.filter((r) => r.severity !== "warning" && r.severity !== "error");
+        for (const record of skipped)
+            buffer.markReported(record.fingerprint);
+        if (uploadable.length === 0)
+            return;
+        const result = await reportDiagnostics(uploadable, undefined, ctx);
+        // Mark reported when the upload landed OR when the reporter has no
+        // endpoint configured (no point re-trying every turn against missing
+        // config). Transient HTTP/network failures stay unreported and will
+        // retry on the next agent_end.
+        if (result.ok || !result.configured) {
+            for (const record of uploadable)
+                buffer.markReported(record.fingerprint);
+        }
+    });
+    api.registerCommand("report-issue", {
+        description: "Report recent diagnostics (/report-issue [last|all|note])",
+        handler: (args, ctx) => handleReportIssue(args, ctx, buffer),
+    });
+}
+async function handleReportIssue(args, ctx, buffer) {
+    const trimmed = args.trim();
+    const records = selectRecords(trimmed, buffer);
+    if (records.length === 0) {
+        ctx.ui.notify("No diagnostics recorded in this session.", "info");
+        return;
+    }
+    const userNote = trimmed && trimmed !== "last" && trimmed !== "all" ? stripQuotes(trimmed) : undefined;
+    const result = await reportDiagnostics(records, userNote, ctx);
+    ctx.ui.notify(result.message, result.ok ? "info" : "warning");
+    if (result.ok) {
+        ctx.ui.setStatus("diagnostics", undefined);
+    }
+}
+function selectRecords(args, buffer) {
+    if (args === "all")
+        return buffer.all();
+    if (args === "last") {
+        const last = buffer.last();
+        return last ? [last] : [];
+    }
+    const all = buffer.all();
+    return all.length > 0 ? all.slice(0, 5) : [];
+}
+function stripQuotes(value) {
+    if ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}

package/dist/extensions/defaults/diagnostics/redaction.d.ts

@@ -0,0 +1,8 @@
+/**
+ * [WHO]: sanitizeDiagnosticValue(), normalizeDiagnosticMessage()
+ * [FROM]: No external dependencies
+ * [TO]: Consumed by diagnostic-buffer.ts and reporter.ts before local persistence or network upload
+ * [HERE]: extensions/defaults/diagnostics/redaction.ts - privacy-preserving diagnostic normalization
+ */
+export declare function normalizeDiagnosticMessage(message: string): string;
+export declare function sanitizeDiagnosticValue(value: unknown, depth?: number): unknown;

package/dist/extensions/defaults/diagnostics/redaction.js

@@ -0,0 +1,45 @@
+/**
+ * [WHO]: sanitizeDiagnosticValue(), normalizeDiagnosticMessage()
+ * [FROM]: No external dependencies
+ * [TO]: Consumed by diagnostic-buffer.ts and reporter.ts before local persistence or network upload
+ * [HERE]: extensions/defaults/diagnostics/redaction.ts - privacy-preserving diagnostic normalization
+ */
+const SECRET_KEY_PATTERN = /(api[_-]?key|authorization|token|secret|password|credential|cookie)/i;
+const SECRET_VALUE_PATTERN = /\b(?:sk|ik|pk|ak|xox[baprs]?|gh[pousr])_[A-Za-z0-9_-]{8,}\b/g;
+const BEARER_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi;
+const HOME_PATH_PATTERN = /\/(?:Users|home|root)\/[^\s"',:)]+/g;
+export function normalizeDiagnosticMessage(message) {
+    return sanitizeString(message)
+        .replace(/\b[0-9a-f]{8}-[0-9a-f-]{27,}\b/gi, "<uuid>")
+        .replace(/\b\d{4}-\d{2}-\d{2}T[\d:.]+Z\b/g, "<timestamp>")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function sanitizeDiagnosticValue(value, depth = 0) {
+    if (depth > 5)
+        return "[MaxDepth]";
+    if (typeof value === "string")
+        return sanitizeString(value);
+    if (typeof value === "number" || typeof value === "boolean" || value == null)
+        return value;
+    if (Array.isArray(value))
+        return value.slice(0, 20).map((item) => sanitizeDiagnosticValue(item, depth + 1));
+    if (typeof value !== "object")
+        return String(value);
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (SECRET_KEY_PATTERN.test(key)) {
+            out[key] = "[Redacted]";
+            continue;
+        }
+        out[key] = sanitizeDiagnosticValue(item, depth + 1);
+    }
+    return out;
+}
+function sanitizeString(value) {
+    return value
+        .replace(BEARER_PATTERN, "Bearer [Redacted]")
+        .replace(SECRET_VALUE_PATTERN, "[Redacted]")
+        .replace(HOME_PATH_PATTERN, "<path>")
+        .slice(0, 2000);
+}

package/dist/extensions/defaults/diagnostics/reporter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * [WHO]: reportDiagnostics(), buildReportPayload()
+ * [FROM]: Depends on node:http, node:https, node:fs, node:os, node:path, node:crypto, core extension context types, ./types.js, ./redaction.js
+ * [TO]: Consumed by extensions/defaults/diagnostics/index.ts for silent auto-upload + /report-issue manual bundles
+ * [HERE]: extensions/defaults/diagnostics/reporter.ts - InsForge pencil_issue_events adapter; reads NANOPENCIL_ISSUE_* env first, falls back to <workspace>/.memory-experiments/credentials.json then ~/.memory-experiments/credentials.json (shared with SAL eval) so issue reporting "just works" once SAL is set up
+ */
+import type { ExtensionContext } from "../../../core/extensions/types.js";
+import type { DiagnosticRecord, DiagnosticReportPayload } from "./types.js";
+interface ReportResult {
+    ok: boolean;
+    configured: boolean;
+    statusCode?: number;
+    message: string;
+}
+export declare function reportDiagnostics(records: DiagnosticRecord[], userNote: string | undefined, ctx: ExtensionContext): Promise<ReportResult>;
+export declare function buildReportPayload(records: DiagnosticRecord[], userNote: string | undefined, ctx: ExtensionContext): DiagnosticReportPayload;
+export {};