pi-crew 0.1.45 → 0.1.49

package/skills/orchestration/SKILL.md

@@ -0,0 +1,157 @@
+---
+name: orchestration
+description: Multi-phase orchestration skill for pi-crew planners and executors. Use when decomposing complex tasks into parallel phases, dispatching workers, verifying gates, and iterating until closure.
+---
+
+# orchestration
+
+Use this skill when orchestrating multi-phase tasks across pi-crew teams and workers.
+
+## Role definition
+
+You are the orchestrator — bạn là người điều phối, không phải người thực thi.
+
+You decompose, dispatch, verify, and iterate. You do NOT edit code directly. If you find yourself opening a file to fix a typo "real quick," stop — spawn a worker instead.
+
+## Rules (8 orchestration rules)
+
+Adapted from oh-my-pi's orchestrate command pattern for pi-crew context.
+
+### 1. Do not yield until everything is closed
+
+Không trả lại control khi vẫn còn việc chưa xong. Run every phase to completion. The orchestrator owns the full lifecycle — from first dispatch to final green gate.
+
+### 2. Enumerate the full surface before dispatching
+
+Before writing any task packet, read every referenced file and understand the complete work surface. Liệt kê toàn bộ surface trước khi giao việc — không giao việc khi chưa hiểu hết scope.
+
+### 3. Parallelize maximally
+
+Every set of edits with disjoint file scope MUST ship as one batch. Nếu 5 tasks chỉnh 5 file khác nhau và không phụ thuộc nhau, dispatch tất cả cùng lúc. Never serialize what can be parallelized.
+
+### 4. Each task assignment is self-contained
+
+Subagents have no shared context. Mỗi worker chỉ biết những gì bạn ghi trong task packet. Include all necessary context, file paths, constraints, and acceptance criteria in every task.
+
+### 5. Verify after every phase before launching the next
+
+Run appropriate gates between phases: typecheck, tests, lint. Không bỏ qua verification — một phase đỏ không được phép chuyển sang phase tiếp theo.
+
+### 6. Commit policy — green only
+
+Commit after each green phase. Never commit a red tree. Chỉ commit khi tất cả gates pass. If the phase fails, fix it first.
+
+### 7. Respawn, do not absorb
+
+If a subagent returns incomplete or broken work, spawn a corrective subagent with a focused fix-up task packet. Không tự sửa lỗi của worker — respawn worker mới để sửa.
+
+### 8. No scope creep, no scope shrink
+
+Maintain the original scope exactly. Không mở rộng scope vì "thấy thêm việc," cũng không thu hẹp vì "tạm đủ." If scope needs to change, escalate to the requester.
+
+## Workflow (7 steps)
+
+### Step 1 — Ingest
+
+- Read every referenced file in the goal/task description.
+- Run `git status` and `git diff` to understand current tree state.
+- Identify all files, symbols, and subsystems in scope.
+- Check workspace tree for project context and existing patterns.
+
+### Step 2 — Plan
+
+- Materialize the full work surface as ordered phases.
+- For each phase, enumerate: files to touch, workers needed, dependencies on other phases.
+- Phases must be ordered by dependency; tasks within a phase must be independent (disjoint file scope).
+- Write the plan down — không giữ plan trong head.
+
+### Step 3 — Dispatch phase
+
+- Launch all parallel subagents in one `team` call.
+- Each subagent receives a complete task packet (see `task-packet` skill).
+- Set explicit file ownership per worker — no two workers touch the same file.
+- Use `workspaceMode: 'worktree'` when parallel edits risk conflict.
+
+### Step 4 — Verify phase
+
+- Run verification gates: typecheck, tests, lint as appropriate.
+- If green → proceed to commit.
+- If red → dispatch fix-up subagents with precise failure context (error output, file, line). Do NOT fix it yourself.
+
+### Step 5 — Commit phase (if applicable)
+
+- Only when all gates are green.
+- Commit message should reference the phase and what was accomplished.
+- Never commit a red tree.
+
+### Step 6 — Advance
+
+- Mark current phase done.
+- Immediately start the next phase — do not pause to ask "ready to continue?"
+- Loop back to Step 3 for the next phase.
+
+### Step 7 — Final verification
+
+- Run the full gate set one more time after all phases complete.
+- This is the final safety net — typecheck, tests, lint, everything.
+- Only report DONE when final verification is green.
+
+## Anti-patterns
+
+These are the behaviours that kill orchestration quality — tránh xa:
+
+| Anti-pattern | Why it's wrong |
+|---|---|
+| Editing files yourself "because it's faster" | You are the orchestrator, not an editor. Speed comes from correct delegation, not shortcutting. |
+| Yielding after phase 1 with "ready to continue?" | The requester gave you a goal, not a conversation. Drive to completion. |
+| Dispatching one subagent at a time when five could run in parallel | Wasted time. Enumerate first, then batch-dispatch all independent tasks. |
+| Skipping typecheck/tests between phases | A red phase propagates errors forward. Always verify before advancing. |
+| Marking todos done without verifying | Unverified work is undone work. Run the gate, check the output, then mark done. |
+
+## pi-crew specific adaptations
+
+### Task delegation pattern
+
+Use the `team` tool with appropriate action for dispatching work:
+
+- `action: 'run'` with a named team for multi-role work (implementation, review, research).
+- Assign one worker per file/symbol to avoid edit conflicts.
+- Each task packet must be fully self-contained — workers cannot see each other's context.
+
+### Mailbox coordination
+
+- Use mailbox (`inbox`/`outbox`) for cross-worker coordination when workers need to signal completion or report blockers.
+- Orchestrator checks mailbox after each phase to collect worker results.
+- Workers report one of: DONE, DONE_WITH_CONCERNS, BLOCKED, NEEDS_CONTEXT.
+
+### Team/workflow/role concepts
+
+| Concept | When to use |
+|---|---|
+| `team: 'implementation'` | Complex multi-phase implementation with parallel specialists |
+| `team: 'fast-fix'` | Small targeted fixes, single-phase |
+| `team: 'review'` | Code review and security review phases |
+| `team: 'research'` | Investigation before implementation planning |
+| `team: 'parallel-research'` | Multi-project/source audits |
+| `workflow: 'implementation'` | Adaptive fanout where planner decides subagent allocation |
+
+### Workspace tree context
+
+- Read `AGENTS.md` and project-level config before planning phases.
+- Different subprojects have different build/test commands — use the right ones.
+- pi-mono: `npm run check` (requires prior build), `./test.sh`
+- pi-crew: `npm test`, `npm run typecheck`
+- pi-subagents: `npm test`, `npm run test:all`
+
+## Verification
+
+For orchestration skill itself:
+
+```bash
+cd pi-crew
+npx tsc --noEmit
+node --experimental-strip-types --test test/unit/team-recommendation.test.ts
+npm test
+```
+
+For orchestrated work: run the gate commands appropriate to the target subproject after each phase, and again after final phase.

