session-orchestrator 3.16.0

package/hooks/subagent-telemetry.mjs

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+/**
+ * subagent-telemetry.mjs — SubagentStart + SubagentStop hook handler.
+ *
+ * Hook events: SubagentStart, SubagentStop (issue #342).
+ * Fires when a subagent lifecycle event occurs. Discriminates on
+ * `hook_event_name` to write either a 'start' or 'stop' record to
+ * `.orchestrator/metrics/subagents.jsonl`.
+ *
+ * Decision flow:
+ *   1. shouldRunHook gate — exit 0 immediately when the hook is disabled.
+ *   2. Read JSON payload from stdin: { hook_event_name, agent_id?, subagent_id?,
+ *        agent_type?, subagent_type?, parent_session_id?, session_id?,
+ *        duration_ms?, transcript_path? }.
+ *   3. Discriminate on hook_event_name → event: 'start' | 'stop'.
+ *   4. For stop events, parse the subagent transcript at `transcript_path` to
+ *        recover token_input / token_output (#624). The harness does NOT send
+ *        token_input / token_output on stdin — they must be extracted from the
+ *        transcript's per-assistant-turn `message.usage` blocks, deduped by
+ *        requestId (streaming snapshots repeat the same requestId ~4-5×).
+ *   5. Build canonical record and call appendSubagent().
+ *   6. Output: nothing on stdout. Diagnostic errors to stderr only.
+ *
+ * Exit codes: 0 always (informational, never blocking).
+ */
+
+import { shouldRunHook } from './_lib/profile-gate.mjs';
+// Exit 0 immediately when disabled via SO_HOOK_PROFILE / SO_DISABLED_HOOKS.
+if (!shouldRunHook('subagent-telemetry')) process.exit(0);
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { appendSubagent } from '../scripts/lib/subagents-schema.mjs';
+import { SO_PROJECT_DIR } from '../scripts/lib/platform.mjs';
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const JSONL_PATH = path.join(SO_PROJECT_DIR, '.orchestrator', 'metrics', 'subagents.jsonl');
+
+/**
+ * Defense-in-depth byte ceiling for transcript reads (#624). The transcript path
+ * is harness-trusted, so this is not an exploitable vector — but the repo follows
+ * a bounded-read discipline: a pathologically large transcript is skipped (yields
+ * the empty/zero-usage result) rather than read whole into memory.
+ */
+const MAX_TRANSCRIPT_BYTES = 50 * 1024 * 1024; // ~50 MB
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Read stdin to EOF (best-effort). Returns parsed JSON or null on failure.
+ * Uses a 5 s timeout consistent with Claude Code hook contract.
+ *
+ * @returns {Promise<object|null>}
+ */
+function readStdinJson() {
+  return new Promise((resolve) => {
+    if (process.stdin.readableEnded || process.stdin.closed) {
+      resolve(null);
+      return;
+    }
+    const chunks = [];
+    const timer = setTimeout(() => { resolve(null); }, 5_000);
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => chunks.push(c));
+    process.stdin.on('end', () => {
+      clearTimeout(timer);
+      const raw = chunks.join('').trim();
+      if (!raw) { resolve(null); return; }
+      try { resolve(JSON.parse(raw)); } catch { resolve(null); }
+    });
+    process.stdin.on('error', () => { clearTimeout(timer); resolve(null); });
+    process.stdin.resume();
+  });
+}
+
+/**
+ * Extract deduped token totals from a subagent transcript JSONL file (#624).
+ *
+ * On SubagentStop the harness supplies `transcript_path`. Each
+ * `{"type":"assistant"}` line carries a `message.usage` block with
+ * `{ input_tokens, output_tokens, ... }`. Streaming snapshots repeat the SAME
+ * `requestId` across consecutive assistant lines, so a naive Σ over every line
+ * double-counts (observed ~4-5× on real transcripts). The correct recipe is to
+ * group by `requestId`, keep ONE usage block per id (the first), then sum.
+ *
+ * token_input is the raw `input_tokens` sum (NOT folded with cache_* fields) to
+ * match the existing OTel `gen_ai.usage.input_tokens` semantic.
+ *
+ * Per-turn clamping (#624): a single poisoned usage value (negative, NaN, or a
+ * non-integer such as 10.5) MUST NOT discard the otherwise-good turns. Each turn's
+ * contribution is added ONLY when it is a non-negative integer; an invalid value
+ * is skipped (its turn still counts toward `counted` so a transcript of mixed
+ * good/bad turns yields the sum of the GOOD turns, never null). Without per-turn
+ * clamping, a final `Number.isInteger(sum) && sum >= 0` aggregate check would
+ * nuke the whole input sum to null on one bad value.
+ *
+ * Dedup assumption (#624): the streaming harness always supplies a `requestId` on
+ * assistant turns, so dedup keys on it. A turn with NO requestId is counted
+ * individually (no dedup) — this is the documented forward-compat fallback, not a
+ * double-count, because the harness never omits requestId in practice.
+ *
+ * Partial-usage assumption (#624): a turn carrying `input_tokens` but no
+ * `output_tokens` (or vice-versa) contributes 0 to the absent side — NOT null —
+ * so the present side still sums and the aggregate stays valid.
+ *
+ * NEVER throws. Any failure (missing/unreadable path, 0 assistant turns, parse
+ * error) yields { tokenInput: null, tokenOutput: null } so the hook still exits 0.
+ *
+ * @param {string|undefined|null} transcriptPath — absolute path from stdin
+ * @returns {{ tokenInput: number|null, tokenOutput: number|null }}
+ */
+function extractTranscriptUsage(transcriptPath) {
+  const nullResult = { tokenInput: null, tokenOutput: null };
+  try {
+    if (typeof transcriptPath !== 'string' || !transcriptPath.trim()) return nullResult;
+    if (!fs.existsSync(transcriptPath)) return nullResult;
+
+    // Bounded-read guard (#624): skip an oversized transcript gracefully rather
+    // than read the whole file into memory. statSync failure (race/unreadable)
+    // falls through to the readFileSync attempt below — both stay inside the
+    // no-throw try/catch, so the worst case is still nullResult, never a throw.
+    const { size } = fs.statSync(transcriptPath);
+    if (size > MAX_TRANSCRIPT_BYTES) return nullResult;
+
+    const raw = fs.readFileSync(transcriptPath, 'utf8');
+    const lines = raw.split('\n');
+
+    const seen = new Set();
+    let tokenInput = 0;
+    let tokenOutput = 0;
+    let counted = 0;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let obj;
+      try {
+        obj = JSON.parse(trimmed);
+      } catch {
+        continue; // skip a single malformed line, keep parsing the rest
+      }
+      if (!obj || obj.type !== 'assistant') continue;
+      const usage = obj.message?.usage;
+      if (!usage || typeof usage !== 'object') continue;
+
+      // Dedup by requestId — keep the first usage block per id.
+      const requestId = obj.requestId;
+      if (typeof requestId === 'string' && requestId) {
+        if (seen.has(requestId)) continue;
+        seen.add(requestId);
+      }
+
+      // Per-turn clamp (#624): add a turn's value ONLY when it is a non-negative
+      // integer. A poisoned value (negative, NaN, float like 10.5) is skipped so
+      // the good turns survive. An absent side contributes 0, not null.
+      const inTok = usage.input_tokens;
+      const outTok = usage.output_tokens;
+      if (Number.isInteger(inTok) && inTok >= 0) tokenInput += inTok;
+      if (Number.isInteger(outTok) && outTok >= 0) tokenOutput += outTok;
+      counted += 1;
+    }
+
+    // No assistant turns with usage → leave fields null (forward-compat).
+    if (counted === 0) return nullResult;
+
+    // The aggregate is guaranteed a non-negative integer by per-turn clamping
+    // above (Σ of non-negative integers), so emit it directly.
+    return {
+      tokenInput,
+      tokenOutput,
+    };
+  } catch {
+    return nullResult;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const input = await readStdinJson();
+  if (!input) return;
+
+  const eventName = input.hook_event_name;
+  const event = eventName === 'SubagentStart' ? 'start' : 'stop';
+
+  // Pick the first non-empty trimmed string from the candidate keys, or the fallback.
+  const firstNonEmptyString = (keys, fallback) => {
+    for (const k of keys) {
+      const v = input[k];
+      if (typeof v === 'string' && v.trim()) return v;
+    }
+    return fallback;
+  };
+
+  // Resolve identifiers from either naming convention the harness may use.
+  const agentId = firstNonEmptyString(['agent_id', 'subagent_id'], 'unknown');
+  const agentType = firstNonEmptyString(['agent_type', 'subagent_type'], null);
+  const parentSessionId = firstNonEmptyString(['parent_session_id', 'session_id'], null);
+
+  /** @type {object} */
+  const record = {
+    timestamp: new Date().toISOString(),
+    event,
+    agent_id: agentId,
+    schema_version: 1,
+    ...(agentType !== null ? { agent_type: agentType } : {}),
+    ...(parentSessionId !== null ? { parent_session_id: parentSessionId } : {}),
+  };
+
+  if (event === 'stop') {
+    // duration_ms is required for stop events; default to 0 if harness omits it.
+    record.duration_ms =
+      typeof input.duration_ms === 'number' && input.duration_ms >= 0
+        ? Math.round(input.duration_ms)
+        : 0;
+
+    // Tokens are NOT sent on stdin (#624) — recover them from the transcript's
+    // per-assistant-turn usage blocks, deduped by requestId. Any failure → null.
+    const { tokenInput, tokenOutput } = extractTranscriptUsage(input.transcript_path);
+    if (tokenInput !== null) record.token_input = tokenInput;
+    if (tokenOutput !== null) record.token_output = tokenOutput;
+
+    // Cost is best-effort / forward-compat (#624): the native transcript does
+    // NOT expose total_cost_usd today, so this is null in practice. No rate
+    // table — use the native cost only, default null when absent.
+    const totalCostUsd =
+      typeof input.total_cost_usd === 'number' && Number.isFinite(input.total_cost_usd) && input.total_cost_usd >= 0
+        ? input.total_cost_usd
+        : null;
+    record.total_cost_usd = totalCostUsd;
+
+    // OTel alias — #411 additive, schema_version=1 backwards-compat
+    record['gen_ai.usage.input_tokens'] = tokenInput;
+    record['gen_ai.usage.output_tokens'] = tokenOutput;
+    record['gen_ai.system'] = 'anthropic';
+  }
+
+  await appendSubagent(JSONL_PATH, record);
+}
+
+// Exit 0 always — informational hook must never block Claude.
+main().catch(() => {}).finally(() => process.exit(0));

