employee001 0.1.2 → 0.2.0

package/.next/standalone/CLAUDE.md

@@ -0,0 +1,57 @@
+# CLAUDE.md — Employee001
+
+Guidance for AI agents (and humans) working in this repo.
+
+## What this is
+
+`employee001` — a local-first "organizational brain": agent twins of real
+employees, running on the user's own machine. Next.js 16 (App Router, Turbopack),
+React 19, TypeScript (strict). Published to npm as **`employee001`** (`npx employee001`).
+
+## Releasing
+
+This repo publishes via a **tag-triggered** GitHub Actions workflow
+(`.github/workflows/release.yml`, fires on `push: tags: v*`).
+
+**Use the global `/release` skill** (`~/.claude/skills/release/`) for the full
+runbook — it handles preflight gates, the version bump, the tag push, and
+watch + verify. Repo-specific details it should honor:
+
+- **Cadence:** pushes to `main` run CI only (`ci.yml`: lint + build) — they do
+  **not** publish. Only a `vX.Y.Z` tag publishes. Commit/push freely; batch many
+  commits into ONE release. Do not release per commit.
+- **Bump command uses `--ignore-scripts`** (the project's chosen flow — skips the
+  `preversion`/`postversion` hooks so the push is explicit):
+  ```bash
+  npm version <patch|minor|major> --ignore-scripts -m "release: v%s"
+  git push origin main --follow-tags
+  ```
+- **Data-leak scan:** `release.yml` runs a post-build scan to ensure no `data/`
+  directory or `.env` ships in the tarball. When verifying a publish, confirm the
+  packed tarball contains only `bin/ .next/ public/ .env.example README.md LICENSE`
+  — never `data/`.
+- **Version-tombstone gotcha:** a published-then-unpublished npm version number is
+  permanently retired (e.g. `0.1.0` is dead — that's why first stable shipped as
+  `0.1.1`). Never reuse a number; always bump forward.
+
+## Conventions
+
+- Work directly on `main` (solo repo) unless asked otherwise.
+- Inline-style objects with CSS custom properties (`var(--text)`, `var(--surface)`,
+  `var(--hairline)`, `var(--sp-*)`, `var(--fs-*)`) + framer-motion. No Tailwind /
+  shadcn in the app UI.
+- Secrets live in `.env.local` (gitignored). The Claude Code harness shell exports
+  an empty `ANTHROPIC_API_KEY` that shadows `.env.local`; when launching the dev
+  server from that shell, `unset ANTHROPIC_API_KEY` first so `.env.local` wins.
+- **npm supply-chain:** never consume a dependency version published <7 days ago
+  (Shai-Hulud worm family). See `docs/SECURITY-SHAI-HULUD.md` for the scan runbook.
+  TipTap is pinned to `3.23.6` via `package.json` overrides for this reason.
+
+## Key surfaces
+
+- `/profile` — twin profile; **Files** tab is a split-pane TipTap editor over the 9
+  base profile files + an uploadable `knowledge/` dir the twin reads on demand.
+- `/handover` (+ `/handover/live`) — Relay: captures a departing employee's knowledge
+  into a portable Role Context Package (`rcp.json`). **DEMO module — not published.**
+- `/flow`, `/cockpit`, `/connections` — twin chat with live memory graph, run
+  observability, and Composio tool connections.