package/skills/ownership-session-security/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: ownership-session-security
+description: Session ownership and authorization workflow. Use when implementing cancel, respond, steer, run ownership, cwd overrides, imported runs, or cross-session actions.
+---
+
+# ownership-session-security
+
+Use this skill for cross-session safety and trust-boundary work.
+
+## Source patterns distilled
+
+- Pi session IDs: `ctx.sessionManager.getSessionId()` from Pi core `ExtensionContext`
+- pi-crew ownership: `TeamRunManifest.ownerSessionId`, `src/extension/team-tool/run.ts`, `cancel.ts`, `respond.ts`
+- Path safety: `src/utils/safe-paths.ts`, `src/state/state-store.ts`, `src/state/mailbox.ts`
+- Destructive actions: `src/extension/team-tool/lifecycle-actions.ts`, `src/worktree/cleanup.ts`
+
+## Rules
+
+- Propagate the active Pi session ID into `TeamContext` for every production tool/command path.
+- New runs should record `ownerSessionId` when available.
+- For owned runs, cross-session actions that mutate state must be rejected unless explicit force/admin semantics are designed and tested.
+- Legacy runs without `ownerSessionId` may remain permissive for backward compatibility, but document this behavior.
+- User/LLM-controlled path fields (`cwd`, import paths, artifact paths, task IDs) must be normalized and contained under an allowed base.
+- Use `resolveContainedPath`, `resolveRealContainedPath`, `assertSafePathId`, and symlink checks rather than ad-hoc `startsWith` checks.
+- Destructive management actions must require `confirm: true`; referenced resource deletes must require `force: true` where applicable.
+
+## Anti-patterns
+
+- Assuming `ctx.sessionId` exists directly on Pi context.
+- Letting `cwd: ../other-project` move run state into another project.
+- Letting `respond`/`cancel` mutate a foreign owned run.
+- Trusting task IDs, run IDs, or artifact paths from tool params without validation.
+
+## Verification
+
+```bash
+cd pi-crew
+npx tsc --noEmit
+node --experimental-strip-types --test test/unit/cancel-ownership.test.ts test/unit/respond-tool.test.ts test/unit/cwd-override-security.test.ts test/unit/api-artifact-security.test.ts
+npm test
+```

