@arnilo/prism 0.0.19 → 0.0.22

package/dist/skill-load.js

@@ -0,0 +1,112 @@
+import { estimateTextBytes } from "./context-budget.js";
+import { HARD_MAX_SKILL_INSTRUCTION_BYTES } from "./skill-disclosure.js";
+export const DEFAULT_LOAD_SKILL_TOOL_NAME = "load_skill";
+export const SKILL_LOAD_ERROR_CODE = "skill_load_failed";
+export const MAX_LOAD_SKILL_RESULT_BYTES = 512;
+export class SkillLoadError extends Error {
+    code = SKILL_LOAD_ERROR_CODE;
+    constructor(message) {
+        super(message);
+        this.name = "SkillLoadError";
+    }
+}
+export function isSkillLoadError(error) {
+    return error instanceof Error && error.code === SKILL_LOAD_ERROR_CODE;
+}
+export function resolveSkillLoad(options) {
+    const name = options.name.trim();
+    if (!name)
+        throw new SkillLoadError("Skill name is required");
+    let skill;
+    try {
+        skill = options.registry.resolve(name);
+    }
+    catch {
+        throw new SkillLoadError(`Unknown skill: ${name}`);
+    }
+    if (options.activeSkillNames && !options.activeSkillNames.includes(skill.name)) {
+        throw new SkillLoadError(`Skill ${skill.name} is not active for this run`);
+    }
+    const toolNames = new Set((options.tools ?? []).map((tool) => tool.name));
+    const missingTool = skill.toolNames?.find((toolName) => !toolNames.has(toolName));
+    if (missingTool)
+        throw new SkillLoadError(`Skill ${skill.name} requires inactive tool: ${missingTool}`);
+    if (!skill.instructions?.trim())
+        throw new SkillLoadError(`Skill ${skill.name} has no instructions to load`);
+    const bytes = estimateTextBytes(skill.instructions);
+    if (bytes > HARD_MAX_SKILL_INSTRUCTION_BYTES) {
+        throw new SkillLoadError(`Skill ${skill.name} instructions exceed hard cap (${HARD_MAX_SKILL_INSTRUCTION_BYTES} bytes)`);
+    }
+    if (options.loaded?.has(skill.name))
+        throw new SkillLoadError(`Skill ${skill.name} is already loaded`);
+    return skill;
+}
+function skillLoadMetadata(context) {
+    const metadata = context.metadata;
+    if (!metadata || typeof metadata !== "object")
+        return undefined;
+    return metadata;
+}
+function capLoadSkillText(text) {
+    const bytes = estimateTextBytes(text);
+    if (bytes <= MAX_LOAD_SKILL_RESULT_BYTES)
+        return text;
+    const suffix = "…";
+    let end = MAX_LOAD_SKILL_RESULT_BYTES - new TextEncoder().encode(suffix).length;
+    const encoded = new TextEncoder().encode(text);
+    while (end > 0 && (encoded[end] & 0xc0) === 0x80)
+        end--;
+    return new TextDecoder().decode(encoded.slice(0, end)) + suffix;
+}
+export function createLoadSkillTool(options) {
+    const toolName = options.name ?? DEFAULT_LOAD_SKILL_TOOL_NAME;
+    return {
+        name: toolName,
+        description: "Load the full instructions for an active skill by exact name.",
+        parameters: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Exact skill name from the catalog." },
+            },
+            required: ["name"],
+        },
+        execute(args, context) {
+            const fail = (reason, text) => {
+                const bounded = capLoadSkillText(text);
+                return {
+                    toolCallId: context.toolCallId,
+                    name: toolName,
+                    value: { ok: false, reason, text: bounded },
+                    content: [{ type: "text", text: bounded }],
+                };
+            };
+            const name = typeof args.name === "string" ? args.name : "";
+            const metadata = skillLoadMetadata(context);
+            const loaded = metadata?.loadedSkills ?? options.loaded;
+            if (!loaded)
+                return fail("no_loaded_set", "Skill load state is unavailable for this session.");
+            try {
+                const skill = resolveSkillLoad({
+                    registry: options.registry,
+                    name,
+                    tools: metadata?.activeTools ?? options.tools,
+                    loaded,
+                    activeSkillNames: metadata?.activeSkillNames,
+                });
+                loaded.add(skill.name);
+                const text = capLoadSkillText(`Loaded skill ${skill.name} for this session.`);
+                return {
+                    toolCallId: context.toolCallId,
+                    name: toolName,
+                    value: { ok: true, name: skill.name, text },
+                    content: [{ type: "text", text }],
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "Skill load failed";
+                return fail("skill_load_failed", message);
+            }
+        },
+    };
+}
+//# sourceMappingURL=skill-load.js.map

