@shanesaravia/hive 0.1.0

package/packages/server/dist/policies/policiesStore.js

@@ -0,0 +1,61 @@
+import fs from "node:fs";
+import path from "node:path";
+import { config } from "../config.js";
+export const DEFAULT_POLICY = {
+    allowedRoots: [],
+    allowedTools: [],
+    networkAccess: true,
+    commits: true,
+    pushes: false,
+    pullRequests: false,
+    releases: false,
+    destructiveActions: false,
+};
+export class PoliciesStore {
+    filePath;
+    policy = DEFAULT_POLICY;
+    constructor(filePath = config.policiesPath) {
+        this.filePath = filePath;
+    }
+    init() {
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        try {
+            this.policy = normalize(JSON.parse(fs.readFileSync(this.filePath, "utf8")));
+        }
+        catch {
+            this.persist();
+        }
+    }
+    get() { return structuredClone(this.policy); }
+    set(input) { this.policy = normalize({ ...this.policy, ...input }); this.persist(); return this.get(); }
+    persist() { const temp = `${this.filePath}.tmp`; fs.writeFileSync(temp, JSON.stringify(this.policy, null, 2)); fs.renameSync(temp, this.filePath); }
+}
+export function normalize(input) {
+    const allowedRoots = Array.isArray(input.allowedRoots) ? [...new Set(input.allowedRoots.map((root) => path.resolve(root)).filter(Boolean))] : [];
+    const allowedTools = Array.isArray(input.allowedTools) ? [...new Set(input.allowedTools.map(String).map((tool) => tool.trim()).filter(Boolean))] : [];
+    return { ...DEFAULT_POLICY, ...input, allowedRoots, allowedTools };
+}
+export function enforceWorkingDirectory(cwd, policy) {
+    if (!policy.allowedRoots.length)
+        return;
+    const resolved = path.resolve(cwd);
+    if (!policy.allowedRoots.some((root) => resolved === root || resolved.startsWith(`${root}${path.sep}`))) {
+        throw new Error(`working directory is outside the workspace policy: ${resolved}`);
+    }
+}
+export function disallowedTools(policy) {
+    const denied = [];
+    if (!policy.networkAccess)
+        denied.push("WebFetch", "WebSearch", "Bash(curl:*)", "Bash(wget:*)");
+    if (!policy.commits)
+        denied.push("Bash(git commit:*)");
+    if (!policy.pushes)
+        denied.push("Bash(git push:*)");
+    if (!policy.pullRequests)
+        denied.push("Bash(gh pr create:*)", "mcp__github");
+    if (!policy.releases)
+        denied.push("Bash(gh release:*)", "Bash(npm publish:*)");
+    if (!policy.destructiveActions)
+        denied.push("Bash(rm:*)", "Bash(git reset --hard:*)", "Bash(git clean:*)");
+    return denied;
+}