package/skills/pi-extension-lifecycle/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: pi-extension-lifecycle
+description: Pi extension lifecycle and registration patterns. Use when adding or reviewing extension tools, commands, resources, providers, event handlers, session hooks, or context-sensitive Pi API usage.
+---
+
+# pi-extension-lifecycle
+
+Use this skill when working on Pi extension registration or lifecycle behavior.
+
+## Source patterns distilled
+
+- Pi core: `source/pi-mono/packages/coding-agent/src/core/extensions/types.ts`, `loader.ts`, `runner.ts`
+- Pi examples: `source/pi-mono/packages/coding-agent/examples/extensions/`
+- pi-crew extension entry: `src/extension/register.ts`, `src/extension/registration/*.ts`
+
+## Rules
+
+- Register tools, commands, shortcuts, widgets, providers, and event handlers from the extension factory or lifecycle callbacks.
+- Tool definitions should use a TypeBox schema and an `execute(toolCallId, params, signal, onUpdate, ctx)` handler.
+- Use fresh `ExtensionContext`/`ExtensionCommandContext` after session replacement (`newSession`, `fork`, `switchSession`, `reload`). Do not retain old context references for later work.
+- For session-scoped work, derive session identity from `ctx.sessionManager.getSessionId()` and pass it into pi-crew `TeamContext`.
+- Prefer small registration modules under `src/extension/registration/`; keep `index.ts` minimal.
+- Clean up intervals, event subscriptions, child processes, and watchers on session switch/shutdown.
+- Wrap optional Pi API hooks in compatibility checks/try-catch when supporting older Pi versions.
+
+## Anti-patterns
+
+- Do not use stale context objects after session switch.
+- Do not register duplicate tool/command names and assume override behavior.
+- Do not perform blocking filesystem or network work inside extension render callbacks.
+- Do not add hardcoded global keybindings without config or collision review.
+
+## Verification
+
+```bash
+cd pi-crew
+npx tsc --noEmit
+npm test
+```

package/skills/requirements-to-task-packet/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: requirements-to-task-packet
+description: Use when a goal, issue, roadmap item, review finding, or user request must become actionable worker tasks.
+---
+
+# requirements-to-task-packet
+
+Core principle: workers need explicit task packets, not inherited ambiguity. Ask only when ambiguity changes architecture, safety, public behavior, or data loss risk; otherwise record assumptions.
+
+Distilled from detailed reads of clarification, spec-to-implementation, subagent-driven development, and skill-authoring patterns.
+
+## Clarify or Proceed
+
+Ask before implementation when ambiguity affects:
+
+- security boundary, permissions, ownership, or secret handling;
+- destructive operations, migrations, publishing, or public API behavior;
+- architecture or data model;
+- acceptance criteria or rollback expectations.
+
+Proceed with explicit assumptions when ambiguity is local, reversible, and testable.
+
+## Task Packet Template
+
+```text
+Objective:
+Scope/paths:
+Allowed edits:
+Forbidden edits/non-goals:
+Inputs/dependencies:
+Relevant context/artifacts:
+Assumptions:
+Risks:
+Acceptance criteria:
+Verification commands:
+Expected output artifacts:
+Escalation conditions:
+```
+
+## Subagent Context Rules
+
+- Give each worker fresh, curated context; do not rely on hidden parent history.
+- Include exact upstream artifact paths and summaries when needed.
+- Keep implementation tasks independent or explicitly sequenced.
+- Require workers to report one of: DONE, DONE_WITH_CONCERNS, NEEDS_CONTEXT, BLOCKED.
+- For BLOCKED/NEEDS_CONTEXT, change context/model/scope before retrying.
+
+## Acceptance Criteria
+
+Use observable checks:
+
+- command output, state transition, UI/status text, artifact contents;
+- regression tests or named test files;
+- security properties such as containment/ownership/no secrets;
+- compatibility requirements such as Windows paths or Pi CLI flags;
+- rollback notes.
+
+## Anti-patterns
+
+- Broad “fix everything” prompts.
+- Buried assumptions.
+- Expanding scope because context remains.
+- Treating tests as proof when the requirement was never asserted.

