pi-messenger 0.12.1 → 0.13.1

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.13.1] - 2026-03-14
+
+### Added
+- **Auto-review after task completion** — Workers' completed tasks now get an automatic reviewer pass before being counted as done. Controlled by existing `config.review.enabled` (default: true) and `config.review.maxIterations` (default: 3). SHIP keeps the task done, NEEDS_WORK resets it to todo for retry with review feedback injected into the next worker's prompt, MAJOR_RETHINK blocks the task. Reviews run sequentially between worker completion and wave result reporting, and respect the abort signal. Adds `review_count` to the Task interface and `task.review` to the activity feed.
+
+## [0.13.0] - 2026-03-02
+
+### Added
+- **Dynamic skill loading for crew workers** — Workers can now acquire domain-specific knowledge on demand during task execution. A three-tier discovery system scans user skills (`~/.pi/agent/skills/`), extension skills (`crew/skills/`), and project skills (`.pi/messenger/crew/skills/`) to build a skill catalog. The planner sees the catalog and can tag tasks with relevant skill names. Workers see tagged skills as "Recommended" in their prompt alongside the full catalog, and load what they need via `read()` — zero upfront token cost, no config changes. Project-level skills override extension, which override user, matching the agent override pattern. When no skills are configured, prompts are unchanged.
+
+### Fixed
+- **Artifact dir creation** — `writeArtifact`, `writeMetadata`, and `appendJsonl` now create parent directories on demand. Fixes ENOENT on first `plan` run.
+- **Multiline feed sanitization** — Feed events with embedded newlines no longer corrupt the TUI overlay layout.
+- **Config model override** — `crew.models` config now actually overrides agent defaults. Priority: task override > config > agent frontmatter.
+
 ## [0.12.1] - 2026-02-22
 
 ### Fixed

package/README.md

