@pencil-agent/nano-pencil 1.13.10 → 1.13.12

package/README.md

@@ -104,7 +104,7 @@ Built-in tools include:
 ### 🌐 Multi-Model Support
 Use the best model for each task.
 
-- 🇨🇳 **Alibaba DashScope** — Qwen series (optimized for coding)
+- 🇨🇳 **Alibaba DashScope / Token Plan** — Qwen, GLM, MiniMax, DeepSeek text models
 - 🤖 **OpenAI** — GPT-4, GPT-3.5
 - 💬 **Anthropic** — Claude 3 Opus/Sonnet/Haiku
 - 🔍 **Google** — Gemini Pro/Ultra

package/dist/build-meta.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.13.10",
-  "commitHash": "027d681",
+  "version": "1.13.12",
+  "commitHash": "6398d50",
   "branch": "main",
-  "builtAt": "2026-04-27T10:15:14.235Z"
+  "builtAt": "2026-05-02T10:48:42.017Z"
 }

package/dist/builtin-extensions.js

@@ -14,6 +14,7 @@ const require = createRequire(import.meta.url);
 const BUNDLED_NANOMEM_EXTENSION_PACKAGES = join(__dirname, "packages", "mem-core", "extension.js");
 const BUNDLED_SIMPLIFY_EXTENSION = join(__dirname, "extensions", "optional", "simplify", "index.js");
 const BUNDLED_LINK_WORLD_EXTENSION = join(__dirname, "extensions", "defaults", "link-world", "index.js");
+const BUNDLED_BROWSER_EXTENSION = join(__dirname, "extensions", "defaults", "browser", "index.js");
 const BUNDLED_SECURITY_AUDIT_EXTENSION = join(__dirname, "extensions", "defaults", "security-audit", "index.js");
 const BUNDLED_SOUL_EXTENSION = join(__dirname, "extensions", "defaults", "soul", "index.js");
 const BUNDLED_PRESENCE_EXTENSION = join(__dirname, "extensions", "defaults", "presence", "index.js");
@@ -142,6 +143,15 @@ export function getBuiltinExtensionPaths() {
         if (existsSync(linkWorldTs))
             paths.push(linkWorldTs);
     }