package/skills/resource-discovery-config/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: resource-discovery-config
+description: pi-crew resource and configuration discovery workflow. Use when changing agents, teams, workflows, skills, resource hooks, config precedence, or project/user overrides.
+---
+
+# resource-discovery-config
+
+Use this skill for pi-crew resource/config work.
+
+## Source patterns distilled
+
+- Pi resource loader: `source/pi-mono/packages/coding-agent/src/core/resource-loader.ts`, extension `resources_discover` hook
+- pi-crew discovery: `src/agents/discover-agents.ts`, `src/teams/discover-teams.ts`, `src/workflows/discover-workflows.ts`
+- Config: `src/config/config.ts`, `src/schema/config-schema.ts`, `schema.json`, `docs/resource-formats.md`
+
+## Rules
+
+- Respect discovery precedence: project resources should override user/builtin where supported.
+- Keep built-in resource formats stable and documented.
+- Project config (`.pi/pi-crew.json`) must be sanitized: do not allow dangerous user-only settings such as agent override injection if project trust is lower.
+- Resource paths exposed through Pi hooks must point to package-root resources after build; verify `__dirname` resolution carefully.
+- Avoid dynamic inline imports; keep discovery synchronous or async according to call-site expectations.
+- Validate config with schema and provide actionable errors.
+- When adding new config fields, update defaults, schema, docs, tests, and examples together.
+
+## Anti-patterns
+
+- Resolving package skills to `src/skills` instead of package-root `skills` after publishing.
+- Letting project-local config inject arbitrary global agent overrides.
+- Introducing precedence ambiguity between project/user/builtin resources.
+- Changing resource file syntax without migration notes.
+
+## Verification
+
+```bash
+cd pi-crew
+npx tsc --noEmit
+node --experimental-strip-types --test test/unit/config-schema-validation.test.ts test/unit/config.test.ts test/unit/extension-api-surface.test.ts test/unit/agent-override-skills.test.ts
+npm test
+npm pack --dry-run
+```

package/skills/runtime-state-reader/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: runtime-state-reader
+description: Safe read-only navigation of pi-crew run state. Use for inspecting manifests, tasks, events, agents, artifacts, health, and diagnostics without modifying state.
+---
+
+# runtime-state-reader
+
+Use this skill when debugging or auditing a pi-crew run.
+
+## Source patterns distilled
+
+- `src/state/types.ts`, `src/state/contracts.ts`, `src/state/state-store.ts`
+- `src/state/event-log.ts`, `src/state/artifact-store.ts`, `src/runtime/crew-agent-records.ts`
+- `src/extension/run-index.ts`, `src/extension/team-tool/status.ts`, `src/extension/team-tool/inspect.ts`
+
+## Rules
+
+- Prefer exported state APIs over direct file parsing: `loadRunManifestById(cwd, runId)`, run index/list helpers, event readers, and agent readers.
+- Treat state as append-mostly/durable. For review and debugging, do not mutate manifests/tasks/events.
+- Validate run IDs and path-derived IDs; never concatenate untrusted path segments outside state helpers.
+- Read events as JSONL; expect partial/corrupt trailing lines in crash scenarios and handle gracefully.
+- Check status contracts before inferring behavior: terminal vs active run/task statuses matter.
+- Agent aggregate records (`agents.json`) and per-agent status files can disagree briefly; prefer the latest loaded run state plus event log for final conclusions.
+- Include exact paths inspected and distinguish direct evidence from inference.
+
+## Common inspection order
+
+1. Load manifest/tasks.
+2. Check run/task statuses and timestamps.
+3. Read recent events.
+4. Read agent records and per-agent output/status if needed.
+5. Inspect artifacts/diagnostics only through contained paths.
+6. Report root cause and smallest safe remediation.
+
+## Verification
+
+For code changes to state readers:
+
+```bash
+cd pi-crew
+npx tsc --noEmit
+node --experimental-strip-types --test test/unit/run-index.test.ts test/unit/crew-contracts.test.ts test/unit/atomic-write.test.ts
+npm test
+```