@@ -16,7 +16,7 @@
 pi install npm:pi-messenger
 ```
 
-Crew agents ship with the extension (`crew/agents/*.md`) and are discovered automatically. The `pi-messenger-crew` skill is auto-loaded from the extension.
+Crew agents ship with the extension (`crew/agents/*.md`) and are discovered automatically. The `pi-messenger-crew` skill is auto-loaded from the extension. Workers can load domain-specific [crew skills](#crew-skills) on demand during task execution.
 
 To show available crew agents:
 
@@ -92,11 +92,13 @@ Chat input supports `@Name msg` for DMs and `@all msg` for broadcasts. Text with
 
 Crew turns a PRD into a dependency graph of tasks, then executes them in parallel waves.
 
+Crew logs are per project, under that project's working directory: `.pi/messenger/crew/`. For example, if you run Crew from `/path/to/my-app`, the planner log lives at `/path/to/my-app/.pi/messenger/crew/planning-progress.md`.
+
 ### Workflow
 
 1. **Plan** — Planner explores the codebase and PRD, drafts tasks with dependencies. A reviewer checks the plan; the planner refines until SHIP or `maxPasses` is reached. History is stored in `planning-progress.md`.
-2. **Work** — Workers implement ready tasks (all dependencies met) in parallel waves. A single `work` call runs one wave. `autonomous: true` runs waves back-to-back until everything is done or blocked.
-3. **Review** — Reviewer checks each implementation: SHIP, NEEDS_WORK, or MAJOR_RETHINK.
+2. **Work** — Workers implement ready tasks (all dependencies met) in parallel waves. A single `work` call runs one wave. `autonomous: true` runs waves back-to-back until everything is done or blocked. Each completed task gets an automatic reviewer pass — SHIP keeps it done, NEEDS_WORK resets it for retry with feedback, MAJOR_RETHINK blocks it. Controlled by `review.enabled` and `review.maxIterations`.
+3. **Review** — Manual review of a specific task or the plan: `pi_messenger({ action: "review", target: "task-1" })`. Returns SHIP, NEEDS_WORK, or MAJOR_RETHINK with detailed feedback.
 
 No special PRD format required — the planner auto-discovers `PRD.md`, `SPEC.md`, `DESIGN.md`, etc. in your project root and `docs/`. Or skip the file entirely:
 
@@ -123,6 +125,34 @@ Wave 3:  task-5 (→ task-2, task-4) ── both deps done
 
 The planner structures tasks to maximize parallelism. Foundation work has no dependencies and starts immediately. Features that don't touch each other get separate chains. Autonomous mode stops when all tasks are done or blocked.
 
+### Crew Skills
+
+Workers follow the same join/read/implement/commit/release protocol regardless of the task — what changes between tasks is domain knowledge. Crew skills let workers acquire that knowledge on demand.
+
+Skills are discovered from three locations (later sources override earlier by name):
+
+1. **User skills** — `~/.pi/agent/skills/` (pi's standard `dir/SKILL.md` format)
+2. **Extension skills** — `crew/skills/` within the extension (flat `.md` files)
+3. **Project skills** — `.pi/messenger/crew/skills/` in your project root (flat `.md` files)
+
+The planner sees a compact index of all discovered skills and can tag tasks with relevant ones. Workers see tagged skills as "Recommended for this task" with the full catalog under "Also available", and load what they need via `read()`. Zero tokens spent until a worker actually needs the knowledge.
+
+To add a project-level skill, drop a `.md` file in `.pi/messenger/crew/skills/`:
+
+```markdown
+---
+name: our-api-patterns
+description: REST API conventions for this project — auth, pagination, error shapes.
+---
+
+# API Patterns
+
+Always use Bearer token auth. Paginate with cursor-based `?after=` params.
+Error responses use `{ error: { code, message, details? } }` shape.
+```
+
+Any skills you already have in `~/.pi/agent/skills/` are automatically available to crew workers — no setup needed.
+
 ### Crew Configuration
 
 Crew spawns multiple LLM sessions in parallel — it can burn tokens fast. Start with a cheap worker model and scale up once you've seen the workflow. Add this to `~/.pi/agent/pi-messenger.json`:
@@ -304,7 +334,7 @@ Incoming messages wake the receiving agent via `pi.sendMessage()` with `triggerT
 
 Crew workers are spawned as `pi --mode json` subprocesses with the agent's system prompt, model, and tool restrictions from their `.md` definitions. Progress is tracked via JSONL streaming — the overlay subscribes to a live progress store that shows each worker's current tool, call count, and token usage in real time. Aborting a work run triggers graceful shutdown: each worker receives an inbox message asking it to stop, followed by a grace period before SIGTERM. The planner and reviewer work the same way — just pi instances with different agent configs.
 
-All coordination is file-based, no daemon required. Shared state (registry, inboxes, swarm claims/completions) lives in `~/.pi/agent/messenger/`. Activity feed and crew data are project-scoped under `.pi/messenger/` inside your project. Dead agents are detected via PID checks and cleaned up automatically.
+All coordination is file-based, no daemon required. Shared state (registry, inboxes, swarm claims/completions) lives in `~/.pi/agent/messenger/`. Activity feed and crew data are project-scoped under `.pi/messenger/` inside your project, so Crew logs live at `<project>/.pi/messenger/crew/` and the shared activity feed lives at `<project>/.pi/messenger/feed.jsonl`. Dead agents are detected via PID checks and cleaned up automatically.
 
 ## Credits
 

package/crew/agents/crew-planner.md

@@ -143,7 +143,7 @@ Dependencies: none
 
 ### JSON format (for reliable parsing):
 
-Include this fenced block after the markdown tasks. Titles must match exactly.
+Include this fenced block after the markdown tasks. Titles must match exactly. If your prompt lists Available Skills, include a `skills` array with relevant skill names.
 
 ````
 ```tasks-json
@@ -151,12 +151,14 @@ Include this fenced block after the markdown tasks. Titles must match exactly.
   {
     "title": "Title matching ### Task 1 above",
     "description": "Full description including acceptance criteria",
-    "dependsOn": []
+    "dependsOn": [],
+    "skills": ["react-best-practices"]
   },
   {
     "title": "Title matching ### Task 2 above",
     "description": "Full description",
-    "dependsOn": ["Title matching ### Task 1 above"]
+    "dependsOn": ["Title matching ### Task 1 above"],
+    "skills": ["testing", "api-design"]
   }
 ]
 ```

package/crew/agents/crew-worker.md

@@ -35,6 +35,18 @@ Read the task spec file for detailed requirements:
 read({ path: ".pi/messenger/crew/tasks/<TASK_ID>.md" })
 ```
 
+## Phase 2.5: Load Relevant Skills
+
+If your task prompt includes an **Available Skills** section, read any that match what you're building before starting implementation.
+
+If skills are marked **Recommended for this task**, read those first.
+
+```typescript
+read({ path: "<skill-path-from-the-list>" })
+```
+
+Skip this phase if no Available Skills section is present.
+
 ## Phase 3: Start Task & Reserve Files
 
 ```typescript

package/crew/agents.ts

@@ -203,7 +203,7 @@ async function runAgent(
   return new Promise((resolve) => {
     // Build args for pi command
     const args = ["--mode", "json", "--no-session", "-p"];
-    const model = task.modelOverride ?? agentConfig?.model;
+    const model = task.modelOverride ?? config.models?.[role] ?? agentConfig?.model;
     if (model) pushModelArgs(args, model);
 
     const thinking = resolveThinking(

package/crew/handlers/plan.ts

@@ -11,7 +11,7 @@ import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
 import type { CrewParams } from "../types.js";
 import { result } from "../utils/result.js";
 import { spawnAgents } from "../agents.js";
-import { discoverCrewAgents } from "../utils/discover.js";
+import { discoverCrewAgents, discoverCrewSkills, type CrewSkillInfo } from "../utils/discover.js";
 import { loadCrewConfig } from "../utils/config.js";
 import { parseVerdict, type ParsedReview } from "../utils/verdict.js";
 import { logFeedEvent } from "../../feed.js";
@@ -298,6 +298,7 @@ export async function execute(
   const config = loadCrewConfig(store.getCrewDir(cwd));
   const maxPasses = Math.max(1, config.planning.maxPasses);
   const hasReviewer = availableAgents.some(a => a.name === "crew-reviewer");
+  const skills = discoverCrewSkills(cwd);
 
   const existingProgress = readProgressForPrompt(cwd);
 
@@ -327,8 +328,8 @@ export async function execute(
     notify(ctx, `Planning pass ${pass}/${maxPasses} in progress`, "info");
 
     const plannerPrompt = pass === 1
-      ? buildFirstPassPrompt(prdPath, prdContent, existingProgress, isPromptBased)
-      : buildRefinementPrompt(prdPath, prdContent, readProgressForPrompt(cwd), isPromptBased);
+      ? buildFirstPassPrompt(prdPath, prdContent, existingProgress, isPromptBased, skills)
+      : buildRefinementPrompt(prdPath, prdContent, readProgressForPrompt(cwd), isPromptBased, skills);
 
     const [plannerResult] = await spawnAgents([{
       agent: PLANNER_AGENT,
@@ -435,13 +436,13 @@ export async function execute(
     });
   }
 
-  const createdTasks: { id: string; title: string; dependsOn: string[] }[] = [];
+  const createdTasks: { id: string; title: string; dependsOn: string[]; skills?: string[] }[] = [];
   const titleToId = new Map<string, string>();
 
   for (let i = 0; i < tasks.length; i++) {
     const task = tasks[i];
     const created = store.createTask(cwd, task.title, task.description);
-    createdTasks.push({ id: created.id, title: task.title, dependsOn: task.dependsOn });
+    createdTasks.push({ id: created.id, title: task.title, dependsOn: task.dependsOn, skills: task.skills });
     titleToId.set(task.title.toLowerCase(), created.id);
     titleToId.set(`task ${i + 1}`, created.id);
     titleToId.set(`task-${i + 1}`, created.id);
@@ -460,6 +461,10 @@ export async function execute(
         store.updateTask(cwd, task.id, { depends_on: resolvedDeps });
       }
     }
+
+    if (task.skills && task.skills.length > 0) {
+      store.updateTask(cwd, task.id, { skills: task.skills });
+    }
   }
 
   pruneTransitiveDeps(cwd, createdTasks.map(t => t.id));
@@ -539,19 +544,40 @@ ${nextSteps}`;
 // Prompt Builders
 // =============================================================================
 
-function buildFirstPassPrompt(prdPath: string, prdContent: string, existingProgress: string, isPromptBased: boolean): string {
+function formatSkillsForPlanner(skills: CrewSkillInfo[]): string {
+  if (skills.length === 0) return "";
+
+  const lines = skills.map(s => `  ${s.name} — ${s.description}`);
+  return `
+## Available Skills
+
+Workers can load these skills on demand during task execution. When creating tasks, you may include a \`skills\` array with relevant skill names to help workers prioritize which to read.
+
+${lines.join("\n")}
+
+`;
+}
+
+function tasksJsonFormatHint(skills: CrewSkillInfo[]): string {
+  return skills.length > 0
+    ? "title, description, dependsOn, and optionally skills (array of skill names from the Available Skills list that are relevant to the task)"
+    : "title, description, and dependsOn";
+}
+
+function buildFirstPassPrompt(prdPath: string, prdContent: string, existingProgress: string, isPromptBased: boolean, skills: CrewSkillInfo[]): string {
   const specType = isPromptBased ? "request" : "PRD";
   const specLabel = isPromptBased ? "Request" : `PRD: ${prdPath}`;
   const progressSection = existingProgress
     ? `\n## Previous Planning Context\n${existingProgress}\n`
     : "";
+  const skillsSection = formatSkillsForPlanner(skills);
 
   return `Create a task breakdown for implementing this ${specType}.
 
 ## ${specLabel}
 
 ${prdContent}
-${progressSection}
+${progressSection}${skillsSection}
 You must follow this sequence strictly:
 1) Understand the ${specType}
 2) Review relevant code/docs/reference resources
@@ -566,7 +592,7 @@ Return output in this exact section order and headings:
 
 In section 4, include both:
 - markdown task breakdown
-- a \`tasks-json\` fenced block with task objects containing title, description, and dependsOn.`;
+- a \`tasks-json\` fenced block with task objects containing ${tasksJsonFormatHint(skills)}.`;
 }
 
 function buildRefinementPrompt(
@@ -574,13 +600,15 @@ function buildRefinementPrompt(
   prdContent: string,
   progressFileContent: string,
   isPromptBased: boolean,
+  skills: CrewSkillInfo[],
 ): string {
   const specLabel = isPromptBased ? "Request" : `PRD: ${prdPath}`;
+  const skillsSection = formatSkillsForPlanner(skills);
   return `Refine your task breakdown based on review feedback.
 
 ## ${specLabel}
 ${prdContent}
-
+${skillsSection}
 ## Planning Progress
 ${progressFileContent}
 
@@ -596,7 +624,7 @@ Return output in this exact section order and headings:
 
 In section 4, include both:
 - markdown task breakdown
-- a \`tasks-json\` fenced block with task objects containing title, description, and dependsOn.`;
+- a \`tasks-json\` fenced block with task objects containing ${tasksJsonFormatHint(skills)}.`;
 }
 
 function buildPlanReviewPrompt(
@@ -652,6 +680,7 @@ interface ParsedTask {
   title: string;
   description: string;
   dependsOn: string[];
+  skills?: string[];
 }
 
 function extractPlanSections(output: string): PlanSections | null {
@@ -701,7 +730,8 @@ function parseJsonTaskBlock(output: string): ParsedTask[] | null {
       .map((t: Record<string, unknown>) => ({
         title: (t.title as string).trim(),
         description: typeof t.description === "string" ? t.description : "",
-        dependsOn: Array.isArray(t.dependsOn) ? t.dependsOn.filter((d: unknown) => typeof d === "string") : []
+        dependsOn: Array.isArray(t.dependsOn) ? t.dependsOn.filter((d: unknown) => typeof d === "string") : [],
+        skills: Array.isArray(t.skills) ? t.skills.filter((s: unknown) => typeof s === "string") : undefined,
       }));
     return tasks.length > 0 ? tasks : null;
   } catch {

package/crew/handlers/review.ts

@@ -55,7 +55,7 @@ export async function execute(
 // Implementation Review
 // =============================================================================
 
-async function reviewImplementation(cwd: string, taskId: string, modelOverride?: string) {
+export async function reviewImplementation(cwd: string, taskId: string, modelOverride?: string) {
   const task = store.getTask(cwd, taskId);
   if (!task) {
     return result(`Error: Task ${taskId} not found.`, {

package/crew/handlers/work.ts

@@ -11,8 +11,9 @@ import type { CrewParams, AppendEntryFn } from "../types.js";
 import { result } from "../utils/result.js";
 import { resolveModel, spawnAgents } from "../agents.js";
 import { loadCrewConfig } from "../utils/config.js";
-import { discoverCrewAgents } from "../utils/discover.js";
+import { discoverCrewAgents, discoverCrewSkills } from "../utils/discover.js";
 import { buildWorkerPrompt } from "../prompt.js";
+import { reviewImplementation } from "./review.js";
 import * as store from "../store.js";
 import { getCrewDir } from "../store.js";
 import { autonomousState, isAutonomousForCwd, startAutonomous, stopAutonomous, addWaveResult, clampConcurrency } from "../state.js";
@@ -109,6 +110,8 @@ export async function execute(
     appendEntry("crew-state", autonomousState);
   }
 
+  const skills = discoverCrewSkills(cwd);
+
   // Assign tasks to lobby workers first (they're already running and warmed up)
   const prdLabel = store.getPlanLabel(plan);
   const lobbyAssigned = new Set<string>();
@@ -118,7 +121,7 @@ export async function execute(
     if (!task) break;
 
     const others = readyTasks.filter(t => t.id !== task.id);
-    const prompt = buildWorkerPrompt(task, prdLabel, cwd, config, others);
+    const prompt = buildWorkerPrompt(task, prdLabel, cwd, config, others, skills);
     store.updateTask(cwd, task.id, {
       status: "in_progress",
       started_at: new Date().toISOString(),
@@ -145,7 +148,7 @@ export async function execute(
       config.models?.worker,
     );
     const others = readyTasks.filter(t => t.id !== task.id);
-    const prompt = buildWorkerPrompt(task, prdLabel, cwd, config, others);
+    const prompt = buildWorkerPrompt(task, prdLabel, cwd, config, others, skills);
     store.appendTaskProgress(cwd, task.id, "system", `Assigned to crew-worker (attempt ${task.attempt_count + 1})`);
 
     return {
@@ -218,6 +221,48 @@ export async function execute(
     }
   }
 
+  // Auto-review succeeded tasks
+  if (config.review.enabled && succeeded.length > 0) {
+    const hasReviewer = availableAgents.some(a => a.name === "crew-reviewer");
+    if (hasReviewer) {
+      for (const taskId of [...succeeded]) {
+        if (signal?.aborted) break;
+        const task = store.getTask(cwd, taskId);
+        if (!task || !task.base_commit) continue;
+        if ((task.review_count ?? 0) >= config.review.maxIterations) continue;
+
+        const rr = await reviewImplementation(cwd, taskId, config.models?.reviewer);
+        const verdict = rr.details?.verdict as string | undefined;
+        if (!verdict) {
+          store.appendTaskProgress(cwd, taskId, "system",
+            `Auto-review skipped: ${rr.details?.error ?? "unknown"}`);
+          continue;
+        }
+
+        const reviewCount = (task.review_count ?? 0) + 1;
+        store.updateTask(cwd, taskId, { review_count: reviewCount });
+
+        if (verdict === "SHIP") {
+          logFeedEvent(cwd, "crew", "task.review", taskId, "SHIP");
+        } else if (verdict === "NEEDS_WORK") {
+          store.resetTask(cwd, taskId);
+          logFeedEvent(cwd, "crew", "task.review", taskId, "NEEDS_WORK — reset for retry");
+          succeeded.splice(succeeded.indexOf(taskId), 1);
+          failed.push(taskId);
+        } else {
+          const lastReview = store.getTask(cwd, taskId)?.last_review;
+          const summary = lastReview?.summary
+            ? lastReview.summary.split("\n")[0].slice(0, 120)
+            : "Major issues found";
+          store.blockTask(cwd, taskId, `Reviewer: ${summary}`);
+          logFeedEvent(cwd, "crew", "task.review", taskId, "MAJOR_RETHINK — blocked");
+          succeeded.splice(succeeded.indexOf(taskId), 1);
+          blocked.push(taskId);
+        }
+      }
+    }
+  }
+
   syncCompletedCount(cwd);
 
   // Save current wave number BEFORE addWaveResult increments it
@@ -325,4 +370,3 @@ function syncCompletedCount(cwd: string): void {
     store.updatePlan(cwd, { completed_count: doneCount });
   }
 }
-

package/crew/prompt.ts

@@ -7,6 +7,7 @@
 
 import type { Task } from "./types.js";
 import type { CrewConfig } from "./utils/config.js";
+import type { CrewSkillInfo } from "./utils/discover.js";
 import * as store from "./store.js";
 import { buildDependencySection, buildCoordinationContext, buildCoordinationInstructions } from "./handlers/coordination.js";
 
@@ -16,6 +17,7 @@ export function buildWorkerPrompt(
   cwd: string,
   config: CrewConfig,
   concurrentTasks: Task[],
+  skills?: CrewSkillInfo[],
 ): string {
   const taskSpec = store.getTaskSpec(cwd, task.id);
   const planSpec = store.getPlanSpec(cwd);
@@ -108,5 +110,47 @@ ${truncatedSpec}
     prompt += coordInstructions;
   }
 
+  const skillsSection = buildSkillsSection(skills, task.skills);
+  if (skillsSection) {
+    prompt += skillsSection;
+  }
+
   return prompt;
 }
+
+function buildSkillsSection(
+  skills: CrewSkillInfo[] | undefined,
+  taskSkills: string[] | undefined,
+): string | null {
+  if (!skills || skills.length === 0) return null;
+
+  const recommended = new Set(taskSkills ?? []);
+  const recSkills = skills.filter(s => recommended.has(s.name));
+  const otherSkills = skills.filter(s => !recommended.has(s.name));
+
+  let section = `## Available Skills
+
+Read any skill that matches what you're implementing.
+
+`;
+
+  if (recSkills.length > 0) {
+    section += "**Recommended for this task:**\n";
+    for (const s of recSkills) {
+      section += `  ${s.name} — ${s.description}\n    ${s.path}\n`;
+    }
+    section += "\n";
+  }
+
+  if (otherSkills.length > 0) {
+    if (recSkills.length > 0) section += "**Also available:**\n";
+    for (const s of otherSkills) {
+      section += `  ${s.name} — ${s.description}\n    ${s.path}\n`;
+    }
+    section += "\n";
+  }
+
+  section += `To load a skill: read({ path: "<skill-path>" })\n`;
+
+  return section;
+}

package/crew/spawn.ts

@@ -8,6 +8,7 @@
 import { join } from "node:path";
 import * as store from "./store.js";
 import { loadCrewConfig } from "./utils/config.js";
+import { discoverCrewSkills } from "./utils/discover.js";
 import { buildWorkerPrompt } from "./prompt.js";
 import { logFeedEvent } from "../feed.js";
 import {
@@ -32,6 +33,7 @@ export function spawnWorkersForReadyTasks(
   const config = loadCrewConfig(crewDir);
   const prdLabel = store.getPlanLabel(plan);
   const inboxDir = join(cwd, ".pi", "messenger", "inbox");
+  const skills = discoverCrewSkills(cwd);
 
   let assigned = 0;
   let firstWorkerName: string | null = null;
@@ -44,7 +46,7 @@ export function spawnWorkersForReadyTasks(
 
     const task = fresh[0];
     const others = fresh.filter(t => t.id !== task.id);
-    const prompt = buildWorkerPrompt(task, prdLabel, cwd, config, others);
+    const prompt = buildWorkerPrompt(task, prdLabel, cwd, config, others, skills);
 
     store.updateTask(cwd, task.id, {
       status: "in_progress",
@@ -71,7 +73,7 @@ export function spawnWorkersForReadyTasks(
 
     const task = fresh[0];
     const others = fresh.filter(t => t.id !== task.id);
-    const prompt = buildWorkerPrompt(task, prdLabel, cwd, config, others);
+    const prompt = buildWorkerPrompt(task, prdLabel, cwd, config, others, skills);
     const worker = spawnWorkerForTask(cwd, task.id, prompt);
     if (!worker) break;
 
@@ -95,9 +97,10 @@ export function spawnSingleWorker(
   const crewDir = store.getCrewDir(cwd);
   const config = loadCrewConfig(crewDir);
   const prdLabel = store.getPlanLabel(plan);
+  const skills = discoverCrewSkills(cwd);
   const readyTasks = store.getReadyTasks(cwd, { advisory: config.dependencies === "advisory" });
   const others = readyTasks.filter(t => t.id !== task.id);
-  const prompt = buildWorkerPrompt(task, prdLabel, cwd, config, others);
+  const prompt = buildWorkerPrompt(task, prdLabel, cwd, config, others, skills);
   const worker = spawnWorkerForTask(cwd, taskId, prompt);
   return worker ? { name: worker.name } : null;
 }

package/crew/types.ts

@@ -40,6 +40,7 @@ export interface Task {
   milestone?: boolean;
   model?: string;
   depends_on: string[];          // Task IDs this depends on
+  skills?: string[];             // Skill names from planner
   created_at: string;            // ISO timestamp
   updated_at: string;            // ISO timestamp
   started_at?: string;           // When task.start was called
@@ -50,6 +51,7 @@ export interface Task {
   evidence?: TaskEvidence;       // Evidence from task.done
   blocked_reason?: string;       // Reason from task.block
   attempt_count: number;         // How many times attempted (for auto-block)
+  review_count?: number;         // How many times reviewed
   last_review?: ReviewFeedback;  // Feedback from last review (for retry)
 }
 

package/crew/utils/artifacts.ts

@@ -37,14 +37,16 @@ export function ensureArtifactsDir(dir: string): void {
 }
 
 export function writeArtifact(filePath: string, content: string): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
   fs.writeFileSync(filePath, content, "utf-8");
 }
 
 export function writeMetadata(filePath: string, metadata: object): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
   fs.writeFileSync(filePath, JSON.stringify(metadata, null, 2), "utf-8");
 }
 
 export function appendJsonl(filePath: string, line: string): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
   fs.appendFileSync(filePath, `${line}\n`);
 }
-

package/crew/utils/discover.ts

@@ -1,10 +1,12 @@
 /**
- * Crew - Agent Discovery
+ * Crew - Agent & Skill Discovery
  *
- * Discovers agent definitions from extension and project directories.
+ * Discovers agent definitions and skill files from extension,
+ * project, and user directories.
  */
 
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import type { MaxOutputConfig } from "./truncate.js";
@@ -12,6 +14,7 @@ import type { MaxOutputConfig } from "./truncate.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const DEFAULT_EXTENSION_AGENTS_DIR = path.resolve(__dirname, "..", "agents");
+const DEFAULT_EXTENSION_SKILLS_DIR = path.resolve(__dirname, "..", "skills");
 
 export type CrewRole = "planner" | "worker" | "reviewer" | "analyst";
 