package/.next/standalone/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "employee001",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "employee001",
-      "version": "0.1.2",
+      "version": "0.2.0",
       "license": "MIT",
       "dependencies": {
         "@anthropic-ai/claude-agent-sdk": "^0.2.123",

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "employee001",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Your company's organizational brain — agent twins of your real employees, running entirely on your own machine. MIT, no cloud, no telemetry.",
   "license": "MIT",
   "author": "Dolev Hayut",

package/.next/standalone/src/app/(workspace)/handover/page.tsx

@@ -704,6 +704,7 @@ function RcpItemList({ items, isTooling }: { items: (CapturedItem | ToolingRef)[
 
 function RcpView({ rcp }: { rcp: RoleContextPackage }) {
   const [rawJson, setRawJson] = useState(false);
+  const [showInfo, setShowInfo] = useState(false);
 
   const sections: { field: CaptureArea; items: (CapturedItem | ToolingRef)[] }[] = useMemo(
     () =>
@@ -714,10 +715,48 @@ function RcpView({ rcp }: { rcp: RoleContextPackage }) {
     [rcp],
   );
 
+  const downloadRcp = () => {
+    const subject = rcp.provenance?.consent?.subjectId ?? "handover";
+    const blob = new Blob([JSON.stringify(rcp, null, 2)], { type: "application/json" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = `rcp-${subject}.json`;
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+    URL.revokeObjectURL(url);
+  };
+
   return (
+    <>
     <Panel>
       <div style={{ display: "flex", alignItems: "center", gap: "var(--sp-8)", marginBottom: 12 }}>
         <SectionLabel>Role Context Package</SectionLabel>
+        <button
+          type="button"
+          onClick={() => setShowInfo(true)}
+          title="What is this package and how to load it into an agent?"
+          aria-label="About this package"
+          style={{
+            width: 18,
+            height: 18,
+            borderRadius: "50%",
+            border: "1px solid var(--text-subtle)",
+            background: "transparent",
+            color: "var(--text-muted)",
+            fontSize: 11,
+            fontWeight: 700,
+            cursor: "pointer",
+            display: "inline-flex",
+            alignItems: "center",
+            justifyContent: "center",
+            lineHeight: 1,
+            flexShrink: 0,
+          }}
+        >
+          ?
+        </button>
         <span
           className="mono"
           style={{
@@ -733,11 +772,19 @@ function RcpView({ rcp }: { rcp: RoleContextPackage }) {
         <div style={{ flex: 1 }} />
         <button
           type="button"
-          className="btn ghost sm"
+          className="btn sm"
           onClick={() => setRawJson((v) => !v)}
         >
           {rawJson ? "Sectioned view" : "Raw JSON"}
         </button>
+        <button
+          type="button"
+          className="btn primary sm"
+          onClick={downloadRcp}
+          title="Download the Role Context Package as a JSON file"
+        >
+          ↓ Download rcp.json
+        </button>
       </div>
 
       <p style={{ fontSize: "var(--fs-meta)", color: "var(--text-muted)", margin: "0 0 14px", lineHeight: 1.5 }}>
@@ -801,6 +848,131 @@ function RcpView({ rcp }: { rcp: RoleContextPackage }) {
         </div>
       )}
     </Panel>
+    {showInfo && <RcpInfoModal subject={rcp.provenance?.consent?.subjectId ?? "the role"} onClose={() => setShowInfo(false)} />}
+    </>
+  );
+}
+
+// ─── "What is this package?" explainer modal ────────────────────────────────────
+
+function RcpInfoModal({ subject, onClose }: { subject: string; onClose: () => void }) {
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => { if (e.key === "Escape") onClose(); };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [onClose]);
+
+  return (
+    <div
+      role="dialog"
+      aria-modal="true"
+      aria-label="About the Role Context Package"
+      onClick={onClose}
+      style={{
+        position: "fixed",
+        inset: 0,
+        zIndex: 1000,
+        background: "rgba(0,0,0,0.55)",
+        display: "grid",
+        placeItems: "center",
+        padding: "var(--sp-24)",
+      }}
+    >
+      <div
+        onClick={(e) => e.stopPropagation()}
+        className="scrollbar"
+        style={{
+          width: "min(640px, 100%)",
+          maxHeight: "82vh",
+          overflowY: "auto",
+          background: "var(--surface)",
+          border: "1px solid var(--hairline-strong)",
+          borderRadius: 12,
+          padding: "var(--sp-24)",
+          boxShadow: "0 24px 64px rgba(0,0,0,0.45)",
+        }}
+      >
+        <div style={{ display: "flex", alignItems: "center", gap: "var(--sp-8)", marginBottom: "var(--sp-12)" }}>
+          <h2 style={{ fontSize: "var(--fs-base)", fontWeight: 700, margin: 0, letterSpacing: "-0.01em" }}>
+            What is a Role Context Package?
+          </h2>
+          <div style={{ flex: 1 }} />
+          <button type="button" className="btn ghost sm" onClick={onClose} aria-label="Close">✕</button>
+        </div>
+
+        <p style={{ fontSize: "var(--fs-sm)", color: "var(--text-muted)", lineHeight: 1.6, margin: "0 0 var(--sp-14)" }}>
+          A portable JSON file that captures {subject}&apos;s <strong style={{ color: "var(--text)" }}>undocumented
+          working knowledge</strong> — the &ldquo;how,&rdquo; not just the &ldquo;what&rdquo; — across 7 dimensions:
+          decision rules, playbooks, the contact graph, edge cases, the tooling map, glossary, and open loops. It carries
+          <strong style={{ color: "var(--text)" }}> zero Employee001 coupling</strong>, so a successor — human or AI agent —
+          can ingest it anywhere. Tooling is stored as <em>references only</em>, never credentials.
+        </p>
+
+        <div style={{ fontSize: "var(--fs-sm)", fontWeight: 700, color: "var(--text)", margin: "0 0 var(--sp-8)" }}>
+          How to load it into an agent like Claude
+        </div>
+
+        <InfoStep n={1} title="Into a successor's Employee001 twin">
+          Drop <span className="mono">rcp-*.json</span> into the new hire&apos;s <span className="mono">knowledge/</span> folder
+          (Profile → <strong style={{ color: "var(--text)" }}>Files</strong> → knowledge/). The twin reads it on demand — the
+          successor inherits the playbooks and decision rules from day one.
+        </InfoStep>
+
+        <InfoStep n={2} title="Claude API / Agent SDK — system-prompt context">
+          Inject the file as an authoritative context block in your system prompt:
+          <pre
+            className="scrollbar mono"
+            style={{
+              marginTop: 8, marginBottom: 0, padding: 12, background: "var(--bg-sunken)",
+              border: "1px solid var(--hairline)", borderRadius: 6, overflowX: "auto",
+              fontSize: "var(--fs-2xs)", lineHeight: 1.5, color: "var(--text)",
+            }}
+          >{`import { readFileSync } from "fs";
+const rcp = readFileSync("rcp-${subject}.json", "utf8");
+
+const system = \`You are taking over this role. The Role Context
+Package below is your authoritative source for how the work is done
+— decision rules, playbooks, contacts, edge cases, tooling, open loops:
+
+\${rcp}\`;
+
+// Anthropic SDK
+await client.messages.create({ model, system, messages });`}</pre>
+        </InfoStep>
+
+        <InfoStep n={3} title="Claude Code / Claude.ai — drop-in context">
+          Save the file in your project and tell Claude to <span className="mono">Read</span> it, or attach it to the
+          conversation. For persistent context across sessions, paste the key sections into your{" "}
+          <span className="mono">CLAUDE.md</span>.
+        </InfoStep>
+
+        <p style={{ fontSize: "var(--fs-2xs)", color: "var(--text-subtle)", lineHeight: 1.5, margin: "var(--sp-14) 0 0" }}>
+          The schema (<span className="mono">relay-rcp-1</span>) is provider-agnostic — the same file works for any agent
+          framework that accepts text context, not just Claude.
+        </p>
+      </div>
+    </div>
+  );
+}
+
+function InfoStep({ n, title, children }: { n: number; title: string; children: React.ReactNode }) {
+  return (
+    <div style={{ display: "flex", gap: "var(--sp-10)", marginBottom: "var(--sp-12)" }}>
+      <div
+        style={{
+          width: 20, height: 20, borderRadius: "50%", flexShrink: 0,
+          background: "var(--text)", color: "var(--bg)",
+          fontSize: 11, fontWeight: 700,
+          display: "grid", placeItems: "center", marginTop: 1,
+        }}
+      >
+        {n}
+      </div>
+      <div style={{ minWidth: 0, flex: 1 }}>
+        <div style={{ fontSize: "var(--fs-sm)", fontWeight: 600, color: "var(--text)", marginBottom: 3 }}>{title}</div>
+        <div style={{ fontSize: "var(--fs-meta)", color: "var(--text-muted)", lineHeight: 1.55 }}>{children}</div>
+      </div>
+    </div>
   );
 }
 

package/.next/standalone/src/lib/consult-mcp.ts

@@ -0,0 +1,99 @@
+// In-process MCP server exposing twin-to-twin consultation tools to a running
+// twin. Pattern mirrors buildOrgBrainMcpServer in org-brain-mcp.ts: pure
+// in-process, no external connection. The actual orchestration (depth caps,
+// visited-set loop guard, nested runSingleTwin) lives in twin-consult.ts.
+//
+// Two tools:
+//   - consult_twin     → ask another twin for advice; returns their answer.
+//   - request_approval → ask another twin to approve/reject an action.
+//
+// Both are classified `allow` by tool-policy (added to LOCAL_SAFE_TOOLS) so
+// they pass the shift-mode canUseTool gate without an approval prompt.
+
+import "server-only";
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+import {
+  consultTwin,
+  requestApproval,
+  availableTargets,
+  type ConsultContext,
+} from "@/lib/twin-consult";
+
+function rosterLines(ctx: ConsultContext): string {
+  const targets = availableTargets(ctx);
+  if (targets.length === 0) return "(no other twins are available to consult right now)";
+  return targets.map((e) => `- \`${e.id}\` — ${e.name}, ${e.role}`).join("\n");
+}
+
+export function buildConsultMcpServer(ctx: ConsultContext) {
+  const roster = rosterLines(ctx);
+  const atDepthCap = ctx.depth >= ctx.maxDepth;
+
+  return createSdkMcpServer({
+    name: "twin_consult",
+    version: "1.0.0",
+    tools: [
+      tool(
+        "consult_twin",
+        [
+          "Ask ANOTHER digital twin for advice or input, synchronously, mid-task.",
+          "Use this when answering well needs a colleague's expertise or perspective — e.g. a designer checking creative direction with the CEO, or anyone validating a call that crosses into another person's domain.",
+          "The consulted twin answers in their own voice; their full reply is returned to you as the tool result, then you continue your own work using it.",
+          "Don't over-use it: only consult when a colleague's input genuinely changes what you'd do. One focused question per call.",
+          atDepthCap
+            ? "NOTE: consultation depth limit reached — this call will be refused. Decide with what you have."
+            : `Twins you can consult (use the exact id):\n${roster}`,
+        ].join("\n"),
+        {
+          targetEmployeeId: z
+            .string()
+            .min(1)
+            .describe("The exact employee id of the twin to consult (from the list in this tool's description)."),
+          question: z
+            .string()
+            .min(8)
+            .max(800)
+            .describe("A single, focused question for that twin. Give enough context that they can answer without seeing your task."),
+        },
+        async ({ targetEmployeeId, question }) => {
+          const text = await consultTwin(targetEmployeeId, question, ctx);
+          return { content: [{ type: "text" as const, text }] };
+        }
+      ),
+      tool(
+        "request_approval",
+        [
+          "Ask another twin to APPROVE or REJECT an action before you take it.",
+          "Use this (instead of consult_twin) when you need a decision/sign-off, not just advice — e.g. publishing content, committing spend, or anything that should clear a manager or the CEO first.",
+          "Returns the approver's verdict (approve/reject) plus their reasoning. The decision is also logged to the CEO's inbox so a human can override it later.",
+          "If you are NOT approved, do not take the action — note it for the CEO in your ShiftReport instead.",
+          atDepthCap
+            ? "NOTE: consultation depth limit reached — this call will be refused (treated as not approved)."
+            : `Twins you can ask for approval (use the exact id):\n${roster}`,
+        ].join("\n"),
+        {
+          approverEmployeeId: z
+            .string()
+            .min(1)
+            .describe("The exact employee id of the twin whose approval you need (from the list in this tool's description)."),
+          what: z
+            .string()
+            .min(8)
+            .max(400)
+            .describe("A one-line description of the action you want to take and have approved."),
+          context: z
+            .string()
+            .max(1200)
+            .optional()
+            .describe("Optional supporting context the approver needs to make the call (the draft, the numbers, the rationale)."),
+        },
+        async ({ approverEmployeeId, what, context }) => {
+          const verdict = await requestApproval(approverEmployeeId, what, context ?? "", ctx);
+          const text = `${verdict.approverName}'s decision: ${verdict.decision.toUpperCase()}\n\nReasoning: ${verdict.reason}`;
+          return { content: [{ type: "text" as const, text }] };
+        }
+      ),
+    ],
+  });
+}

package/.next/standalone/src/lib/council-runner.ts

@@ -61,6 +61,8 @@ import {
   type TwinSubagentName,
 } from "@/lib/twin-subagents";
 import { knowledgeIndexMarkdown } from "@/lib/knowledge-files";
+import { buildConsultMcpServer } from "@/lib/consult-mcp";
+import type { ConsultContext } from "@/lib/twin-consult";
 
 // ─── Event types ──────────────────────────────────────────────────────────────
 
@@ -578,6 +580,21 @@ export type RunOptions = {
    * `claude-sonnet-4-6`; CEO can pick `claude-opus-4-7` for harder asks.
    */
   modelOverride?: string;
+  /**
+   * Lightweight consultation run — this twin is being consulted by another
+   * twin's run, not driving its own. Skips the personal Composio + org MCP
+   * setup and the intent planner, and caps turns lower, so a consultation
+   * chain stays cheap. The twin still has its profile, org-brain search,
+   * artifacts, and (when `consultContext` is set) the ability to consult on.
+   */
+  consultMode?: boolean;
+  /**
+   * When set, registers the twin-to-twin consultation MCP server for this run
+   * so the twin can consult / request approval from peers. Threaded one hop
+   * deeper on each consultation; the shared `visited` set + depth cap inside
+   * prevent runaway chains. See twin-consult.ts.
+   */
+  consultContext?: ConsultContext;
 };
 
 // ─── Mention detection ────────────────────────────────────────────────────────
@@ -775,25 +792,31 @@ export async function runSingleTwin(
     // and merge in any org-wide custom MCP servers the CEO configured in /settings.
     // Composio outages must NOT abort the twin's turn — degrade gracefully by
     // omitting the toolkit so the twin can still answer from its profile files.
-    const [composioMcp, orgMcpServers] = await Promise.all([
-      buildEmployeeMcpServer(employee.id).catch((err) => {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.warn(`[composio] tools unavailable, twin will answer without them: ${msg}`);
-        onEvent({
-          type: "tool_blocked",
-          employeeId: employee.id,
-          tool: "composio",
-          reason: `Composio is temporarily unavailable — tools are degraded. ${msg}`,
-          ts: ts(),
-        });
-        return null;
-      }),
-      loadOrgCustomMcpServers().catch((err) => {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.warn(`[org-mcp] load failed: ${msg}`);
-        return {};
-      }),
-    ]);
+    // Consultation runs stay light: skip the personal Composio + org-wide MCP
+    // setup entirely (the consulted twin gives advice from its profile +
+    // org-brain, it doesn't act on external systems on this hop).
+    const consultMode = options.consultMode === true;
+    const [composioMcp, orgMcpServers] = consultMode
+      ? [null, {} as Awaited<ReturnType<typeof loadOrgCustomMcpServers>>]
+      : await Promise.all([
+          buildEmployeeMcpServer(employee.id).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.warn(`[composio] tools unavailable, twin will answer without them: ${msg}`);
+            onEvent({
+              type: "tool_blocked",
+              employeeId: employee.id,
+              tool: "composio",
+              reason: `Composio is temporarily unavailable — tools are degraded. ${msg}`,
+              ts: ts(),
+            });
+            return null;
+          }),
+          loadOrgCustomMcpServers().catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.warn(`[org-mcp] load failed: ${msg}`);
+            return {};
+          }),
+        ]);
 
     const meetingId = options.teamMeetingContext?.meetingId;
 
@@ -807,6 +830,12 @@ export async function runSingleTwin(
       // gate (the twin can already Read these files directly; the MCP
       // tool is just a more efficient retrieval surface).
       org_brain: buildOrgBrainMcpServer(),
+      // Twin-to-twin consultation — only when the caller threaded a context.
+      // Lets this twin synchronously consult / request approval from peers;
+      // the context's depth cap + shared visited-set guard against loops.
+      ...(options.consultContext
+        ? { twin_consult: buildConsultMcpServer(options.consultContext) }
+        : {}),
       // Per-meeting scratch — only when we're inside a Team Meeting run.
       // The handler callback fires after persistence succeeds; we forward
       // it as `file_shared` so the UI can render the chip in the right
@@ -902,7 +931,8 @@ export async function runSingleTwin(
           : "chat";
 
     let responseIntentBlock = "";
-    try {
+    // Skip the intent-planner LLM call on consultation hops — keeps chains cheap.
+    if (!consultMode) try {
       const plan = await planEmployeeResponseIntent(question, {
         employeeName: employee.name,
         employeeRole: employee.role,
@@ -1126,7 +1156,7 @@ export async function runSingleTwin(
         agents: buildTwinAgentDefinitions(),
         toolConfig: { askUserQuestion: { previewFormat: "html" } },
         ...(hasMcp ? { mcpServers } : {}),
-        maxTurns: hasMcp ? 20 : 6,
+        maxTurns: consultMode ? 8 : hasMcp ? 20 : 6,
         ...(options.maxBudgetUsd ? { maxBudgetUsd: options.maxBudgetUsd } : {}),
         includePartialMessages: true,
         permissionMode: hasMcp ? "default" : "bypassPermissions",

package/.next/standalone/src/lib/shift-runner.ts

@@ -17,6 +17,8 @@ import { appendFeedItem } from "@/lib/feed-store";
 import { registerRun, updateRun, unregisterRun } from "@/lib/active-runs";
 import { appendRunLog, logPathFor } from "@/lib/run-logs";
 import { recordSpend } from "@/lib/twin-budget";
+import { createConsultContext } from "@/lib/twin-consult";
+import { buildConsultMcpServer } from "@/lib/consult-mcp";
 
 // ─── Return type ──────────────────────────────────────────────────────────────
 
@@ -85,6 +87,7 @@ You are running in autonomous shift mode. No CEO is present. Your job is to:
 - Read before you write. Prefer read-only tools first.
 - Do NOT send messages, emails, or post to external channels without a prior decision recorded in your shift log.
 - Destructive or external-facing actions are automatically deferred to /flow for CEO review.
+- If a decision needs a colleague's expertise or sign-off, use \`consult_twin\` for advice or \`request_approval\` for a go/no-go — don't guess outside your lane. Use sparingly, only when their input changes what you'd do.
 - Keep the summary to one short line: what actually happened, not what you planned.`;
 
   const shiftLog = readShiftLog(employee.id);
@@ -241,6 +244,21 @@ export async function runShift(args: {
       }
     }
 
+    // Twin-to-twin consultation: this twin can synchronously consult / request
+    // approval from peers mid-shift. Created AFTER the no-MCP gate above so the
+    // gate still measures real action tools — consultation augments an
+    // action-capable shift, it isn't a reason to run an actionless one.
+    const consultCtx = await createConsultContext({
+      requester: employee,
+      runId,
+      surface: "shift",
+      maxDepth: 3,
+    });
+    const mcpServersWithConsult = {
+      ...mcpServers,
+      twin_consult: buildConsultMcpServer(consultCtx),
+    };
+
     const canUseTool: CanUseTool = async (
       toolName,
       input
@@ -306,7 +324,7 @@ export async function runShift(args: {
         cwd: employeeDir,
         systemPrompt: buildSystemPromptBlocks(employee, employeeDir, trigger, focusBlock),
         allowedTools: ["TodoWrite"],
-        ...(hasMcp ? { mcpServers } : {}),
+        mcpServers: mcpServersWithConsult,
         maxTurns: 12,
         includePartialMessages: true,
         permissionMode: hasMcp ? "default" : "bypassPermissions",

package/.next/standalone/src/lib/tool-policy.ts

@@ -52,6 +52,12 @@ const LOCAL_SAFE_TOOLS = new Set([
   "view_meeting_image",
   "analyze_csv",
   "query_csv",
+  // Twin-to-twin consultation — purely internal orchestration (a nested twin
+  // run on the same host). Loop-guarded by depth cap + visited set in
+  // twin-consult.ts; request_approval additionally logs to /inbox for the
+  // human to override. No external side effects of their own.
+  "consult_twin",
+  "request_approval",
 ]);
 
 /**