package/skills/secure-agent-orchestration-review/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: secure-agent-orchestration-review
+description: Use when reviewing delegation, skill loading, tool access, worker prompts, artifacts, runtime config, state, ownership, or subprocess execution.
+---
+
+# secure-agent-orchestration-review
+
+Core principle: every delegated worker crosses trust boundaries. Safe orchestration requires contained paths, explicit ownership, scoped tools, non-invasive defaults, and prompt-injection resistance.
+
+Distilled from detailed reads of security notice, insecure-defaults, sharp-edges, differential-review, guardrail, and skill quality patterns.
+
+## Trust Boundaries
+
+Review:
+
+- parent session ↔ child Pi worker;
+- user prompt ↔ generated task packet;
+- project skills ↔ package skills;
+- global config ↔ project config;
+- artifacts/logs ↔ future prompts/UI;
+- mailbox/respond/steer/cancel ↔ session ownership;
+- external skills/docs ↔ prompt injection/tool poisoning;
+- runtime env/CLI args ↔ provider/model behavior.
+
+## Must-Check Findings
+
+- Unsafe defaults: scaffold mode unexpectedly enabled, dangerous limits, missing depth guards, overbroad tools.
+- Path containment: cwd override escape, symlink traversal, unsafe skill names, absolute path leakage.
+- Prompt injection: untrusted output treated as instruction, skill metadata overtrusted, missing precedence text.
+- Secrets: env/config/log/artifact/diagnostic leakage.
+- Destructive commands: delete/prune/reset/force push without explicit confirmation.
+- Ownership races: authorization checked outside lock, stale task/manifest written after re-read.
+- Supply chain: external skill content imported without review, unknown tool requirements, hidden commands.
+
+## Secure Defaults for pi-crew
+
+- Real execution should be explicit and disable-able, but generated config must not accidentally block normal workflows.
+- Project overrides should be contained to the project root.
+- Missing/invalid config should fall back safely.
+- Skills should be loaded by safe name and source-labeled without absolute path disclosure.
+- Worker prompts should state instruction precedence and treat artifacts as data.
+
+## Finding Format
+
+Include severity, path/symbol, scenario, fix, and verification. Separate must-fix security issues from hardening suggestions.