@@ -123,3 +126,94 @@ export function discoverCrewAgents(cwd: string, extensionAgentsDir?: string): Cr
 
   return Array.from(agentMap.values());
 }
+
+// =============================================================================
+// Skill Discovery
+// =============================================================================
+
+export interface CrewSkillInfo {
+  name: string;
+  description: string;
+  path: string;
+  source: "user" | "extension" | "project";
+}
+
+function loadSkillsFromFlatDir(dir: string, source: "extension" | "project"): CrewSkillInfo[] {
+  if (!fs.existsSync(dir)) return [];
+  const skills: CrewSkillInfo[] = [];
+
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.name.endsWith(".md")) continue;
+    if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+
+    const filePath = path.join(dir, entry.name);
+    let content: string;
+    try {
+      content = fs.readFileSync(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+
+    const { frontmatter } = parseFrontmatter(content);
+    if (!frontmatter.name || !frontmatter.description) continue;
+
+    skills.push({
+      name: frontmatter.name as string,
+      description: (frontmatter.description as string).split("\n")[0].trim(),
+      path: filePath,
+      source,
+    });
+  }
+
+  return skills;
+}
+
+function loadSkillsFromUserDir(dir: string): CrewSkillInfo[] {
+  if (!fs.existsSync(dir)) return [];
+  const skills: CrewSkillInfo[] = [];
+
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+
+    const skillFile = path.join(dir, entry.name, "SKILL.md");
+    let content: string;
+    try {
+      content = fs.readFileSync(skillFile, "utf-8");
+    } catch {
+      continue;
+    }
+
+    const { frontmatter } = parseFrontmatter(content);
+    if (!frontmatter.name || !frontmatter.description) continue;
+
+    skills.push({
+      name: frontmatter.name as string,
+      description: (frontmatter.description as string).split("\n")[0].trim(),
+      path: skillFile,
+      source: "user",
+    });
+  }
+
+  return skills;
+}
+
+export function discoverCrewSkills(
+  cwd: string,
+  extensionSkillsDir?: string,
+  userSkillsDir?: string,
+): CrewSkillInfo[] {
+  const extDir = extensionSkillsDir ?? DEFAULT_EXTENSION_SKILLS_DIR;
+  const projectSkillsDir = path.join(cwd, ".pi", "messenger", "crew", "skills");
+  const userDir = userSkillsDir ?? path.join(os.homedir(), ".pi", "agent", "skills");
+
+  const userSkills = loadSkillsFromUserDir(userDir);
+  const extensionSkills = loadSkillsFromFlatDir(extDir, "extension");
+  const projectSkills = loadSkillsFromFlatDir(projectSkillsDir, "project");
+
+  const skillMap = new Map<string, CrewSkillInfo>();
+  for (const skill of userSkills) skillMap.set(skill.name, skill);
+  for (const skill of extensionSkills) skillMap.set(skill.name, skill);
+  for (const skill of projectSkills) skillMap.set(skill.name, skill);
+
+  return Array.from(skillMap.values());
+}