package/hooks/wave-scope-commit-guard.mjs

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+// hooks/wave-scope-commit-guard.mjs
+//
+// PSA-004 sub-mode B + sub-mode C guard: runs at pre-commit time and rejects
+// the commit when staged paths violate either the active wave-scope.json
+// allowedPaths (sub-mode B) or the cross-agent staging-fence (sub-mode C).
+//
+// Sub-mode B — lint-staged sweep
+//   lint-staged's eslint --fix / prettier --write step touches files matching
+//   its globs in package.json (not just the agent's staged set) and re-stages
+//   them via internal `git add`. PreToolUse Edit/Write gates never see these
+//   files. This guard catches them at the very last moment before the commit
+//   object is created.
+//
+// Sub-mode C — concurrent git-add race (issue #552)
+//   Two wave-agents in the same repo can both `git add` overlapping paths
+//   between each other's `git diff --cached` and `git commit`. Each individual
+//   `git add` is recorded by hooks/pre-bash-staging-fence.mjs in a per-agent
+//   fence file under .orchestrator/staging-fence/<agent-id>.json. At commit
+//   time this guard walks ALL fence files (under a withStagingFenceLock mutex)
+//   and rejects the commit when ANY staged path is also recorded in a SIBLING
+//   agent's fence — i.e. another agent's intent to stage that path.
+//
+// Behavior summary
+//   - No .orchestrator/wave-scope.json → exit 0 (no active wave; sub-mode B
+//     short-circuits). Sub-mode C still runs if a fence directory exists.
+//   - Allowed paths violation → exit 1 with restore hint.
+//   - Cross-agent fence overlap → exit 1 with "staging-fence: cross-agent
+//     overlap" stderr.
+//   - --no-verify bypass: this hook is invoked as a git pre-commit hook;
+//     `git commit --no-verify` skips it entirely (operator opts out by name).
+
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+// Re-use existing helpers from scripts/lib/hardening.mjs.
+// IMPORTANT: import is resolved relative to THIS file's location (the hook
+// ships with the session-orchestrator package), NOT relative to the git
+// repo it is protecting. The two diverge when the hook is invoked from a
+// consumer repo or a test tmp-dir.
+import { pathMatchesPattern, findScopeFile } from '../scripts/lib/hardening.mjs';
+import { withStagingFenceLock } from '../scripts/lib/session-lock.mjs';
+
+const repoRoot = execSync('git rev-parse --show-toplevel', { encoding: 'utf8' }).trim();
+// #801: resolve wave-scope.json via the same precedence every other reader
+// uses (.pi/.cursor/.codex/.claude — scope-gate.mjs findScopeFile). The prior
+// hardcoded `.orchestrator/wave-scope.json` path was DEAD — the coordinator
+// writes wave-scope.json to the state dir (.claude/ on Claude Code; see
+// skills/wave-executor/wave-loop.md), so this guard never fired. findScopeFile
+// returns null when no scope file exists at any precedence dir, preserving
+// the "no active wave → exit 0" semantics below.
+const scopePath = findScopeFile(repoRoot);
+const fenceDir = join(repoRoot, '.orchestrator', 'staging-fence');
+
+// ---------------------------------------------------------------------------
+// Sub-mode B — allowedPaths check
+// ---------------------------------------------------------------------------
+
+const stagedOutput = execSync('git diff --cached --name-only', { encoding: 'utf8' });
+const stagedFiles = stagedOutput.split('\n').filter(Boolean);
+
+if (scopePath) {
+  let scope;
+  try {
+    scope = JSON.parse(readFileSync(scopePath, 'utf8'));
+  } catch (err) {
+    process.stderr.write(`wave-scope-commit-guard: failed to parse wave-scope.json: ${err.message}\n`);
+    process.exit(1);
+  }
+
+  const allowedPaths = Array.isArray(scope.allowedPaths) ? scope.allowedPaths : [];
+  if (allowedPaths.length > 0) {
+    const violations = stagedFiles.filter(
+      (f) => !allowedPaths.some((pattern) => pathMatchesPattern(f, pattern)),
+    );
+
+    if (violations.length > 0) {
+      process.stderr.write('✗ wave-scope-commit-guard: staged paths outside wave-scope.allowedPaths:\n');
+      for (const v of violations) process.stderr.write(`  - ${v}\n`);
+      process.stderr.write('\nThese files were likely added by lint-staged eslint --fix / prettier --write.\n');
+      process.stderr.write('To proceed:\n');
+      process.stderr.write('  1) git restore --staged <path>   # for each foreign path\n');
+      process.stderr.write('  2) git commit                    # retry\n');
+      process.exit(1);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Sub-mode C — cross-agent staging-fence reconciliation (issue #552)
+// ---------------------------------------------------------------------------
+//
+// Skip entirely when no fence dir exists OR no staged files. The fence dir
+// only appears when a wave-agent invoked `git add` while SO_WAVE_AGENT=1.
+// Manual / coordinator commits never write a fence file, so this branch
+// short-circuits to exit 0 for them (AC5 safe-default).
+if (!existsSync(fenceDir) || stagedFiles.length === 0) {
+  process.exit(0);
+}
+
+// Resolve the "current" agent id from SO_WAVE_AGENT_ID (when set by the
+// caller) or fall back to a PID-derived marker. The fence files themselves
+// embed the agent_id; the env-var is only used to skip THIS agent's own
+// fence entries (we cross-check against SIBLINGS, not ourselves).
+const ownAgentId = process.env.SO_WAVE_AGENT_ID ?? null;
+
+/**
+ * Build a regex that finds a staged path inside a `git add` command string.
+ * Word-boundary on both sides so `src/foo.ts` does not match `src/foo.ts.bak`.
+ * The path is escaped so glob metacharacters (`*`, `?`) and shell metas
+ * cannot be reinterpreted.
+ */
+function pathRegex(p) {
+  const escaped = p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`(?:^|[\\s'"])${escaped}(?:$|[\\s'"])`);
+}
+
+/**
+ * Walk a single sibling fence file and return the staged paths whose path
+ * pattern matches any of our staged files.
+ */
+function findOverlaps(fenceJsonPath, ourStaged) {
+  let body;
+  try {
+    body = JSON.parse(readFileSync(fenceJsonPath, 'utf8'));
+  } catch {
+    return [];
+  }
+  if (!body || typeof body !== 'object') return [];
+  if (!Array.isArray(body.staged_paths)) return [];
+  if (ownAgentId && body.agent_id === ownAgentId) return []; // skip self
+
+  const matches = [];
+  for (const entry of body.staged_paths) {
+    const cmd = entry?.command;
+    if (typeof cmd !== 'string') continue;
+    for (const ours of ourStaged) {
+      if (pathRegex(ours).test(cmd)) {
+        matches.push({ ourPath: ours, siblingAgent: body.agent_id ?? '<unknown>', cmd });
+      }
+    }
+  }
+  return matches;
+}
+
+let overlaps = [];
+
+try {
+  await withStagingFenceLock(
+    repoRoot,
+    async () => {
+      let entries;
+      try {
+        entries = readdirSync(fenceDir);
+      } catch {
+        return;
+      }
+      for (const name of entries) {
+        if (!name.endsWith('.json')) continue;
+        if (name.startsWith('.')) continue; // skip .commit.lock, tmp files
+        const overlapsFromFile = findOverlaps(join(fenceDir, name), stagedFiles);
+        overlaps = overlaps.concat(overlapsFromFile);
+      }
+    },
+    { timeoutMs: 5000 },
+  );
+} catch (err) {
+  // Lock acquisition failed — emit a warning but do NOT block the commit.
+  // The race-detection layer is opportunistic; a lock-acquire timeout is
+  // strictly less severe than blocking a legitimate commit on flaky FS.
+  process.stderr.write(
+    `⚠ wave-scope-commit-guard: staging-fence lock failed — ${err?.message ?? err}\n`,
+  );
+  process.exit(0);
+}
+
+if (overlaps.length > 0) {
+  process.stderr.write('✗ wave-scope-commit-guard: staging-fence: cross-agent overlap detected:\n');
+  for (const o of overlaps) {
+    process.stderr.write(`  - ${o.ourPath} (also staged by sibling agent ${o.siblingAgent})\n`);
+  }
+  process.stderr.write('\nAnother wave-agent recorded a `git add` for one or more of your staged paths.\n');
+  process.stderr.write('To proceed:\n');
+  process.stderr.write('  1) Coordinate with the sibling agent OR\n');
+  process.stderr.write('  2) git restore --staged <path>   # for each conflicting path, then retry\n');
+  process.stderr.write('  3) git commit --no-verify        # bypass (PSA-001/PSA-003 risk — operator opt-out)\n');
+  process.exit(1);
+}
+
+process.exit(0);

package/monitors/monitors.json

@@ -0,0 +1,14 @@
+[
+  {
+    "name": "ecosystem-health",
+    "command": "node \"${CLAUDE_PLUGIN_ROOT}\"/scripts/lib/ecosystem-health.mjs --watch",
+    "description": "Ecosystem repo health watcher (CI status, branch drift, stale baselines across vault-registered projects). Emits one NDJSON line per detected state change.",
+    "when": "on-skill-invoke:ecosystem-health"
+  },
+  {
+    "name": "convergence-monitor",
+    "command": "node \"${CLAUDE_PLUGIN_ROOT}\"/scripts/lib/convergence-monitor.mjs --tail",
+    "description": "Wave convergence telemetry monitor — tails .orchestrator/metrics/events.jsonl + sessions.jsonl, surfaces convergence signals (shrinking diff, pass-rate plateau, velocity).",
+    "when": "on-skill-invoke:wave-executor"
+  }
+]

package/output-styles/finding-report.md

@@ -0,0 +1,48 @@
+# Finding Report Style
+
+Use this format for discovery probes and code analysis findings.
+
+## Structure
+
+### Finding Header
+
+```
+### [{severity}] {title}
+```
+
+Severity levels: `critical`, `high`, `medium`, `low`, `info`
+
+### Finding Body
+
+| Field | Value |
+|-------|-------|
+| Severity | `{level}` |
+| Confidence | `{high\|medium\|low}` |
+| File | `{path}:{line}` |
+| Issue | GL#{n} (if applicable) |
+
+### Description
+
+One paragraph maximum. What was found and why it matters.
+
+### Evidence
+
+Code snippet with file reference:
+
+```{lang}
+// path/to/file.ts:42
+<relevant code>
+```
+
+### Recommendation
+
+One-line fix suggestion. Link to docs or patterns if applicable.
+
+## Rules
+
+- Severity + confidence always visible — drives prioritization
+- One finding per block — never combine multiple issues
+- Evidence is mandatory — no findings without code references
+- Recommendations are actionable — "rename X to Y" not "consider renaming"
+- Sort by severity descending within a report
+- Keep description under 3 sentences

package/output-styles/session-report.md

@@ -0,0 +1,53 @@
+# Session Report Style
+
+Use this format for session-start presentations and session-end summaries.
+
+## Structure
+
+### Session Overview Table
+
+| Field | Value |
+|-------|-------|
+| Type | `{housekeeping\|feature\|deep}` |
+| Repo | `{name}` on `{branch}` |
+| Git | {uncommitted} uncommitted, {unpushed} unpushed, {branches} branches |
+| GitLab | {open} open issues ({high} high), {mrs} open MRs |
+| Health | Tests: {status} \| Validator: {status} \| CI: {status} |
+
+### Findings Section
+
+Use bullet points with status icons:
+- Items requiring action
+- Observations and context
+
+Status icons: `pass` / `fail` / `warn` / `info` / `skip`
+
+### Recommendations
+
+Present as numbered options with clear rationale:
+
+1. **Option A (recommended):** Description — why this is best
+2. **Option B:** Description — trade-offs
+
+### Scope Table (session-end)
+
+| Issue | Status | Summary |
+|-------|--------|---------|
+| GL#{n} | done/partial/deferred | One-line description |
+
+### Metrics (session-end)
+
+| Metric | Value |
+|--------|-------|
+| Files changed | {n} |
+| Tests | {n} passing |
+| Commits | {n} pushed |
+| Duration | {estimate} |
+
+## Rules
+
+- Tables over prose — scannable beats readable
+- One line per finding — no multi-paragraph explanations
+- Link issues as `GL#{n}` — clickable in GitLab context
+- Quantify everything — "3 issues" not "several issues"
+- Lead with status — good news first, then blockers

package/output-styles/wave-summary.md

@@ -0,0 +1,38 @@
+# Wave Summary Style
+
+Use this format for wave completion reports between waves.
+
+## Structure
+
+### Header
+
+```
+## Wave {N}/{total} Complete
+```
+
+### Agent Status Table
+
+| Agent | Task | Status | Files |
+|-------|------|--------|-------|
+| {agent-name} | {1-line task} | done/partial/failed | {file list} |
+
+### Quality Gate Results
+
+- Tests: {n} passing, {n} failing
+- Validator: {n}/{n} checks
+- TypeScript: {n} errors (if applicable)
+
+### Adaptations
+
+Only include if the plan changed:
+- What changed and why
+- Impact on remaining waves
+
+## Rules
+
+- One table row per agent — no nested details
+- Status is exactly one of: `done`, `partial`, `failed`
+- File lists use short relative paths (e.g., `hooks/on-stop.sh`)
+- Quality gates are pass/fail — no ambiguity
+- Adaptations only when deviating from plan — omit if on track
+- Keep under 20 lines total

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "session-orchestrator",
+  "version": "3.16.0",
+  "description": "Loop engineering for AI coding agents — turn ad-hoc sessions into a repeatable research → plan → wave-execute → close loop with verification gates. Runs on Claude Code, Codex CLI, Cursor, and Pi.",
+  "type": "module",
+  "homepage": "https://session-orchestrator.com",
+  "keywords": [
+    "pi-package",
+    "claude-code",
+    "codex",
+    "cursor",
+    "ai-agents",
+    "orchestration"
+  ],
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "files": [
+    ".mcp.json",
+    "CHANGELOG.md",
+    "pi/",
+    "skills/",
+    "agents/",
+    "commands/",
+    "hooks/",
+    "scripts/",
+    "rules/",
+    "templates/",
+    "output-styles/",
+    "monitors/",
+    "assets/",
+    ".claude-plugin/",
+    ".codex-plugin/",
+    ".cursor/",
+    "docs/*.md",
+    "NOTICE",
+    "SECURITY.md",
+    "!**/node_modules/**",
+    "!**/.DS_Store"
+  ],
+  "scripts": {
+    "test": "node scripts/check-package-manager.mjs && vitest --run",
+    "test:coverage": "node scripts/check-package-manager.mjs && vitest --run --coverage",
+    "test:watch": "node scripts/check-package-manager.mjs && vitest",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "typecheck": "node scripts/typecheck.mjs",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "share:hw-learnings": "node scripts/export-hw-learnings.mjs",
+    "vault-watcher": "node scripts/vault-integration-watcher.mjs",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.26.0",
+    "ajv": "^8.17.1",
+    "js-yaml": "^4.2.0",
+    "mdast-util-to-string": "^4.0.0",
+    "remark": "^15.0.0",
+    "remark-parse": "^11.0.0",
+    "unified": "^11.0.0",
+    "zx": "^8.1.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.6.0",
+    "@commitlint/config-conventional": "^19.6.0",
+    "@eslint/js": "^10.0.1",
+    "@vitest/coverage-v8": "^4.1.5",
+    "eslint": "^10.2.1",
+    "husky": "^9.1.7",
+    "lint-staged": "^15.2.10",
+    "prettier": "^3.0.0",
+    "vitest": "^4.1.5"
+  },
+  "overrides": {
+    "vite": "^8.0.16"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Kanevry/session-orchestrator.git"
+  },
+  "pi": {
+    "extensions": [
+      "./pi/extensions/session-orchestrator.ts"
+    ],
+    "skills": [
+      "./skills"
+    ],
+    "prompts": [
+      "./pi/prompts/*.md"
+    ]
+  }
+}