package/skills/state-mutation-locking/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: state-mutation-locking
+description: Durable state mutation and locking workflow. Use when changing manifests, tasks, mailbox, claims, events, stale reconciliation, recovery, cancel/respond/resume, or retry logic.
+---
+
+# state-mutation-locking
+
+Use this skill before modifying pi-crew run state.
+
+## Source patterns distilled
+
+- `src/state/locks.ts` — run-level sync/async locks
+- `src/state/state-store.ts` — manifest/tasks persistence
+- `src/state/contracts.ts` — allowed status transitions
+- `src/state/mailbox.ts`, `src/state/task-claims.ts`, `src/state/atomic-write.ts`
+- `src/runtime/crash-recovery.ts`, `src/runtime/stale-reconciler.ts`, `src/runtime/team-runner.ts`
+
+## Rules
+
+- Mutations to a run's `manifest.json`, `tasks.json`, mailbox delivery state, claims, or recovery status must be protected by a run lock when concurrent actions are possible.
+- Re-read manifest/tasks inside the lock before making a decision; pre-lock reads are only for locating the run.
+- Persist with atomic write helpers (`atomicWriteJson`, async variants, or state-store helpers). Do not partially write JSON files.
+- Respect status contracts. Do not transition terminal tasks/runs unless the action explicitly supports force semantics.
+- Separate analysis from persistence: pure reconcilers should return intended repaired state; locked callers should persist it.
+- In retry/resume paths, reload fresh task status immediately before execution and skip if the task is no longer retryable/runnable.
+- Include event-log entries for externally visible state changes.
+
+## Anti-patterns
+
+- Reading state, waiting/doing async work, then writing the old copy.
+- Updating `tasks.json` from a reconciler or watcher without a lock.
+- Cancelling/responding to runs owned by another session.
+- Using `fs.writeFileSync` for JSON state outside atomic helpers.
+
+## Verification
+
+```bash
+cd pi-crew
+npx tsc --noEmit
+node --experimental-strip-types --test test/unit/cancel-ownership.test.ts test/unit/respond-tool.test.ts test/unit/stale-reconciler.test.ts test/unit/api-claim.test.ts
+npm test
+```

package/skills/systematic-debugging/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: systematic-debugging
+description: Use when encountering a bug, test failure, blocked run, provider error, stale state, crash, or unexpected behavior before proposing fixes.
+---
+
+# systematic-debugging
+
+Core principle: no fixes without root-cause investigation first. Symptom patches create new bugs and hide the real failure.
+
+Distilled from detailed reads of systematic-debugging, root-cause tracing, TDD, and error-analysis skill patterns.
+
+## Four Phases
+
+### 1. Root Cause Investigation
+
+Before any fix:
+
+- read error messages, stack traces, failing assertions, task status, and logs completely;
+- reproduce narrowly and record the exact command/steps;
+- check recent diffs, commits, config changes, dependency changes, and environment differences;
+- trace data/control flow across component boundaries;
+- add temporary diagnostics only when they answer a specific question.
+
+For pi-crew, trace:
+
+```text
+user/tool params → config resolution → team/workflow/agent discovery → model/runtime routing → child args/env → state/events/artifacts → status/UI
+```
+
+### 2. Pattern Analysis
+
+- Find a similar working path in the codebase.
+- Compare working vs broken behavior field-by-field.
+- Identify dependencies: config home, project root markers, env vars, locks, stale caches, provider model capabilities.
+- Do not assume small differences are irrelevant.
+
+### 3. Hypothesis and Test
+
+- State one hypothesis: “I think X is the root cause because Y.”
+- Test one variable at a time with the smallest read-only probe or targeted test.
+- If wrong, discard the hypothesis instead of piling on fixes.
+- After three failed fixes, question architecture or assumptions before continuing.
+
+### 4. Implementation
+
+- Add or identify a failing regression test when practical.
+- Fix the root cause, not the symptom.
+- Avoid “while I’m here” refactors.
+- Verify targeted behavior, then broader gates.
+
+## Evidence to Collect
+
+- failing command and exit code;
+- relevant manifest/tasks/events/mailbox files;
+- effective config paths and redacted config;
+- child Pi args/env after redaction;
+- git diff and recent commits;
+- provider/model/thinking resolution;
+- async timing/race indicators.
+
+## Anti-patterns
+
+- Fixing before reproducing.
+- Assuming real user global config cannot pollute tests.
+- Treating provider errors as only transient network failures.
+- Removing guards because they reveal a blocked state.
+- Editing unrelated layers before checking the hypothesis.

