@gotgenes/pi-subagents 6.19.0 → 7.0.0

package/CHANGELOG.md

@@ -5,6 +5,40 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [7.0.0](https://github.com/gotgenes/pi-packages/compare/pi-subagents-v6.19.1...pi-subagents-v7.0.0) (2026-05-24)
+
+
+### ⚠ BREAKING CHANGES
+
+* `src/session/memory.ts` and all persistent agent memory functionality (MEMORY.md, agent-memory directories) are removed from pi-subagents. This is scope reduction — agent spawning, execution, and result retrieval remain.
+* `MemoryScope` is no longer exported from the package. The `memory` field is removed from `AgentConfig`. Custom agent .md files with a `memory:` frontmatter key will have it silently ignored.
+* The `memory` field in agent configuration no longer has any effect. Memory block injection, memory tool augmentation, and the `AssemblerIO.buildMemoryBlock` / `buildReadOnlyMemoryBlock` collaborators are removed from the session assembler.
+
+### Features
+
+* delete memory module ([78ace55](https://github.com/gotgenes/pi-packages/commit/78ace558b1988bce8e002b28fe3152c5de708b84))
+* remove memory from session assembly and config layers ([6ebeb91](https://github.com/gotgenes/pi-packages/commit/6ebeb91f28c56c1d21fc4e1a7b6bededa8eba025))
+* remove MemoryScope type and memory config field ([d6e3bcb](https://github.com/gotgenes/pi-packages/commit/d6e3bcbb58902133a3704d89d88b548f8f2a4769))
+
+
+### Documentation
+
+* plan remove persistent agent memory ([#185](https://github.com/gotgenes/pi-packages/issues/185)) ([0f6b3ad](https://github.com/gotgenes/pi-packages/commit/0f6b3adb6c35c3879c5d1e176e1c6d9da36a5cf1))
+* **retro:** add planning stage notes for issue [#185](https://github.com/gotgenes/pi-packages/issues/185) ([58dcfbc](https://github.com/gotgenes/pi-packages/commit/58dcfbc3124ec7695048ad3df8fc6f397a883d1a))
+* **retro:** add retro notes for issue [#188](https://github.com/gotgenes/pi-packages/issues/188) ([8eeaf6b](https://github.com/gotgenes/pi-packages/commit/8eeaf6b52f7b40a2126f3ffa3ca01a8e3b84f338))
+* **retro:** add TDD stage notes for issue [#185](https://github.com/gotgenes/pi-packages/issues/185) ([8e75b18](https://github.com/gotgenes/pi-packages/commit/8e75b18b2c87b47f1a29df9d2c544a8ad2023f9f))
+* update architecture after memory removal ([52716d5](https://github.com/gotgenes/pi-packages/commit/52716d5f89b729ce183d4a450d8539e6cabdbadc))
+
+## [6.19.1](https://github.com/gotgenes/pi-packages/compare/pi-subagents-v6.19.0...pi-subagents-v6.19.1) (2026-05-24)
+
+
+### Documentation
+
+* plan replace any casts with SDK types ([#188](https://github.com/gotgenes/pi-packages/issues/188)) ([96207da](https://github.com/gotgenes/pi-packages/commit/96207dacf0035db11605d55a61132cf43f7c3b40))
+* **retro:** add planning stage notes for issue [#188](https://github.com/gotgenes/pi-packages/issues/188) ([6e38b12](https://github.com/gotgenes/pi-packages/commit/6e38b128a5bbaad3ca81b31adbf390482081a41e))
+* **retro:** add retro notes for issue [#172](https://github.com/gotgenes/pi-packages/issues/172) ([270c00a](https://github.com/gotgenes/pi-packages/commit/270c00a5f84bf454352443a6c57a6076803090c6))
+* **retro:** add TDD stage notes for issue [#188](https://github.com/gotgenes/pi-packages/issues/188) ([8a5f51a](https://github.com/gotgenes/pi-packages/commit/8a5f51a2fd02a143e85f176417b31af4a11b34f4))
+
 ## [6.19.0](https://github.com/gotgenes/pi-packages/compare/pi-subagents-v6.18.8...pi-subagents-v6.19.0) (2026-05-24)
 
 

package/docs/architecture/architecture.md

@@ -42,7 +42,7 @@ flowchart TB
         SessionConfig["assembleSessionConfig\n(pure assembler)"]
         Prompts["prompts\n(system prompt)"]
         Context["context\n(parent history)"]
-        Memory["memory\n(MEMORY.md)"]
+        SafeFs["safe-fs\n(symlink/name guards)"]
         SkillLoader["skill-loader\n(preload skills)"]
         Env["env\n(git/platform)"]
         ModelResolver["model-resolver\n(fuzzy match)"]
@@ -86,7 +86,8 @@ flowchart TB
     AgentManager --> AgentRunner
     AgentRunner --> SessionConfig
     SessionConfig --> AgentTypeRegistry
-    SessionConfig --> Prompts & Memory & SkillLoader & Env
+    SessionConfig --> Prompts & SkillLoader & Env
+    SkillLoader --> SafeFs
     AgentTypeRegistry --> DefaultAgents & CustomAgents
     RecordObserver -.->|subscribes| AgentRunner
     UIObserver -.->|subscribes| AgentRunner
@@ -246,7 +247,7 @@ src/
 │   ├── prompts.ts                  system prompt building
 │   ├── content-items.ts            shared message content parsing (tool-call names, assistant content)
 │   ├── context.ts                  parent conversation extraction
-│   ├── memory.ts                   persistent MEMORY.md per agent
+│   ├── safe-fs.ts                  symlink rejection and safe file reads
 │   ├── skill-loader.ts             skill preloading
 │   ├── env.ts                      git/platform detection
 │   ├── model-resolver.ts           fuzzy model name resolution
@@ -338,7 +339,7 @@ They declare this package as an optional peer dependency and use dynamic import
 - `ParentSnapshot` — immutable snapshot of parent session state, captured once at spawn time.
 - `record-observer` — session-event observer that updates record statistics without callback threading.
 - Agent type registry — default agents, custom `.md` file loading.
-- Prompt assembly, context extraction, memory, skills, environment.
+- Prompt assembly, context extraction, skills, environment.
 - Worktree isolation.
 - Token usage tracking.
 - Session directory derivation and persisted `SessionManager` for subagent transcripts.

package/docs/plans/0185-remove-persistent-agent-memory.md

@@ -0,0 +1,161 @@
+---
+issue: 185
+issue_title: "pi-subagents: Remove persistent agent memory feature"
+---
+
+# Remove persistent agent memory feature
+
+## Problem Statement
+
+The `memory.ts` module and all supporting code for persistent agent memory (`MEMORY.md`, `agent-memory/` directories) should be removed from `pi-subagents`.
+The memory feature invents its own filesystem layout, file format, and security model — all outside the stated scope of `pi-subagents`, which is agent spawning, execution, and result retrieval.
+This follows the same scope-reduction rationale as the scheduling subsystem removal (issue #52).
+
+## Goals
+
+- Remove the `memory.ts` module and all memory-related code from the package.
+- Remove `MemoryScope` type and `memory` field from `AgentConfig`.
+- Remove memory block injection from session assembly.
+- Remove memory tool augmentation from agent-types.
+- Remove memory parsing from custom agent loading.
+- Remove memory display from UI components.
+- Extract `isSymlink`, `isUnsafeName`, and `safeReadFile` to a shared utility module — `skill-loader.ts` depends on them independently of memory.
+- Update architecture documentation to reflect the removal.
+
+## Non-Goals
+
+- Replacing memory with an alternative persistence mechanism — that is out of scope.
+- Changing the `skill-loader.ts` logic beyond updating the import source for the extracted utilities.
+
+## Background
+
+The memory system spans six source modules and two UI modules:
+
+| File                              | Memory surface                                                                                                                                                                           |
+| --------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `src/session/memory.ts`           | Core module: `buildMemoryBlock`, `buildReadOnlyMemoryBlock`, `resolveMemoryDir`, `ensureMemoryDir`, `readMemoryIndex`, plus shared utilities `isSymlink`, `isUnsafeName`, `safeReadFile` |
+| `src/types.ts`                    | `MemoryScope` type, `memory?: MemoryScope` field on `AgentConfig`                                                                                                                        |
+| `src/session/session-config.ts`   | `AssemblerIO.buildMemoryBlock` / `buildReadOnlyMemoryBlock` fields, memory logic block (~25 lines), `MemoryScope` import                                                                 |
+| `src/config/agent-types.ts`       | `getMemoryToolNames()`, `getReadOnlyMemoryToolNames()`, `MEMORY_TOOL_NAMES`, `READONLY_MEMORY_TOOL_NAMES`                                                                                |
+| `src/config/custom-agents.ts`     | `parseMemory()` function, `memory: parseMemory(fm.memory)` assignment                                                                                                                    |
+| `src/session/prompts.ts`          | `memoryBlock` field on `PromptExtras`, injection into system prompt                                                                                                                      |
+| `src/ui/agent-config-editor.ts`   | `if (cfg.memory) fmFields.push(...)`                                                                                                                                                     |
+| `src/ui/agent-creation-wizard.ts` | `memory:` line in frontmatter help text                                                                                                                                                  |
+| `src/index.ts`                    | Imports `buildMemoryBlock`, `buildReadOnlyMemoryBlock`; wires them into `assemblerIO`                                                                                                    |
+
+The three utility functions (`isSymlink`, `isUnsafeName`, `safeReadFile`) are imported by `skill-loader.ts` for filesystem safety — they are not memory-specific and must survive the removal.
+
+AGENTS.md constraint: the architecture doc in `docs/architecture/architecture.md` references `memory.ts` in the module listing and domain model diagram — both need updating.
+
+## Design Overview
+
+This is a pure removal with one extraction.
+The only design decision is where to place the extracted utilities.
+
+The three functions (`isSymlink`, `isUnsafeName`, `safeReadFile`) are filesystem safety primitives used by `skill-loader.ts`.
+They belong in a new `src/session/safe-fs.ts` module in the session domain, co-located with their sole remaining consumer.
+
+The removal works consumers-first, declaration-last:
+
+1. Extract shared utilities to `safe-fs.ts` (additive, no behavior change).
+2. Remove all memory consumers — session-config, prompts, agent-types, custom-agents, UI, index wiring.
+3. Remove the declarations — `MemoryScope`, `AgentConfig.memory`, `memory.ts`.
+4. Update architecture docs.
+
+## Module-Level Changes
+
+### New files
+
+- `src/session/safe-fs.ts` — extracted `isSymlink`, `isUnsafeName`, `safeReadFile`.
+- `test/session/safe-fs.test.ts` — tests moved from `memory.test.ts` for these three functions.
+
+### Modified files
+
+- `src/session/skill-loader.ts` — change import from `#src/session/memory` to `#src/session/safe-fs`.
+- `src/session/session-config.ts` — remove `buildMemoryBlock` / `buildReadOnlyMemoryBlock` from `AssemblerIO`; remove `MemoryScope` import; remove entire memory logic block (~lines 215–242).
+- `src/session/prompts.ts` — remove `memoryBlock` from `PromptExtras` interface; remove `extras?.memoryBlock` injection.
+- `src/config/agent-types.ts` — remove `MEMORY_TOOL_NAMES`, `READONLY_MEMORY_TOOL_NAMES`, `getMemoryToolNames()`, `getReadOnlyMemoryToolNames()`.
+- `src/config/custom-agents.ts` — remove `MemoryScope` import; remove `memory: parseMemory(fm.memory)` assignment; remove `parseMemory()` function.
+- `src/types.ts` — remove `MemoryScope` type; remove `memory?: MemoryScope` from `AgentConfig`; remove associated doc comment.
+- `src/ui/agent-config-editor.ts` — remove `if (cfg.memory)` line.
+- `src/ui/agent-creation-wizard.ts` — remove `memory:` line from frontmatter help text.
+- `src/index.ts` — remove `buildMemoryBlock` / `buildReadOnlyMemoryBlock` import; remove those fields from `assemblerIO` object.
+- `docs/architecture/architecture.md` — remove `memory.ts` from module listing; remove Memory node from domain model Mermaid diagram; update session domain description.
+
+### Deleted files
+
+- `src/session/memory.ts` — entire module.
+- `test/session/memory.test.ts` — entire test file (tests for `isSymlink`, `isUnsafeName`, `safeReadFile` are moved to `safe-fs.test.ts` first; remaining memory-specific tests are deleted).
+
+### Test files modified
+
+- `test/session/session-config.test.ts` — remove `mockBuildMemoryBlock` / `mockBuildReadOnlyMemoryBlock` mocks from `AssemblerIO` construction; remove "assembleSessionConfig — memory block selection" describe block (~lines 354–427).
+- `test/session/prompts.test.ts` — remove "injects memory block in replace mode", "injects memory block in append mode", and "injects both memory and skills" test cases.
+- `test/config/agent-types.test.ts` — remove `getMemoryToolNames` / `getReadOnlyMemoryToolNames` imports and test suite (~lines 26–51).
+- `test/config/custom-agents.test.ts` — remove memory scope parsing tests (~lines 361–403).
+
+## Test Impact Analysis
+
+1. The extraction of `isSymlink`, `isUnsafeName`, `safeReadFile` to `safe-fs.ts` enables their tests to exist independently of the memory module — currently they are co-located with memory-specific tests in `memory.test.ts`.
+2. The memory-specific tests in `memory.test.ts` (`resolveMemoryDir`, `ensureMemoryDir`, `readMemoryIndex`, `buildMemoryBlock`, `buildReadOnlyMemoryBlock`) become redundant and are deleted — the code they test is being removed.
+3. The memory block selection tests in `session-config.test.ts` (~70 lines) test the memory branching logic in `assembleSessionConfig` — they are deleted because that logic is removed.
+4. The memory injection tests in `prompts.test.ts` test `memoryBlock` injection — deleted because the field and injection code are removed.
+5. The memory parsing tests in `custom-agents.test.ts` test `parseMemory` — deleted because the function is removed.
+6. The memory tool name helper tests in `agent-types.test.ts` test `getMemoryToolNames` / `getReadOnlyMemoryToolNames` — deleted because the functions are removed.
+7. All other tests remain as-is — they do not depend on memory functionality.
+
+## TDD Order
+
+1. **Extract utilities to `safe-fs.ts`.**
+   Create `src/session/safe-fs.ts` with `isSymlink`, `isUnsafeName`, `safeReadFile`.
+   Create `test/session/safe-fs.test.ts` with tests moved from `memory.test.ts` for these three functions.
+   Update `src/session/skill-loader.ts` import to point to `#src/session/safe-fs`.
+   Update `src/session/memory.ts` import to point to `#src/session/safe-fs` (temporary — keeps memory working until removal).
+   Verify: `pnpm vitest run` and `pnpm run check`.
+   Commit: `refactor: extract safe-fs utilities from memory module`
+
+2. **Remove memory from session assembly and config layers.**
+   Remove `buildMemoryBlock` / `buildReadOnlyMemoryBlock` from `AssemblerIO` in `session-config.ts`.
+   Remove `MemoryScope` import and all memory logic from `session-config.ts`.
+   Remove `memoryBlock` from `PromptExtras` in `prompts.ts` and its injection logic.
+   Remove `getMemoryToolNames`, `getReadOnlyMemoryToolNames`, `MEMORY_TOOL_NAMES`, `READONLY_MEMORY_TOOL_NAMES` from `agent-types.ts`.
+   Remove `getMemoryToolNames` / `getReadOnlyMemoryToolNames` import from `session-config.ts`.
+   Remove `buildMemoryBlock` / `buildReadOnlyMemoryBlock` import and `assemblerIO` fields from `index.ts`.
+   Update `test/session/session-config.test.ts`: remove memory mocks from IO construction and memory block selection test suite.
+   Update `test/session/prompts.test.ts`: remove memory injection tests.
+   Update `test/config/agent-types.test.ts`: remove memory tool name helper tests.
+   Verify: `pnpm vitest run` and `pnpm run check`.
+   Commit: `feat!: remove memory from session assembly and config layers`
+
+3. **Remove memory from types, custom-agents, and UI.**
+   Remove `MemoryScope` type and `memory` field from `AgentConfig` in `types.ts`.
+   Remove `parseMemory()` function, `MemoryScope` import, and `memory:` assignment from `custom-agents.ts`.
+   Remove `if (cfg.memory)` line from `agent-config-editor.ts`.
+   Remove `memory:` help text line from `agent-creation-wizard.ts`.
+   Update `test/config/custom-agents.test.ts`: remove memory parsing tests.
+   Verify: `pnpm vitest run` and `pnpm run check`.
+   Commit: `feat!: remove MemoryScope type and memory config field`
+
+4. **Delete `memory.ts` and its test file.**
+   Delete `src/session/memory.ts`.
+   Delete `test/session/memory.test.ts`.
+   Verify: `pnpm vitest run` and `pnpm run check`.
+   Commit: `feat!: delete memory module`
+
+5. **Update architecture documentation.**
+   Remove Memory node from the domain model Mermaid diagram.
+   Remove `memory.ts` from the module listing.
+   Update session domain description.
+   Commit: `docs: update architecture after memory removal`
+
+## Risks and Mitigations
+
+| Risk                                                                                   | Mitigation                                                                                                                                                              |
+| -------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Users with `memory:` in custom agent frontmatter — the field silently becomes a no-op. | `parseMemory` removal means unknown frontmatter keys are ignored by the markdown parser. No error, no crash — just no memory. This is acceptable for a feature removal. |
+| `skill-loader.ts` breaks if the utility extraction has a typo or missing re-export.    | Step 1 runs full test suite before proceeding. The skill-loader tests exercise `isUnsafeName` and `safeReadFile` indirectly.                                            |
+| Architecture doc Mermaid diagram breaks after node removal.                            | Verify the diagram renders correctly after editing — remove both the node and all edges referencing it.                                                                 |
+
+## Open Questions
+
+None — the issue scope is unambiguous and all affected files have been traced.

package/docs/plans/0188-replace-any-casts-with-sdk-types.md

@@ -0,0 +1,162 @@
+---
+issue: 188
+issue_title: "refactor(pi-subagents): replace any casts with SDK types in extractText and SubscribableSession"
+---
+
+# Replace `any` casts with SDK types
+
+## Problem Statement
+
+Two places in pi-subagents use `any` where proper SDK types are available and already imported in adjacent files.
+`extractText` in `session/context.ts` uses `(c: any)` in a filter/map chain, requiring a top-level `eslint-disable` for `no-unsafe-member-access` and `no-unsafe-return`.
+`record-observer.ts` and `ui-observer.ts` each define an identical local `SubscribableSession` interface with `(event: any) => void`, creating both a type hole and duplicated boilerplate.
+
+## Goals
+
+- Replace `any` casts in `extractText` with a `TextContent` type predicate.
+- Remove the `eslint-disable` comment from `session/context.ts`.
+- Replace `any` in the `SubscribableSession` interface with `AgentSessionEvent`.
+- Deduplicate the `SubscribableSession` interface into a single shared definition.
+
+## Non-Goals
+
+- Changing the `extractText` parameter type from `unknown[]` — callers in `message-formatters.ts` pass `unknown[]`, and widening the refactoring surface is out of scope.
+- Replacing the `SubscribableSession` interface with the full `AgentSession` class — ISP requires a narrow interface (the observers only need `subscribe`).
+- Addressing the `eslint-disable` in `record-observer.ts` and `ui-observer.ts` for `no-unsafe-member-access` / `no-unsafe-assignment` — those are caused by the `event` property access pattern inside the callback body, not by the parameter type.
+  Once the callback parameter is typed as `AgentSessionEvent`, the unsafe-access rules should be satisfied and those `eslint-disable` comments can be removed too.
+
+## Background
+
+### Existing conventions
+
+`content-items.ts` already imports `TextContent` from `@earendil-works/pi-ai` and uses `(c as TextContent).text` after a `c.type === "text"` guard.
+`agent-runner.ts` already imports `AgentSessionEvent` from `@earendil-works/pi-coding-agent` and uses it as the parameter type in `session.subscribe((event: AgentSessionEvent) => { ... })`.
+Both SDK types are proven to work in this package.
+
+### `extractText` callers
+
+`extractText(content: unknown[])` is called from:
+
+- `session/context.ts` — `buildParentContext` passes `msg.content` from session entries.
+- `lifecycle/agent-runner.ts` — `getLastAssistantText` and `getAgentConversation` pass `msg.content`.
+- `ui/message-formatters.ts` — `formatUserMessage` and `formatToolResult` pass `unknown[]` content.
+
+The parameter type stays `unknown[]` to avoid rippling through callers.
+The type predicate narrows inside the function body.
+
+### `SubscribableSession` consumers
+
+Both `subscribeRecordObserver` and `subscribeUIObserver` accept a `SubscribableSession` parameter.
+Tests use `createMockSession()` from `test/helpers/mock-session.ts`, which returns a `MockSession` with `subscribe: Mock<(fn: (event: unknown) => void) => () => void>`.
+
+Changing `SubscribableSession.subscribe` to accept `(event: AgentSessionEvent) => void` is structurally sound: the mock's `subscribe` accepting `(fn: (event: unknown) => void)` is a supertype — a function that accepts any event can accept an `AgentSessionEvent`.
+The TypeScript compiler allows this because of function parameter contravariance.
+Tests construct inline event objects that match `AgentSessionEvent` member shapes, so no test changes are needed.
+
+### Shared location for `SubscribableSession`
+
+The interface is used by two domains (observation, UI).
+A new shared types location is needed.
+The existing `types.ts` at the package root contains cross-cutting types (`SubagentType`, `ThinkingLevel`, `ShellExec`).
+`SubscribableSession` fits there — it's a narrow cross-domain interface for session event subscription.
+
+## Design Overview
+
+### `extractText` type predicate
+
+Replace the `any` casts with a user-defined type guard:
+
+```typescript
+import type { TextContent } from "@earendil-works/pi-ai";
+
+function isTextContent(c: unknown): c is TextContent {
+  return typeof c === "object" && c !== null && (c as { type: string }).type === "text";
+}
+
+export function extractText(content: unknown[]): string {
+  return content
+    .filter(isTextContent)
+    .map((c) => c.text ?? "")
+    .join("\n");
+}
+```
+
+The type predicate eliminates both `any` casts and the `eslint-disable` at the top of the file.
+
+### `SubscribableSession` with `AgentSessionEvent`
+
+Move the interface to `types.ts` and type the callback:
+
+```typescript
+import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+
+export interface SubscribableSession {
+  subscribe(fn: (event: AgentSessionEvent) => void): () => void;
+}
+```
+
+Both observer files import from `types.ts` instead of defining their own.
+
+### Event property access in observer callbacks
+
+Once the callback parameter is typed as `AgentSessionEvent`, TypeScript knows the event's discriminated union members.
+The `event.type` checks narrow the union, so `event.toolName`, `event.message`, etc. become type-safe.
+The `eslint-disable` comments for `no-unsafe-member-access` and `no-unsafe-assignment` can be removed from both observer files.
+
+## Module-Level Changes
+
+| File                                 | Change                                                                                                                                                        |
+| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `src/session/context.ts`             | Import `TextContent`; add `isTextContent` type predicate; replace `any` filter/map; remove top-level `eslint-disable`                                         |
+| `src/types.ts`                       | Add `SubscribableSession` interface with `AgentSessionEvent` callback type; add `AgentSessionEvent` import                                                    |
+| `src/observation/record-observer.ts` | Import `SubscribableSession` from `types.ts`; remove local interface; remove top-level `eslint-disable`; remove inline `any` annotation on callback parameter |
+| `src/ui/ui-observer.ts`              | Import `SubscribableSession` from `types.ts`; remove local interface; remove top-level `eslint-disable`; remove inline `any` annotation on callback parameter |
+
+No test file changes expected — the mock session's structural typing remains compatible.
+
+## Test Impact Analysis
+
+1. No new unit tests are needed — the refactoring is type-only (no behavioral change).
+2. No existing tests become redundant.
+3. All existing tests for `subscribeRecordObserver` and `subscribeUIObserver` must pass as-is — they verify the same event-handling behavior.
+
+## TDD Order
+
+This is a pure refactoring with no behavioral change.
+Each step should pass `pnpm run check` (type-check) and `pnpm vitest run` (tests) before committing.
+
+1. **Add `isTextContent` type predicate and remove `any` from `extractText`.**
+   Import `TextContent` from `@earendil-works/pi-ai`.
+   Add `isTextContent` predicate function.
+   Replace the `any`-cast filter/map chain with the predicate.
+   Remove the top-level `eslint-disable` comment.
+   Verify: `pnpm run check`, `pnpm vitest run`.
+   Commit: `refactor: replace any casts in extractText with TextContent type predicate (#188)`
+
+2. **Move `SubscribableSession` to `types.ts` with `AgentSessionEvent`.**
+   Add `AgentSessionEvent` import and `SubscribableSession` interface to `src/types.ts`.
+   Update `record-observer.ts`: import from `types.ts`, remove local interface, remove `eslint-disable`, remove `any` from callback parameter.
+   Update `ui-observer.ts`: import from `types.ts`, remove local interface, remove `eslint-disable`, remove `any` from callback parameter.
+   Verify: `pnpm run check`, `pnpm vitest run`.
+   Commit: `refactor: replace any in SubscribableSession with AgentSessionEvent (#188)`
+
+## Risks and Mitigations
+
+1. **`AgentSessionEvent` union may not cover all event shapes accessed in observers.**
+   Mitigation: `agent-runner.ts` already uses the same type for identical event patterns (`event.type`, `event.toolName`, `event.message`).
+   The type checker will flag any property access that the union doesn't support.
+   Run `pnpm run check` after each step.
+
+2. **Mock session type incompatibility.**
+   The mock's `subscribe` accepts `(fn: (event: unknown) => void)`.
+   A `SubscribableSession` with `(fn: (event: AgentSessionEvent) => void)` is structurally compatible via contravariance.
+   If the compiler disagrees, the mitigation is to update `MockSession.subscribe` to accept `(fn: (event: AgentSessionEvent) => void)` — a one-line change.
+
+3. **`TextContent.text` is non-optional in the SDK type.**
+   The current code uses `c.text ?? ""` which implies `text` could be undefined.
+   `TextContent` defines `text: string` (required), so the nullish coalescing is harmless but unnecessary.
+   Keep it for safety — removing it is a separate cleanup.
+
+## Open Questions
+
+None — the issue's proposed approach is unambiguous and the SDK types are already validated in adjacent files.

package/docs/retro/0172-extract-turn-formatting.md

@@ -38,3 +38,43 @@ Test count went from 896 to 907 (+11).
 - `message-formatters.ts` had both an import and a re-export of `getToolCallName`; simplified to a pure re-export only.
 - The lint fixup (unused import) was amended into the same refactor commit before pushing.
 - Architecture doc updated: `content-items.ts` added to session module listing, production-duplication section updated, Step 9 marked Done.
+
+## Stage: Final Retrospective (2026-05-24T20:30:00Z)
+
+### Session summary
+
+Planned, implemented, and shipped the extraction of shared turn-formatting logic from `lifecycle/agent-runner.ts` and `ui/message-formatters.ts` into `session/content-items.ts`.
+Released as `pi-subagents-v6.19.0`.
+During code review the user challenged double-casts in the initial implementation, which led to discovering that the local `ToolCallContent` type was dead code and the SDK exports the real `ToolCall` type — the final implementation is significantly cleaner than what the plan specified.
+Filed #188 for broader `any`-to-SDK-type cleanup discovered during the investigation.
+
+### Observations
+
+#### What went well
+
+- The user's Socratic challenge ("Talk to me about these double-casts") was the pivotal moment.
+  Rather than directing a fix, it prompted an investigation of the SDK's actual `ToolCall` type, which revealed that `ToolCall.name` is always required and `toolName` never appears on content items.
+  This eliminated the `ToolCallContent` interface, the `toolName` fallback, the index-signature parameter type, and all double-casts — none of which the plan anticipated.
+- Cross-session retro context worked well: the planning-stage note about #170 shifting the duplication target saved time during TDD.
+- The SDK source investigation yielded a follow-up issue (#188) for replacing `any` casts in `extractText` and `SubscribableSession` with proper SDK types.
+
+#### What caused friction (agent side)
+
+- `missing-context` — Did not check SDK type exports during planning.
+  The plan copied `ToolCallContent` verbatim from the existing code without verifying what `@earendil-works/pi-ai` exports.
+  The source comments ("SDK doesn't export the narrow type") were wrong — the types have been exported for some time.
+  Impact: the initial TDD implementation introduced a `{ type: string; [key: string]: unknown }` parameter type that forced `as unknown as` double-casts, requiring a full rework after user review.
+- `premature-convergence` — When TypeScript rejected excess properties in test object literals, I widened the parameter type to include an index signature instead of exploring alternatives.
+  The correct fix (using `ReadonlyArray<{ type: string }>` with `in` narrowing, or importing SDK types as test fixtures) was simpler and avoided the cast cascade.
+  Impact: one round of rework plus an amended commit that muddied the git history.
+
+#### What caused friction (user side)
+
+- The user's intervention at the cast review stage was well-timed and effective.
+  One earlier opportunity: if the user had flagged the `toolName` fallback or the SDK-type question during the plan review (before TDD started), the initial implementation would have been correct from the start.
+  However, this is a marginal improvement — the plan review was clean and the friction was minor.
+
+### Changes made
+
+1. `.pi/skills/code-design/SKILL.md` — Added two rules to "Pi SDK boundaries": verify SDK exports before redeclaring types locally; prefer minimal structural supertypes over index-signature types for parameters accepting SDK content.
+2. `.pi/skills/testing/SKILL.md` — Added TDD planning rule: verify SDK exports when extracting locally-declared types that shadow SDK types.

package/docs/retro/0185-remove-persistent-agent-memory.md

@@ -0,0 +1,39 @@
+---
+issue: 185
+issue_title: "pi-subagents: Remove persistent agent memory feature"
+---
+
+# Retro: #185 — pi-subagents: Remove persistent agent memory feature
+
+## Stage: Planning (2026-05-24T20:46:56Z)
+
+### Session summary
+
+Traced all memory-related code across 9 source files, 5 test files, and the architecture doc.
+Produced a 5-step TDD plan: extract shared utilities (`isSymlink`, `isUnsafeName`, `safeReadFile`) to `safe-fs.ts`, then remove memory consumers (session assembly, config, UI), then delete the module, then update docs.
+
+### Observations
+
+- The three utility functions in `memory.ts` are the only complication — `skill-loader.ts` imports them independently of memory.
+  Extracting to `src/session/safe-fs.ts` keeps them co-located with their sole remaining consumer.
+- The removal is consumers-first, declaration-last: session-config and prompts lose their memory logic before `MemoryScope` is removed from `types.ts`, avoiding intermediate type errors.
+- No ambiguous design choices — the issue scope section is precise about what to remove and what to extract.
+- Memory field in custom agent frontmatter will silently become a no-op (ignored by the YAML parser) — no user-facing error, just loss of the feature.
+- The `AssemblerIO` interface shrinks from 4 fields to 2 after removal, which is a welcome simplification.
+
+## Stage: Implementation — TDD (2026-05-24T22:41:23Z)
+
+### Session summary
+
+All 5 TDD steps completed across 5 commits.
+Test count went from 901 (54 files) to 848 (53 files) — a net reduction of 53 tests and 1 file, reflecting the deletion of the `memory.test.ts` file with its memory-specific tests and the removal of memory-related tests from `session-config.test.ts`, `prompts.test.ts`, `agent-types.test.ts`, and `custom-agents.test.ts`.
+New file `safe-fs.test.ts` was created with 13 tests for the extracted utilities.
+
+### Observations
+
+- Step 1 had a subtle bug: after re-exporting `isUnsafeName` from `safe-fs` in `memory.ts`, the function was not imported into the `memory.ts` module scope itself, so `resolveMemoryDir` got a `ReferenceError` at runtime.
+  Fix was trivial: add `isUnsafeName` to the import alongside `isSymlink` and `safeReadFile`.
+- Step 3 introduced a type error in `memory.ts` (still alive at that point): `MemoryScope` was imported from `#src/types` which no longer exported it.
+  Fix: inline the literal union `"user" | "project" | "local"` directly in `memory.ts` as a local type, so it compiles cleanly until deletion in step 4.
+- The `SKILL.md` for `package-pi-subagents` also listed `memory.ts` in the session domain table — updated alongside `architecture.md` in the docs commit.
+- No deviations from the plan other than the two minor bugs above (both self-corrected within the same TDD step).

package/docs/retro/0188-replace-any-casts-with-sdk-types.md

@@ -0,0 +1,69 @@
+---
+issue: 188
+issue_title: "refactor(pi-subagents): replace any casts with SDK types in extractText and SubscribableSession"
+---
+
+# Retro: #188 — Replace any casts with SDK types
+
+## Stage: Planning (2026-05-24T20:04:58Z)
+
+### Session summary
+
+Produced a two-step refactoring plan for replacing `any` casts in `extractText` (with a `TextContent` type predicate) and `SubscribableSession` (with `AgentSessionEvent`).
+Verified that both SDK types are already imported and used in adjacent files within the package.
+Confirmed mock session compatibility via function parameter contravariance — no test changes expected.
+
+### Observations
+
+- The `extractText` parameter type stays `unknown[]` to avoid rippling through callers in `message-formatters.ts` that declare `content: unknown[]`.
+  A future cleanup could tighten those caller signatures.
+- `SubscribableSession` moves to `src/types.ts` as the shared location, matching existing cross-domain types there (`SubagentType`, `ThinkingLevel`, `ShellExec`).
+- All three `eslint-disable` top-level comments (`context.ts`, `record-observer.ts`, `ui-observer.ts`) should be removable once the `any` casts are gone, since the SDK union's discriminated members cover the property access patterns.
+- Risk: if `AgentSessionEvent` doesn't cover `assistantMessageEvent` in `ui-observer.ts`, the type checker will surface it immediately — the mitigation is to check the union members during implementation.
+
+## Stage: Implementation — TDD (2026-05-24T20:17:38Z)
+
+### Session summary
+
+Completed both TDD steps from the plan.
+Step 1 replaced the `any` filter/map chain in `extractText` with an `isTextContent` type predicate; the `??""` removal was required because `TextContent.text` is non-optional per the SDK type.
+Step 2 moved `SubscribableSession` to `types.ts` typed with `AgentSessionEvent`, removed both duplicate local interfaces, and removed all three `eslint-disable` comments.
+Test count: 902 → 901 (one test removed).
+
+### Observations
+
+- The `??` operator on `c.text` in `extractText` triggered `@typescript-eslint/no-unnecessary-condition` at commit time because `TextContent.text` is `string` (non-nullable); removing it was necessary, not just cosmetic.
+- After typing the `record-observer` callback as `AgentSessionEvent`, five additional lint errors surfaced: `event.message?.role` (optional chain unnecessary since `MessageEndEvent.message` is required), `if (u)` guard (unnecessary since `AssistantMessage.usage` is required), and three `?? 0` guards on `input`/`output`/`cacheWrite` (all required `number` fields per `Usage` interface in the Pi source at `~/development/pi/pi/packages/ai/src/types.ts`).
+- The test `"ignores message_end without usage"` was removed — it emitted a non-conforming event that the SDK types guarantee cannot occur at runtime.
+- `ui-observer.ts` had one analogous fix: `event.assistantMessageEvent?.type` → `.type` (the field is required on `MessageUpdateEvent`).
+- No test file changes were needed for `ui-observer.ts` — its existing tests all emit conforming events.
+- The plan's contravariance reasoning about mock session compatibility was correct: `pnpm run check` passed without updating `MockSession.subscribe`.
+
+## Stage: Final Retrospective (2026-05-24T20:41:42Z)
+
+### Session summary
+
+Clean two-step refactoring shipped as `pi-subagents-v6.19.1`.
+Both TDD steps completed in a single session with two minor deviations from the plan, both caught by pre-commit hooks.
+Test count: 902 → 901 (one non-conforming test removed).
+
+### Observations
+
+#### What went well
+
+- The plan's contravariance analysis of `MockSession.subscribe` vs `SubscribableSession` was correct — zero test infrastructure changes needed.
+- Pre-commit hooks (ESLint) caught both deviations from the plan at commit time, before they could reach CI.
+- The user providing the Pi source path (`~/development/pi/pi`) unblocked verification of `AssistantMessage.usage` field requirements without guesswork.
+
+#### What caused friction (agent side)
+
+- `missing-context` — The plan's Risk 3 said "keep `?? ""` for safety" on `TextContent.text`, but `@typescript-eslint/no-unnecessary-condition` rejected it at commit time because `TextContent.text: string` is non-optional.
+  Impact: one failed commit attempt, immediate fix (changed `.map((c) => c.text ?? "")` to `.map((c) => c.text)`).
+- `missing-context` — The plan's step 2 didn't anticipate the five additional lint errors surfaced by properly typing the `record-observer` callback: unnecessary optional chain on `event.message?.role`, unnecessary `if (u)` guard, and three unnecessary `?? 0` guards on usage fields.
+  Impact: added ~5 minutes of investigation to verify the SDK types were truly non-optional before removing guards; required removing one test case (`"ignores message_end without usage"`).
+  Both instances stem from the same root cause: the plan checked that the SDK types *existed* but didn't trace the *field optionality* of types downstream of `AgentSessionEvent` (specifically `AgentMessage.usage` and `Usage.{input,output,cacheWrite}`).
+
+#### What caused friction (user side)
+
+- The Pi source path (`~/development/pi/pi`) was provided reactively after I'd already spent several tool calls trying to locate `AgentMessage` type definitions in `node_modules`.
+  Sharing this path earlier (or noting it in the package skill) would have saved ~4 `grep`/`find` calls.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotgenes/pi-subagents",
-  "version": "6.19.0",
+  "version": "7.0.0",
   "type": "module",
   "exports": {
     ".": "./src/service.ts"

package/src/config/agent-types.ts

@@ -133,23 +133,3 @@ export class AgentTypeRegistry implements AgentConfigLookup {
 
 /** All known built-in tool names. */
 export const BUILTIN_TOOL_NAMES: string[] = ["read", "bash", "edit", "write", "grep", "find", "ls"];
-
-/** Tool names required for memory management. */
-const MEMORY_TOOL_NAMES = ["read", "write", "edit"];
-
-/**
- * Get memory tool names (read/write/edit) not already in the provided set.
- */
-export function getMemoryToolNames(existingToolNames: Set<string>): string[] {
-  return MEMORY_TOOL_NAMES.filter(n => !existingToolNames.has(n));
-}
-
-/** Tool names needed for read-only memory access. */
-const READONLY_MEMORY_TOOL_NAMES = ["read"];
-
-/**
- * Get read-only memory tool names not already in the provided set.
- */
-export function getReadOnlyMemoryToolNames(existingToolNames: Set<string>): string[] {
-  return READONLY_MEMORY_TOOL_NAMES.filter(n => !existingToolNames.has(n));
-}

package/src/config/custom-agents.ts

@@ -7,7 +7,7 @@ import { basename, join } from "node:path";
 import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
 import { BUILTIN_TOOL_NAMES } from "#src/config/agent-types";
 import { debugLog } from "#src/debug";
-import type { AgentConfig, MemoryScope, ThinkingLevel } from "#src/types";
+import type { AgentConfig, ThinkingLevel } from "#src/types";
 
 /**
  * Scan for custom agent .md files from multiple locations.
@@ -69,7 +69,6 @@ function loadFromDir(dir: string, agents: Map<string, AgentConfig>, source: "pro
       inheritContext: fm.inherit_context != null ? fm.inherit_context === true : undefined,
       runInBackground: fm.run_in_background != null ? fm.run_in_background === true : undefined,
       isolated: fm.isolated != null ? fm.isolated === true : undefined,
-      memory: parseMemory(fm.memory),
       isolation: fm.isolation === "worktree" ? "worktree" : undefined,
       enabled: fm.enabled !== false,  // default true; explicitly false disables
       source,
@@ -119,15 +118,6 @@ function csvListOptional(val: unknown): string[] | undefined {
   return parseCsvField(val);
 }
 
-/**
- * Parse a memory scope field.
- * omitted → undefined; "user"/"project"/"local" → MemoryScope.
- */
-function parseMemory(val: unknown): MemoryScope | undefined {
-  if (val === "user" || val === "project" || val === "local") return val;
-  return undefined;
-}
-
 /**
  * Parse an inherit field (extensions, skills).
  * omitted/true → true (inherit all); false/"none"/empty → false; csv → listed names.

package/src/index.ts

@@ -34,7 +34,7 @@ import { createSubagentRuntime } from "#src/runtime";
 import { publishSubagentsService, unpublishSubagentsService } from "#src/service/service";
 import { createSubagentsService } from "#src/service/service-adapter";
 import { detectEnv } from "#src/session/env";
-import { buildMemoryBlock, buildReadOnlyMemoryBlock } from "#src/session/memory";
+
 import { type ModelRegistry, resolveModel } from "#src/session/model-resolver";
 import { buildAgentPrompt } from "#src/session/prompts";
 import { deriveSubagentSessionDir } from "#src/session/session-dir";
@@ -146,8 +146,6 @@ export default function (pi: ExtensionAPI) {
     createSession: (opts) => createAgentSession(opts as any),
     assemblerIO: {
       preloadSkills,
-      buildMemoryBlock,
-      buildReadOnlyMemoryBlock,
       buildAgentPrompt,
     },
   };

package/src/observation/record-observer.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment -- Pi SDK types are not fully exported; see upstream Pi SDK for type improvements */
 /**
  * record-observer.ts — Subscribes to session events and updates AgentRecord stats.
  *
@@ -8,11 +7,7 @@
 
 import type { CompactionInfo } from "#src/lifecycle/agent-manager";
 import type { AgentRecord } from "#src/lifecycle/agent-record";
-
-/** Narrow session interface — only the subscribe method needed by the observer. */
-interface SubscribableSession {
-  subscribe(fn: (event: any) => void): () => void;
-}
+import type { SubscribableSession } from "#src/types";
 
 export interface RecordObserverOptions {
   onCompact?: (record: AgentRecord, info: CompactionInfo) => void;
@@ -33,20 +28,18 @@ export function subscribeRecordObserver(
   record: AgentRecord,
   options?: RecordObserverOptions,
 ): () => void {
-  return session.subscribe((event: any) => {
+  return session.subscribe((event) => {
     if (event.type === "tool_execution_end") {
       record.incrementToolUses();
     }
 
-    if (event.type === "message_end" && event.message?.role === "assistant") {
+    if (event.type === "message_end" && event.message.role === "assistant") {
       const u = event.message.usage;
-      if (u) {
-        record.addUsage({
-          input: u.input ?? 0,
-          output: u.output ?? 0,
-          cacheWrite: u.cacheWrite ?? 0,
-        });
-      }
+      record.addUsage({
+        input: u.input,
+        output: u.output,
+        cacheWrite: u.cacheWrite,
+      });
     }
 
     if (event.type === "compaction_end" && !event.aborted && event.result) {

package/src/session/context.ts

@@ -1,15 +1,20 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return -- Pi SDK types are not fully exported; see upstream Pi SDK for type improvements */
 /**
  * context.ts — Extract parent conversation context for subagent inheritance.
  */
 
+import type { TextContent } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
+/** Type predicate: narrow an unknown content block to TextContent. */
+function isTextContent(c: unknown): c is TextContent {
+  return typeof c === "object" && c !== null && (c as { type: string }).type === "text";
+}
+
 /** Extract text from a message content block array. */
 export function extractText(content: unknown[]): string {
   return content
-    .filter((c: any) => c.type === "text")
-    .map((c: any) => c.text ?? "")
+    .filter(isTextContent)
+    .map((c) => c.text)
     .join("\n");
 }
 

package/src/session/prompts.ts

@@ -5,10 +5,8 @@
 import type { EnvInfo } from "#src/session/env";
 import type { AgentPromptConfig } from "#src/types";
 
-/** Extra sections to inject into the system prompt (memory, skills, etc.). */
+/** Extra sections to inject into the system prompt (skills, etc.). */
 export interface PromptExtras {
-  /** Persistent memory content to inject (first 200 lines of MEMORY.md + instructions). */
-  memoryBlock?: string;
   /** Preloaded skill contents to inject. */
   skillBlocks?: { name: string; content: string }[];
 }
@@ -45,9 +43,6 @@ Platform: ${env.platform}`;
 
   // Build optional extras suffix
   const extraSections: string[] = [];
-  if (extras?.memoryBlock) {
-    extraSections.push(extras.memoryBlock);
-  }
   if (extras?.skillBlocks?.length) {
     for (const skill of extras.skillBlocks) {
       extraSections.push(

package/src/session/safe-fs.ts

@@ -0,0 +1,45 @@
+/**
+ * safe-fs.ts — Filesystem safety utilities for reading untrusted paths.
+ *
+ * Used by skill-loader.ts to reject symlinks and path-traversal names
+ * before reading skill files from disk.
+ */
+
+import { existsSync, lstatSync, readFileSync } from "node:fs";
+import { debugLog } from "#src/debug";
+
+/**
+ * Returns true if a name contains characters not allowed in agent/skill names.
+ * Uses a whitelist: only alphanumeric, hyphens, underscores, and dots (no leading dot).
+ */
+export function isUnsafeName(name: string): boolean {
+  if (!name || name.length > 128) return true;
+  return !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name);
+}
+
+/**
+ * Returns true if the given path is a symlink (defense against symlink attacks).
+ */
+export function isSymlink(filePath: string): boolean {
+  try {
+    return lstatSync(filePath).isSymbolicLink();
+  } catch (err) {
+    debugLog("lstatSync", err);
+    return false;
+  }
+}
+
+/**
+ * Safely read a file, rejecting symlinks.
+ * Returns undefined if the file doesn't exist, is a symlink, or can't be read.
+ */
+export function safeReadFile(filePath: string): string | undefined {
+  if (!existsSync(filePath)) return undefined;
+  if (isSymlink(filePath)) return undefined;
+  try {
+    return readFileSync(filePath, "utf-8");
+  } catch (err) {
+    debugLog("readFileSync", err);
+    return undefined;
+  }
+}

package/src/session/session-config.ts

@@ -10,20 +10,11 @@
  * before invoking this function, keeping the assembler synchronous.
  */
 
-import {
-  type AgentConfigLookup,
-  getMemoryToolNames,
-  getReadOnlyMemoryToolNames,
-} from "#src/config/agent-types";
+import type { AgentConfigLookup } from "#src/config/agent-types";
 import type { EnvInfo } from "#src/session/env";
 import type { PromptExtras } from "#src/session/prompts";
 import type { PreloadedSkill } from "#src/session/skill-loader";
-import type {
-  AgentPromptConfig,
-  MemoryScope,
-  SubagentType,
-  ThinkingLevel,
-} from "#src/types";
+import type { AgentPromptConfig, SubagentType, ThinkingLevel } from "#src/types";
 
 // ── Public interfaces ────────────────────────────────────────────────────────
 
@@ -52,12 +43,6 @@ export interface ToolFilterConfig {
  */
 export interface AssemblerIO {
   preloadSkills: (skills: string[], cwd: string) => PreloadedSkill[];
-  buildMemoryBlock: (name: string, scope: MemoryScope, cwd: string) => string;
-  buildReadOnlyMemoryBlock: (
-    name: string,
-    scope: MemoryScope,
-    cwd: string,
-  ) => string;
   buildAgentPrompt: (
     config: AgentPromptConfig,
     cwd: string,
@@ -210,38 +195,7 @@ export function assembleSessionConfig(
     }
   }
 
-  let toolNames = registry.getToolNamesForType(type);
-
-  // Persistent memory: detect write capability and branch accordingly.
-  // Account for disallowedTools — a tool in the base set but on the denylist
-  // is not truly available.
-  if (agentConfig.memory) {
-    const existingNames = new Set(toolNames);
-    const denied = agentConfig.disallowedTools
-      ? new Set(agentConfig.disallowedTools)
-      : undefined;
-    const effectivelyHas = (name: string) =>
-      existingNames.has(name) && !denied?.has(name);
-    const hasWriteTools = effectivelyHas("write") || effectivelyHas("edit");
-
-    if (hasWriteTools) {
-      const extraNames = getMemoryToolNames(existingNames);
-      if (extraNames.length > 0) toolNames = [...toolNames, ...extraNames];
-      extras.memoryBlock = io.buildMemoryBlock(
-        agentConfig.name,
-        agentConfig.memory,
-        effectiveCwd,
-      );
-    } else {
-      const extraNames = getReadOnlyMemoryToolNames(existingNames);
-      if (extraNames.length > 0) toolNames = [...toolNames, ...extraNames];
-      extras.memoryBlock = io.buildReadOnlyMemoryBlock(
-        agentConfig.name,
-        agentConfig.memory,
-        effectiveCwd,
-      );
-    }
-  }
+  const toolNames = registry.getToolNamesForType(type);
 
   // Build system prompt from the resolved agent config
   const systemPrompt = io.buildAgentPrompt(

package/src/session/skill-loader.ts

@@ -24,7 +24,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { debugLog } from "#src/debug";
-import { isSymlink, isUnsafeName, safeReadFile } from "#src/session/memory";
+import { isSymlink, isUnsafeName, safeReadFile } from "#src/session/safe-fs";
 
 export interface PreloadedSkill {
   name: string;

package/src/types.ts

@@ -3,17 +3,23 @@
  */
 
 import type { ThinkingLevel } from "@earendil-works/pi-ai";
+import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 
 
 export { AgentRecord } from "#src/lifecycle/agent-record";
-export type { ThinkingLevel };
+export type { AgentSessionEvent, ThinkingLevel };
+
+/**
+ * Narrow session interface for event subscription.
+ * Used by record-observer and ui-observer — only the subscribe method is needed.
+ */
+export interface SubscribableSession {
+  subscribe(fn: (event: AgentSessionEvent) => void): () => void;
+}
 
 /** Agent type: any string name (built-in defaults or user-defined). */
 export type SubagentType = string;
 
-/** Memory scope for persistent agent memory. */
-export type MemoryScope = "user" | "project" | "local";
-
 /** Isolation mode for agent execution. */
 export type IsolationMode = "worktree";
 
@@ -50,8 +56,6 @@ export interface AgentConfig extends AgentIdentity, AgentPromptConfig {
   runInBackground?: boolean;
   /** Default for spawn: no extension tools. undefined = caller decides. */
   isolated?: boolean;
-  /** Persistent memory scope — agents with memory get a persistent directory and MEMORY.md */
-  memory?: MemoryScope;
   /** Isolation mode — "worktree" runs the agent in a temporary git worktree */
   isolation?: IsolationMode;
   /** true = this is an embedded default agent (informational) */

package/src/ui/agent-config-editor.ts

@@ -131,7 +131,6 @@ export function createAgentConfigEditor(
     if (cfg.inheritContext) fmFields.push("inherit_context: true");
     if (cfg.runInBackground) fmFields.push("run_in_background: true");
     if (cfg.isolated) fmFields.push("isolated: true");
-    if (cfg.memory) fmFields.push(`memory: ${cfg.memory}`);
     if (cfg.isolation) fmFields.push(`isolation: ${cfg.isolation}`);
 
     const content = `---\n${fmFields.join("\n")}\n---\n\n${cfg.systemPrompt}\n`;

package/src/ui/agent-creation-wizard.ts

@@ -115,7 +115,6 @@ disallowed_tools: <comma-separated tool names to block, even if otherwise availa
 inherit_context: <true to fork parent conversation into agent so it sees chat history. Default: false>
 run_in_background: <true to run in background by default. Default: false>
 isolated: <true for no extension/MCP tools, only built-in tools. Default: false>
-memory: <"user" (global), "project" (per-project), or "local" (gitignored per-project) for persistent memory. Omit for none>
 isolation: <"worktree" to run in isolated git worktree. Omit for normal>
 ---
 

package/src/ui/ui-observer.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument -- Pi SDK types are not fully exported; see upstream Pi SDK for type improvements */
 /**
  * ui-observer.ts — Subscribes to session events and updates AgentActivityTracker state.
  *
@@ -7,13 +6,9 @@
  * turn count, lifetime usage).
  */
 
+import type { SubscribableSession } from "#src/types";
 import type { AgentActivityTracker } from "#src/ui/agent-activity-tracker";
 
-/** Narrow session interface — only the subscribe method needed by the observer. */
-interface SubscribableSession {
-	subscribe(fn: (event: any) => void): () => void;
-}
-
 /**
  * Subscribe to session events and stream UI state into an AgentActivityTracker.
  *
@@ -34,7 +29,7 @@ export function subscribeUIObserver(
 	tracker: AgentActivityTracker,
 	onUpdate?: () => void,
 ): () => void {
-	return session.subscribe((event: any) => {
+	return session.subscribe((event) => {
 		if (event.type === "tool_execution_start") {
 			tracker.onToolStart(event.toolName);
 			onUpdate?.();
@@ -51,7 +46,7 @@ export function subscribeUIObserver(
 
 		if (
 			event.type === "message_update" &&
-			event.assistantMessageEvent?.type === "text_delta"
+			event.assistantMessageEvent.type === "text_delta"
 		) {
 			tracker.onMessageUpdate(event.assistantMessageEvent.delta);
 			onUpdate?.();

package/src/session/memory.ts

@@ -1,168 +0,0 @@
-/**
- * memory.ts — Persistent agent memory: per-agent memory directories that persist across sessions.
- *
- * Memory scopes:
- *   - "user"    → ~/.pi/agent-memory/{agent-name}/
- *   - "project" → .pi/agent-memory/{agent-name}/
- *   - "local"   → .pi/agent-memory-local/{agent-name}/
- */
-
-import { existsSync, lstatSync, mkdirSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, } from "node:path";
-import { debugLog } from "#src/debug";
-import type { MemoryScope } from "#src/types";
-
-/** Maximum lines to read from MEMORY.md */
-const MAX_MEMORY_LINES = 200;
-
-/**
- * Returns true if a name contains characters not allowed in agent/skill names.
- * Uses a whitelist: only alphanumeric, hyphens, underscores, and dots (no leading dot).
- */
-export function isUnsafeName(name: string): boolean {
-  if (!name || name.length > 128) return true;
-  return !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name);
-}
-
-/**
- * Returns true if the given path is a symlink (defense against symlink attacks).
- */
-export function isSymlink(filePath: string): boolean {
-  try {
-    return lstatSync(filePath).isSymbolicLink();
-  } catch (err) {
-    debugLog("lstatSync", err);
-    return false;
-  }
-}
-
-/**
- * Safely read a file, rejecting symlinks.
- * Returns undefined if the file doesn't exist, is a symlink, or can't be read.
- */
-export function safeReadFile(filePath: string): string | undefined {
-  if (!existsSync(filePath)) return undefined;
-  if (isSymlink(filePath)) return undefined;
-  try {
-    return readFileSync(filePath, "utf-8");
-  } catch (err) {
-    debugLog("readFileSync", err);
-    return undefined;
-  }
-}
-
-/**
- * Resolve the memory directory path for a given agent + scope + cwd.
- * Throws if agentName contains path traversal characters.
- */
-export function resolveMemoryDir(agentName: string, scope: MemoryScope, cwd: string): string {
-  if (isUnsafeName(agentName)) {
-    throw new Error(`Unsafe agent name for memory directory: "${agentName}"`);
-  }
-  switch (scope) {
-    case "user":
-      return join(homedir(), ".pi", "agent-memory", agentName);
-    case "project":
-      return join(cwd, ".pi", "agent-memory", agentName);
-    case "local":
-      return join(cwd, ".pi", "agent-memory-local", agentName);
-  }
-}
-
-/**
- * Ensure the memory directory exists, creating it if needed.
- * Refuses to create directories if any component in the path is a symlink
- * to prevent symlink-based directory traversal attacks.
- */
-export function ensureMemoryDir(memoryDir: string): void {
-  // If the directory already exists, verify it's not a symlink
-  if (existsSync(memoryDir)) {
-    if (isSymlink(memoryDir)) {
-      throw new Error(`Refusing to use symlinked memory directory: ${memoryDir}`);
-    }
-    return;
-  }
-  mkdirSync(memoryDir, { recursive: true });
-}
-
-/**
- * Read the first N lines of MEMORY.md from the memory directory, if it exists.
- * Returns undefined if no MEMORY.md exists or if the path is a symlink.
- */
-export function readMemoryIndex(memoryDir: string): string | undefined {
-  // Reject symlinked memory directories
-  if (isSymlink(memoryDir)) return undefined;
-
-  const memoryFile = join(memoryDir, "MEMORY.md");
-  const content = safeReadFile(memoryFile);
-  if (content === undefined) return undefined;
-
-  const lines = content.split("\n");
-  if (lines.length > MAX_MEMORY_LINES) {
-    return lines.slice(0, MAX_MEMORY_LINES).join("\n") + "\n... (truncated at 200 lines)";
-  }
-  return content;
-}
-
-/**
- * Build the memory block to inject into the agent's system prompt.
- * Also ensures the memory directory exists (creates it if needed).
- */
-export function buildMemoryBlock(agentName: string, scope: MemoryScope, cwd: string): string {
-  const memoryDir = resolveMemoryDir(agentName, scope, cwd);
-  // Create the memory directory so the agent can immediately write to it
-  ensureMemoryDir(memoryDir);
-
-  const existingMemory = readMemoryIndex(memoryDir);
-
-  const header = `# Agent Memory
-
-You have a persistent memory directory at: ${memoryDir}/
-Memory scope: ${scope}
-
-This memory persists across sessions. Use it to build up knowledge over time.`;
-
-  const memoryContent = existingMemory
-    ? `\n\n## Current MEMORY.md\n${existingMemory}`
-    : `\n\nNo MEMORY.md exists yet. Create one at ${join(memoryDir, "MEMORY.md")} to start building persistent memory.`;
-
-  const instructions = `
-
-## Memory Instructions
-- MEMORY.md is an index file — keep it concise (under 200 lines). Lines after 200 are truncated.
-- Store detailed memories in separate files within ${memoryDir}/ and link to them from MEMORY.md.
-- Each memory file should use this frontmatter format:
-  \`\`\`markdown
-  ---
-  name: <memory name>
-  description: <one-line description>
-  type: <user|feedback|project|reference>
-  ---
-  <memory content>
-  \`\`\`
-- Update or remove memories that become outdated. Check for existing memories before creating duplicates.
-- You have Read, Write, and Edit tools available for managing memory files.`;
-
-  return header + memoryContent + instructions;
-}
-
-/**
- * Build a read-only memory block for agents that lack write/edit tools.
- * Does NOT create the memory directory — agents can only consume existing memory.
- */
-export function buildReadOnlyMemoryBlock(agentName: string, scope: MemoryScope, cwd: string): string {
-  const memoryDir = resolveMemoryDir(agentName, scope, cwd);
-  const existingMemory = readMemoryIndex(memoryDir);
-
-  const header = `# Agent Memory (read-only)
-
-Memory scope: ${scope}
-You have read-only access to memory. You can reference existing memories but cannot create or modify them.`;
-
-  const memoryContent = existingMemory
-    ? `\n\n## Current MEMORY.md\n${existingMemory}`
-    : `\n\nNo memory is available yet. Other agents or sessions with write access can create memories for you to consume.`;
-
-  return header + memoryContent;
-}