@warren-dean/code-kit 0.19.0 → 0.21.0

package/bin/code-kit.mjs

@@ -29,6 +29,8 @@
 //   report [--json] | report send|discard <id>   the person sends a draft to code-kit's GitHub, or not
 //   stops [--session id] [--json]     finish checks that refused an agent's last stop, still failing
 //   sent-back <branch> [--reason …]   records that a review sent the branch back at its current commit
+//   standards [--json] [--for <path>...]
+//                                    the project's standards, with an organisation's, and their problems
 //   settings [--json] | settings set <key> <value> --reason … [--via pane]
 //                                    the harness settings; set is the person's own change
 //                         record approvals a person gave in chat (with approvals.lead on, the lead runs it)
@@ -57,7 +59,20 @@ import {
 } from '../hooks/lib/config.mjs';
 import { diffConfigs, ownershipMoves } from '../hooks/lib/diff.mjs';
 import { CODE, importsOf, layerOf, layerProblems, targetOf } from '../hooks/lib/layers.mjs';
-import { ADAPTERS, activeAdapters, adapterFacts } from '../hooks/lib/adapters/index.mjs';
+import {
+  ADAPTERS,
+  activeAdapters,
+  adapterFacts,
+  providerAdapterOf,
+} from '../hooks/lib/adapters/index.mjs';
+import {
+  EVENT_PARTS,
+  USAGE_DIR,
+  buildSnapshot,
+  mainCheckout,
+  snapshotHash,
+  snapshotProblems,
+} from '../hooks/lib/snapshot.mjs';
 import { nextStep } from '../hooks/lib/next.mjs';
 import { discardReport, draftReport, readReports, sendReport } from '../hooks/lib/report.mjs';
 import {
@@ -92,6 +107,7 @@ import {
   claimChanges,
   storyOfBranch,
   syncBoard,
+  readCache,
   teamOf,
   teamProvider,
   whoami,
@@ -117,6 +133,13 @@ import { dependencyRuleProblems, npmFacts, packageOf } from '../hooks/lib/regist
 import { heldTo, laneOfBranch, verifyBranch } from '../hooks/lib/verify.mjs';
 import { skippedLine } from '../hooks/lib/checks.mjs';
 import { TESTS_APPROVAL } from '../hooks/lib/regression.mjs';
+import {
+  appliesTo,
+  projectStandards,
+  readInherited,
+  standardLine,
+  writeInherited,
+} from '../hooks/lib/standards.mjs';
 
 const out = (s) => process.stdout.write(`${s}\n`);
 // Piped into `head` and the like: stop quietly when the reader closes.
@@ -172,6 +195,8 @@ const FLAGS = [
   '--off',
   '--blocks',
   '--take',
+  '--dry-run',
+  '--for',
 ];
 const flag = (name) => args.includes(name);
 const writeBaseline = flag('--write');
@@ -242,7 +267,7 @@ function check() {
   if (team) {
     const me = whoami(resolve('.'));
     out(
-      `Team: ${team.techLead} is the tech lead; a claim is stale after ${team.staleDays} working day${team.staleDays === 1 ? '' : 's'} without a push; provider ${team.provider === 'github' ? 'GitHub' : team.provider.command}.`,
+      `Team: ${team.techLead} is the tech lead; a claim is stale after ${team.staleDays} working day${team.staleDays === 1 ? '' : 's'} without a push; provider ${team.provider === 'github' ? 'GitHub' : (team.provider.name ?? team.provider.command)}.`,
     );
     for (const [lane, owners] of Object.entries(team.owners))
       out(`Lane ${lane} is owned by ${owners.join(', ')}`);
@@ -412,6 +437,7 @@ const VERIFY_GROUPS = {
   design: 'Designs before screens',
   tests: 'Weakened tests',
   regression: 'Fixes and their tests',
+  standards: 'Standards',
   checks: 'Checks',
 };
 
@@ -1461,8 +1487,12 @@ function teamCommand() {
     die(
       'This project has no "team" in its config, so it has no claims or owners. Add "team": { "techLead": "<GitHub handle>" } to share them.',
     );
+  // HUBR-6: a hosted provider's own commands (sign in, connect, status), through its adapter.
+  if (rest[0] === 'provider') return providerCommand(raw);
   const provider = teamProvider(resolve('.'), team);
   const [sub, story] = rest;
+  if (sub === 'report') return teamReport(team, provider);
+  if (sub === 'pulse') return pulseCommand(raw, team, provider);
   const holderWords = (h) =>
     `${h.story} is claimed by ${h.by} (${ago(h.at)}). Ask them, or the tech lead (${team.techLead}), to release it.`;
   if (sub === 'claim') {
@@ -1577,7 +1607,7 @@ function teamCommand() {
   }
   if (sub !== undefined)
     die(
-      'code-kit team [--json] [--fresh] | team init … | team since [--json] [--peek] | team claim|keep|release <story> | team reassign <story> <handle>',
+      'code-kit team [--json] [--fresh] | team init … | team since [--json] [--peek] | team claim|keep|release <story> | team reassign <story> <handle> | team report [--dry-run] [--json]',
     );
   const state = provider.state({ fresh: flag('--fresh') });
   if (flag('--json')) return out(JSON.stringify(state, null, 2));
@@ -1608,6 +1638,134 @@ function teamCommand() {
     out(`  #${p.number} ${p.title} (${p.by}, ${p.branch}${p.draft ? ', draft' : ''})`);
 }
 
+// --- what a project reports (docs/specs/21-hub-adapter-and-reports.md) ----------------------------
+
+const REPORT_SENT = '.claude/state/report-sent.json';
+const REPORT_MINUTES = 10;
+
+/** HUBR-2: the snapshot, from what status, timeline, trail, the journal and the config already know. */
+function snapshotNow(team) {
+  const { config } = load();
+  if (!config.docs?.specs || !config.docs?.plan) return null;
+  const from = base(config, false);
+  const status = buildStatus('.', config, from, tracked());
+  const claims = (readCache(resolve('.')) ?? {}).claims ?? [];
+  return buildSnapshot({
+    root: resolve('.'),
+    config,
+    status,
+    base: from,
+    claims,
+    version: JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version,
+  });
+}
+
+/**
+ * HUBR-3: sends the snapshot when what happened changed (stages, approvals, send-backs, merges), or when
+ * only usage changed and ten minutes have passed; never the same snapshot twice. A provider that can't
+ * be reached is tried again with the next change. `{ sent, why }`.
+ */
+function sendSnapshot(team, provider, snapshot, { force = false } = {}) {
+  if (team.provider === 'github') return { sent: false, why: 'GitHub keeps no reports.' };
+  if (!team.report) return { sent: false, why: 'team.report is false.' };
+  const problems = snapshotProblems(snapshot);
+  if (problems.length) return { sent: false, why: `The report isn't valid: ${problems[0]}.` };
+  const file = join(mainCheckout(resolve('.')), REPORT_SENT);
+  let last = {};
+  try {
+    last = JSON.parse(readFileSync(file, 'utf8'));
+  } catch {
+    // nothing sent yet
+  }
+  const events = snapshotHash(snapshot, EVENT_PARTS);
+  const all = snapshotHash(snapshot);
+  const due =
+    force ||
+    events !== last.events ||
+    (all !== last.all && Date.now() - (last.at ?? 0) >= REPORT_MINUTES * 60_000);
+  if (!due) return { sent: false, why: 'Nothing new to report.' };
+  const r = provider.report(snapshot);
+  if (!r || r.ok === false)
+    return { sent: false, why: r?.why ?? 'The provider refused the report.' };
+  mkdirSync(join(mainCheckout(resolve('.')), '.claude/state'), { recursive: true });
+  writeFileSync(file, `${JSON.stringify({ events, all, at: Date.now() })}\n`);
+  return { sent: true };
+}
+
+/** HUBR-2, HUBR-4: `team report` sends what's new; `--dry-run` prints exactly what would be sent. */
+function teamReport(team, provider) {
+  const snapshot = snapshotNow(team);
+  if (!snapshot)
+    die(
+      'A report needs docs.specs and docs.plan in the config. The spec-design skill writes both.',
+    );
+  if (flag('--dry-run')) return out(JSON.stringify(snapshot, null, 2));
+  const r = sendSnapshot(team, provider, snapshot, { force: true });
+  if (flag('--json')) return out(JSON.stringify(r, null, 2));
+  out(
+    r.sent
+      ? `Reported this project's facts to ${team.provider.name ?? 'the team provider'}.`
+      : r.why,
+  );
+}
+
+/**
+ * The mod's pulse (HUBR-3, HUBR-6), every 30 seconds while a session runs, only for a hosted provider:
+ * stdin is `{ agents, usage }`, the session's agents by tool and branch and its token ledger (USE-1).
+ * Keeps both for the provider's client and the report, and reports when something new happened.
+ */
+async function pulseCommand(raw, team, provider) {
+  const hosted = providerAdapterOf(raw.team?.provider);
+  if (!hosted || hosted.problem || !sessionId) return;
+  let input = {};
+  try {
+    let raw = '';
+    for await (const chunk of process.stdin) raw += chunk;
+    input = raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    input = {};
+  }
+  const root = resolve('.');
+  const id = sessionId.replace(/[^\w-]/g, '');
+  if (input.agents) hosted.adapter.presence(root, id, input.agents);
+  if (input.usage && typeof input.usage === 'object') {
+    const dir = join(mainCheckout(root), USAGE_DIR);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, `${id}.json`),
+      `${JSON.stringify({ at: Date.now(), entries: input.usage })}\n`,
+    );
+  }
+  // STD-6: the organisation's standards, for the hooks and instructions, read every ten minutes.
+  const inherited = readInherited(root);
+  if (!inherited.at || Date.now() - Date.parse(inherited.at) >= REPORT_MINUTES * 60_000) {
+    const r = provider.standards();
+    if (r && r.ok !== false && Array.isArray(r.standards)) writeInherited(root, r);
+  }
+  // Building the snapshot reads git: at most once a minute.
+  const built = join(mainCheckout(root), '.claude/state/report-built.json');
+  let at = 0;
+  try {
+    at = JSON.parse(readFileSync(built, 'utf8')).at ?? 0;
+  } catch {
+    // never built
+  }
+  if (Date.now() - at < 60_000) return;
+  writeFileSync(built, `${JSON.stringify({ at: Date.now() })}\n`);
+  const snapshot = snapshotNow(team);
+  if (snapshot) sendSnapshot(team, provider, snapshot);
+}
+
+/** HUBR-6: `team provider signin|signout|status|connect|drift-model …`, run by the provider's client. */
+function providerCommand(raw) {
+  const hosted = providerAdapterOf(raw.team?.provider);
+  if (!hosted || hosted.problem)
+    die(
+      "This team's provider isn't a hosted one: claims and intents go through GitHub, and there's nothing to sign in to.",
+    );
+  process.exit(hosted.adapter.run(rest.slice(1), hosted.url));
+}
+
 /**
  * TEAM-13: `team init` sets the project up as a team's, or (`--off`) as one developer's again. Without
  * `--write` it shows the team section it would write; with it, it writes the config and says what the
@@ -1671,7 +1829,7 @@ function teamInit(raw) {
   if (flag('--json'))
     return out(JSON.stringify({ written: true, ...section, me: state.me ?? null, setup }, null, 2));
   out(
-    `Wrote the team to ${file}: ${team.techLead} is the tech lead; a claim is stale after ${team.staleDays} working day${team.staleDays === 1 ? '' : 's'} without a push; intents go in "${team.intents}".`,
+    `Wrote the team to ${file}: ${team.techLead} is the tech lead; a claim is stale after ${team.staleDays} working day${team.staleDays === 1 ? '' : 's'} without a push; ${team.intents ? `intents go in "${team.intents}"` : `${team.provider.name ?? 'the provider'} keeps intents`}.`,
   );
   for (const [lane, owners] of Object.entries(team.owners))
     out(`Lane ${lane}: ${owners.join(', ')}`);
@@ -1900,8 +2058,11 @@ function instructionsCommand() {
   const { config } = load();
   const root = resolve('.');
   if (rest[0] === 'show') {
-    if (!['lead', 'lane'].includes(rest[1])) die('code-kit instructions show lead|lane');
-    return out(rest[1] === 'lead' ? leadSection(root, config) : agentRules(root, config));
+    if (!['lead', 'lane'].includes(rest[1])) die('code-kit instructions show lead|lane [<lane>]');
+    if (rest[2] && !config.lanes[rest[2]])
+      die(`No lane is called ${rest[2]}: ${Object.keys(config.lanes).join(', ') || 'none'}.`);
+    // A named lane's rules carry the standards for its layers (spec 22, STD-3).
+    return out(rest[1] === 'lead' ? leadSection(root, config) : agentRules(root, config, rest[2]));
   }
   const changed = flag('--write') ? writeInstructions(root, config) : [];
   const files = instructionsState(root, config);
@@ -1927,7 +2088,7 @@ function instructionsCommand() {
   for (const f of files) out(`  ${f.file}: ${said[f.state]}`);
   if (files.some((f) => f.state === 'legacy'))
     out(
-      '\nTo merge one: replace its old code-kit part (in CLAUDE.md from `## Enforced, not advised` to the line about changing the rules; in an agent file from `Always:` to the end of its list) with what `code-kit instructions show lead` or `show lane` prints. Keep every line the project wrote itself (its own rules, its layer order, its docs) outside the markers, under a heading of its own, so a later refresh never touches them.',
+      '\nTo merge one: replace its old code-kit part (in CLAUDE.md from `## Enforced, not advised` to the line about changing the rules; in an agent file from `Always:` to the end of its list) with what `code-kit instructions show lead` or `show lane <lane>` prints. Keep every line the project wrote itself (its own rules, its layer order, its docs) outside the markers, under a heading of its own, so a later refresh never touches them.',
     );
 }
 
@@ -2006,8 +2167,78 @@ function worktreesCommand() {
     );
 }
 
+/**
+ * Spec 22: `standards` lists the standards that apply (the project's file, merged with what an
+ * organisation's team provider supplies) and what's wrong with them (STD-1, STD-6); `--for <path>...`
+ * keeps the ones for those files' layers, as a review reads them (STD-4). Exits 1 on a problem.
+ */
+function standardsCommand() {
+  const { raw, config } = load();
+  const root = resolve('.');
+  const team = teamOf(raw);
+  let fetched = null;
+  if (team && team.provider !== 'github') {
+    const r = teamProvider(root, team).standards();
+    if (r && r.ok !== false && Array.isArray(r.standards)) writeInherited(root, r);
+    else fetched = r?.why ?? "The team provider didn't answer.";
+  }
+  const found = projectStandards(root, config);
+  const { waivers } = readInherited(root);
+  const files = flag('--for') ? rest : [];
+  const layersOf = (f) =>
+    config.layers.length ? [layerOf(f, config.layers)?.name].filter(Boolean) : null;
+  const standards = files.length
+    ? found.standards.filter((s) => files.some((f) => appliesTo(s, layersOf(f))))
+    : found.standards;
+  if (flag('--json')) {
+    out(
+      JSON.stringify(
+        {
+          file: found.file,
+          exists: found.exists,
+          version: found.version,
+          ...(files.length ? { for: files } : {}),
+          standards,
+          waivers,
+          problems: found.problems,
+          ...(fetched ? { provider: fetched } : {}),
+        },
+        null,
+        2,
+      ),
+    );
+    if (found.problems.length) process.exit(1);
+    return;
+  }
+  if (!found.exists && !found.standards.length)
+    return out(
+      `This project has no standards yet: ${found.file} doesn't exist. /code-kit:init suggests them from the specs or the code, and the person approves each.`,
+    );
+  if (fetched)
+    out(`The organisation's standards weren't refreshed (${fetched}); using the last ones read.`);
+  const inherited = found.standards.filter((s) => s.origin !== 'own').length;
+  out(
+    `${found.standards.length} standard${found.standards.length === 1 ? '' : 's'} apply${files.length ? `; ${standards.length} to ${files.join(', ')}` : ''}: ${found.standards.length - inherited} from ${found.file}${inherited ? `, ${inherited} from the organisation${found.version ? ` (version ${found.version})` : ''}` : ''}.`,
+  );
+  for (const s of standards) {
+    const rule = s.applied === 'enforced' && s.enforcedBy ? ` · enforced by ${s.enforcedBy}` : '';
+    const where = s.layers?.length ? ` · ${s.layers.join(', ')}` : '';
+    const origin = s.origin === 'own' ? '' : ` · ${s.origin}`;
+    out(`  ${standardLine({ ...s, origin: 'own', waiver: null })}${where}${rule}${origin}`);
+    if (s.waiver)
+      out(
+        `    waived${s.waiver.paths?.length ? ` for ${s.waiver.paths.join(', ')}` : ''}${s.waiver.expires ? ` until ${s.waiver.expires}` : ''}${s.waiver.approvedBy ? `, approved by ${s.waiver.approvedBy}` : ''}${s.waiver.reason ? `: ${s.waiver.reason}` : ''}`,
+      );
+  }
+  if (!found.problems.length) return;
+  out(`\nProblems:`);
+  for (const p of found.problems) out(`  ${p}`);
+  process.exit(1);
+}
+
 const commands = {
   check,
+  standards: standardsCommand,
   worktrees: worktreesCommand,
   instructions: instructionsCommand,
   loop: loopCommand,
@@ -2046,7 +2277,8 @@ function usage() {
       '              | verify [--base ref] [--branch name] [--no-checks] | status [--base ref] [--json]\n' +
       '              | security [--base ref] [--branch name] [--json]\n' +
       '              | next [--base ref] [--json] | adapters | trace <path>... [--json]\n' +
-      '              | instructions [--write] [--json] | instructions show lead|lane\n' +
+      '              | instructions [--write] [--json] | instructions show lead|lane [<lane>]\n' +
+      '              | standards [--json] [--for <path>...]\n' +
       '              | worktrees [--json] | worktrees release <branch> | worktrees prune\n' +
       '              | approve <name>... --reason "…" [--lane name]   [--config file]\n' +
       '              | merge <branch> --delegated|--person [--into branch] | requests [--json] | requests drop <n>|all\n' +

package/hooks/guard-bash.mjs

@@ -21,6 +21,12 @@ import { laneOfBranch, storyOfBranch, teamOf, teamProvider, whoami } from './lib
 import { matchesAny } from './lib/glob.mjs';
 import { noteBefore } from './lane-audit.mjs';
 import { TESTS_APPROVAL, commitWeakenings } from './lib/regression.mjs';
+import {
+  STANDARDS_APPROVAL,
+  noteFor,
+  standardsFile,
+  standardsWeakenings,
+} from './lib/standards.mjs';
 import {
   APPROVAL_LOG,
   actorFor,
@@ -30,6 +36,7 @@ import {
   askHowTo,
   currentBranch,
   decidedBy,
+  delegatedMark,
   dependencyChange,
   dependencyGrants,
   useApproval,
@@ -176,7 +183,9 @@ for (const { pattern, why, person, command } of config.shell.block) {
     person && actor.kind === 'lead'
       ? '\nTo let the lead run it when the person says so in chat, a person sets "approvals": { "lead": true } in the config.'
       : '';
-  block(`Blocked: ${why}${hint}\nCommand: ${cmd}`);
+  block(
+    `Blocked: ${why}${noteFor(project, config, { kind: 'shell', name: why })}${hint}\nCommand: ${cmd}`,
+  );
 }
 
 if (approves && actor.kind !== 'lead')
@@ -471,16 +480,47 @@ function recordApprovals() {
         session: input.session_id ?? null,
       }),
     );
+  // STD-5: removing a standard, or weakening a required one, is the person's own call, never the lead's,
+  // delegated or not. The commit waits for their `standards` approval, which records what it weakened.
+  const stdFile = standardsFile(config);
+  const stdWeak =
+    files.includes(stdFile) && !arrivesWithMerge(root, stdFile, { staged: true })
+      ? standardsWeakenings(
+          git('show', `HEAD:${stdFile}`),
+          existsSync(join(root, stdFile)) ? readFileSync(join(root, stdFile), 'utf8') : '',
+        )
+      : [];
+  if (stdWeak.length) {
+    const granted = approval(root, STANDARDS_APPROVAL, actor);
+    if (!granted || granted.reason.includes(delegatedMark('').slice(0, -1))) {
+      recordRequest(
+        root,
+        actor,
+        STANDARDS_APPROVAL,
+        stdFile,
+        `Standards weakened: ${stdWeak.join('; ')}.`,
+      );
+      const personOnly = { ...config, approvals: { ...config.approvals, delegate: null } };
+      block(
+        `Blocked: this commit weakens the project's standards in ${stdFile}: ${stdWeak.join('; ')}. Removing a standard, or weakening a required one, is the person's call, never the lead's. Ask them, with what the standard costs the project and your recommendation; they approve it with\n${approvalHowTo(STANDARDS_APPROVAL, actor, root, 'weakening the standards in one commit', personOnly)}`,
+      );
+    }
+  }
   for (const file of files) {
     // Concluding a merge: what arrives as the other branch has it was logged there, with its approvals.
     if (arrivesWithMerge(root, file, { staged: true })) continue;
-    const entry = protectedEntry(file, config);
+    // A weakened standards file is the person's even where the config doesn't protect it.
+    const entry =
+      protectedEntry(file, config) ??
+      (file === stdFile && stdWeak.length
+        ? { approval: STANDARDS_APPROVAL, why: "the project's standards" }
+        : null);
     const granted = entry && approval(root, entry.approval, actor);
     const byDependency = actor.kind === 'lane' && dependencyChange(actor, file, root, config);
     if (entry && !granted && actor.kind !== 'lead' && !byDependency) {
       recordRequest(root, actor, entry.approval, file, entry.why);
       block(
-        `Blocked: ${file} is ${entry.why}; committing it needs ${decidedBy(entry.approval, config) === 'lead' ? "the lead's" : "a person's"} approval in force. ${askHowTo(entry.approval, actor, root, config)}`,
+        `Blocked: ${file} is ${entry.why}; committing it needs ${decidedBy(entry.approval, config) === 'lead' ? "the lead's" : "a person's"} approval in force.${noteFor(root, config, { kind: 'protected', name: entry.approval, glob: entry.glob })} ${askHowTo(entry.approval, actor, root, config)}`,
       );
     }
     if (granted)
@@ -488,6 +528,7 @@ function recordApprovals() {
         approval: entry.approval,
         reason: granted.reason,
         grantedAt: granted.grantedAt,
+        ...(file === stdFile && stdWeak.length ? { weakened: stdWeak } : {}),
       });
     else if (byDependency && (entry || !owns(actor, file, config))) {
       const grants = dependencyGrants(root, actor);
@@ -538,6 +579,7 @@ ${approvalHowTo(TESTS_APPROVAL, actor, root, 'weakening tests in one commit', pe
       });
     useApproval(root, TESTS_APPROVAL, actor);
   }
+  if (stdWeak.length) useApproval(root, STANDARDS_APPROVAL, actor);
   // A dependency approval is used up by the commit that adds its package to a manifest or lockfile.
   const manifests = files.filter((f) => isDependencyFile(f));
   if (manifests.length && actor.kind !== 'readonly') {

package/hooks/guard-paths.mjs

@@ -6,7 +6,8 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { loadBaseline, newProblems } from './lib/baseline.mjs';
 import { CONFIG_FILE } from './lib/config.mjs';
-import { layerProblems } from './lib/layers.mjs';
+import { brokenLayerRule, layerProblems } from './lib/layers.mjs';
+import { noteFor } from './lib/standards.mjs';
 import { block, start } from './lib/hook.mjs';
 import { teamOf, teamProvider, teamRefusal, whoami } from './lib/team.mjs';
 import { spawnSync } from 'node:child_process';
@@ -83,7 +84,7 @@ if (after !== null) {
   );
   if (added.length)
     block(
-      `Blocked: this edit would break the layer rules (.claude/code-kit.json › layers):\n  ${added.join('\n  ')}\nDepend only on the layers listed, or ask the lead to change the rule.`,
+      `Blocked: this edit would break the layer rules (.claude/code-kit.json › layers):\n  ${added.join('\n  ')}\nDepend only on the layers listed, or ask the lead to change the rule.${noteFor(root, config, added.map(brokenLayerRule))}`,
     );
 }
 process.exit(0);

package/hooks/hooks.json

@@ -46,6 +46,28 @@
         ]
       }
     ],
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/team-session.mjs\" start",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/team-session.mjs\" end",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
     "Stop": [
       {
         "hooks": [