package/dist/tool-result-fold.d.ts

@@ -0,0 +1,40 @@
+import type { Message, ToolResult } from "./contracts.js";
+export declare const DEFAULT_TOOL_RESULT_FOLD_MIN_AGE_TURNS = 2;
+export declare const DEFAULT_TOOL_RESULT_FOLD_MIN_BYTES = 4096;
+export declare const DEFAULT_TOOL_RESULT_FOLD_MAX_SUMMARY_BYTES = 512;
+export declare const HARD_TOOL_RESULT_FOLD_MAX_SUMMARY_BYTES = 4096;
+export declare const TOOL_RESULT_FOLD_TURN_METADATA_KEY: "prismToolResultTurn";
+export interface ToolResultFoldInput {
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly turn: number;
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly text: string;
+}
+export interface ToolResultFoldOptions {
+    readonly minAgeTurns?: number;
+    readonly minBytes?: number;
+    readonly maxSummaryBytes?: number;
+    readonly summarize: (input: ToolResultFoldInput) => Promise<string> | string;
+}
+export interface ResolvedToolResultFoldOptions {
+    readonly minAgeTurns: number;
+    readonly minBytes: number;
+    readonly maxSummaryBytes: number;
+    readonly summarize: (input: ToolResultFoldInput) => Promise<string> | string;
+}
+export interface FoldToolResultsContext {
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly turn: number;
+    readonly signal?: AbortSignal;
+}
+/** Run overrides agent; disabled when neither supplies `summarize`. */
+export declare function resolveToolResultFold(run?: ToolResultFoldOptions, agent?: ToolResultFoldOptions): ResolvedToolResultFoldOptions | undefined;
+/** Projection-only fold for history tool messages; does not mutate the input array. */
+export declare function foldToolResultHistory(history: readonly Message[], options: ResolvedToolResultFoldOptions, context: FoldToolResultsContext): Promise<readonly Message[]>;
+/** Projection-only fold for in-flight tool results before message conversion. */
+export declare function foldToolResults(results: readonly ToolResult[], options: ResolvedToolResultFoldOptions, context: FoldToolResultsContext): Promise<readonly ToolResult[]>;
+export declare function formatFoldedToolResult(summary: string): string;
+export declare function foldedToolResultHeader(toolName: string, toolCallId: string, summary: string): string;

package/dist/tool-result-fold.js