package/skills/ui-render-performance/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: ui-render-performance
+description: Non-blocking Pi TUI render workflow. Use when changing widgets, powerbar/statusbar segments, dashboard panes, overlays, snapshot caches, or live UI refresh behavior.
+---
+
+# ui-render-performance
+
+Use this skill for Pi/pi-crew TUI work.
+
+## Source patterns distilled
+
+- Pi TUI is synchronous immediate-mode/string rendering: `source/pi-mono/packages/coding-agent/src/modes/interactive/interactive-mode.ts`
+- Pi extension examples use event-driven state updates, not render-time loading.
+- pi-crew UI: `src/extension/register.ts`, `src/ui/run-dashboard.ts`, `src/ui/run-snapshot-cache.ts`, `src/ui/crew-widget.ts`, `src/ui/powerbar-publisher.ts`, `src/ui/render-scheduler.ts`
+
+## Rules
+
+- Treat every `render(width)` and widget/powerbar update as a hot synchronous path.
+- Render from in-memory snapshots only. Preload config, manifests, snapshots, agents, and mailbox counts asynchronously.
+- Use `RenderScheduler.schedule()` to coalesce renders; avoid direct repeated rendering.
+- Prefer `snapshotCache.get(runId)` in render paths. If a sync fallback is unavoidable, classify it as first-load/rare and document why.
+- Keep dashboard panes pure: accept a snapshot/model and format strings; do not call `fs.readFileSync`, `fs.readdirSync`, `fs.statSync`, or network APIs from pane render methods.
+- On session switch, cancel timers and ensure in-flight async preloads cannot update stale session UI.
+- Watch TTL interactions: a preload interval shorter than cache TTL prevents render-time refresh gaps.
+
+## Anti-patterns
+
+- Do not call `loadConfig()`, `manifestCache.list()`, or `refreshIfStale()` repeatedly inside `renderTick()` unless backed by preloaded frame data.
+- Do not do large JSON parsing or directory scans inside widget render/update functions.
+- Do not show stale health warnings for completed/cancelled/failed runs.
+
+## Verification
+
+```bash
+cd pi-crew
+npx tsc --noEmit
+node --experimental-strip-types --test test/unit/run-snapshot-cache.test.ts test/unit/crew-widget.test.ts test/unit/powerbar-publisher.test.ts test/unit/run-dashboard.test.ts
+npm test
+```

package/skills/verification-before-done/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: verification-before-done
+description: Use when about to claim work is complete, fixed, passing, reviewed, committed, or ready to hand off.
+---
+
+# verification-before-done
+
+Core principle: evidence before claims. A worker report, green-looking log, or previous run is not fresh verification.
+
+Distilled from detailed reads of agent-skill patterns for verification-before-completion, TDD, review reception, and QA workflows.
+
+## Gate Function
+
+Before any completion claim:
+
+1. Identify the command or inspection that proves the claim.
+2. Run the full command fresh, or explicitly state why a command cannot be run.
+3. Read the output, including exit code and failure counts.
+4. Compare the output to the claim.
+5. Report the claim only with the evidence.
+
+## Claim-to-Evidence Table
+
+| Claim | Requires | Not sufficient |
+|---|---|---|
+| Tests pass | Fresh test output with zero failures | Prior run, “should pass” |
+| Typecheck passes | Typecheck command exit 0 | Lint or targeted tests only |
+| Bug fixed | Original symptom/regression test passes | Code changed |
+| Requirements met | Checklist against request/plan | Generic test success |
+| Agent completed | Worker output plus artifact/diff/state inspection | Worker says DONE |
+| Safe to commit | Relevant checks pass and status reviewed | Partial local confidence |
+
+## Verification Ladder
+
+Choose the smallest reliable gate, then escalate when risk requires it:
+
+1. Read-only inspection for plans/reviews.
+2. Targeted unit test for touched behavior.
+3. Typecheck for TypeScript/schema/API changes.
+4. Integration test for runtime, subprocess, state, filesystem, UI, config, or session behavior.
+5. Full suite before commit/release or broad changes.
+6. Real Pi smoke only when safe and needed.
+
+## Done Report
+
+Include:
+
+- changed files or read-only status;
+- commands run and pass/fail result;
+- artifacts, run IDs, logs, or state paths inspected;
+- behavior actually verified;
+- skipped checks and why;
+- risks and rollback notes.
+
+## Red Flags
+
+Stop before saying done if you are using words like “should”, “probably”, “looks”, “seems”, “I think”, or if you are trusting an agent report without checking evidence.