feat: company-in-a-box — goal-aware company layer (0.4.0) (#171)

* feat(goals): company charter singleton — data layer (Business Goals slice 1)

First slice of the company-in-a-box "Business Goals" phase: a single CEO-owned
charter row (north star + objectives + constraints + operating policy) that
will be injected into every agent's context_briefing so all work is goal-aware.

- CompanyGoalsTable: singleton table (all-zeros id), JSON objectives /
  constraints / operating_policy, updated_at / updated_by.
- migration 032: create + seed the singleton row (offline-renderable; column
  server-defaults fill an INSERT of just the id).
- CompanyGoalsService: get() (empty defaults when unset) + upsert() (singleton,
  partial update, caller commits).
- tests: empty defaults, roundtrip, singleton + partial-update preservation.

Next slices (mapped, not yet built): briefing injection (BriefingInputs +
build_context_briefing + EvidenceRepo), API route (GET any / PUT CEO-only),
panel /goals page, and base/Board/PM prompt mentions.

* feat(goals): inject the company charter into every agent briefing (slice 2)

The charter is now goal-aware context for every agent:
- BriefingInputs gains company_goals; build_context_briefing surfaces it.
- EvidenceRepo.company_goals(): single-row lookup returning a COMPACT charter
  (north star + objectives + constraints + operating policy; audit columns
  dropped, lists capped) or None when unset, so an empty charter never bloats
  the per-verb briefing.
- _briefing_for wires it into every context_briefing.

Tests: briefing surfaces company_goals (defaults None); repo returns None for an
absent/empty charter and the compact dict when set.

* feat(goals): company charter API — GET any agent, PUT CEO-only (slice 3)

- routes/company_goals.py: GET returns the charter (any authenticated agent —
  it drives every briefing); PUT is CEO-only (403 otherwise), partial update via
  model_dump(exclude_unset=True), explicit commit.
- schemas/company_goals.py: response + partial-update models.
- registered at /api/company-goals.
- tests: GET open to any role, CEO update persists + is readable, non-CEO 403.

* feat(goals): make the company charter actionable in agent prompts (slice 5)

Agents already receive company_goals in the briefing (slice 2); now tell them to
act on it:
- base.md: universal "Align with the company charter" section — favour work and
  trade-offs that advance the objectives, honour the constraints, flag conflicts;
  never a license to leave your role.
- board / main_pm / cell_pm: role-specific lines tying triage / cell-routing /
  subtask decomposition to the charter.

Prompts are composed at spawn from base.md + roles/*.md directly (compose_prompt),
so no _generated regeneration is needed.

* feat(goals): company charter panel page (slice 4)

CEO-facing editor for the charter at /company-goals:
- lib/api/company-goals.ts: get / update (PUT) client.
- company-goals-card.tsx: edit north star + constraints (one per line) +
  objectives / operating_policy (JSON, parsed + validated with toast errors);
  display derives from server state (no set-state-in-effect).
- (dashboard)/company-goals/page.tsx + a "Company Goals" sidebar nav link.

tsc --noEmit + eslint clean. Completes Phase 1 (Business Goals): data, briefing
injection, API, prompts, panel.

* fix(test): make test_app route assertions robust to FastAPI 0.137 _IncludedRouter

FastAPI 0.137 stopped flattening include_router into app.routes — each include is
now an _IncludedRouter (a BaseRoute with no .path), so `{r.path for r in
app.routes}` raised AttributeError and the two router-registration tests failed
(the bump arrived via the claude-agent-sdk update in uv.lock). Add
_registered_paths(): OpenAPI schema paths (the stable public contract) plus each
included router's prefix, which also covers the websocket /ws mount (never in the
schema). Drops the now-incorrect type: ignore[attr-defined].

* feat(research): pluggable web search/fetch for Board + PM agents

Add a provider-agnostic web-research capability so the Board and PMs can
ground decisions in current external evidence the knowledge base can't
answer.

- ResearchService selects a provider adapter from config: Tavily, Brave,
  and Exa adapters plus a NullProvider that degrades gracefully when no
  key is set. Result count and fetched-content size are clamped to caps.
- /api/research/search and /api/research/fetch: role-gated to Board + PMs
  (and the CEO), with a per-agent/day Redis quota that fails open.
- roboco-search MCP server (web_search / web_fetch) calls those routes;
  the provider key stays server-side and agent containers never egress.
  Mounted per role by the orchestrator, behind a master switch.
- Charter-aware prompt guidance for Board, Main PM, and Cell PM.

Additive: with no key configured it is a no-op and the existing delivery
lifecycle is unchanged.

* feat(pitch): Board pitch -> CEO approve -> auto-provision repos

Add an additive origination path so a product can be proposed, approved,
and stood up without manual repo/Project setup.

- Pitch entity + migration (pitches table); PitchService create/list/
  reject/approve.
- GitHubProvisioningService: the one place that creates repos (POST
  /orgs/{org}/repos). Server-side token/org; when unconfigured the whole
  approve path is inert and nothing is created.
- On approval: provision one repo per target cell, register a Project per
  repo, create a Product when multi-cell, and seed one Main-PM delivery
  task — all reusing the existing Product / coordination-task machinery.
- /api/pitches: Board authors (PO/HoM), CEO approves/rejects, Board+PM+CEO
  view. Errors mapped via a single translator.

Additive: the delivery lifecycle is untouched; with no provisioning token
the capability is a no-op. Agent-facing pitch tool + panel are follow-ups.

* feat(strategy): dormant autonomous strategy engine (engine 2)

Add a second, optional engine that watches the company against its
standing goals and surfaces what needs the CEO — without touching the
delivery lifecycle (engine 1).

- StrategyEngine.assess() reports observations: the company is idle while
  goals stand, and tasks stranded in 'blocked' past a threshold.
- run_cycle() notifies the CEO (notify-only; it never spends, builds, or
  auto-approves — originating work stays a CEO decision).
- Orchestrator runs it on its own interval, started/stopped with the other
  background loops; the loop returns immediately unless enabled.

DORMANT by default (strategy_engine_enabled=False): the loop never runs and
a standard deployment is unchanged. Auto-origination is a further opt-in.

* docs(changelog): record Business Goals, Web Research, Pitch->Provision, and the dormant strategy engine under Unreleased

* feat(secretary): wire the Secretary role end-to-end (foundation)

Add SECRETARY as a distinct role — the CEO's conversational chief-of-staff,
governed separately from the Prompter (which stays read-only/human-only).
This is the role foundation only; authority, the live agent, and the panel
land in following commits.

- foundation/identity: Role.SECRETARY (board level), seeded secretary-1 agent,
  role-level mapping.
- journaling read tier (ALL — it advises the CEO), role_config entry,
  per-role model (opus), prompt-layer mapping + roles/secretary.md.
- i_am_idle gains SECRETARY so the role has a verb surface.
- migration 034: add 'secretary' to the agentrole enum (mirrors 025).
- Role-registry tests updated for the new role.

Inert by itself (nothing spawns it yet); additive — existing roles unchanged.

* feat(secretary): directives + gate-list authority (backend)

The Secretary acts only under CEO command. Low-risk directives (relay a
dictated message) execute immediately; high-impact ones — charter edits,
task start/cancel/override, pitch approval, announcements — are recorded
pending and run only after the CEO confirms (the gate list).

- secretary_directives table (migration 035) as the command audit + queue.
- SecretaryService: read company state; submit (direct->run, gated->queue +
  notify CEO); confirm/reject; execution runs with the CEO as actor through
  the existing services (the Secretary never holds CEO authority itself).
- /api/secretary: submit + state/task reads (Secretary or CEO); list/confirm/
  reject (CEO only). Writes commit explicitly.

* feat(secretary): live conversational agent (container + bridge)

Stand up the Secretary as a persistent Claude-SDK container the CEO chats
with, mirroring the Intake agent and reusing its driver/session machinery.

- secretary_driver: build_secretary_options exposes read_company_state /
  read_task / submit_directive as SDK tools that call /api/secretary/* with
  the agent's HMAC token; backend-call logic is module-level + tested.
- secretary_main: container entrypoint (receiver + relay) reusing IntakeDriver.
- orchestrator: start/spawn/reap secretary session + run-cmd builder; no
  workspace clone (reads state via API), mints a role=secretary token.
- secretary_live routes: panel <-> container bridge over the live registry.
- agent-secretary image (Dockerfile + compose build service).

Inert until a session is started; additive — intake and all agents unchanged.

* feat(secretary): panel chat + directive confirmation queue

The CEO's Secretary surface: a live chat (SSE) to talk to the Secretary, and
a 'Needs your confirmation' queue listing gated directives the Secretary
proposed — each with Confirm / Reject. Adds the sidebar nav entry.

- lib/api/secretary.ts: live (start/stream/status/send/stop) + directive
  (list/confirm/reject) + state clients (all as the CEO).
- hooks/use-secretary.ts: drives one chat, accumulating SSE token deltas.
- secretary page: chat pane + pending-directive cards.

Completes the Secretary end-to-end (role + authority + live agent + panel).

* feat(pitch): agent-facing pitch tool + pitches panel

Complete the pitch path: the Board can now author pitches through the gateway,
and the CEO reviews/approves them in the panel.

- content_actions.pitch (Board-only) -> PitchService.create, returning an
  Envelope; wired as a do-tool (do_server + /api/v1/do/pitch + schema) and
  added to the Board's do-tools.
- Panel /pitches page: lists pitches with CEO Approve & provision / Reject;
  sidebar nav entry.

Pitch (Phase 4) is now end-to-end: author -> CEO approve -> auto-provision.

* feat(cockpit): read-only 'is the business winning?' summary

A pure aggregation for the CEO over existing data — no new state, no writes.

- CockpitService.summary(): charter north-star/objectives, delivery counts
  (in-flight/blocked/awaiting-CEO), 30-day spend vs the charter's budget cap,
  pending pitches, and the strategy engine's signals (what needs you). Stamped
  basis='proxy' — performance is a proxy until real launches.
- GET /api/cockpit/summary (CEO / Board / Main PM / Secretary).
- Panel /cockpit page + sidebar nav.

Reuses goals + usage + StrategyEngine.assess(); reads only.

* docs(changelog): add the Secretary and Cockpit to Unreleased

* fix(test): isolate the company-goals empty-defaults test from committed state

The shared test DB persists committed writes across tests; a route test
commits a charter, so the unit test's 'unset' assertion must establish its
own clean precondition rather than assume global emptiness.

* fix(gateway): lower evidence_repo complexity to rank A (xenon gate)

company_goals()'s 4-way `or` emptiness check tipped the module average to
rank B; `any(...)` is equivalent and keeps the module under the gate's A bar.

* chore(compose): mirror agent-secretary-image build into docker-compose.yaml

Both compose files are byte-identical and tracked; .yaml carries the same
agent-secretary-image build service already present in docker-compose.yml.

* chore(lifecycle): regenerate artifacts for secretary i_am_idle

The secretary role gained i_am_idle in the lifecycle spec; regenerate the
generated prompt/doc/json artifacts so foundation-check stays green.

* docs(changelog): cut the company-in-a-box phases to 0.4.0

Label the six additive phases (business goals, web research, pitch-provision,
strategy engine, secretary, cockpit) as 0.4.0; tag v0.4.0 is held until the
branch merges to master so it points at the release commit.

---------

Co-authored-by: Renn F <rennf93@users.noreply.github.com>
This commit is contained in:
Renzo F
2026-06-15 20:47:41 +02:00
committed by GitHub
co-authored by Renn F
parent 9f668b2a50
commit 46d89b58fe
92 changed files with 7249 additions and 5 deletions
+127
View File
@@ -0,0 +1,127 @@
"use client";
import { useQuery } from "@tanstack/react-query";
import { AlertTriangle, Loader2 } from "lucide-react";
import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
import { Badge } from "@/components/ui/badge";
import { cockpitApi } from "@/lib/api/cockpit";
function Stat({ label, value }: { label: string; value: string | number }) {
return (
<div className="rounded-lg border p-3">
<p className="text-xs text-muted-foreground">{label}</p>
<p className="text-2xl font-semibold">{value}</p>
</div>
);
}
export default function CockpitPage() {
const { data, isLoading } = useQuery({
queryKey: ["cockpit", "summary"],
queryFn: () => cockpitApi.summary(),
refetchInterval: 30000,
});
if (isLoading || !data) {
return (
<div className="flex items-center gap-2 text-sm text-muted-foreground">
<Loader2 className="h-4 w-4 animate-spin" /> Loading the cockpit
</div>
);
}
const cap = data.spend.monthly_budget_cap_usd;
return (
<div className="space-y-6">
<div className="flex items-center justify-between">
<div>
<h1 className="text-3xl font-bold tracking-tight">Cockpit</h1>
<p className="text-muted-foreground">
Is the business winning, what&apos;s happening, what needs you.
</p>
</div>
<Badge variant="secondary" title="Performance is a proxy until real launches">
basis: {data.basis}
</Badge>
</div>
<Card>
<CardHeader>
<CardTitle>North star</CardTitle>
</CardHeader>
<CardContent className="space-y-3">
<p className="text-sm">
{data.north_star || "No north star set yet — define it in Company Goals."}
</p>
{data.objectives.length > 0 && (
<ul className="list-disc space-y-1 pl-5 text-sm text-muted-foreground">
{data.objectives.map((o, i) => (
<li key={i}>{JSON.stringify(o)}</li>
))}
</ul>
)}
</CardContent>
</Card>
<div className="grid gap-4 sm:grid-cols-3">
<Stat label="In flight" value={data.delivery.in_flight} />
<Stat label="Blocked" value={data.delivery.blocked} />
<Stat label="Awaiting your approval" value={data.delivery.awaiting_ceo} />
</div>
<Card>
<CardHeader>
<CardTitle>Spend (30 days)</CardTitle>
</CardHeader>
<CardContent className="space-y-2">
<div className="flex items-center gap-3">
<span className="text-2xl font-semibold">
${data.spend.spend_30d_usd.toFixed(2)}
</span>
{cap != null && (
<span className="text-sm text-muted-foreground">
/ ${cap.toFixed(2)} cap
</span>
)}
{data.spend.over_budget && (
<Badge variant="destructive">
<AlertTriangle className="mr-1 h-3 w-3" /> over budget
</Badge>
)}
</div>
{data.spend.projected_monthly_usd != null && (
<p className="text-xs text-muted-foreground">
Projected this month: ${data.spend.projected_monthly_usd.toFixed(2)}
</p>
)}
</CardContent>
</Card>
<Card>
<CardHeader>
<CardTitle>Needs your attention</CardTitle>
</CardHeader>
<CardContent className="space-y-3">
{data.pending_pitches > 0 && (
<p className="text-sm">
{data.pending_pitches} pitch(es) awaiting your approval.
</p>
)}
{data.signals.length === 0 && data.pending_pitches === 0 ? (
<p className="text-sm text-muted-foreground">
Nothing needs you right now.
</p>
) : (
data.signals.map((s, i) => (
<div key={i} className="rounded-lg border p-3">
<p className="text-sm font-medium">{s.summary}</p>
<p className="text-xs text-muted-foreground">{s.detail}</p>
</div>
))
)}
</CardContent>
</Card>
</div>
);
}
@@ -0,0 +1,18 @@
"use client";
import { CompanyGoalsCard } from "@/components/company-goals/company-goals-card";
export default function CompanyGoalsPage() {
return (
<div className="space-y-6 max-w-3xl">
<div>
<h1 className="text-3xl font-bold tracking-tight">Company Goals</h1>
<p className="text-muted-foreground">
The organization&apos;s charter north star, objectives, constraints,
and operating policy that steer every agent&apos;s work.
</p>
</div>
<CompanyGoalsCard />
</div>
);
}
+138
View File
@@ -0,0 +1,138 @@
"use client";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { toast } from "sonner";
import { Check, Loader2, X } from "lucide-react";
import { Button } from "@/components/ui/button";
import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
import { Badge } from "@/components/ui/badge";
import { getErrorMessage } from "@/lib/api/client";
import { pitchesApi, type Pitch } from "@/lib/api/pitches";
function PitchCard({
pitch,
onApprove,
onReject,
busy,
}: {
pitch: Pitch;
onApprove: (id: string) => void;
onReject: (id: string) => void;
busy: boolean;
}) {
const proposed = pitch.status === "proposed";
return (
<Card>
<CardHeader>
<div className="flex items-center justify-between">
<CardTitle className="text-lg">{pitch.title}</CardTitle>
<Badge variant={proposed ? "default" : "secondary"}>{pitch.status}</Badge>
</div>
<div className="flex flex-wrap gap-1">
{pitch.target_cells.map((c) => (
<Badge key={c} variant="outline">
{c}
</Badge>
))}
</div>
</CardHeader>
<CardContent className="space-y-3">
<div>
<p className="text-xs font-medium text-muted-foreground">Problem</p>
<p className="text-sm whitespace-pre-wrap">{pitch.problem}</p>
</div>
<div>
<p className="text-xs font-medium text-muted-foreground">
Proposed solution
</p>
<p className="text-sm whitespace-pre-wrap">{pitch.proposed_solution}</p>
</div>
{proposed ? (
<div className="flex gap-2">
<Button size="sm" disabled={busy} onClick={() => onApprove(pitch.id)}>
<Check className="mr-1 h-4 w-4" /> Approve &amp; provision
</Button>
<Button
size="sm"
variant="outline"
disabled={busy}
onClick={() => onReject(pitch.id)}
>
<X className="mr-1 h-4 w-4" /> Reject
</Button>
</div>
) : (
pitch.decision_notes && (
<p className="text-xs text-muted-foreground">
Decision: {pitch.decision_notes}
</p>
)
)}
</CardContent>
</Card>
);
}
export default function PitchesPage() {
const qc = useQueryClient();
const { data: pitches = [], isLoading } = useQuery({
queryKey: ["pitches"],
queryFn: () => pitchesApi.list(),
refetchInterval: 30000,
});
const approveMutation = useMutation({
mutationFn: (id: string) => pitchesApi.approve(id),
onSuccess: () => {
toast.success("Pitch approved — provisioning started");
void qc.invalidateQueries({ queryKey: ["pitches"] });
},
onError: (e) => toast.error(getErrorMessage(e)),
});
const rejectMutation = useMutation({
mutationFn: (id: string) => pitchesApi.reject(id, "Rejected by CEO"),
onSuccess: () => {
toast.success("Pitch rejected");
void qc.invalidateQueries({ queryKey: ["pitches"] });
},
onError: (e) => toast.error(getErrorMessage(e)),
});
const busy = approveMutation.isPending || rejectMutation.isPending;
return (
<div className="max-w-3xl space-y-6">
<div>
<h1 className="text-3xl font-bold tracking-tight">Pitches</h1>
<p className="text-muted-foreground">
Board proposals. Approving a pitch provisions a repository per target
cell, registers the projects, and seeds the first task to Main PM.
</p>
</div>
{isLoading ? (
<div className="flex items-center gap-2 text-sm text-muted-foreground">
<Loader2 className="h-4 w-4 animate-spin" /> Loading
</div>
) : pitches.length === 0 ? (
<p className="text-sm text-muted-foreground">
No pitches yet. The Board authors them; they appear here for your
approval.
</p>
) : (
<div className="space-y-4">
{pitches.map((p) => (
<PitchCard
key={p.id}
pitch={p}
busy={busy}
onApprove={(id) => approveMutation.mutate(id)}
onReject={(id) => rejectMutation.mutate(id)}
/>
))}
</div>
)}
</div>
);
}
@@ -0,0 +1,216 @@
"use client";
import { useState } from "react";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { toast } from "sonner";
import { Check, Loader2, Send, X } from "lucide-react";
import { Button } from "@/components/ui/button";
import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
import { Textarea } from "@/components/ui/textarea";
import { getErrorMessage } from "@/lib/api/client";
import { secretaryApi, type SecretaryDirective } from "@/lib/api/secretary";
import { useSecretary } from "@/hooks/use-secretary";
function DirectiveCard({
directive,
onConfirm,
onReject,
busy,
}: {
directive: SecretaryDirective;
onConfirm: (id: string) => void;
onReject: (id: string) => void;
busy: boolean;
}) {
return (
<div className="space-y-2 rounded-lg border p-3">
<div className="flex items-center justify-between">
<span className="text-sm font-medium">{directive.kind}</span>
<span className="text-xs text-muted-foreground">{directive.status}</span>
</div>
<pre className="overflow-x-auto rounded bg-muted p-2 text-xs">
{JSON.stringify(directive.payload, null, 2)}
</pre>
<div className="flex gap-2">
<Button size="sm" disabled={busy} onClick={() => onConfirm(directive.id)}>
<Check className="mr-1 h-4 w-4" /> Confirm
</Button>
<Button
size="sm"
variant="outline"
disabled={busy}
onClick={() => onReject(directive.id)}
>
<X className="mr-1 h-4 w-4" /> Reject
</Button>
</div>
</div>
);
}
export default function SecretaryPage() {
const qc = useQueryClient();
const { sessionId, messages, streaming, start, send, stop } = useSecretary();
const [input, setInput] = useState("");
const [starting, setStarting] = useState(false);
const { data: pending = [] } = useQuery({
queryKey: ["secretary", "directives", "pending"],
queryFn: () => secretaryApi.listDirectives("pending"),
refetchInterval: 15000,
});
const confirmMutation = useMutation({
mutationFn: (id: string) => secretaryApi.confirmDirective(id),
onSuccess: (d) => {
toast.success(`Directive ${d.kind}: ${d.status}`);
void qc.invalidateQueries({ queryKey: ["secretary", "directives"] });
},
onError: (e) => toast.error(getErrorMessage(e)),
});
const rejectMutation = useMutation({
mutationFn: (id: string) => secretaryApi.rejectDirective(id),
onSuccess: () => {
toast.success("Directive rejected");
void qc.invalidateQueries({ queryKey: ["secretary", "directives"] });
},
onError: (e) => toast.error(getErrorMessage(e)),
});
const busy = confirmMutation.isPending || rejectMutation.isPending;
const handleStart = async () => {
setStarting(true);
try {
await start(input.trim() || undefined);
setInput("");
} catch (e) {
toast.error(getErrorMessage(e));
} finally {
setStarting(false);
}
};
const handleSend = async () => {
const text = input.trim();
if (!text) return;
setInput("");
try {
await send(text);
} catch (e) {
toast.error(getErrorMessage(e));
}
};
return (
<div className="space-y-6">
<div className="flex items-start justify-between">
<div>
<h1 className="text-3xl font-bold tracking-tight">Secretary</h1>
<p className="text-muted-foreground">
Your chief-of-staff. It acts only on your command; high-impact
actions wait for your confirmation on the right.
</p>
</div>
{sessionId && (
<Button variant="outline" onClick={() => void stop()}>
End session
</Button>
)}
</div>
<div className="grid gap-6 lg:grid-cols-3">
<Card className="flex min-h-[60vh] flex-col lg:col-span-2">
<CardHeader>
<CardTitle>Chat</CardTitle>
</CardHeader>
<CardContent className="flex flex-1 flex-col gap-4">
<div className="flex-1 space-y-3 overflow-y-auto">
{messages.length === 0 && (
<p className="text-sm text-muted-foreground">
{sessionId
? "Say something to your Secretary…"
: "Start a session to talk to your Secretary."}
</p>
)}
{messages.map((m, i) => (
<div
key={i}
className={
m.role === "user"
? "ml-auto max-w-[80%] rounded-lg bg-primary px-3 py-2 text-sm text-primary-foreground"
: "mr-auto max-w-[80%] whitespace-pre-wrap rounded-lg bg-muted px-3 py-2 text-sm"
}
>
{m.text}
</div>
))}
{streaming && (
<div className="flex items-center gap-2 text-xs text-muted-foreground">
<Loader2 className="h-3 w-3 animate-spin" /> thinking
</div>
)}
</div>
<div className="flex gap-2">
<Textarea
value={input}
onChange={(e) => setInput(e.target.value)}
placeholder={
sessionId
? "Message your Secretary…"
: "Opening message (optional)…"
}
rows={2}
onKeyDown={(e) => {
if (e.key === "Enter" && !e.shiftKey) {
e.preventDefault();
if (sessionId) void handleSend();
else void handleStart();
}
}}
/>
{sessionId ? (
<Button onClick={() => void handleSend()} disabled={!input.trim()}>
<Send className="h-4 w-4" />
</Button>
) : (
<Button onClick={() => void handleStart()} disabled={starting}>
{starting ? (
<Loader2 className="h-4 w-4 animate-spin" />
) : (
"Start"
)}
</Button>
)}
</div>
</CardContent>
</Card>
<Card className="flex flex-col">
<CardHeader>
<CardTitle>Needs your confirmation</CardTitle>
</CardHeader>
<CardContent className="space-y-3">
{pending.length === 0 ? (
<p className="text-sm text-muted-foreground">
No directives waiting. High-impact actions the Secretary proposes
will appear here for you to confirm or reject.
</p>
) : (
pending.map((d) => (
<DirectiveCard
key={d.id}
directive={d}
busy={busy}
onConfirm={(id) => confirmMutation.mutate(id)}
onReject={(id) => rejectMutation.mutate(id)}
/>
))
)}
</CardContent>
</Card>
</div>
</div>
);
}