package/feed.ts

@@ -18,6 +18,7 @@ export type FeedEventType =
   | "edit"
   | "task.start"
   | "task.done"
+  | "task.review"
   | "task.block"
   | "task.unblock"
   | "task.reset"
@@ -47,6 +48,31 @@ function feedPath(cwd: string): string {
   return path.join(cwd, ".pi", "messenger", "feed.jsonl");
 }
 
+function sanitizeInlineText(value?: string): string | undefined {
+  if (!value) return undefined;
+  const normalized = value
+    .replaceAll("\r", " ")
+    .replaceAll("\n", " ")
+    .replaceAll("\t", " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  return normalized.length > 0 ? normalized : undefined;
+}
+
+function sanitizeAgentName(value: string): string {
+  return sanitizeInlineText(value) ?? "unknown";
+}
+
+export function sanitizeFeedEvent(event: FeedEvent): FeedEvent {
+  return {
+    ts: event.ts,
+    type: event.type,
+    agent: sanitizeAgentName(event.agent),
+    target: sanitizeInlineText(event.target),
+    preview: sanitizeInlineText(event.preview),
+  };
+}
+
 export function appendFeedEvent(cwd: string, event: FeedEvent): void {
   const p = feedPath(cwd);
   try {
@@ -54,7 +80,8 @@ export function appendFeedEvent(cwd: string, event: FeedEvent): void {
     if (!fs.existsSync(feedDir)) {
       fs.mkdirSync(feedDir, { recursive: true });
     }
-    fs.appendFileSync(p, JSON.stringify(event) + "\n");
+    const sanitized = sanitizeFeedEvent(event);
+    fs.appendFileSync(p, JSON.stringify(sanitized) + "\n");
   } catch {
     // Best effort
   }
@@ -71,7 +98,8 @@ export function readFeedEvents(cwd: string, limit: number = 20): FeedEvent[] {
     const events: FeedEvent[] = [];
     for (const line of lines) {
       try {
-        events.push(JSON.parse(line));
+        const parsed = JSON.parse(line) as FeedEvent;
+        events.push(sanitizeFeedEvent(parsed));
       } catch {
         // Skip malformed lines
       }
@@ -101,6 +129,7 @@ export function pruneFeed(cwd: string, maxEvents: number): void {
 const CREW_EVENT_TYPES = new Set<FeedEventType>([
   "task.start",
   "task.done",
+  "task.review",
   "task.block",
   "task.unblock",
   "task.reset",
@@ -119,25 +148,27 @@ const CREW_EVENT_TYPES = new Set<FeedEventType>([
 ]);
 
 export function formatFeedLine(event: FeedEvent): string {
-  const time = new Date(event.ts).toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false });
-  const isCrew = CREW_EVENT_TYPES.has(event.type);
+  const sanitized = sanitizeFeedEvent(event);
+  const time = new Date(sanitized.ts).toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false });
+  const isCrew = CREW_EVENT_TYPES.has(sanitized.type);
   const prefix = isCrew ? "[Crew] " : "";
-  let line = `${time} ${prefix}${event.agent}`;
+  let line = `${time} ${prefix}${sanitized.agent}`;
 
-  const rawPreview = event.preview?.trim();
+  const rawPreview = sanitized.preview;
   const preview = rawPreview
     ? rawPreview.length > 90 ? rawPreview.slice(0, 87) + "..." : rawPreview
     : "";
   const withPreview = (base: string) => preview ? `${base} — ${preview}` : base;
+  const target = sanitized.target ?? "";
 
-  switch (event.type) {
+  switch (sanitized.type) {
     case "join": line += " joined"; break;
     case "leave": line = withPreview(line + " left"); break;
-    case "reserve": line += ` reserved ${event.target ?? ""}`; break;
-    case "release": line += ` released ${event.target ?? ""}`; break;
+    case "reserve": line += ` reserved ${target}`; break;
+    case "release": line += ` released ${target}`; break;
     case "message":
-      if (event.target) {
-        line += ` → ${event.target}`;
+      if (target) {
+        line += ` → ${target}`;
         if (preview) line += `: ${preview}`;
       } else {
         line += " ✦";
@@ -150,16 +181,17 @@ export function formatFeedLine(event: FeedEvent): string {
     case "test":
       line += preview ? ` ran tests (${preview})` : " ran tests";
       break;
-    case "edit": line += ` editing ${event.target ?? ""}`; break;
-    case "task.start": line += withPreview(` started ${event.target ?? ""}`); break;
-    case "task.done": line += withPreview(` completed ${event.target ?? ""}`); break;
-    case "task.block": line += withPreview(` blocked ${event.target ?? ""}`); break;
-    case "task.unblock": line += withPreview(` unblocked ${event.target ?? ""}`); break;
-    case "task.reset": line += withPreview(` reset ${event.target ?? ""}`); break;
-    case "task.delete": line += withPreview(` deleted ${event.target ?? ""}`); break;
-    case "task.split": line += withPreview(` split ${event.target ?? ""}`); break;
-    case "task.revise": line += withPreview(` revised ${event.target ?? ""}`); break;
-    case "task.revise-tree": line += withPreview(` revised ${event.target ?? ""} + dependents`); break;
+    case "edit": line += ` editing ${target}`; break;
+    case "task.start": line += withPreview(` started ${target}`); break;
+    case "task.done": line += withPreview(` completed ${target}`); break;
+    case "task.review": line += withPreview(` reviewed ${target}`); break;
+    case "task.block": line += withPreview(` blocked ${target}`); break;
+    case "task.unblock": line += withPreview(` unblocked ${target}`); break;
+    case "task.reset": line += withPreview(` reset ${target}`); break;
+    case "task.delete": line += withPreview(` deleted ${target}`); break;
+    case "task.split": line += withPreview(` split ${target}`); break;
+    case "task.revise": line += withPreview(` revised ${target}`); break;
+    case "task.revise-tree": line += withPreview(` revised ${target} + dependents`); break;
     case "plan.start": line += withPreview(" planning started"); break;
     case "plan.pass.start": line += withPreview(" planning pass started"); break;
     case "plan.pass.done": line += withPreview(" planning pass finished"); break;
@@ -169,7 +201,7 @@ export function formatFeedLine(event: FeedEvent): string {
     case "plan.cancel": line += " planning cancelled"; break;
     case "plan.failed": line += withPreview(" planning failed"); break;
     case "stuck": line += " appears stuck"; break;
-    default: line += ` ${event.type}`; break;
+    default: line += ` ${sanitized.type}`; break;
   }
   return line;
 }

package/overlay-coordinator.ts

@@ -0,0 +1,150 @@
+import type { OverlayHandle, TUI } from "@mariozechner/pi-tui";
+
+const QUIET_PERIOD_MS = 80;
+const RENDER_THROTTLE_MS = 32;
+const STDOUT_GUARD_MS = 32;
+
+type StdoutWrite = typeof process.stdout.write;
+
+function hasRenderableOutput(chunk: unknown): boolean {
+  if (typeof chunk === "string") return chunk.length > 0;
+  if (chunk instanceof Uint8Array) return chunk.length > 0;
+  return false;
+}
+
+/**
+ * Coordinates overlay rendering with main agent stdout to prevent visual collision.
+ * 
+ * Strategy: Keep overlay visible, but schedule a "repair" render after foreign
+ * output settles. Brief visual corruption is acceptable if it self-heals quickly.
+ */
+export class OverlayRenderCoordinator {
+  private tui: TUI | null = null;
+  private handle: OverlayHandle | null = null;
+  private originalRequestRender: TUI["requestRender"] | null = null;
+  private originalStdoutWrite: StdoutWrite | null = null;
+  private repairTimer: ReturnType<typeof setTimeout> | null = null;
+  private lastRenderAt = 0;
+  private stdoutGuardUntil = 0;
+  private foreignOutputDetected = false;
+
+  installStdoutInterceptor(): void {
+    if (this.originalStdoutWrite) return;
+
+    const original = process.stdout.write.bind(process.stdout) as StdoutWrite;
+    this.originalStdoutWrite = original;
+
+    const coordinator = this;
+    (process.stdout.write as StdoutWrite) = function writeIntercept(
+      chunk: Parameters<StdoutWrite>[0],
+      ...args: Parameters<StdoutWrite> extends [unknown, ...infer Rest] ? Rest : never
+    ) {
+      const result = original(chunk, ...args);
+      coordinator.handleStdoutWrite(chunk);
+      return result;
+    } as StdoutWrite;
+  }
+
+  uninstallStdoutInterceptor(): void {
+    if (!this.originalStdoutWrite) return;
+    (process.stdout.write as StdoutWrite) = this.originalStdoutWrite;
+    this.originalStdoutWrite = null;
+  }
+
+  attach(tui: TUI): void {
+    if (this.tui === tui && this.originalRequestRender) return;
+
+    this.detach();
+    this.tui = tui;
+    this.originalRequestRender = tui.requestRender.bind(tui);
+    tui.requestRender = ((force?: boolean) => {
+      this.requestRender(force);
+    }) as TUI["requestRender"];
+  }
+
+  setHandle(handle: OverlayHandle | null): void {
+    this.handle = handle;
+  }
+
+  detach(): void {
+    if (this.repairTimer) {
+      clearTimeout(this.repairTimer);
+      this.repairTimer = null;
+    }
+    if (this.tui && this.originalRequestRender) {
+      this.tui.requestRender = this.originalRequestRender;
+    }
+    this.tui = null;
+    this.handle = null;
+    this.originalRequestRender = null;
+    this.lastRenderAt = 0;
+    this.stdoutGuardUntil = 0;
+    this.foreignOutputDetected = false;
+  }
+
+  dispose(): void {
+    this.detach();
+    this.uninstallStdoutInterceptor();
+  }
+
+  /** Called by hooks when main agent activity is expected */
+  noteForegroundActivity(): void {
+    if (!this.tui || !this.handle) return;
+    if (this.handle.isHidden()) return;
+
+    this.foreignOutputDetected = true;
+    this.scheduleRepair();
+  }
+
+  private handleStdoutWrite(chunk: unknown): void {
+    if (!this.tui || !this.handle) return;
+    if (!hasRenderableOutput(chunk)) return;
+    if (Date.now() <= this.stdoutGuardUntil) return;
+    if (this.handle.isHidden()) return;
+
+    this.foreignOutputDetected = true;
+    this.scheduleRepair();
+  }
+
+  private scheduleRepair(): void {
+    if (this.repairTimer) clearTimeout(this.repairTimer);
+    this.repairTimer = setTimeout(() => {
+      this.repairTimer = null;
+      this.repair();
+    }, QUIET_PERIOD_MS);
+  }
+
+  private repair(): void {
+    if (!this.tui || !this.handle) return;
+    if (this.handle.isHidden()) return;
+    if (!this.foreignOutputDetected) return;
+
+    this.foreignOutputDetected = false;
+    this.flushRender(true);
+  }
+
+  requestRender(force = false): void {
+    if (!this.originalRequestRender) return;
+    if (this.handle?.isHidden()) return;
+
+    const now = Date.now();
+    if (!force) {
+      const elapsed = now - this.lastRenderAt;
+      if (elapsed < RENDER_THROTTLE_MS) {
+        // Skip this render, repair timer will catch up
+        return;
+      }
+    }
+
+    this.flushRender(force);
+  }
+
+  private flushRender(force: boolean): void {
+    if (!this.originalRequestRender) return;
+    if (this.handle?.isHidden()) return;
+
+    this.lastRenderAt = Date.now();
+    this.stdoutGuardUntil = this.lastRenderAt + STDOUT_GUARD_MS;
+    this.originalRequestRender(force);
+  }
+}

package/overlay-render.ts

@@ -27,7 +27,7 @@ import {
 import type { Task } from "./crew/types.js";
 import { getLiveWorkers, type LiveWorkerInfo } from "./crew/live-progress.js";
 import type { ToolEntry } from "./crew/utils/progress.js";
-import { formatFeedLine as sharedFormatFeedLine, type FeedEvent } from "./feed.js";
+import { formatFeedLine as sharedFormatFeedLine, sanitizeFeedEvent, type FeedEvent } from "./feed.js";
 import { discoverCrewAgents } from "./crew/utils/discover.js";
 import { loadConfig } from "./config.js";
 import { loadCrewConfig } from "./crew/utils/config.js";
@@ -224,18 +224,19 @@ export function renderFeedSection(theme: Theme, events: FeedEvent[], width: numb
   let lastWasMessage = false;
 
   for (const event of events) {
-    const isNew = lastSeenTs === null || event.ts > lastSeenTs;
-    const isMessage = event.type === "message";
+    const sanitized = sanitizeFeedEvent(event);
+    const isNew = lastSeenTs === null || sanitized.ts > lastSeenTs;
+    const isMessage = sanitized.type === "message";
 
     if (lines.length > 0 && isMessage !== lastWasMessage) {
       lines.push(theme.fg("dim", "  ·"));
     }
 
     if (isMessage) {
-      lines.push(...renderMessageLines(theme, event, width));
+      lines.push(...renderMessageLines(theme, sanitized, width));
     } else {
-      const formatted = sharedFormatFeedLine(event);
-      const dimmed = DIM_EVENTS.has(event.type) || !isNew;
+      const formatted = sharedFormatFeedLine(sanitized);
+      const dimmed = DIM_EVENTS.has(sanitized.type) || !isNew;
       lines.push(truncateToWidth(dimmed ? theme.fg("dim", formatted) : formatted, width));
     }
     lastWasMessage = isMessage;
@@ -341,7 +342,8 @@ export function renderEmptyState(theme: Theme, cwd: string, width: number, heigh
     lines.push(theme.fg("dim", "  (none discovered)"));
   } else {
     for (const agent of agents) {
-      const model = agent.model ? ` (model: ${agent.model})` : "";
+      const effectiveModel = crewConfig.models?.[agent.crewRole ?? "worker"] ?? agent.model;
+      const model = effectiveModel ? ` (model: ${effectiveModel})` : "";
       lines.push(`  ${agent.name}${model}`);
     }
   }

package/overlay.ts

@@ -3,7 +3,7 @@
  */
 
 import type { Component, Focusable, TUI } from "@mariozechner/pi-tui";
-import { matchesKey, visibleWidth } from "@mariozechner/pi-tui";
+import { matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
 import type { Theme } from "@mariozechner/pi-coding-agent";
 import {
   extractFolder,
@@ -553,7 +553,14 @@ export class MessengerOverlay implements Component, Focusable {
     const sectionW = innerW - 2;
     const border = (s: string) => this.theme.fg("dim", s);
     const pad = (s: string, len: number) => s + " ".repeat(Math.max(0, len - visibleWidth(s)));
-    const row = (content: string) => border("│") + pad(" " + content, innerW) + border("│");
+    const sanitizeRowContent = (content: string) => content
+      .replaceAll("\r", " ")
+      .replaceAll("\n", " ")
+      .replaceAll("\t", " ");
+    const row = (content: string) => {
+      const safe = truncateToWidth(sanitizeRowContent(content), sectionW);
+      return border("│") + pad(" " + safe, innerW) + border("│");
+    };
     const emptyRow = () => border("│") + " ".repeat(innerW) + border("│");
     const sectionSeparator = this.theme.fg("dim", "─".repeat(sectionW));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-messenger",
-  "version": "0.12.1",
+  "version": "0.13.1",
   "description": "Inter-agent messaging and file reservation system for pi coding agent",
   "type": "module",
   "author": "Nico Bailon",