package/packages/server/dist/reports/githubPublisher.js

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { config } from "../config.js";
+const execFileAsync = promisify(execFile);
+export function normalizeGitHubTarget(value) { const target = value.trim().replace(/^#/, ""); if (/^\d+$/.test(target))
+    return target; if (/^https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/(issues|pull)\/\d+(?:[#?].*)?$/.test(target))
+    return target; throw new Error("enter a GitHub issue/PR number or full github.com URL"); }
+export function githubCommentArgs(kind, target, bodyFile) { return [kind, "comment", normalizeGitHubTarget(target), "--body-file", bodyFile]; }
+export async function publishGitHubReport(input) { fs.mkdirSync(config.hiveDataDir, { recursive: true }); const file = path.join(config.hiveDataDir, `report-${randomUUID()}.md`); try {
+    fs.writeFileSync(file, input.markdown);
+    await execFileAsync("gh", githubCommentArgs(input.kind, input.target, file), { cwd: input.cwd });
+}
+finally {
+    try {
+        fs.unlinkSync(file);
+    }
+    catch { /* best-effort cleanup */ }
+} }

package/packages/server/dist/reports/missionReport.js

@@ -0,0 +1,16 @@
+import { allPlanTasks } from "../plans/plansStore.js";
+import { config } from "../config.js";
+export function missionReport(node, decisions) {
+    const tasks = node.plan?.phases.flatMap((phase) => allPlanTasks(phase.tasks)) ?? [];
+    const missionUrl = `${config.dashboardUrl}/?mission=${encodeURIComponent(node.missionId)}`;
+    const changes = [...new Set(tasks.flatMap((task) => task.changedFiles ?? []))];
+    const branches = [...new Set(tasks.map((task) => task.branch).filter((value) => Boolean(value)))];
+    return {
+        generatedAt: new Date().toISOString(), mission: { id: node.missionId, url: missionUrl, name: node.name, request: node.mission.objective, repository: node.mission.repository, mode: node.mission.mode, lifecycle: node.lifecycleStatus, activity: node.activityStatus, summary: node.mission.compactSummary, currentState: node.mission.currentState },
+        plan: node.plan, decisions, workers: node.workers, changes, verification: node.plan?.gates ?? [], outputs: { pullRequests: node.prs, evidence: tasks.flatMap((task) => task.evidence.map((evidence) => ({ task: task.title, evidence }))) }, traceability: { missionUrl, files: changes.map((file) => ({ file, missionUrl })), branches: branches.map((branch) => ({ branch, missionUrl })), pullRequests: node.prs.map((pr) => ({ href: pr.href, missionUrl })) }, usage: { tokens: node.tokens, elapsedMs: Math.max(0, node.updatedAt - node.createdAt), jobs: node.jobHistory.length, workers: node.workers.length }, remainingRisks: [...node.alerts.map((alert) => `${alert.title}: ${alert.explanation}`), ...tasks.filter((task) => task.status === "blocked" || task.status === "failed").map((task) => `${task.title}: ${task.blocker ?? task.status}`), ...(node.plan?.gates ?? []).filter((gate) => gate.required && gate.status !== "satisfied" && gate.status !== "waived").map((gate) => `Unresolved gate: ${gate.label}`)], conversation: node.messages,
+    };
+}
+export function reportMarkdown(report) {
+    const lines = [`# ${report.mission.name} — Mission Report`, "", `Generated: ${report.generatedAt}`, `Mission: [${report.mission.id}](${report.mission.url})`, `Status: ${report.mission.lifecycle} / ${report.mission.activity}`, report.mission.repository ? `Repository: ${report.mission.repository}` : "", "", "## Request", "", report.mission.request, "", "## Summary", "", report.mission.summary ?? "No compact summary available.", report.mission.currentState ? `\nCurrent state: ${report.mission.currentState}` : "", "", "## Progress", "", report.plan ? `${report.plan.progress.completedTasks}/${report.plan.progress.totalTasks} tasks complete${report.plan.progress.percent !== undefined ? ` (${report.plan.progress.percent}%)` : ""}.` : "No structured plan.", "", "## Workers", "", ...report.workers.map((worker) => `- ${worker.label} — ${worker.doneAt ? "completed" : worker.jobState}`), "", "## Changes", "", ...(report.changes.length ? report.changes.map((file) => `- ${file} · [mission](${report.mission.url})`) : ["No changed files reported."]), ...report.traceability.branches.map(({ branch }) => `- Branch \`${branch}\` · [mission](${report.mission.url})`), "", "## Verification", "", ...(report.verification.length ? report.verification.map((gate) => `- ${gate.label}: ${gate.status}${gate.evidence.length ? ` — ${gate.evidence.join("; ")}` : ""}`) : ["No completion gates defined."]), "", "## Outputs", "", ...report.outputs.pullRequests.map((pr) => `- ${pr.kind}: ${pr.href} · [mission](${report.mission.url})`), ...report.outputs.evidence.map((item) => `- ${item.task}: ${item.evidence}`), "", "## Usage", "", `- Tokens: ${report.usage.tokens.toLocaleString()}`, `- Jobs: ${report.usage.jobs}`, `- Workers: ${report.usage.workers}`, "", "## Decisions", "", ...(report.decisions.length ? report.decisions.map((decision) => `- ${decision.question}${decision.answer ? ` → ${decision.answer}` : " (pending)"}`) : ["No decisions recorded."]), "", "## Remaining Risks", "", ...(report.remainingRisks.length ? report.remainingRisks.map((risk) => `- ${risk}`) : ["No known remaining risks."]), ""];
+    return lines.filter((line, index) => line !== "" || lines[index - 1] !== "").join("\n");
+}

package/packages/server/dist/roster/rosterBuilder.js

@@ -0,0 +1,243 @@
+import { deriveStatus, } from "@hive/shared";
+import { allPlanTasks } from "../plans/plansStore.js";
+import { config } from "../config.js";
+import { deriveAlerts } from "../health/deriveAlerts.js";
+const ORCHESTRATOR_AGENT_NAME = "hive-orchestrator";
+function dateMs(value) {
+    const parsed = value ? Date.parse(value) : NaN;
+    return Number.isNaN(parsed) ? 0 : parsed;
+}
+function resultText(job) {
+    if (typeof job.output === "string")
+        return job.output;
+    if (job.output && typeof job.output === "object" && "result" in job.output) {
+        const result = job.output.result;
+        if (typeof result === "string")
+            return result;
+    }
+    return undefined;
+}
+/** Joins Claude's short-lived jobs into durable, Hive-managed missions. */
+export function buildFleetSnapshot(sessions, jobs, events, missions, messageStore, planStore, now = Date.now()) {
+    const orchestrators = [];
+    const other = [];
+    const sessionsByJob = new Map();
+    const sessionsById = new Map();
+    for (const session of sessions.values()) {
+        sessionsById.set(session.sessionId, session);
+        if (session.jobId)
+            sessionsByJob.set(session.jobId, session);
+    }
+    const groups = new Map();
+    const claimedSessions = new Set();
+    for (const [jobId, job] of jobs) {
+        const session = sessionsByJob.get(jobId) ??
+            (job.sessionId ? sessionsById.get(job.sessionId) : undefined) ??
+            (job.resumeSessionId ? sessionsById.get(job.resumeSessionId) : undefined);
+        if (missions?.isDeletedJob(jobId)) {
+            if (session)
+                claimedSessions.add(session.pid);
+            continue;
+        }
+        const isOrchestrator = job.template === ORCHESTRATOR_AGENT_NAME ||
+            session?.agent === ORCHESTRATOR_AGENT_NAME ||
+            Boolean(missions?.get(missions.missionFor(jobId)));
+        if (!isOrchestrator)
+            continue;
+        if (session)
+            claimedSessions.add(session.pid);
+        const missionId = missions?.missionFor(jobId) ?? jobId;
+        const group = groups.get(missionId) ?? [];
+        group.push({ jobId, job });
+        groups.set(missionId, group);
+    }
+    for (const [missionId, group] of groups) {
+        group.sort((a, b) => dateMs(a.job.createdAt) - dateMs(b.job.createdAt));
+        const latest = group[group.length - 1];
+        const oldest = group[0];
+        const session = sessionsByJob.get(latest.jobId) ??
+            (latest.job.sessionId
+                ? sessionsById.get(latest.job.sessionId)
+                : undefined) ??
+            (latest.job.resumeSessionId
+                ? sessionsById.get(latest.job.resumeSessionId)
+                : undefined);
+        const eventIds = new Set();
+        for (const { job } of group) {
+            if (job.sessionId)
+                eventIds.add(job.sessionId);
+            if (job.resumeSessionId)
+                eventIds.add(job.resumeSessionId);
+        }
+        for (const { jobId } of group)
+            eventIds.add(jobId);
+        if (session)
+            eventIds.add(session.sessionId);
+        const recentEvents = [...new Map([...eventIds]
+                .flatMap((id) => events.recentFor(id))
+                .map((event) => [`${event.sessionId}:${event.jobId ?? ""}:${event.ts}:${event.phase}:${event.decisionId ?? ""}:${event.targetWorker ?? ""}:${event.detail}`, event])).values()]
+            .sort((a, b) => a.ts - b.ts)
+            .slice(-100);
+        const derived = deriveStatus(session, latest.job, recentEvents);
+        const workers = group.flatMap(({ jobId, job }) => (job.fan ?? []).map((worker) => ({
+            ...worker,
+            jobId,
+            jobState: job.state,
+            jobUpdatedAt: dateMs(job.updatedAt) || undefined,
+        })));
+        const workerIds = new Set(workers.map((worker) => worker.id));
+        for (const event of recentEvents) {
+            if (!event.targetWorker || workerIds.has(event.targetWorker))
+                continue;
+            const related = recentEvents.filter((candidate) => candidate.targetWorker === event.targetWorker);
+            const start = related.find((candidate) => candidate.phase === "delegating" || candidate.phase?.toLowerCase().includes("subagentstart"));
+            if (!start)
+                continue;
+            const done = [...related].reverse().find((candidate) => candidate.phase === "worker_reported" || candidate.phase?.toLowerCase().includes("subagentstop"));
+            workers.push({ id: event.targetWorker, label: event.targetWorker, kind: "subagent", startedAt: start.ts, doneAt: done?.ts, updatedAt: related.at(-1)?.ts, jobId: event.jobId ?? latest.jobId, jobState: done ? "done" : latest.job.state });
+            workerIds.add(event.targetWorker);
+        }
+        const derivedMessages = group.flatMap(({ jobId, job }) => {
+            const createdAt = dateMs(job.createdAt);
+            const updatedAt = dateMs(job.updatedAt) || createdAt;
+            const result = resultText(job);
+            const turns = [];
+            if (job.intent) {
+                turns.push({
+                    id: `${jobId}:user`,
+                    role: "user",
+                    text: job.intent,
+                    createdAt,
+                    jobId,
+                });
+            }
+            if (result) {
+                turns.push({
+                    id: `${jobId}:assistant`,
+                    role: "assistant",
+                    text: result,
+                    createdAt: updatedAt,
+                    jobId,
+                });
+            }
+            return turns;
+        });
+        const storedMessages = messageStore?.recent(missionId, 30) ?? [];
+        const missionMessages = storedMessages.length ? storedMessages : derivedMessages;
+        const prsByHref = new Map();
+        for (const { job } of group) {
+            for (const child of job.children ?? [])
+                prsByHref.set(child.href, child);
+        }
+        const createdAt = dateMs(oldest.job.createdAt) || session?.startedAt || 0;
+        const updatedAt = Math.max(...group.map(({ job }) => dateMs(job.updatedAt)), session?.updatedAt ?? 0, createdAt);
+        const mission = missions?.summaryFor(missionId, oldest.job.intent ?? "") ?? {
+            id: missionId,
+            objective: oldest.job.intent ?? "",
+            acceptanceCriteria: [],
+            lifecycleStatus: "active",
+            mode: "orchestrated",
+        };
+        const missionPlan = planStore?.get(missionId);
+        const inactiveForMs = Math.max(0, now - updatedAt);
+        let activityStatus = derived.status;
+        if (mission.lifecycleStatus !== "active" && !session) {
+            activityStatus = "offline";
+        }
+        else if (mission.lifecycleStatus === "active") {
+            // A Claude turn can be done while its durable mission is still ongoing.
+            // In that case the runtime is idle, not mission-complete.
+            if (activityStatus === "done")
+                activityStatus = "idle";
+            const workExpected = session?.status === "busy" || latest.job.state === "working" || latest.job.state === "busy" || workers.some((worker) => !worker.doneAt && (worker.jobState === "working" || worker.jobState === "busy")) || Boolean(missionPlan?.phases.some((phase) => phase.status === "working" || phase.status === "reviewing" || allPlanTasks(phase.tasks).some((task) => task.status === "working" || task.status === "reviewing")));
+            if (activityStatus === "idle" && workExpected && inactiveForMs >= config.stalledAfterMs) {
+                activityStatus = "stalled";
+            }
+        }
+        const runStartedAt = dateMs(latest.job.createdAt) || createdAt;
+        const alerts = deriveAlerts({ lifecycle: mission.lifecycleStatus, activity: activityStatus, stale: derived.stale, turnCompleted: latest.job.state === "done", workers, events: recentEvents, now, turnTokens: latest.job.tokens ?? 0, runStartedAt });
+        orchestrators.push({
+            missionId,
+            threadId: missionId,
+            mission,
+            jobId: latest.jobId,
+            jobIds: group.map(({ jobId }) => jobId),
+            jobHistory: group.map(({ jobId, job }) => ({ jobId, sessionId: job.sessionId, resumedFrom: job.resumeSessionId, state: job.state, createdAt: job.createdAt, updatedAt: job.updatedAt, tokens: job.tokens ?? 0 })),
+            sessionId: session?.sessionId ??
+                latest.job.sessionId ??
+                latest.job.resumeSessionId ??
+                latest.jobId,
+            pid: session?.pid ?? -1,
+            name: missions?.nameFor(missionId) ??
+                oldest.job.name ??
+                latest.job.name ??
+                missionId,
+            status: activityStatus,
+            lifecycleStatus: mission.lifecycleStatus,
+            activityStatus,
+            turnCompleted: latest.job.state === "done",
+            inactiveForMs,
+            waitingFor: session?.waitingFor ?? latest.job.needs,
+            worktreePath: latest.job.worktreePath ?? oldest.job.worktreePath,
+            worktreeBranch: latest.job.worktreeBranch ?? oldest.job.worktreeBranch,
+            tokens: group.reduce((total, { job }) => total + (job.tokens ?? 0), 0),
+            workers,
+            messages: missionMessages,
+            hasMoreMessages: (messageStore?.count(missionId) ?? missionMessages.length) >
+                missionMessages.length,
+            detail: latest.job.detail,
+            intent: latest.job.intent,
+            inFlight: latest.job.inFlight ?? { tasks: 0, queued: 0, kinds: [] },
+            recentEvents,
+            alerts,
+            plan: missionPlan,
+            prs: [...prsByHref.values()],
+            stale: derived.stale,
+            createdAt,
+            runStartedAt,
+            updatedAt,
+        });
+    }
+    for (const session of sessions.values()) {
+        if (claimedSessions.has(session.pid))
+            continue;
+        const jobEntry = session.jobId ? jobs.get(session.jobId) : undefined;
+        const recentEvents = events.recentFor(session.sessionId);
+        const { status } = deriveStatus(session, jobEntry, recentEvents);
+        other.push({
+            jobId: session.jobId,
+            sessionId: session.sessionId,
+            pid: session.pid,
+            name: missions?.nameFor(`session:${session.sessionId}`) ??
+                jobEntry?.name ??
+                session.name ??
+                session.sessionId,
+            status,
+            waitingFor: session.waitingFor,
+            cwd: session.cwd,
+        });
+    }
+    orchestrators.sort((a, b) => b.updatedAt - a.updatedAt);
+    const decisions = orchestrators.flatMap((node) => {
+        const resolved = new Set(node.recentEvents.filter((event) => event.phase === "decision_resolved" && event.decisionId).map((event) => event.decisionId));
+        const missionContext = { missionObjective: node.mission.objective || undefined, repository: node.mission.repository };
+        const fromEvents = node.recentEvents.filter((event) => event.phase === "blocked_on_user" && event.decisionId && !resolved.has(event.decisionId)).map((event) => ({
+            id: event.decisionId, missionId: node.missionId, missionName: node.name,
+            kind: event.decisionKind ?? "question", question: event.detail, context: event.context,
+            choices: event.choices ?? [], recommendation: event.recommendation, impact: event.impact, createdAt: event.ts, ...missionContext,
+        }));
+        // A permission prompt parks the session mid-turn (tempo blocked, the ask
+        // in needs) with no TTY to answer it — surface it as an answerable
+        // decision. It self-clears once the job is no longer parked.
+        const latestJob = jobs.get(node.jobId);
+        const parked = latestJob?.tempo === "blocked" && latestJob.needs && /^approve\s/i.test(latestJob.needs) && !resolved.has(`perm:${node.jobId}`)
+            ? [{
+                    id: `perm:${node.jobId}`, missionId: node.missionId, missionName: node.name,
+                    kind: "permission", question: latestJob.needs, context: latestJob.detail,
+                    choices: ["Approve & continue", "Deny"], impact: "The session is parked at this prompt until you answer.", createdAt: node.updatedAt, ...missionContext,
+                }]
+            : [];
+        return [...fromEvents, ...parked];
+    }).sort((a, b) => b.createdAt - a.createdAt);
+    return { orchestrators, decisions, other, generatedAt: Date.now() };
+}

package/packages/server/dist/security/originPolicy.js

@@ -0,0 +1,31 @@
+function normalizedOrigin(value) {
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "http:" && url.protocol !== "https:")
+            return undefined;
+        return url.origin;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function allowedBrowserOrigins(options) {
+    const candidates = [
+        options.dashboardUrl,
+        `http://127.0.0.1:${options.serverPort}`,
+        `http://localhost:${options.serverPort}`,
+        "http://127.0.0.1:4318",
+        "http://localhost:4318",
+        ...(options.additionalOrigins?.split(",") ?? []),
+    ];
+    return new Set(candidates.map((value) => normalizedOrigin(value.trim())).filter((value) => Boolean(value)));
+}
+export function browserOriginAllowed(origin, allowed) {
+    // Provider hooks and local CLI calls do not send Origin. Browsers do, so an
+    // absent header remains available to trusted local processes while foreign
+    // pages and WebSocket connections must match an explicit Hive origin.
+    if (origin === undefined)
+        return true;
+    const normalized = normalizedOrigin(origin);
+    return normalized !== undefined && allowed.has(normalized);
+}

package/packages/server/dist/skills/skillDiscovery.js

@@ -0,0 +1,69 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { requireWorkingDirectory } from "../paths/pathResolver.js";
+function metadata(file) {
+    const text = fs.readFileSync(file, "utf8").slice(0, 8192);
+    const frontmatter = text.match(/^---\s*\n([\s\S]*?)\n---/);
+    const field = (name) => frontmatter?.[1].match(new RegExp(`^${name}:\\s*(.+)$`, "m"))?.[1]?.trim().replace(/^['"]|['"]$/g, "");
+    return { description: field("description"), argumentHint: field("argument-hint") ?? field("argument_hint") ?? field("usage") };
+}
+function collect(root, source) {
+    if (!fs.existsSync(root))
+        return [];
+    return fs.readdirSync(root, { withFileTypes: true }).flatMap((entry) => {
+        if (entry.name.startsWith("."))
+            return [];
+        const file = entry.isDirectory()
+            ? path.join(root, entry.name, "SKILL.md")
+            : entry.isFile() && entry.name.endsWith(".md") ? path.join(root, entry.name) : "";
+        if (!file || !fs.existsSync(file))
+            return [];
+        return [{ name: entry.isDirectory() ? entry.name : path.basename(entry.name, ".md"), ...metadata(file), source }];
+    });
+}
+function collectPluginSkills(root) {
+    if (!fs.existsSync(root))
+        return [];
+    const output = [];
+    const queue = [{ directory: root, depth: 0 }];
+    let visited = 0;
+    while (queue.length && visited < 2_000) {
+        const item = queue.shift();
+        visited += 1;
+        let entries;
+        try {
+            entries = fs.readdirSync(item.directory, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        const skillFile = entries.find((entry) => entry.isFile() && entry.name === "SKILL.md");
+        if (skillFile) {
+            output.push({ name: path.basename(item.directory), ...metadata(path.join(item.directory, skillFile.name)), source: item.directory.includes(`${path.sep}built-in${path.sep}`) ? "built-in" : "plugin" });
+            continue;
+        }
+        if (item.depth < 7)
+            for (const entry of entries)
+                if (entry.isDirectory() && !entry.name.startsWith("."))
+                    queue.push({ directory: path.join(item.directory, entry.name), depth: item.depth + 1 });
+    }
+    return output;
+}
+export function discoverSkills(cwd) {
+    const project = requireWorkingDirectory(cwd);
+    const all = [
+        ...collect(path.join(project, ".claude", "skills"), "project"),
+        ...collect(path.join(project, ".claude", "commands"), "project"),
+        ...collect(path.join(os.homedir(), ".claude", "skills"), "user"),
+        ...collect(path.join(os.homedir(), ".claude", "commands"), "user"),
+        ...collectPluginSkills(path.join(os.homedir(), ".claude", "plugins")),
+        ...collect(path.join(project, ".codex", "skills"), "project"),
+        ...collect(path.join(os.homedir(), ".codex", "skills"), "user"),
+        ...collectPluginSkills(path.join(os.homedir(), ".codex", "plugins", "cache")),
+    ];
+    const unique = new Map();
+    for (const skill of all.reverse())
+        unique.set(skill.name, skill);
+    return [...unique.values()].sort((a, b) => a.name.localeCompare(b.name));
+}

package/packages/server/dist/templates/templateDiscovery.js

@@ -0,0 +1,97 @@
+import fs from "node:fs";
+import path from "node:path";
+import { config } from "../config.js";
+import { requireWorkingDirectory } from "../paths/pathResolver.js";
+const definitions = [
+    ["feature", "Feature implementation", "Build and verify a product feature.", ["investigation", "implementation", "testing", "review"], ["test", "typecheck", "review"]], ["bugfix", "Bug fixing", "Reproduce, fix, and regress a defect.", ["investigation", "implementation", "testing"], ["test", "review"]], ["pr-review", "PR review", "Perform an evidence-backed pull-request review.", ["review", "testing"], ["review"]], ["incident", "Incident investigation", "Investigate impact, cause, mitigation, and follow-up.", ["investigation", "testing", "documentation"], ["documentation"]], ["security", "Security audit", "Assess threats, validate findings, and recommend fixes.", ["investigation", "review", "testing"], ["test", "review"]], ["refactor", "Refactor", "Improve structure while preserving behavior.", ["investigation", "implementation", "testing", "review"], ["test", "typecheck"]], ["dependency", "Dependency upgrade", "Upgrade dependencies and verify compatibility.", ["investigation", "implementation", "testing"], ["test", "typecheck"]], ["ui", "UI implementation", "Implement and visually verify an interface change.", ["implementation", "browser_qa", "testing", "review"], ["test", "screenshot", "review"]],
+];
+const permissions = { commits: true, pushes: false, pullRequests: false, releases: false, destructiveActions: false, network: true };
+export const BUILT_IN_TEMPLATES = definitions.map(([id, name, description, roles, gates]) => ({ id, name, description, version: 1, source: "built-in", mode: "orchestrated", worktree: true, managerInstructions: `${name}: delegate independent stages, require concrete evidence, and stop for user approval before external or destructive actions.`, stages: roles.map((role, index) => ({ id: `${id}-${index + 1}`, title: role.replaceAll("_", " ").replace(/^./, (value) => value.toUpperCase()), role })), gates: gates.map((type) => ({ id: `${id}-${type}`, label: `${type.replaceAll("_", " ")} complete`, type, status: "pending", required: true, evidence: [] })), budgets: { maxWorkers: 8, maxConcurrentWorkers: 4 }, permissions }));
+const roles = ["investigation", "implementation", "testing", "review", "browser_qa", "documentation", "custom"];
+const gateTypes = ["test", "typecheck", "lint", "ci", "review", "pr", "screenshot", "documentation", "user_approval", "custom"];
+const permissionKeys = ["commits", "pushes", "pullRequests", "releases", "destructiveActions", "network"];
+export function validateTemplate(value, source) {
+    if (!value || typeof value !== "object")
+        throw new Error("template must be an object");
+    const input = value;
+    if (!input.id?.match(/^[a-z0-9][a-z0-9-]{1,62}$/))
+        throw new Error("template ID must be 2–63 lowercase letters, numbers, or hyphens");
+    if (!input.name?.trim() || !input.description?.trim() || !input.managerInstructions?.trim())
+        throw new Error("name, description, and manager instructions are required");
+    if (!Number.isInteger(input.version) || Number(input.version) < 1)
+        throw new Error("template version must be a positive integer");
+    if (input.mode !== "direct" && input.mode !== "orchestrated")
+        throw new Error("template mode must be direct or orchestrated");
+    if (typeof input.worktree !== "boolean")
+        throw new Error("template worktree setting must be boolean");
+    if (!Array.isArray(input.stages) || !input.stages.length || input.stages.some((stage) => !stage?.id || !stage.title?.trim() || !roles.includes(stage.role)))
+        throw new Error("template requires valid stages and worker roles");
+    if (new Set(input.stages.map((stage) => stage.id)).size !== input.stages.length)
+        throw new Error("template stage IDs must be unique");
+    const stageIds = new Set(input.stages.map((stage) => stage.id));
+    if (input.stages.some((stage) => (stage.dependsOn ?? []).some((dependency) => !stageIds.has(dependency) || dependency === stage.id)))
+        throw new Error("stage dependencies must reference another stage in the template");
+    const visiting = new Set();
+    const visited = new Set();
+    const byId = new Map(input.stages.map((stage) => [stage.id, stage]));
+    const cyclic = (id) => { if (visiting.has(id))
+        return true; if (visited.has(id))
+        return false; visiting.add(id); if ((byId.get(id)?.dependsOn ?? []).some(cyclic))
+        return true; visiting.delete(id); visited.add(id); return false; };
+    if (input.stages.some((stage) => cyclic(stage.id)))
+        throw new Error("stage dependencies cannot contain a cycle");
+    if (!Array.isArray(input.gates) || input.gates.some((gate) => !gate?.id || !gate.label?.trim() || !gateTypes.includes(gate.type)))
+        throw new Error("template contains an invalid completion gate");
+    if (!input.permissions || permissionKeys.some((key) => typeof input.permissions?.[key] !== "boolean"))
+        throw new Error("template requires explicit permission settings");
+    for (const [key, limit] of Object.entries(input.budgets ?? {}))
+        if (!Number.isFinite(limit) || Number(limit) <= 0)
+            throw new Error(`${key} must be a positive number`);
+    return { ...input, id: input.id, name: input.name.trim(), description: input.description.trim(), managerInstructions: input.managerInstructions.trim(), source };
+}
+function templateRoot(source, cwd) { return source === "user" ? path.join(config.hiveDataDir, "templates") : path.join(requireWorkingDirectory(cwd), ".hive", "templates"); }
+function custom(root, source, diagnostics = []) { if (!fs.existsSync(root))
+    return []; return fs.readdirSync(root).filter((file) => file.endsWith(".json")).flatMap((file) => { try {
+    return [validateTemplate(JSON.parse(fs.readFileSync(path.join(root, file), "utf8")), source)];
+}
+catch (err) {
+    diagnostics.push({ source, file: path.join(root, file), error: err.message });
+    return [];
+} }); }
+export function discoverTemplatesDetailed(cwd) { const project = requireWorkingDirectory(cwd); const diagnostics = []; const merged = new Map(BUILT_IN_TEMPLATES.map((template) => [template.id, template])); for (const template of [...custom(path.join(config.hiveDataDir, "templates"), "user", diagnostics), ...custom(path.join(project, ".hive", "templates"), "repository", diagnostics)])
+    merged.set(template.id, template); return { templates: [...merged.values()], diagnostics }; }
+export function discoverTemplates(cwd) { return discoverTemplatesDetailed(cwd).templates; }
+export function createTemplate(value, source, cwd) {
+    const template = validateTemplate(value, source);
+    const root = templateRoot(source, cwd);
+    fs.mkdirSync(root, { recursive: true });
+    const target = path.join(root, `${template.id}.json`);
+    if (fs.existsSync(target))
+        throw new Error(`a ${source} template with ID ${template.id} already exists`);
+    const temp = `${target}.tmp`;
+    fs.writeFileSync(temp, JSON.stringify(template, null, 2));
+    fs.renameSync(temp, target);
+    return template;
+}
+export function updateTemplate(id, value, source, cwd) {
+    if (!id.match(/^[a-z0-9][a-z0-9-]{1,62}$/))
+        throw new Error("invalid template ID");
+    const template = validateTemplate(value, source);
+    if (template.id !== id)
+        throw new Error("template ID cannot be changed while editing; duplicate it with a new ID instead");
+    const target = path.join(templateRoot(source, cwd), `${id}.json`);
+    if (!fs.existsSync(target))
+        throw new Error(`${source} template not found: ${id}`);
+    const temp = `${target}.tmp`;
+    fs.writeFileSync(temp, JSON.stringify(template, null, 2));
+    fs.renameSync(temp, target);
+    return template;
+}
+export function deleteTemplate(id, source, cwd) {
+    if (!id.match(/^[a-z0-9][a-z0-9-]{1,62}$/))
+        throw new Error("invalid template ID");
+    const target = path.join(templateRoot(source, cwd), `${id}.json`);
+    if (!fs.existsSync(target))
+        throw new Error(`${source} template not found: ${id}`);
+    fs.unlinkSync(target);
+}