@@ -0,0 +1,164 @@
+import { estimateTextBytes } from "./context-budget.js";
+export const DEFAULT_TOOL_RESULT_FOLD_MIN_AGE_TURNS = 2;
+export const DEFAULT_TOOL_RESULT_FOLD_MIN_BYTES = 4_096;
+export const DEFAULT_TOOL_RESULT_FOLD_MAX_SUMMARY_BYTES = 512;
+export const HARD_TOOL_RESULT_FOLD_MAX_SUMMARY_BYTES = 4_096;
+export const TOOL_RESULT_FOLD_TURN_METADATA_KEY = "prismToolResultTurn";
+/** Run overrides agent; disabled when neither supplies `summarize`. */
+export function resolveToolResultFold(run, agent) {
+    const options = run ?? agent;
+    if (!options?.summarize)
+        return undefined;
+    const minAgeTurns = options.minAgeTurns ?? DEFAULT_TOOL_RESULT_FOLD_MIN_AGE_TURNS;
+    const minBytes = options.minBytes ?? DEFAULT_TOOL_RESULT_FOLD_MIN_BYTES;
+    const maxSummaryBytes = options.maxSummaryBytes ?? DEFAULT_TOOL_RESULT_FOLD_MAX_SUMMARY_BYTES;
+    assertPositiveInt(minAgeTurns, "minAgeTurns", 1, 1_024);
+    assertPositiveInt(minBytes, "minBytes", 1, 32 * 1024 * 1024);
+    assertPositiveInt(maxSummaryBytes, "maxSummaryBytes", 1, HARD_TOOL_RESULT_FOLD_MAX_SUMMARY_BYTES);
+    return { minAgeTurns, minBytes, maxSummaryBytes, summarize: options.summarize };
+}
+/** Projection-only fold for history tool messages; does not mutate the input array. */
+export async function foldToolResultHistory(history, options, context) {
+    if (history.length === 0)
+        return history;
+    const turns = inferToolResultTurns(history);
+    const out = [];
+    for (let index = 0; index < history.length; index += 1) {
+        const message = history[index];
+        const folded = await foldToolResultMessage(message, options, {
+            ...context,
+            toolResultTurn: turns[index] ?? context.turn,
+        });
+        out.push(folded);
+    }
+    return out;
+}
+/** Projection-only fold for in-flight tool results before message conversion. */
+export async function foldToolResults(results, options, context) {
+    if (results.length === 0)
+        return results;
+    const out = [];
+    for (const result of results) {
+        const folded = await foldToolResultValue(result, options, { ...context, toolResultTurn: context.turn });
+        out.push(folded);
+    }
+    return out;
+}
+async function foldToolResultMessage(message, options, context) {
+    if (message.role !== "tool")
+        return message;
+    const block = message.content.find((part) => part.type === "tool_result");
+    if (!block || block.type !== "tool_result")
+        return message;
+    const text = toolResultText(block.result, block.error, message.content);
+    const folded = await maybeFold({
+        options,
+        context,
+        toolCallId: block.toolCallId,
+        toolName: block.name,
+        text,
+        apply: (summary) => ({
+            ...message,
+            content: message.content.map((part) => part.type === "tool_result"
+                ? { ...part, result: foldedToolResultHeader(block.name, block.toolCallId, summary), error: undefined }
+                : part),
+            metadata: { ...message.metadata, prismFolded: true },
+        }),
+    });
+    return folded ?? message;
+}
+async function foldToolResultValue(result, options, context) {
+    const text = toolResultText(result.value, result.error, result.content);
+    const folded = await maybeFold({
+        options,
+        context,
+        toolCallId: result.toolCallId,
+        toolName: result.name,
+        text,
+        apply: (summary) => ({
+            ...result,
+            value: foldedToolResultHeader(result.name, result.toolCallId, summary),
+            error: undefined,
+            metadata: { ...result.metadata, prismFolded: true },
+        }),
+    });
+    return folded ?? result;
+}
+async function maybeFold(input) {
+    const age = input.context.turn - input.context.toolResultTurn;
+    if (age < input.options.minAgeTurns)
+        return undefined;
+    if (estimateTextBytes(input.text) < input.options.minBytes)
+        return undefined;
+    throwIfAborted(input.context.signal);
+    try {
+        const summary = await input.options.summarize({
+            sessionId: input.context.sessionId,
+            runId: input.context.runId,
+            turn: input.context.toolResultTurn,
+            toolCallId: input.toolCallId,
+            toolName: input.toolName,
+            text: input.text,
+        });
+        return input.apply(capSummaryBytes(String(summary), input.options.maxSummaryBytes));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function formatFoldedToolResult(summary) {
+    return summary;
+}
+export function foldedToolResultHeader(toolName, toolCallId, summary) {
+    return `Tool result ${toolName} [${toolCallId}]: ${summary}`;
+}
+function toolResultText(result, error, extra) {
+    const parts = [JSON.stringify(error ?? result ?? null)];
+    for (const block of extra ?? []) {
+        if (block.type === "text" && "text" in block && typeof block.text === "string")
+            parts.push(block.text);
+    }
+    return parts.join("\n");
+}
+function capSummaryBytes(summary, maxBytes) {
+    const bytes = estimateTextBytes(summary);
+    if (bytes <= maxBytes)
+        return summary;
+    const encoded = new TextEncoder().encode(summary);
+    const suffix = new TextEncoder().encode("…");
+    let end = Math.max(0, maxBytes - suffix.length);
+    while (end > 0 && (encoded[end] & 0xc0) === 0x80)
+        end--;
+    return new TextDecoder().decode(encoded.slice(0, end)) + "…";
+}
+function inferToolResultTurns(history) {
+    const turns = new Array(history.length).fill(1);
+    let providerTurn = 0;
+    let toolTurn = 1;
+    for (let index = 0; index < history.length; index += 1) {
+        const message = history[index];
+        const stamped = readToolResultTurn(message.metadata);
+        if (message.role === "assistant") {
+            providerTurn += 1;
+            toolTurn = providerTurn;
+        }
+        if (message.role === "tool") {
+            turns[index] = stamped ?? toolTurn;
+        }
+    }
+    return turns;
+}
+function readToolResultTurn(metadata) {
+    const value = metadata?.[TOOL_RESULT_FOLD_TURN_METADATA_KEY];
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+function assertPositiveInt(value, name, min, max) {
+    if (!Number.isSafeInteger(value) || value < min || value > max) {
+        throw new TypeError(`toolResultFold.${name} must be a safe integer from ${min} to ${max}`);
+    }
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw signal.reason instanceof Error ? signal.reason : new Error("Tool result fold aborted");
+}
+//# sourceMappingURL=tool-result-fold.js.map

package/docs/0.1.0-readiness.md

@@ -1,6 +1,6 @@
 # 0.1.0 / 1.0 Readiness Gates
 
-Status: **0.0.19** is the current release line (Phase 2 observational memory lifecycle); **1.0** readiness remains operator-gated, not automatic.
+Status: **0.0.22** is the current release line (Phase 5 third-party behavior integrations); **1.0** readiness remains operator-gated, not automatic.
 
 This page distills runnable readiness gates into one command-per-gate table. The
 **Last evidence** column records the 2026-07-26 **0.0.16** baseline snapshot
@@ -14,13 +14,13 @@ Evidence trail: [`docs/review-coverage-2026-07-26-phase-11.md`](./review-coverag
 (addenda 0–9), [`docs/release-and-install.md`](./release-and-install.md),
 [`docs/migration.md`](./migration.md), [`docs/performance.md`](./performance.md).
 
-## Current line (0.0.19)
+## Current line (0.0.21)
 
 | Item | Status |
 |---|---|
-| Published graph | **44** publishable manifests at **0.0.19** (`docs/release-and-install.md`) |
-| Phase 2 observational memory | `createObservationalMemory().attach()`, four-layer context, nested settings, recall paging, hard fold/render caps |
-| Docs tripwires | `node --test dist/__tests__/docs.test.js` — migration section `0.0.18 → 0.0.19 observational memory lifecycle` documents intentional breaks |
+| Published graph | **44** publishable manifests at **0.0.21** (`docs/release-and-install.md`) |
+| Phase 4 coding-tool gaps | `outputMode`, bounded `glob`, optional read-before-write, bounded `delete`/`move`, approval/sandbox wiring |
+| Docs tripwires | `node --test dist/__tests__/docs.test.js` — migration section `0.0.20 → 0.0.21 coding-tool capability gaps` documents intentional breaks |
 | Readiness table below | **0.0.16 measured values** — refresh evidence columns when 1.0 RC gates are recorded |
 
 ## Gate table

package/docs/agent-session-runtime.md

@@ -51,6 +51,8 @@ string | Message | readonly Message[]
 
 `RunOptions.model` can override the request model for a run. Model overrides append a `model_change` entry. `AgentConfig.inputLayout` selects the default input assembly layout (`"cache_aware"` by default, or opt-in `"legacy"`); `RunOptions.inputLayout` wins for one run. `AgentConfig.providerOptions`/`RunOptions.providerOptions` supply generic provider request options; `timeoutMs`, `maxRetries`, and `maxRetryDelayMs` are deprecated inert provider-level hints in first-party providers. Use `RunOptions.signal`/host abort controllers for timeouts and `AgentConfig.retry`/`RunOptions.retry` for retry. `AgentConfig.providerRequestPolicies`/`RunOptions.providerRequestPolicies` run before `AIProvider.generate()` and before `provider_request` middleware. `AgentConfig.systemPrompt` and `RunOptions.systemPrompt` add explicit layered system prompt contributions; `RunOptions.systemPrompt: false` disables configured prompt layers for that run while keeping `AgentConfig.instructions` as the base path. `RunOptions.compaction` can enable auto-compaction for that run or use `false` to disable configured auto-compaction. `RunOptions.retry` can enable provider-turn retry for that run or use `false` to disable configured retry. `RunOptions.metadata` is merged with agent/session metadata for assembly, provider requests, and tool contexts. Deprecated `RunOptions.maxToolRounds` narrows `limits.maxToolRounds`. `RunOptions.signal` is bridged into the per-run abort signal passed to assembly, providers, tools, auto-compaction, and retry backoff.
 
+`RunOptions.activeSkills` selects named skills from a configured `SkillRegistry`; `RunOptions.skills` replaces a plain `Skill[]` config for one run. When `AgentConfig.skills` is a registry and neither is set, **no skills activate** unless `activateAllSkills: true` (run or agent). `skillsDisclosure` (`"progressive"` default, `"eager"` opt-in; run wins) controls catalog vs full instruction bodies; the session-owned `LoadedSkillSet` is populated by `load_skill` when the host registers `createLoadSkillTool`. `toolResultFold` (off unless the host supplies `summarize`) optionally folds aged large tool results in provider input only. See [Context and skills](context-and-skills.md).
+
 ## Outputs / response / events
 
 `session.run()` / `session.prompt()` resolve to an `AgentRunResult` with `sessionId`, `runId`, `status`, `text`, `content`, optional `message`/`usage`/`leafId`, and terminal `error`/`abortReason` when applicable. Callers may ignore the return value. Failed and aborted runs still emit their terminal events, then reject with `AgentRunError` whose `.result` carries the same shape.

package/docs/caveman.md

@@ -0,0 +1,129 @@
+# Caveman behavior integration
+
+## What it does
+
+`@arnilo/prism-caveman` is an optional package that wires [juliusbrussee/caveman](https://github.com/juliusbrussee/caveman) into Prism contribution contracts.
+
+It registers upstream skills and commands, injects active level prompt slices via `InstructionInjector`, and persists level as session custom `caveman-level` entries. Import and extension `setup` without a resolvable upstream path fail closed with a bounded redacted error and register zero contributions.
+
+Upstream prompt fragments, skill bodies, and rules load from the host-supplied upstream checkout — Prism does not reimplement or vendor Caveman content.
+
+## When to use it
+
+Use it when a host wants terse token-efficient communication modes (`lite`, `full`, `ultra`, wenyan variants, `micro`) with upstream Caveman skills (`caveman-commit`, `caveman-review`, `caveman-stats`, `caveman-compress`, `caveman-help`, `cavecrew`) in a Prism extension kernel.
+
+Skip it when you do not have a local Caveman checkout (Caveman is not published on npm) or when you only need progressive skill catalog without mode injection.
+
+Pair with Phase 3 progressive disclosure: register `createLoadSkillTool` and keep `skillsDisclosure: "progressive"` so full `SKILL.md` bodies stay catalog-only; mode slices come from the `caveman-mode` injector, not eager skill bodies.
+
+## Inputs / request
+
+`createCavemanExtension(options)`:
+
+| Field | Type | Required | Purpose |
+| --- | --- | --- | --- |
+| `upstreamPath` | `string` | yes | Absolute path to a Caveman checkout containing `skills/`. |
+| `defaultLevel` | `CavemanLevel` | no | Initial level when no session entry exists (default upstream: `full`). |
+| `showStatus` | `boolean` | no | Emit `caveman:status` extension events on level changes. |
+| `appendEntry` | `(entry, opts?) => Promise<void>` | yes | Host session append (OM `attach` pattern). |
+| `getEntries` | `() => readonly SessionEntry[] \| Promise<...>` | yes | Current branch entries for level restore. |
+| `configPath` | `string` | no | Bounded local config file for `defaultLevel` / `showStatus`. |
+
+`CavemanLevel`: `off` \| `lite` \| `full` \| `ultra` \| `wenyan-lite` \| `wenyan` \| `wenyan-ultra` \| `micro`.
+
+Session custom entry shape:
+
+```json
+{ "kind": "custom", "data": { "type": "caveman-level", "level": "full" } }
+```
+
+Registered skills: `caveman`, `caveman-commit`, `caveman-review`, `caveman-stats`, `caveman-compress`, `caveman-help`, `cavecrew`.
+
+Registered commands: `caveman`, `caveman-init`, `caveman-commit`, `caveman-review`, `caveman-stats`, `caveman-compress`.
+
+## Outputs / response / events
+
+| Export | Purpose |
+| --- | --- |
+| `createCavemanExtension(options)` | Returns an inert `Extension` until `kernel.load([...])`. |
+| `caveman-mode` injector | `InstructionInjector` — upstream filtered `skills/caveman/SKILL.md` slice when level ≠ `off`. |
+| `caveman` command | Set level (`/caveman lite\|full\|ultra\|wenyan\|micro\|off`) or toggle `off`↔`full`. |
+| Alias commands | Dispatch `{ skill, dispatch: "load_skill" }` metadata for companion skills. |
+| `caveman:status` event | Optional metadata when `showStatus: true`. |
+
+Deactivation phrases `stop caveman` and `normal mode` clear active injection without erasing session history.
+
+## Request/response example
+
+```json
+{ "command": "caveman", "args": { "level": "ultra" }, "sessionId": "s1" }
+```
+
+```json
+{ "kind": "custom", "data": { "type": "caveman-level", "level": "ultra" } }
+```
+
+## Implementation example
+
+```ts
+import { createCavemanExtension } from "@arnilo/prism-caveman";
+import {
+  createExtensionKernel,
+  createLoadSkillTool,
+  createLoadedSkillSet,
+  createMemorySessionStore,
+  createSkillRegistry,
+  createSessionEntry,
+} from "@arnilo/prism";
+
+const store = createMemorySessionStore();
+const callbacks = {
+  appendEntry: async (entry, options) => store.append(entry, options),
+  getEntries: async () => store.list("s1"),
+};
+
+const kernel = createExtensionKernel({ errorPolicy: "throw" });
+await kernel.load([
+  createCavemanExtension({
+    upstreamPath: "/path/to/juliusbrussee-caveman",
+    defaultLevel: "full",
+    ...callbacks,
+  }),
+]);
+
+const registry = createSkillRegistry(kernel.registries.skills.list());
+const loaded = createLoadedSkillSet();
+const loadSkill = createLoadSkillTool({ registry, loaded });
+
+await kernel.registries.commands.get("caveman")!.execute({ level: "lite" }, { sessionId: "s1" });
+// Select instructionInjectors: ["caveman-mode"] on runs that should receive level slices.
+```
+
+See `examples/caveman-ponytail.ts` for progressive catalog + `load_skill` wiring with fixture upstream trees (network-free).
+
+## Extension and configuration notes
+
+- Import alone registers nothing and starts no timers, watchers, or network I/O (`sideEffects: false`).
+- `kernel.load` calls `setup`, which resolves upstream first; failure throws before any `register*`.
+- Level restore scans `getEntries()` for the latest `data.type === "caveman-level"` — same OM attach pattern; core does not auto-emit `session_start`.
+- Host must register `createLoadSkillTool` and pass `skillsDisclosure: "progressive"` for catalog-only skill bodies.
+- `caveman-stats` dispatches skill metadata only; full stats need host session-log integration.
+- `caveman-init` returns upstream guidance text; it does not write files in the host repo.
+- No TUI status bar; optional `caveman:status` events for host UI.
+
+## Security and performance notes
+
+- Upstream `SKILL.md` and injected text are untrusted host-supplied content; reads are size-bounded (`MAX_SKILL_FILE_BYTES` 256 KiB, `MAX_INJECTED_INSTRUCTION_BYTES` 32 KiB).
+- Config read/write is bounded (`MAX_CONFIG_FILE_BYTES` 16 KiB) at host-owned `configPath` only.
+- Errors redact home directories and absolute paths.
+- Setup is O(skills) directory scan; mode read/write is O(1) per change; injection is O(1) upstream lookup per turn.
+- Session custom entries respect host session ownership and redaction policies.
+
+## Related APIs
+
+- [Ponytail behavior integration](ponytail.md): complementary lazy-minimalism mode package.
+- [Extension kernel and event bus](extensions.md): `kernel.load` and contribution registration.
+- [Context and skills](context-and-skills.md): progressive disclosure + `createLoadSkillTool`.
+- [Instruction injection](instruction-injection.md): `caveman-mode` injector selection.
+- [Observational memory compaction package](compaction-observational-memory.md): `appendEntry` / `getEntries` attach precedent.
+- [Migration guide](migration.md): `0.0.21 → 0.0.22` install and opt-in notes.