+    // === Browser Harness extension (built-in CDP browser automation) ===
+    if (existsSync(BUNDLED_BROWSER_EXTENSION)) {
+        paths.push(BUNDLED_BROWSER_EXTENSION);
+    }
+    else {
+        const browserTs = join(__dirname, "extensions", "defaults", "browser", "index.ts");
+        if (existsSync(browserTs))
+            paths.push(browserTs);
+    }
     // === Security Audit extension (built-in source, compiled to dist/extensions/defaults/security-audit) ===
     if (existsSync(BUNDLED_SECURITY_AUDIT_EXTENSION)) {
         paths.push(BUNDLED_SECURITY_AUDIT_EXTENSION);

package/dist/core/extensions/runner.d.ts

@@ -69,6 +69,7 @@ export declare class ExtensionRunner {
     private errorListeners;
     private getModel;
     private completeSimpleFn;
+    private completeJsonFn;
     private isIdleFn;
     private waitForIdleFn;
     private abortFn;

package/dist/core/extensions/runner.js

@@ -87,6 +87,7 @@ export class ExtensionRunner {
     errorListeners = new Set();
     getModel = () => undefined;
     completeSimpleFn = async () => undefined;
+    completeJsonFn;
     isIdleFn = () => true;
     waitForIdleFn = async () => { };
     abortFn = () => { };
@@ -159,6 +160,7 @@ export class ExtensionRunner {
         // Context actions (required)
         this.getModel = contextActions.getModel;
         this.completeSimpleFn = contextActions.completeSimple;
+        this.completeJsonFn = contextActions.completeJson;
         this.isIdleFn = contextActions.isIdle;
         this.runtime.isIdle = () => this.isIdleFn();
         this.abortFn = contextActions.abort;
@@ -393,6 +395,9 @@ export class ExtensionRunner {
                 return getModel();
             },
             completeSimple: (systemPrompt, userMessage) => this.completeSimpleFn(systemPrompt, userMessage),
+            completeJson: this.completeJsonFn
+                ? (systemPrompt, userMessage, schema, options) => this.completeJsonFn(systemPrompt, userMessage, schema, options)
+                : undefined,
             isIdle: () => this.isIdleFn(),
             abort: () => this.abortFn(),
             hasPendingMessages: () => this.hasPendingMessagesFn(),

package/dist/core/extensions/types.d.ts

@@ -190,6 +190,11 @@ export interface ExtensionContext {
     model: Model<any> | undefined;
     /** One-shot LLM completion with current model (e.g. for memory extraction). Undefined when no model or no API key. */
     completeSimple(systemPrompt: string, userMessage: string): Promise<string | undefined>;
+    /** One-shot structured JSON completion with current model. Uses provider tool-calling when available. */
+    completeJson?(systemPrompt: string, userMessage: string, schema: Record<string, unknown>, options?: {
+        toolName?: string;
+        resultKey?: string;
+    }): Promise<string | undefined>;
     /** Whether the agent is idle (not streaming) */
     isIdle(): boolean;
     /** Abort the current agent operation */
@@ -937,6 +942,11 @@ export interface ExtensionContextActions {
     getModel: () => Model<any> | undefined;
     /** One-shot completion with current model for extensions (e.g. memory extraction). Returns undefined if no model or no API key. */
     completeSimple: (systemPrompt: string, userMessage: string) => Promise<string | undefined>;
+    /** One-shot structured JSON completion with current model. Returns undefined if no model, no API key, or no structured payload. */
+    completeJson?: (systemPrompt: string, userMessage: string, schema: Record<string, unknown>, options?: {
+        toolName?: string;
+        resultKey?: string;
+    }) => Promise<string | undefined>;
     isIdle: () => boolean;
     abort: () => void;
     hasPendingMessages: () => boolean;

package/dist/core/model-resolver.js

@@ -28,6 +28,8 @@ export const defaultModelPerProvider = {
     opencode: "claude-opus-4-6",
     "opencode-go": "claude-opus-4-6",
     "kimi-coding": "kimi-k2-thinking",
+    "ali-token-plan-openai": "qwen3.6-plus",
+    "ali-token-plan-anthropic": "qwen3.6-plus",
 };
 /**
  * Helper to check if a model ID looks like an alias (no date suffix)

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

@@ -151,6 +151,7 @@ export declare class AgentSession {
     readonly settingsManager: SettingsManager;
     private _scopedModels;
     private _unsubscribeAgent?;
+    private _detachExternalAbort?;
     private _eventListeners;
     /** Tracks pending steering messages for UI display. Removed when delivered. */
     private _steeringMessages;

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

@@ -10,6 +10,21 @@ import { completeSimple, isContextOverflow, modelsAreEqual, resetApiProviders, s
 import { getDocsPath } from "../../config.js";
 import { theme } from "../../modes/interactive/theme/theme.js";
 import { stripFrontmatter } from "../../utils/frontmatter.js";
+function getStructuredToolChoice(model, toolName) {
+    switch (model.api) {
+        case "openai-completions":
+            return { type: "function", function: { name: toolName } };
+        case "anthropic-messages":
+        case "bedrock-converse-stream":
+            return { type: "tool", name: toolName };
+        case "google-generative-ai":
+        case "google-gemini-cli":
+        case "google-vertex":
+            return "any";
+        default:
+            return "required";
+    }
+}
 /**
  * Custom error for model cycling with additional context.
  */
@@ -86,6 +101,7 @@ export class AgentSession {
     _scopedModels;
     // Event subscription state
     _unsubscribeAgent;
+    _detachExternalAbort;
     _eventListeners = [];
     /** Tracks pending steering messages for UI display. Removed when delivered. */
     _steeringMessages = [];
@@ -155,11 +171,16 @@ export class AgentSession {
         // Always subscribe to agent events for internal handling
         // (session persistence, extensions, auto-compaction, retry logic)
         this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
-        // Listen to external abort signal (e.g., from SubAgent runtime)
+        // Listen to external abort signal (e.g., from SubAgent runtime).
+        // Track the handler and remove it on dispose so a long-lived parent
+        // signal that spawns many short-lived AgentSessions does not accumulate
+        // listeners (Node fires MaxListenersExceededWarning at 11).
         if (config.signal) {
-            config.signal.addEventListener("abort", () => {
-                this.abort();
-            });
+            const externalAbortHandler = () => { this.abort(); };
+            config.signal.addEventListener("abort", externalAbortHandler, { once: true });
+            this._detachExternalAbort = () => {
+                config.signal?.removeEventListener("abort", externalAbortHandler);
+            };
         }
         this._buildRuntime({
             activeToolNames: this._initialActiveToolNames,
@@ -558,6 +579,10 @@ export class AgentSession {
         this._disconnectFromAgent();
         this._extensionRunner?.dispose();
         this._eventListeners = [];
+        if (this._detachExternalAbort) {
+            this._detachExternalAbort();
+            this._detachExternalAbort = undefined;
+        }
     }
     // =========================================================================
     // Read-only State Access
@@ -1939,6 +1964,45 @@ export class AgentSession {
                     return undefined;
                 }
             },
+            completeJson: async (systemPrompt, userMessage, schema, options) => {
+                const model = this.model;
+                if (!model)
+                    return undefined;
+                const apiKey = await this.modelRegistry.getApiKey(model);
+                if (!apiKey)
+                    return undefined;
+                const toolName = options?.toolName || "submit_json";
+                try {
+                    const response = await completeSimple(model, {
+                        systemPrompt: `${systemPrompt}\n\nYou must call the ${toolName} tool exactly once with the final structured JSON payload. Do not answer in prose.`,
+                        messages: [
+                            { role: "user", content: userMessage, timestamp: Date.now() },
+                        ],
+                        tools: [
+                            {
+                                name: toolName,
+                                description: "Submit the final structured JSON payload.",
+                                parameters: schema,
+                            },
+                        ],
+                    }, {
+                        maxTokens: 1500,
+                        temperature: 0,
+                        apiKey,
+                        toolChoice: getStructuredToolChoice(model, toolName),
+                    });
+                    const toolCall = response.content?.find((b) => b.type === "toolCall" && b.name === toolName);
+                    if (!toolCall)
+                        return undefined;
+                    const payload = options?.resultKey
+                        ? toolCall.arguments?.[options.resultKey]
+                        : toolCall.arguments;
+                    return JSON.stringify(payload);
+                }
+                catch {
+                    return undefined;
+                }
+            },
             getSettings: () => this.settingsManager.getSettings(),
             isIdle: () => !this.isStreaming,
             abort: () => this.abort(),

package/dist/core/tools/bash.d.ts

@@ -56,6 +56,8 @@ export interface BashSandboxOptions {
     additionalBlockedPatterns?: RegExp[];
     /** Custom error message for blocked commands */
     blockedMessage?: string;
+    /** Optional path allowlist hook for simple write commands. Defaults to denying all writes. */
+    allowWritePath?: (absolutePath: string) => boolean;
 }
 /**
  * Create a sandboxed bash hook that blocks dangerous write operations.

package/dist/core/tools/bash.js

@@ -7,7 +7,7 @@
 import { randomBytes } from "node:crypto";
 import { createWriteStream, existsSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { isAbsolute, join, resolve } from "node:path";
 import { Type } from "@sinclair/typebox";
 import { spawn } from "child_process";
 import { getShellConfig, getShellEnv, killProcessTree } from "../utils/shell.js";
@@ -284,6 +284,23 @@ export function createSandboxHook(options) {
     const blockedMessage = options?.blockedMessage ?? "Write operations are not allowed in sandbox mode";
     return (context) => {
         const command = context.command.trim();
+        const writePaths = extractSimpleWritePaths(command, context.cwd);
+        if (writePaths === null) {
+            return {
+                ...context,
+                command: `echo "${blockedMessage}" >&2; exit 1`,
+            };
+        }
+        if (writePaths.length > 0) {
+            const allAllowed = writePaths.every((path) => options?.allowWritePath?.(path) === true);
+            if (!allAllowed) {
+                return {
+                    ...context,
+                    command: `echo "${blockedMessage}" >&2; exit 1`,
+                };
+            }
+            return context;
+        }
         // Check if command contains any blocked patterns
         for (const pattern of blockedPatterns) {
             if (pattern.test(command)) {
@@ -296,3 +313,103 @@ export function createSandboxHook(options) {
         return context;
     };
 }
+function extractSimpleWritePaths(command, cwd) {
+    if (/[;&|`$()]/.test(command))
+        return null;
+    const tokens = tokenizeSimpleShell(command);
+    if (tokens.length === 0)
+        return [];
+    const paths = [];
+    for (let index = 0; index < tokens.length; index++) {
+        const token = tokens[index];
+        if (token === ">" || token === ">>" || /^&?\d?>&?\d?$/.test(token)) {
+            const next = tokens[index + 1];
+            if (!next)
+                return null;
+            paths.push(resolveSandboxPath(next, cwd));
+            index++;
+            continue;
+        }
+        const redirectMatch = /^(?:\d?>|>>)(.+)$/.exec(token);
+        if (redirectMatch?.[1]) {
+            paths.push(resolveSandboxPath(redirectMatch[1], cwd));
+            continue;
+        }
+    }
+    const cmd = tokens[0];
+    if (cmd === "mkdir") {
+        const targets = tokens.slice(1).filter((token) => !token.startsWith("-"));
+        if (targets.length === 0)
+            return null;
+        paths.push(...targets.map((target) => resolveSandboxPath(target, cwd)));
+    }
+    else if (cmd === "cp" || cmd === "mv") {
+        const operands = tokens.slice(1).filter((token) => !token.startsWith("-"));
+        if (operands.length < 2)
+            return null;
+        paths.push(resolveSandboxPath(operands[operands.length - 1], cwd));
+    }
+    else if (cmd === "rm") {
+        const targets = tokens.slice(1).filter((token) => !token.startsWith("-"));
+        if (targets.length === 0)
+            return null;
+        paths.push(...targets.map((target) => resolveSandboxPath(target, cwd)));
+    }
+    else if (cmd === "tee") {
+        const targets = tokens.slice(1).filter((token) => !token.startsWith("-"));
+        if (targets.length === 0)
+            return null;
+        paths.push(...targets.map((target) => resolveSandboxPath(target, cwd)));
+    }
+    else if (cmd === "touch") {
+        const targets = tokens.slice(1).filter((token) => !token.startsWith("-"));
+        if (targets.length === 0)
+            return null;
+        paths.push(...targets.map((target) => resolveSandboxPath(target, cwd)));
+    }
+    return paths;
+}
+function tokenizeSimpleShell(command) {
+    const tokens = [];
+    let current = "";
+    let quote;
+    let escaped = false;
+    for (const ch of command) {
+        if (escaped) {
+            current += ch;
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (ch === quote) {
+                quote = undefined;
+            }
+            else {
+                current += ch;
+            }
+            continue;
+        }
+        if (ch === "'" || ch === "\"") {
+            quote = ch;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += ch;
+    }
+    if (current)
+        tokens.push(current);
+    return tokens;
+}
+function resolveSandboxPath(path, cwd) {
+    return resolve(isAbsolute(path) ? path : join(cwd, path));
+}

package/dist/core/tools/edit.d.ts

@@ -33,6 +33,8 @@ export interface EditOperations {
 export interface EditToolOptions {
     /** Custom operations for file editing. Default: local filesystem */
     operations?: EditOperations;
+    /** Optional guard called with the resolved absolute path before writing. */
+    beforeWrite?: (absolutePath: string) => void | Promise<void>;
 }
 export declare function createEditTool(cwd: string, options?: EditToolOptions): AgentTool<typeof editSchema>;
 /** Default edit tool using process.cwd() - for backwards compatibility */

package/dist/core/tools/edit.js

@@ -22,6 +22,7 @@ export function createEditTool(cwd, options) {
         parameters: editSchema,
         execute: async (_toolCallId, { path, oldText, newText }, signal) => {
             const absolutePath = resolveToCwd(path, cwd);
+            await options?.beforeWrite?.(absolutePath);
             return new Promise((resolve, reject) => {
                 // Check if already aborted
                 if (signal?.aborted) {

package/dist/core/tools/index.d.ts

@@ -15,7 +15,9 @@ export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationOption
 export { createWriteTool, type WriteOperations, type WriteToolInput, type WriteToolOptions, writeTool, } from "./write.js";
 import type { AgentTool } from "@pencil-agent/agent-core";
 import { type BashToolOptions } from "./bash.js";
+import { type EditToolOptions } from "./edit.js";
 import { type ReadToolOptions } from "./read.js";
+import { type WriteToolOptions } from "./write.js";
 /** Tool type (AgentTool from nanopencil-ai) */
 export type Tool = AgentTool<any>;
 export declare const codingTools: Tool[];
@@ -68,6 +70,10 @@ export interface ToolsOptions {
     read?: ReadToolOptions;
     /** Options for the bash tool */
     bash?: BashToolOptions;
+    /** Options for the edit tool */
+    edit?: EditToolOptions;
+    /** Options for the write tool */
+    write?: WriteToolOptions;
 }
 /**
  * Create coding tools configured for a specific working directory.

package/dist/core/tools/index.js

@@ -43,8 +43,8 @@ export function createCodingTools(cwd, options) {
     return [
         createReadTool(cwd, options?.read),
         createBashTool(cwd, options?.bash),
-        createEditTool(cwd),
-        createWriteTool(cwd),
+        createEditTool(cwd, options?.edit),
+        createWriteTool(cwd, options?.write),
         createTimeTool(),
     ];
 }
@@ -61,8 +61,8 @@ export function createAllTools(cwd, options) {
     return {
         read: createReadTool(cwd, options?.read),
         bash: createBashTool(cwd, options?.bash),
-        edit: createEditTool(cwd),
-        write: createWriteTool(cwd),
+        edit: createEditTool(cwd, options?.edit),
+        write: createWriteTool(cwd, options?.write),
         grep: createGrepTool(cwd),
         find: createFindTool(cwd),
         ls: createLsTool(cwd),

package/dist/core/tools/write.d.ts

@@ -24,6 +24,8 @@ export interface WriteOperations {
 export interface WriteToolOptions {
     /** Custom operations for file writing. Default: local filesystem */
     operations?: WriteOperations;
+    /** Optional guard called with the resolved absolute path before writing. */
+    beforeWrite?: (absolutePath: string) => void | Promise<void>;
 }
 export declare function createWriteTool(cwd: string, options?: WriteToolOptions): AgentTool<typeof writeSchema>;
 /** Default write tool using process.cwd() - for backwards compatibility */

package/dist/core/tools/write.js

@@ -20,6 +20,7 @@ export function createWriteTool(cwd, options) {
         execute: async (_toolCallId, { path, content }, signal) => {
             const absolutePath = resolveToCwd(path, cwd);
             const dir = dirname(absolutePath);
+            await options?.beforeWrite?.(absolutePath);
             return new Promise((resolve, reject) => {
                 // Check if already aborted
                 if (signal?.aborted) {

package/dist/core/utils/sleep.d.ts

@@ -2,6 +2,6 @@
  * [WHO]: sleep()
  * [FROM]: No external dependencies
  * [TO]: Consumed by core/runtime/agent-session.ts
- * [HERE]: core/utils/sleep.ts - sleep helper that respects abort signal
+ * [HERE]: core/utils/sleep.ts - sleep helper that respects abort signal; cleans the abort listener on both resolve and reject so repeated sleeps against the same long-lived signal do not stack listeners (Node fires MaxListenersExceededWarning at 11)
  */
 export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;

package/dist/core/utils/sleep.js

@@ -2,7 +2,7 @@
  * [WHO]: sleep()
  * [FROM]: No external dependencies
  * [TO]: Consumed by core/runtime/agent-session.ts
- * [HERE]: core/utils/sleep.ts - sleep helper that respects abort signal
+ * [HERE]: core/utils/sleep.ts - sleep helper that respects abort signal; cleans the abort listener on both resolve and reject so repeated sleeps against the same long-lived signal do not stack listeners (Node fires MaxListenersExceededWarning at 11)
  */
 export function sleep(ms, signal) {
     return new Promise((resolve, reject) => {
@@ -10,10 +10,14 @@ export function sleep(ms, signal) {
             reject(new Error("Aborted"));
             return;
         }
-        const timeout = setTimeout(resolve, ms);
-        signal?.addEventListener("abort", () => {
+        const onAbort = () => {
             clearTimeout(timeout);
             reject(new Error("Aborted"));
-        });
+        };
+        const timeout = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
     });
 }

package/dist/extensions/defaults/AGENT.md

@@ -8,7 +8,16 @@ diagnostics/types.ts: Diagnostic event/report type contract and diagnostic:event
 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
+browser/index.ts: Browser Harness extension entry, registers browser/browser_admin tools, /browser command, Browser Harness resource discovery, project-local browser workspace seeding
+browser/browser.md: Browser Harness day-to-day skill instructions for NanoPencil tool use and workspace contribution
+browser/install.md: Browser Harness setup and troubleshooting instructions, exposed as a skill resource
+browser/src/browser_harness/: Vendored Browser Harness Python package, CDP daemon, IPC bridge, admin commands, and helper functions
+browser/interaction-skills/: Reusable Browser Harness mechanics guides for browser interactions
+browser/agent-workspace/: Seed workspace copied to .nanopencil/browser-workspace for editable helpers and domain skills
+link-world/index.ts: Internet access integration entry, registers link_world_admin/link_world_exec/web_search/web_fetch tools, /link-world status/doctor/version/install commands, and bundled internet-search resources
+link-world/link-world-agent.md: Agent-facing skill that tells models to prefer web_search/web_fetch and link_world_admin/link_world_exec over bash for internet tasks
+link-world/network-routing.md: Routing skill that tells models when to use web_search/web_fetch/link-world versus browser automation
+link-world/agent-workspace/: Seed workspace copied to .nanopencil/link-world-workspace for project-local domain skills and notes
 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
 plan/index.ts: Plan Mode extension entry, /plan /plan:validate /plan:approve commands, EnterPlanMode/ExitPlanMode tools, permission gating, TUI status/widget, workflow prompt injection
@@ -52,13 +61,18 @@ sal/eval/noop-sink.ts: noopSink — silent EvalSink used when eval disabled or n
 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
-team/team-types.ts: TeammateRole/TeammateMode/TeammateStatus/TeammateIdentity/TeammateMessage/PersistedTeammate/TeamSpawnSpec/TeamSendResult types
+team/index.ts: AgentTeam extension entry, /team <task>, /team:spawn/:preset/:send/:status/:progress/:psyche/:dashboard/:task/:mail/:allow-path/:stop/:terminate/:approve/:mode commands, TEAM_MESSAGE_TYPE renderer, realtime status/dashboard updates
+team/team-types.ts: TeammateRole/TeammateMode/TeammateStatus/TeamTask/HarnessState/PsycheWeights/TeammateLiveState/TeammateIdentity/TeammateMessage/PersistedTeammate/TeamSpawnSpec/TeamSendResult types
 team/team-state-store.ts: TeamStateStore class - durable teammate persistence via JSON files in <agentDir>/teams/
 team/team-parser.ts: Team command parser - parseTeamCommand/buildTeamHelp for /team:* subcommands
-team/team-runtime.ts: TeamRuntime class - teammate registry, lifecycle, mailbox + permission + transcript wiring
+team/team-runtime.ts: TeamRuntime class - teammate registry, per-teammate send queue, task/mailbox prompt context, lifecycle, realtime status/live events, durable tasks, mailbox + permission + transcript wiring
+team/team-task-store.ts: TeamTaskStore class - durable shared task list in <storageDir>/tasks.json
+team/team-harness.ts: Harness protocol helpers - context files, phase instructions, checkpoint/revert, feature validation
+team/team-presets.ts: Preset definitions and executor - solo/duo/squad spawning, model-assisted auto team selection, heuristic fallback
+team/team-dashboard.ts: Text dashboard/status rendering - teammate cards, live stream preview, progress bars, footer summary
+team/team-psyche.ts: Psyche prompt layer - role/phase weighted Id/Ego/Superego prompt construction
 team/team-permissions.ts: PermissionStore - pending permission request queue, approve/deny, path allowlists
-team/team-mailbox.ts: TeamMailbox - typed append-only message log for leader↔teammate
+team/team-mailbox.ts: TeamMailbox - typed JSONL-backed append-only message log for leader↔teammate and teammate↔teammate
 team/team-transcript.ts: TeamTranscriptWriter - per-teammate JSONL transcripts
 team/TESTING.md: Manual & smoke-test guide for Phase B AgentTeam
 

package/dist/extensions/defaults/browser/AGENT.md

@@ -0,0 +1,17 @@
+# extensions/defaults/browser/
+
+> P2 | Parent: ../AGENT.md
+
+Member List
+index.ts: Browser Harness extension entry, registers browser/browser_admin tools, /browser command, Browser Harness resource discovery for core/interaction/domain skills, project-local browser workspace seeding
+browser.md: Browser Harness day-to-day skill instructions for NanoPencil tool use and workspace contribution
+install.md: Browser Harness setup and troubleshooting instructions, exposed as a skill resource
+src/browser_harness/: Vendored Browser Harness Python package, CDP daemon, IPC bridge, admin commands, and helper functions
+src/browser_harness/AGENT.md: P2 module map for the vendored Browser Harness Python package
+interaction-skills/: Reusable Browser Harness mechanics guides for tabs, screenshots, iframes, cookies, uploads, dialogs, scrolling, and related browser interactions
+agent-workspace/: Seed workspace copied to .nanopencil/browser-workspace for editable helpers and domain skills
+.env.example: Browser Harness environment variable template for Browser Use cloud integration
+
+Rule: Members complete, one item per line, parent links valid, precise terms first
+
+[COVENANT]: Update this file header on changes and verify against parent AGENT.md