@warren-dean/code-kit 0.18.0 → 0.20.0

package/hooks/lib/team.mjs

@@ -4,6 +4,7 @@ import { spawnSync } from 'node:child_process';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { matchesAny } from './glob.mjs';
+import { providerAdapterOf } from './adapters/index.mjs';
 import {
   isHandle,
   isStoryId,
@@ -57,19 +58,24 @@ export function teamProblems(c) {
       );
     if (t.intents !== undefined && !(typeof t.intents === 'string' && t.intents.trim()))
       p.push('"team.intents" must name the discussion category intents go in');
+    const adapter = providerAdapterOf(t.provider);
     if (
       t.provider !== undefined &&
       t.provider !== 'github' &&
+      !(adapter && !adapter.problem) &&
       !(
         isObj(t.provider) &&
+        !adapter &&
         typeof t.provider.command === 'string' &&
         t.provider.command.trim() &&
         (t.provider.fallback === undefined || t.provider.fallback === 'github')
       )
     )
       p.push(
-        '"team.provider" must be "github" or { "command": "<the provider\'s command>", "fallback"?: "github" }',
+        '"team.provider" must be "github" or { "command": "<the provider\'s command>", "fallback"?: "github" }, or a hosted provider in preview: { "<its name>": "<its https address>" }',
       );
+    if (t.report !== undefined && typeof t.report !== 'boolean')
+      p.push('"team.report" must be true or false');
   }
   for (const [name, lane] of Object.entries(isObj(c.lanes) ? c.lanes : {})) {
     if (!isObj(lane) || lane.owners === undefined) continue;
@@ -86,12 +92,26 @@ export function teamProblems(c) {
  */
 export function teamOf(raw) {
   if (!isObj(raw?.team)) return null;
+  // HUBR-6: a hosted provider's adapter runs as a command, with GitHub as its fallback.
+  const adapter = providerAdapterOf(raw.team.provider);
+  const hosted = adapter && !adapter.problem ? adapter : null;
   return {
     techLead: raw.team.techLead,
     staleDays: raw.team.staleDays ?? 3,
-    intents: raw.team.intents ?? 'Intents',
+    // HUBR-7: a hosted provider keeps intents; Discussions only when the team mirrors them there.
+    intents: raw.team.intents ?? (hosted ? null : 'Intents'),
     board: raw.team.board ?? null,
-    provider: raw.team.provider ?? 'github',
+    // HUBR-4: whether the project reports its facts to a provider that isn't GitHub.
+    report: raw.team.report !== false,
+    provider: hosted
+      ? {
+          command: hosted.adapter.command(hosted.url),
+          fallback: 'github',
+          adapter: hosted.adapter.key,
+          url: hosted.url,
+          name: hosted.adapter.label,
+        }
+      : (raw.team.provider ?? 'github'),
     owners: Object.fromEntries(
       Object.entries(raw.lanes ?? {})
         .filter(([, l]) => Array.isArray(l?.owners))
@@ -139,6 +159,9 @@ export function whoami(root, now = Date.now()) {
 // the config, called with the operation's name and its input as JSON on stdin, answering JSON.
 
 const CLAIMS = 'refs/code-kit/claims';
+/** HUBR-7: what an intent waits on while the hosted provider that keeps intents is down. */
+const KEPT =
+  "This team's intents are kept by its hosted provider, which can't be reached: raise or settle it again when it's back, or set team.intents to mirror intents to a GitHub Discussions category.";
 const SEEN = 'refs/code-kit/seen-claims';
 const TEAM_STATE = '.claude/state/team.json';
 const STATE_SECONDS = 60;
@@ -157,7 +180,7 @@ function claimOf(message) {
 
 /**
  * The provider for this project's team: GitHub's, or the config's command. A command with
- * `fallback: "github"` (a hosted provider, such as the code-kit teams hub) hands each operation it
+ * `fallback: "github"` (a hosted provider, such as code-kit hub) hands each operation it
  * can't reach to the GitHub provider, so claims are still checked while it's down (TEAM-8).
  */
 export function teamProvider(root, team) {
@@ -189,6 +212,7 @@ export function teamProvider(root, team) {
         'reassign',
         'intent',
         'since',
+        'report',
       ].map((op) => [op, either(op)]),
     ),
     forget: () => (command.forget(), github.forget()),
@@ -223,8 +247,14 @@ function githubProvider(root, team) {
       return null;
     }
   };
-  /** The repository's discussions, the Intents category among its categories: null when unreadable. */
+  /**
+   * The repository's discussions, the Intents category among its categories: null when unreadable.
+   * HUBR-7: a team whose hosted provider keeps its intents, and that mirrors none to Discussions, has
+   * none here to read (`kept`).
+   */
   const discussions = () => {
+    if (!team.intents)
+      return { repoId: null, enabled: false, category: null, intents: [], kept: true };
     const d = graphql(
       `
         query ($owner: String!, $name: String!) {
@@ -452,13 +482,15 @@ function githubProvider(root, team) {
         provider: {
           name: 'GitHub',
           live: false,
-          detail: `claims are refs on origin, intents are discussions in "${team.intents}"`,
+          detail: team.intents
+            ? `claims are refs on origin, intents are discussions in "${team.intents}"`
+            : 'claims are refs on origin; intents wait for the hosted provider',
         },
         // TEAM-13: what the team still needs set up for its claims and intents to work.
         setup: [
           ...(who ? [] : ["gh isn't signed in on this machine: run gh auth login."]),
           ...(claims ? [] : ["The shared repository (origin) can't be reached."]),
-          ...(found && !found.category
+          ...(found && !found.category && !found.kept
             ? [noCategory(found).replace(/, then raise the intent again\.$/, '.')]
             : []),
         ],
@@ -489,6 +521,7 @@ function githubProvider(root, team) {
       if (!by) return { ok: false, why: 'Sign in to GitHub first (gh auth login).' };
       const found = discussions();
       if (!found) return unreachable("GitHub can't be reached, so the intent wasn't raised.");
+      if (found.kept) return unreachable(KEPT);
       if (!found.category) return { ok: false, why: noCategory(found) };
       const body = `${touches.length ? `Touches: ${touches.join(', ')}\n\n` : ''}Raised with code-kit by @${by} before any code, so the team sees it first. The tech lead agrees, drops or marks it a duplicate here.`;
       const made = graphql(
@@ -585,6 +618,7 @@ function githubProvider(root, team) {
     },
     /** TEAM-10: one intent with its comments, for its decision record; null when unreadable. */
     intent(id) {
+      if (!team.intents) return null;
       const d = graphql(
         `
           query ($owner: String!, $name: String!, $number: Int!) {
@@ -627,6 +661,7 @@ function githubProvider(root, team) {
     },
     /** TEAM-5: the tech lead agrees an intent (resolved), drops it (outdated) or marks it a duplicate. */
     settle(id, outcome, why = '') {
+      if (!team.intents) return unreachable(KEPT);
       const by = me();
       if (by !== team.techLead)
         return {
@@ -689,6 +724,8 @@ function githubProvider(root, team) {
       provider.forget();
       return { ok: true, id: Number(id), outcome };
     },
+    // HUBR-1: the free team mode has no server to report to; nothing is written anywhere.
+    report: () => ({ ok: true, sent: false }),
     forget: () => writeCache(root, null),
   };
   return provider;
@@ -739,6 +776,8 @@ function commandProvider(root, team, command) {
       const r = call('since', { at });
       return Array.isArray(r) ? r : null;
     },
+    // HUBR-1: the project's facts, on stdin as the operation's input.
+    report: (snapshot) => call('report', { snapshot }),
     forget: () => writeCache(root, null),
   };
 }

package/hooks/lib/teamfacts.mjs

@@ -122,17 +122,21 @@ export function decisionRecord(d, techLead) {
     .replace(/^Touches:.*$/m, '')
     .replace(/Raised with code-kit by @\S+ before any code[^\n]*/, '')
     .trim();
-  const agreed = (d.comments ?? [])
-    .filter((c) => c.author?.login === techLead && /^Agreed by @/.test(c.body))
-    .at(-1)
-    ?.body.replace(/^Agreed by @\S+, the tech lead(: |\.)?/, '')
-    .trim();
+  // Who settled it: the provider says (a lane owner whose paths it touches may agree it with a hosted
+  // provider), or the tech lead, who alone settles intents through GitHub.
+  const by = d.settledBy ?? d.settled_by ?? techLead;
+  const agreed =
+    (d.comments ?? [])
+      .filter((c) => c.author?.login === by && /^Agreed by @/.test(c.body))
+      .at(-1)
+      ?.body.replace(/^Agreed by @[\w-]+(?:, [^:.]*)?(: |\.)?/, '')
+      .trim() || (typeof d.why === 'string' ? d.why.trim() : '');
   return [
     `# ${d.title}`,
     '',
     '**Status:** agreed',
     `**Date:** ${date}`,
-    `**Raised by:** @${d.author?.login ?? 'someone'} · **Agreed by:** @${techLead}`,
+    `**Raised by:** @${d.author?.login ?? 'someone'} · **Agreed by:** @${by}`,
     `**Discussion:** ${d.url}`,
     '',
     '## What changes, and why',

package/hooks/mod/loop.mjs

@@ -340,10 +340,27 @@ export function milestonesDone(stories = []) {
   return [...by].filter(([, list]) => list.every((s) => s.state === 'done')).map(([m]) => m);
 }
 
-/** LEAN-3: what the lead's summary keeps when its context is compacted after a milestone. */
-export const compactInstructions = (milestone) =>
+/** LEAN-3, LEAN-4: what the lead's summary keeps when its context is compacted, after a milestone or not. */
+export const compactInstructions = (milestone = null) =>
   [
-    `${milestone} is done; the build goes on with the next milestone.`,
+    milestone
+      ? `${milestone} is done; the build goes on with the next milestone.`
+      : "The lead's context is compacted between turns; the build goes on.",
     'Keep: the milestone just finished, in a line; every story in flight now, with its lane, its branch and where it stands (building, in review, in the merge queue, waiting and on what); the decisions and questions waiting on the person; what the person decided or asked for in this session that still applies; and the rules and preferences they set.',
     "Drop: the finished stories' details, lane reports and hand-backs, command output, diffs and file contents. Each is in git, the plan or the lanes' report files, to read again when it's needed.",
   ].join('\n');
+
+/** LEAN-5: the context a model request carried: what it sent, read from the cache, and wrote to it. */
+export const requestContext = (usage) =>
+  (usage?.input_tokens ?? 0) +
+  (usage?.cache_read_input_tokens ?? 0) +
+  (usage?.cache_creation_input_tokens ?? 0);
+
+/** LEAN-5: what a lane agent past its context limit is told. */
+export const wrapUpText = (limit) =>
+  `Your context is past ${Math.round(limit / 1000)}k tokens, and every step from here rereads all of it. Finish the step you're on, commit your work, write your report, and hand back now. The lead carries the story on with a fresh agent that reads your report.`;
+
+/** LEAN-5, LEAN-6: the lead's prompt to carry a story on with a fresh agent once its agent handed back at the limit. */
+export function continuePrompt({ type, story, branch, cli = 'code-kit' }) {
+  return `${type} handed ${story} back at its context limit, with its work committed${branch ? ` on ${branch}` : ''}. Carry the story on with a fresh agent: run node "${cli}" worktrees release ${branch ?? '<branch>'} (it keeps the commits and moves the report to the main checkout), then dispatch ${story} again with the same brief, adding "Read your earlier report first: .claude/state/reports/${(branch ?? '<branch>').replace(/[^\w.-]+/g, '_')}.md in the main checkout": /code-kit:dispatch ${story}`;
+}

package/hooks/mod/register.mjs

@@ -36,6 +36,8 @@ import {
   resultPane,
   settingsView,
   usageSummary,
+  usageForReport,
+  presenceOf,
   withUsage,
 } from './view.mjs';
 import { holdable } from './hold.mjs';
@@ -61,6 +63,9 @@ import {
   COMPACT_FLOOR,
   PARK_MS,
   compactInstructions,
+  continuePrompt,
+  requestContext,
+  wrapUpText,
   milestonesDone,
   parkWatch,
   readOutcome,
@@ -106,6 +111,7 @@ let pendingSetting = null; // a change waiting for the person's reason: { key, v
 let ledger = {}; // the session's tokens by agent and story (USE-1)
 let rateLimits = []; // the session's limits, as session.measure last gave them
 const agentsSeen = new Map(); // agent id → its $.agent.list() entry, kept once it leaves the list
+const present = new Map(); // agent id (or 'main') → its presence for a hosted team provider (HUBR-6)
 const held = new Map(); // tool_use_id → a call held for the person (HOLD-2)
 const denied = new Map(); // tool_use_id → a call Claude Code's own permission check refused (PERM-1)
 const briefLater = new Set(); // the brief's questions the person put off this session (ASK-4)
@@ -1049,6 +1055,23 @@ export function register(on) {
         const who = attribution(agentId, agentsSeen.get(agentId) ?? null, model.check, model.state);
         ledger = withUsage(ledger, who, usage);
         $.ui.invalidate('ui.render');
+        // LEAN-5: a lane agent past its context limit is told to wrap up; its story goes on fresh.
+        const limit = harness().agents.lanes.contextLimit;
+        const agent = agentId ? agentsSeen.get(agentId) : null;
+        const lane = Object.entries(model.check?.lanes ?? {}).find(
+          ([, l]) => l.agent === agent?.type,
+        );
+        if (!limit || !lane || requestContext(usage) < limit) return;
+        const a = activityOf(agentId, await $.clock.now());
+        if (a.overflow) return;
+        a.overflow = true;
+        a.lane = lane[0];
+        a.story = who.story ?? a.story ?? lane[0];
+        await act.record(
+          'wrap up',
+          `${lane[0]} · ${a.story} at ${Math.round(requestContext(usage) / 1000)}k`,
+        );
+        await $.session.send({ to: { agentId }, text: wrapUpText(limit) }).catch(() => {});
       },
       // --- the lead loop (spec 05) ---------------------------------------------------------------
       record: async (kind, target, prompt) => {
@@ -1177,14 +1200,15 @@ export function register(on) {
         const done = milestonesDone(model.state?.stories ?? []);
         if (loop.milestones === null) {
           loop.milestones = new Set(done);
-          return false;
+          return act.compactAtThreshold();
         }
         const fresh = done.filter((m) => !loop.milestones.has(m));
-        if (!fresh.length) return false;
+        // LEAN-4: past compact.at, the lead's context is compacted between turns, milestone or not.
+        if (!fresh.length) return act.compactAtThreshold();
         const mode = harness().compact?.milestone ?? 'ask';
         if (mode === 'off' || offering || !where.interactive || (lease.other && !lease.mine)) {
           for (const m of fresh) loop.milestones.add(m);
-          return false;
+          return act.compactAtThreshold();
         }
         const box = await $.prompt.read().catch(() => null);
         if (box?.text?.trim()) return false;
@@ -1219,6 +1243,25 @@ export function register(on) {
           });
         return true;
       },
+      // LEAN-4: the lead's context compacted at once when it's past compact.at; true when it took over.
+      compactAtThreshold: async () => {
+        const at = harness().compact?.at ?? 40;
+        if (!at || offering || !where.interactive || (lease.other && !lease.mine)) return false;
+        const percent = (await $.session.usage().catch(() => null))?.context?.percent ?? 0;
+        if (percent < Math.max(at, COMPACT_FLOOR)) return false;
+        const box = await $.prompt.read().catch(() => null);
+        if (box?.text?.trim()) return false;
+        Promise.resolve()
+          .then(() => $.session.compact({ instructions: compactInstructions() }))
+          .catch((err) => ({ skip: String(err?.message ?? err) }))
+          .then(async (r) => {
+            if (r?.skip) notice = `The lead's context wasn't compacted: ${r.skip}`;
+            await act.record('compact', `at ${Math.round(percent)}%`);
+            $.ui.invalidate('ui.render');
+            await act.step('resume').catch(() => {});
+          });
+        return true;
+      },
       // LOOP-11: the lead's last reply, read once before the loop prompts it again. A reply that waits on
       // the person, or a turn they stopped, holds the loop until they speak; a step the lead didn't take
       // holds that step while it's still next.
@@ -1258,9 +1301,15 @@ export function register(on) {
           return;
         }
         if (!reply.text.trim()) return act.parkUnmoved(sent, null);
-        const said = await act.sideCall(
-          outcomePrompt({ prompt: sent?.prompt ?? null, answer: reply.text }),
-        );
+        // LEAN-6: the reply and the prompt it answered are enough to read it, so a small model reads
+        // them, instead of a fork over the lead's whole conversation on its own model at every turn's end.
+        const said = await $.model
+          .complete({
+            model: 'sonnet',
+            prompt: outcomePrompt({ prompt: sent?.prompt ?? null, answer: reply.text }),
+            maxTokens: 600,
+          })
+          .catch(() => ({ isAnswered: false }));
         const heard = said.isAnswered ? readOutcome(said.text) : null;
         // Spec 05's data: what came of the step, once known.
         const record = sent ? loop.steps.findLast((x) => x.prompt === sent.prompt) : null;
@@ -1845,6 +1894,26 @@ export function register(on) {
     $.clock.every(1000, () => {
       if (held.size) $.ui.invalidate('ui.render');
     });
+    // HUBR-3, HUBR-6: with a hosted team provider, the session's agents and its token ledger go to it
+    // every 30 seconds, and the project reports what's new. Nothing runs for a team on GitHub.
+    let pulsing = false;
+    $.clock.every(30_000, async () => {
+      if (pulsing || !model.check?.team?.provider?.adapter) return;
+      pulsing = true;
+      try {
+        const now = await $.clock.now();
+        for (const [k, a] of present) if (now - a.at > 10 * 60_000) present.delete(k);
+        const usage = usageForReport(ledger, (key) => agentsSeen.get(key)?.type ?? null);
+        await $.process.run(['node', cli, 'team', 'pulse', '--session', session], {
+          cwd,
+          stdin: JSON.stringify({ agents: Object.fromEntries(present), usage }),
+        });
+      } catch {
+        // tried again in 30 seconds
+      } finally {
+        pulsing = false;
+      }
+    });
     return next(e);
   });
 
@@ -1911,6 +1980,18 @@ export function register(on) {
       busy.tool = toolLine(e);
       busy.at = calledAt;
     } else if (!e.agentId) leadLast = { tool: toolLine(e), at: calledAt };
+    if (model.check?.team?.provider?.adapter)
+      present.set(
+        e.agentId ?? 'main',
+        presenceOf({
+          agentId: e.agentId,
+          type: agentsSeen.get(e.agentId)?.type,
+          tool: e.tool,
+          lane: busy?.lane,
+          lanes: model.state?.lanes,
+          at: calledAt,
+        }),
+      );
     // MAP-2: the file the call reads or edits glows in the code map, in its lane's colour. An agent
     // first seen on this call has its lane found by its type.
     const touch = touchOf(e, where?.cwd);
@@ -2021,6 +2102,16 @@ export function register(on) {
   // SET-4: a lane agent starts on the lane model the person set, unless the lead's call names one or
   // the lane's agent file sets its own.
   on('agent.spawn', async ($, e, next) => {
+    // LEAN-7: the security reviewer runs on the reviewers' model, unless the call or its file names one.
+    const reviewerModel = harness().agents.reviewer.model;
+    if (e.subagentType === 'security-reviewer' && reviewerModel && !e.model) {
+      const file = where
+        ? await $.fs.read(`${where.cwd}/.claude/agents/security-reviewer.md`).catch(() => null)
+        : null;
+      const own = typeof file === 'string' ? agentFileModel(file) : null;
+      if (!own || own === 'inherit') return next({ ...e, model: reviewerModel });
+      return next(e);
+    }
     const setting = harness().agents.lanes.model;
     const lanes = model.check?.lanes ?? {};
     if (!setting || e.model || !Object.values(lanes).some((l) => l.agent === e.subagentType))
@@ -2078,7 +2169,25 @@ export function register(on) {
     const res = await next(e);
     // LOOP-3: a lane agent that has handed back its work isn't stalled while it waits; a message that
     // starts it again shows as its next tool call.
-    if (e.agentId) activityOf(e.agentId, await $.clock.now()).handedBack = true;
+    if (e.agentId) {
+      const a = activityOf(e.agentId, await $.clock.now());
+      a.handedBack = true;
+      // LEAN-5: an agent that handed back at its limit: the lead carries its story on with a fresh one.
+      if (a.overflow && !a.continued && act) {
+        a.continued = true;
+        const agent = agentsSeen.get(e.agentId);
+        const story = (model.state?.stories ?? []).find((s) => s.id === a.story);
+        loop.pending.push({
+          story: a.story,
+          prompt: continuePrompt({
+            type: agent?.type ?? 'The lane agent',
+            story: a.story,
+            branch: story?.branch ?? null,
+            cli: where?.cli,
+          }),
+        });
+      }
+    }
     // REVW-3: a subagent's last turn may be the reviewer's report.
     if (e.agentId && act) await act.reviewed(e.agentId, e.answer).catch(() => {});
     // LOOP-1: the lead is idle; the loop's next step, if one is due (submitted from turn.complete,

package/hooks/mod/register.test.ts

@@ -85,6 +85,7 @@ function project() {
     closed: [] as string[],
     prompts: [] as string[],
     acts: [] as string[][],
+    pulses: [] as any[],
     runs: 0,
     settings: [
       {
@@ -236,6 +237,11 @@ function stub(on: any, w: World) {
       w.acts.push([...argv.slice(2)]);
       return ran(0, JSON.stringify(w.teamSince));
     }
+    if (sub === 'team' && argv[3] === 'pulse') {
+      w.acts.push([...argv.slice(2)]);
+      w.pulses.push(JSON.parse(e.init?.stdin ?? '{}'));
+      return ran(0, '');
+    }
     if (sub === 'team' && ['keep', 'release', 'board', 'reassign'].includes(argv[3])) {
       w.acts.push([...argv.slice(2)]);
       return ran(0, '');
@@ -382,6 +388,8 @@ function stub(on: any, w: World) {
   });
   on('model.complete', ($: any, e: any) => {
     w.sideAsks.push({ model: e.model, prompt: e.prompt });
+    // LEAN-6: the loop reads the lead's reply with a small model; the test's reading answers it.
+    if (/Say where that reply left things/.test(e.prompt)) return { value: w.sideReply };
     return { value: { isAnswered: true, text: 'From the facts alone.', usage: null } };
   });
   // Claude Code's own settings hooks beneath: none answer a permission denial.
@@ -2312,6 +2320,60 @@ test(
   },
 );
 
+test('LEAN-5 a lane agent past its context limit is told to wrap up, and its story goes on with a fresh agent', async ($, on) => {
+  const w = project();
+  w.next = { step: 'wait', args: '', then: [] };
+  w.agents = [
+    { id: 'a1', type: 'web-engineer', description: 'ST-4 booking form', status: 'running' },
+  ];
+  const clock = await start($, on, w);
+  await clock.advance(2000);
+  await request($, 'a1', 100);
+  expect(w.sent).toEqual([]);
+  // 270k of context, past the 250k limit: told once, however many requests follow.
+  await request($, 'a1', 300);
+  await request($, 'a1', 320);
+  expect(w.sent).toHaveLength(1);
+  expect(w.sent[0].text).toMatch(/^Your context is past 250k tokens/);
+  await $.turn.complete({
+    turnId: 't-a1',
+    agentId: 'a1',
+    answer: 'ST-4: committed, report written.',
+    durationMs: 1,
+    isAborted: false,
+  } as any);
+  await leadTurn($, 't-2');
+  await settle(clock);
+  expect(w.prompts.at(-1)).toMatch(
+    /^web-engineer handed ST-4 back at its context limit, with its work committed on web\/st-4\. Carry the story on with a fresh agent: run node ".*" worktrees release web\/st-4/,
+  );
+  expect(w.prompts.at(-1)).toMatch(
+    /Read your earlier report first: \.claude\/state\/reports\/web_st-4\.md/,
+  );
+});
+
+test("LEAN-4 past compact.at the lead's context is compacted between turns, without asking", async ($, on) => {
+  const w = project();
+  const compacted: string[] = [];
+  on('session.compact', ($: any, e: any) => {
+    compacted.push(e.instructions);
+    return {
+      messages: [{ role: 'user', text: 'Summary: ST-4 in progress on web/st-4.', toolUses: [] }],
+    };
+  });
+  w.contextPercent = 35;
+  const clock = await start($, on, w);
+  await leadTurn($);
+  await settle(clock);
+  expect(compacted).toEqual([]);
+  w.contextPercent = 46;
+  await leadTurn($, 't-2');
+  await settle(clock);
+  expect(compacted).toHaveLength(1);
+  expect(compacted[0]).toMatch(/^The lead's context is compacted between turns/);
+  expect(w.asked.filter((a) => /Compact/.test(a.question))).toEqual([]);
+});
+
 test('LOOP-3 an agent whose work is done is never nudged or restarted: it handed back, or its branch waits in the merge queue', async ($, on) => {
   const w = project();
   w.next = { step: 'wait', args: '', then: [] };
@@ -2477,7 +2539,9 @@ test("LOOP-11 a reply that waits on the person holds the loop; the dialog asks t
   await leadSays($, 't-2', 'Before I dispatch ST-9: should its prices include GST?');
   await settle(clock);
   // The side call read the reply over the lead's own conversation, with the step it answered.
-  expect(w.sideAsks.at(-1).fork).toBe(true);
+  // LEAN-6: read by a small model from the reply itself, not a fork over the lead's conversation.
+  expect(w.sideAsks.at(-1).fork).toBeUndefined();
+  expect(w.sideAsks.at(-1).model).toBe('sonnet');
   expect(w.sideAsks.at(-1).prompt).toMatch(/prompted you: "Dispatch ST-9/);
   expect(w.sideAsks.at(-1).prompt).toMatch(/should its prices include GST\?/);
   expect(w.asked.at(-1)).toEqual({
@@ -2541,7 +2605,8 @@ test("LEAN-3 when a milestone finishes, the person is asked to compact the lead'
     ...w.stories.map((s) => ({ ...s, milestone: 'M1' })),
   ];
   const compacted: string[] = [];
-  w.contextPercent = 62;
+  // Under compact.at (40%), so only the milestone brings the question.
+  w.contextPercent = 30;
   on('session.compact', ($: any, e: any) => {
     compacted.push(e.instructions);
     // A compaction leaves the summary in the conversation's place.
@@ -2561,6 +2626,7 @@ test("LEAN-3 when a milestone finishes, the person is asked to compact the lead'
   w.refs += ' m1 refs/heads/main-moved\n';
   await clock.advance(2000);
   w.answer = 'Compact now';
+  w.contextPercent = 62;
   await leadTurn($, 't-2');
   await settle(clock);
   expect(w.asked.at(-1)?.question).toMatch(
@@ -2903,6 +2969,17 @@ test('SET-4 with no lane model set, lane agents start as Claude Code decides', a
   expect(w.spawned[0].model ?? null).toBe(null);
 });
 
+test("LEAN-7 the security reviewer starts on the reviewers' model, Sonnet unless set, and its own file's model wins", async ($, on) => {
+  const w = project();
+  await start($, on, w);
+  await dispatch($, 'security-reviewer');
+  await dispatch($, 'security-reviewer', 'opus');
+  w.agentFiles['/work/.claude/agents/security-reviewer.md'] =
+    '---\nname: security-reviewer\nmodel: opus\n---\n';
+  await dispatch($, 'security-reviewer');
+  expect(w.spawned.map((e) => e.model ?? null)).toEqual(['sonnet', 'opus', null]);
+});
+
 // --- the reviewer -----------------------------------------------------------------------------------
 
 /** ST-4 finished on web/st-4, the reviewer on. */
@@ -4359,7 +4436,7 @@ test('a live provider says so in the Team pane, by its own name, and has a Drift
   w.team = {
     ...teamOf('kim'),
     provider: {
-      name: 'the code-kit teams hub',
+      name: 'code-kit hub',
       live: true,
       account: 'kim',
       detail: 'claims, leases and intents as they happen',
@@ -4371,7 +4448,7 @@ test('a live provider says so in the Team pane, by its own name, and has a Drift
   await teamCmd($);
   const ui = await pane($, TEAM);
   expect((await ui.find({ key: 'team-provider' }))?.text).toBe(
-    'Through the code-kit teams hub · live · signed in as kim: claims, leases and intents as they happen',
+    'Through code-kit hub · live · signed in as kim: claims, leases and intents as they happen',
   );
   await press($, 'team-tab-drift', TEAM);
   expect(
@@ -4385,7 +4462,7 @@ test("with a live provider (the hub), the band says when it fell back to GitHub,
   const at = new Date().toISOString();
   w.team = {
     ...teamOf('kim'),
-    fallback: "The code-kit teams hub can't be reached.",
+    fallback: "code-kit hub can't be reached.",
     sessions: [
       {
         login: 'kim',
@@ -4435,7 +4512,7 @@ test("with a live provider (the hub), the band says when it fell back to GitHub,
   expect(w.opened).toEqual([TEAM]);
   const ui = await pane($, TEAM);
   expect((await ui.find({ key: 'team-provider' }))?.text).toMatch(
-    /can't be reached \(The code-kit teams hub can't be reached\.\): claims are checked through GitHub/,
+    /can't be reached \(code-kit hub can't be reached\.\): claims are checked through GitHub/,
   );
   expect((await ui.find({ key: 'team-drift-web/st-9' }))?.text).toMatch(
     /web\/st-9 · kim[\s\S]*blocker · spec docs\/specs\/02-booking\.md: BOOK-2 now holds prices in cents\./,
@@ -4461,6 +4538,41 @@ test('TEAM-12 with a board, the mod syncs it in the background, at most every 10
   expect(syncs()).toBe(2);
 });
 
+test('HUBR-6 with a hosted provider, the mod sends the session agents and token use every 30 seconds', async ($, on) => {
+  const w = project();
+  w.team = teamOf('sam');
+  (w.check as any).team = {
+    techLead: 'alex',
+    provider: {
+      command: 'x',
+      fallback: 'github',
+      adapter: 'hub',
+      url: 'https://h.example',
+      name: 'a hosted provider',
+    },
+  };
+  const clock = await start($, on, w);
+  await $.tool.call({ tool: 'Bash', tool_use_id: 'tu-p', command: 'cat secrets.txt' } as any);
+  await clock.advance(30000);
+  const pulses = () => w.acts.filter((a) => a[0] === 'team' && a[1] === 'pulse');
+  expect(pulses().length).toBe(1);
+  expect(pulses()[0]).toContain('--session');
+  expect(w.pulses[0].agents.main).toMatchObject({ type: 'lead', tool: 'Bash' });
+  // By tool name only: never what the call read or ran.
+  expect(JSON.stringify(w.pulses[0])).not.toMatch(/secrets/);
+  expect(typeof w.pulses[0].usage).toBe('object');
+});
+
+test('HUBR-6 a team on GitHub sends no pulse', async ($, on) => {
+  const w = project();
+  w.team = teamOf('sam');
+  (w.check as any).team = { techLead: 'alex', provider: 'github' };
+  const clock = await start($, on, w);
+  await $.tool.call({ tool: 'Bash', tool_use_id: 'tu-q', command: 'ls' } as any);
+  await clock.advance(60000);
+  expect(w.acts.some((a) => a[0] === 'team' && a[1] === 'pulse')).toBe(false);
+});
+
 test('TRACE-2 a project with more requirements than a list holds still draws its trail', async ($, on) => {
   const w = project();
   w.requirements = Array.from({ length: 134 }, (_, i) => ({

package/hooks/mod/teamview.mjs

@@ -582,12 +582,18 @@ function setupTab(team, config, { Box, Text, Button }, on) {
   const rows = [
     ['Tech lead', team.techLead],
     ['Stale after', `${team.staleDays ?? t.staleDays ?? 3} working days without a push`],
-    ['Intents', `discussions in "${t.intents ?? 'Intents'}"`],
+    // HUBR-7: a hosted provider keeps intents, in Discussions too only when the team mirrors them.
+    [
+      'Intents',
+      typeof t.provider === 'object' && !t.provider.command && !t.intents
+        ? `kept by ${team.provider?.name ?? 'the provider'}`
+        : `discussions in "${t.intents ?? 'Intents'}"`,
+    ],
     [
       'Provider',
       team.provider?.name ?? (typeof t.provider === 'object' ? t.provider.command : 'GitHub'),
     ],
-    ...(typeof t.provider === 'object' && t.provider.fallback
+    ...(typeof t.provider === 'object' && (t.provider.fallback || !t.provider.command)
       ? [['Fallback', 'GitHub, while the provider is down']]
       : []),
     ...(t.board ? [['Board', `${t.board.owner}/${t.board.number}`]] : []),