@suwujs/king-ai 0.2.0

package/dist/src/shared-skills.js

@@ -0,0 +1,85 @@
+import { cp, mkdir, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { basename, delimiter, join } from "node:path";
+function splitRoots(value) {
+    if (!value)
+        return [];
+    return value
+        .split(delimiter)
+        .flatMap((entry) => entry.split(","))
+        .map((entry) => entry.trim())
+        .filter(Boolean)
+        .filter((entry, idx, all) => all.indexOf(entry) === idx);
+}
+export function sharedSkillRoots(env = process.env) {
+    return splitRoots(env.KING_AI_SHARED_SKILLS);
+}
+export function sharedSkillSnapshotsRoot(env = process.env) {
+    return env.KING_AI_SKILL_SNAPSHOTS_DIR;
+}
+export async function listSharedSkills(sourceRoots) {
+    const skills = [];
+    const seen = new Set();
+    for (const root of sourceRoots) {
+        if (!existsSync(root))
+            continue;
+        for (const entry of await readdir(root, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const sourceDir = join(root, entry.name);
+            if (!existsSync(join(sourceDir, "SKILL.md")))
+                continue;
+            if (seen.has(entry.name))
+                continue;
+            seen.add(entry.name);
+            skills.push({ name: entry.name, sourceDir });
+        }
+    }
+    return skills.sort((left, right) => left.name.localeCompare(right.name));
+}
+export async function installSharedSkills(agentHome, sourceRoots = sharedSkillRoots(), env = process.env) {
+    const skills = await listSharedSkills(sourceRoots);
+    const targets = [join(agentHome, ".claude", "skills"), join(agentHome, ".codex", "skills")];
+    const snapshot = await createSharedSkillSnapshot(agentHome, skills, env);
+    for (const target of targets)
+        await mkdir(target, { recursive: true });
+    for (const skill of skills) {
+        const sourceStat = await stat(skill.sourceDir);
+        if (!sourceStat.isDirectory())
+            continue;
+        for (const target of targets) {
+            const dest = join(target, skill.name || basename(skill.sourceDir));
+            await rm(dest, { recursive: true, force: true });
+            const snapshotSkill = snapshot?.skills.find((entry) => entry.name === skill.name);
+            await cp(snapshotSkill?.snapshotDir ?? skill.sourceDir, dest, { recursive: true });
+        }
+    }
+    return { sourceRoots, installed: skills, targets, snapshot };
+}
+async function createSharedSkillSnapshot(agentHome, skills, env = process.env) {
+    if (skills.length === 0)
+        return undefined;
+    const snapshotId = `skills-${new Date().toISOString().replace(/[:.]/g, "-")}-${randomUUID()}`;
+    const root = join(sharedSkillSnapshotsRoot(env) || join(agentHome, ".king-ai", "skill-snapshots"), snapshotId);
+    await mkdir(root, { recursive: true });
+    const snapshotSkills = [];
+    for (const skill of skills) {
+        const snapshotDir = join(root, skill.name || basename(skill.sourceDir));
+        await cp(skill.sourceDir, snapshotDir, { recursive: true });
+        snapshotSkills.push({
+            name: skill.name,
+            sourceDir: skill.sourceDir,
+            snapshotDir
+        });
+    }
+    const snapshot = {
+        id: snapshotId,
+        createdAt: new Date().toISOString(),
+        root,
+        manifestPath: join(root, "manifest.json"),
+        skills: snapshotSkills
+    };
+    await writeFile(snapshot.manifestPath, `${JSON.stringify(snapshot, null, 2)}\n`, "utf8");
+    return snapshot;
+}

package/dist/src/shim.d.ts

@@ -0,0 +1 @@
+export declare function writeShim(binDir: string): Promise<void>;

package/dist/src/shim.js

@@ -0,0 +1,64 @@
+import { chmod, mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const SHIM = `#!/usr/bin/env node
+'use strict'
+;(async () => {
+  const commandName = require('path').basename(process.argv[1] || process.argv[0] || 'king-ai')
+  const url = process.env.KING_AI_AGENT_RUNTIME_URL
+  let token = process.env.KING_AI_AGENT_RUNTIME_TOKEN
+  const tenant = process.env.KING_AI_AGENT_RUNTIME_TENANT
+  const tokenFile = process.env.KING_AI_AGENT_RUNTIME_TOKEN_FILE
+  if (tokenFile) {
+    try {
+      const fresh = require('fs').readFileSync(tokenFile, 'utf8').trim()
+      if (fresh) token = fresh
+    } catch {}
+  }
+  if (!url || !token) {
+    console.error(commandName + ': runtime env not set')
+    process.exit(70)
+  }
+  const fs = require('fs')
+  const argv = process.argv.slice(2)
+  const fileIdx = argv.indexOf('--file')
+  if (fileIdx >= 0 && argv[fileIdx + 1] !== undefined) {
+    try {
+      argv.splice(fileIdx, 2, fs.readFileSync(argv[fileIdx + 1], 'utf8'))
+    } catch {
+      console.error(commandName + ': cannot read --file ' + argv[fileIdx + 1])
+      process.exit(70)
+    }
+  }
+  const stdinIdx = argv.indexOf('--stdin')
+  if (stdinIdx >= 0) {
+    let body = ''
+    try { body = fs.readFileSync(0, 'utf8') } catch {}
+    argv.splice(stdinIdx, 1, body)
+  }
+  const res = await fetch(url + '/cli', {
+    method: 'POST',
+    headers: { Authorization: 'Bearer ' + token, 'Content-Type': 'application/json', ...(tenant ? { 'X-King-AI-Tenant': tenant } : {}) },
+    body: JSON.stringify({ argv, agentId: process.env.KING_AI_AGENT_ID || undefined, engine: process.env.KING_AI_AGENT_ENGINE || undefined })
+  })
+  if (!res.ok) {
+    const text = await res.text().catch(() => '')
+    console.error(commandName + ': HTTP ' + res.status + ' ' + text)
+    process.exit(70)
+  }
+  const data = await res.json()
+  if (typeof data.text === 'string' && data.text) process.stdout.write(data.text + '\\n')
+  process.exit(typeof data.exitCode === 'number' ? data.exitCode : 0)
+})().catch((err) => {
+  const commandName = require('path').basename(process.argv[1] || process.argv[0] || 'king-ai')
+  console.error(commandName + ':', err && err.message ? err.message : err)
+  process.exit(70)
+})
+`;
+export async function writeShim(binDir) {
+    await mkdir(binDir, { recursive: true });
+    for (const name of ["king-ai"]) {
+        const shim = join(binDir, name);
+        await writeFile(shim, SHIM, "utf8");
+        await chmod(shim, 0o755);
+    }
+}

package/dist/src/skill-check.d.ts

@@ -0,0 +1,17 @@
+export declare const KNOWN_COMMANDS: Set<string>;
+export declare const KNOWN_SUBCOMMANDS: Record<string, Set<string>>;
+export interface SkillCheckResult {
+    skillName: string;
+    filePath: string;
+    referencedCommands: string[];
+    invalidCommands: string[];
+    warnings: string[];
+    valid: boolean;
+}
+export declare function extractCommands(content: string): string[];
+export declare function validateCommand(commandReference: string): boolean;
+export declare function checkSkill(filePath: string): SkillCheckResult;
+export declare function findSkillFiles(skillsDir: string): string[];
+export declare function checkAllSkills(skillsDir: string): SkillCheckResult[];
+export declare function formatDashboard(results: SkillCheckResult[], commandName?: string): string;
+export declare function runSkillCheck(skillsDir: string, commandName?: string): void;

package/dist/src/skill-check.js

@@ -0,0 +1,158 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+export const KNOWN_COMMANDS = new Set([
+    "agent",
+    "agents",
+    "agenda",
+    "artifact",
+    "calendar",
+    "capsule",
+    "card",
+    "claim",
+    "contacts",
+    "context",
+    "dm",
+    "doc",
+    "escalate",
+    "eval",
+    "evaluate",
+    "feedback",
+    "glance",
+    "hypothesis",
+    "inbox",
+    "initiative",
+    "loop",
+    "messages",
+    "merge",
+    "observe",
+    "participants",
+    "preamble",
+    "plan",
+    "react",
+    "reaction",
+    "recv",
+    "reply",
+    "review",
+    "route",
+    "roster",
+    "safety",
+    "send",
+    "status",
+    "task",
+    "unclaim",
+    "watch",
+    "whoami"
+]);
+export const KNOWN_SUBCOMMANDS = {
+    agent: new Set(["computer"]),
+    agents: new Set(["spawn", "destroy"]),
+    artifact: new Set(["put", "list", "get", "check"]),
+    calendar: new Set(["list", "create"]),
+    capsule: new Set(["create", "list", "mine", "get", "update"]),
+    card: new Set(["list", "create", "claim", "move", "done", "release"]),
+    context: new Set(["get", "set", "list", "delete"]),
+    doc: new Set(["list", "create", "show", "append", "update"]),
+    eval: new Set(["parse", "record", "list", "get"]),
+    evaluate: new Set(["parse", "record", "list", "get"]),
+    feedback: new Set(["record", "list", "summary", "get"]),
+    hypothesis: new Set(["create", "list", "update"]),
+    safety: new Set(["check", "request", "list", "get", "approve", "deny", "pending"]),
+    initiative: new Set(["create", "list", "get", "update"]),
+    loop: new Set(["tick", "emit", "classify", "recent", "snapshot", "list"]),
+    merge: new Set(["enqueue", "list", "get", "mark"]),
+    plan: new Set(["parse", "apply"]),
+    review: new Set(["record", "list", "get"]),
+    route: new Set(["set", "list", "delete", "remove", "emit"]),
+    task: new Set(["create", "list", "get", "update", "done"])
+};
+export function extractCommands(content) {
+    const commands = [];
+    const regex = /\bking-ai\s+([a-z][\w:-]*)(?:\s+([a-z][\w:-]*))?/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        const topLevel = match[1];
+        const subcommand = match[2];
+        if (!topLevel)
+            continue;
+        if (subcommand && KNOWN_SUBCOMMANDS[topLevel]) {
+            commands.push(`${topLevel} ${subcommand}`);
+            continue;
+        }
+        commands.push(topLevel);
+    }
+    return [...new Set(commands)];
+}
+export function validateCommand(commandReference) {
+    const [topLevel, subcommand] = commandReference.split(" ");
+    if (!topLevel || !KNOWN_COMMANDS.has(topLevel))
+        return false;
+    if (!subcommand)
+        return true;
+    return KNOWN_SUBCOMMANDS[topLevel]?.has(subcommand) ?? true;
+}
+export function checkSkill(filePath) {
+    const content = readFileSync(filePath, "utf8");
+    const referencedCommands = extractCommands(content);
+    const invalidCommands = referencedCommands.filter((commandReference) => !validateCommand(commandReference));
+    const warnings = [];
+    if (referencedCommands.length === 0)
+        warnings.push("No king-ai CLI commands referenced");
+    return {
+        skillName: basename(dirname(filePath)),
+        filePath,
+        referencedCommands,
+        invalidCommands,
+        warnings,
+        valid: invalidCommands.length === 0
+    };
+}
+export function findSkillFiles(skillsDir) {
+    if (!existsSync(skillsDir))
+        return [];
+    const files = [];
+    for (const entry of readdirSync(skillsDir, { withFileTypes: true })) {
+        const entryPath = join(skillsDir, entry.name);
+        if (entry.isDirectory()) {
+            const skillFile = join(entryPath, "SKILL.md");
+            if (existsSync(skillFile))
+                files.push(skillFile);
+            files.push(...findSkillFiles(entryPath));
+        }
+    }
+    return [...new Set(files)].sort();
+}
+export function checkAllSkills(skillsDir) {
+    return findSkillFiles(skillsDir).map((filePath) => checkSkill(filePath));
+}
+export function formatDashboard(results, commandName = "king-ai") {
+    const lines = [
+        `${commandName} skill-check - Skill command reference health`,
+        "=".repeat(56)
+    ];
+    let passed = 0;
+    let failed = 0;
+    for (const result of results) {
+        if (result.valid)
+            passed++;
+        else
+            failed++;
+        lines.push(`${result.valid ? "[ok]" : "[fail]"} ${result.skillName}`);
+        lines.push(`  Commands: ${result.referencedCommands.length ? result.referencedCommands.join(", ") : "none"}`);
+        if (result.invalidCommands.length)
+            lines.push(`  Invalid: ${result.invalidCommands.join(", ")}`);
+        for (const warning of result.warnings)
+            lines.push(`  [warn] ${warning}`);
+    }
+    lines.push("-".repeat(56));
+    lines.push(`Total: ${results.length} skills, ${passed} passed, ${failed} failed`);
+    return lines.join("\n");
+}
+export function runSkillCheck(skillsDir, commandName = "king-ai") {
+    if (!existsSync(skillsDir)) {
+        throw new Error(`Skills directory not found: ${skillsDir}`);
+    }
+    const results = checkAllSkills(skillsDir);
+    console.log(formatDashboard(results, commandName));
+    if (results.some((result) => !result.valid))
+        process.exitCode = 1;
+}

package/dist/src/sse.d.ts

@@ -0,0 +1,9 @@
+export interface SseEvent {
+    event?: string;
+    data?: string;
+    id?: string;
+}
+export declare const DEFAULT_SSE_MAX_BUFFER_BYTES: number;
+export declare function parseSseStream(body: AsyncIterable<Uint8Array | string>, options?: {
+    maxBufferBytes?: number;
+}): AsyncGenerator<SseEvent>;

package/dist/src/sse.js

@@ -0,0 +1,36 @@
+export const DEFAULT_SSE_MAX_BUFFER_BYTES = 1024 * 1024;
+export async function* parseSseStream(body, options = {}) {
+    const decoder = new TextDecoder("utf-8");
+    const maxBufferBytes = options.maxBufferBytes ?? DEFAULT_SSE_MAX_BUFFER_BYTES;
+    let buf = "";
+    for await (const chunk of body) {
+        buf += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+        if (Buffer.byteLength(buf, "utf8") > maxBufferBytes) {
+            throw new Error(`SSE frame exceeded ${maxBufferBytes} bytes without a terminator`);
+        }
+        let splitAt;
+        while ((splitAt = buf.indexOf("\n\n")) >= 0) {
+            const block = buf.slice(0, splitAt);
+            buf = buf.slice(splitAt + 2);
+            const event = {};
+            for (const rawLine of block.split("\n")) {
+                const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+                if (!line || line.startsWith(":"))
+                    continue;
+                const colon = line.indexOf(":");
+                if (colon < 0)
+                    continue;
+                const field = line.slice(0, colon);
+                const value = line.slice(colon + 1).replace(/^ /, "");
+                if (field === "event")
+                    event.event = value;
+                if (field === "id")
+                    event.id = value;
+                if (field === "data")
+                    event.data = (event.data ?? "") + value;
+            }
+            if (event.event || event.data || event.id)
+                yield event;
+        }
+    }
+}

package/dist/src/team-routing.d.ts

@@ -0,0 +1,55 @@
+import type { KingHandoffPolicy, KingTeamSpec, KingWorkflowObjectType } from "./team-workflow.js";
+/**
+ * The minimal shape of a workflow card the router reasons about. Kept structural (not coupled to
+ * the ledger record type) so the engine stays a pure function of team policy + card state.
+ */
+export interface RoutableCard {
+    id: string;
+    kind: KingWorkflowObjectType;
+    status: string;
+    ownerRole?: string;
+    reviewerRole?: string;
+    handoffPolicy?: KingHandoffPolicy;
+    sourceId?: string;
+    sourceOwnerRole?: string;
+    result?: string;
+}
+export interface HandoffCard {
+    kind: KingWorkflowObjectType;
+    title: string;
+    status: string;
+    ownerRole?: string;
+    reviewerRole?: string;
+    targetRole?: string;
+    sourceId: string;
+    dependsOn: string[];
+    decisionBy?: string;
+    detail: string;
+    handoffPolicy?: KingHandoffPolicy;
+}
+export interface HandoffAction {
+    reason: "review" | "human-escalation" | "next-role";
+    card: HandoffCard;
+}
+export type ReviewVerdict = "approved" | "changes_requested";
+/**
+ * Resolve the handoff policy that governs a card: an explicit policy on the card wins, otherwise the
+ * owning role's policy from the team spec.
+ */
+export declare function roleHandoffPolicy(team: KingTeamSpec, roleId: string | undefined): KingHandoffPolicy | undefined;
+/**
+ * Capability-first owner selection: pick the role whose declared capabilities best overlap the work's
+ * required capabilities. Returns undefined when routing is not capability-first or nothing matches,
+ * leaving the caller to fall back to an explicit owner.
+ */
+export declare function selectOwnerRole(team: KingTeamSpec, requiredCapabilities: string[]): string | undefined;
+export declare function normalizeReviewVerdict(result?: string): ReviewVerdict | undefined;
+/**
+ * Given a card that has just reached `done`, compute the follow-up workflow cards the team policy
+ * requires. This is what turns routingPolicy/handoffPolicy from declared data into an executed
+ * workflow: completing a builder card routes to its reviewer, an ops/human-gated card escalates to a
+ * decision, and a card with a `nextRole` hands off down the chain.
+ *
+ * Returns an empty list when no routing applies (not done, a decision being resolved, or no policy).
+ */
+export declare function planHandoff(card: RoutableCard, team: KingTeamSpec): HandoffAction[];

package/dist/src/team-routing.js

@@ -0,0 +1,131 @@
+/**
+ * Resolve the handoff policy that governs a card: an explicit policy on the card wins, otherwise the
+ * owning role's policy from the team spec.
+ */
+export function roleHandoffPolicy(team, roleId) {
+    if (!roleId)
+        return undefined;
+    const role = team.roles.find((entry) => entry.id === roleId) ?? team.roles.find((entry) => entry.template === roleId);
+    return role?.handoffPolicy;
+}
+/**
+ * Capability-first owner selection: pick the role whose declared capabilities best overlap the work's
+ * required capabilities. Returns undefined when routing is not capability-first or nothing matches,
+ * leaving the caller to fall back to an explicit owner.
+ */
+export function selectOwnerRole(team, requiredCapabilities) {
+    if (!team.routingPolicy.capabilityFirst || requiredCapabilities.length === 0)
+        return undefined;
+    const required = new Set(requiredCapabilities);
+    let best;
+    let bestScore = 0;
+    for (const role of team.roles) {
+        const score = role.capabilities.reduce((count, capability) => (required.has(capability) ? count + 1 : count), 0);
+        if (score > bestScore) {
+            bestScore = score;
+            best = role.id;
+        }
+    }
+    return best;
+}
+export function normalizeReviewVerdict(result) {
+    const value = result?.trim().toLowerCase().replace(/[\s-]+/g, "_");
+    if (!value)
+        return undefined;
+    if (value === "approved" || value === "approve" || value === "accepted" || value === "pass" || value === "passed")
+        return "approved";
+    if (value === "changes_requested" || value === "change_requested" || value === "rejected" || value === "needs_work" || value === "fail" || value === "failed")
+        return "changes_requested";
+    return undefined;
+}
+/**
+ * Given a card that has just reached `done`, compute the follow-up workflow cards the team policy
+ * requires. This is what turns routingPolicy/handoffPolicy from declared data into an executed
+ * workflow: completing a builder card routes to its reviewer, an ops/human-gated card escalates to a
+ * decision, and a card with a `nextRole` hands off down the chain.
+ *
+ * Returns an empty list when no routing applies (not done, a decision being resolved, or no policy).
+ */
+export function planHandoff(card, team) {
+    if (card.status !== "done")
+        return [];
+    // Resolving a decision must never spawn another decision/review, or the gate would never close.
+    if (card.kind === "decision")
+        return [];
+    const verdict = card.kind === "review" ? normalizeReviewVerdict(card.result) : undefined;
+    if (verdict === "changes_requested" && card.sourceId && card.sourceOwnerRole) {
+        return [{
+                reason: "next-role",
+                card: {
+                    kind: "handoff",
+                    title: `Changes requested for ${card.sourceId}`,
+                    status: "assigned",
+                    ownerRole: card.sourceOwnerRole,
+                    targetRole: card.sourceOwnerRole,
+                    sourceId: card.id,
+                    dependsOn: [card.id],
+                    detail: `Review ${card.id} requested changes on ${card.sourceId}; route back to ${card.sourceOwnerRole}.`
+                }
+            }];
+    }
+    const policy = card.handoffPolicy ?? roleHandoffPolicy(team, card.ownerRole);
+    if (!policy)
+        return [];
+    const reviewer = card.reviewerRole ?? policy.reviewerRole;
+    const owner = card.ownerRole ?? "owner";
+    if (policy.acceptanceRequired && reviewer && card.kind !== "review") {
+        return [{
+                reason: "review",
+                card: {
+                    kind: "review",
+                    title: `Review ${card.id}`,
+                    status: "review",
+                    ownerRole: reviewer,
+                    reviewerRole: reviewer,
+                    targetRole: reviewer,
+                    sourceId: card.id,
+                    dependsOn: [card.id],
+                    detail: `Auto-routed for review by ${reviewer} after ${owner} completed ${card.id}.`,
+                    // Carry the onward policy so completing the review continues the chain without re-triggering
+                    // another review.
+                    handoffPolicy: {
+                        mode: policy.mode,
+                        nextRole: policy.nextRole,
+                        escalation: policy.escalation,
+                        acceptanceRequired: false
+                    }
+                }
+            }];
+    }
+    if (policy.escalation === "human" || policy.mode === "human-decision") {
+        return [{
+                reason: "human-escalation",
+                card: {
+                    kind: "decision",
+                    title: `Decision after ${card.id}`,
+                    status: "waiting_human",
+                    ownerRole: card.ownerRole,
+                    sourceId: card.id,
+                    dependsOn: [card.id],
+                    decisionBy: "human",
+                    detail: `Auto-routed: ${owner} completed ${card.id}; a human decision is required before continuing.`
+                }
+            }];
+    }
+    if (policy.nextRole) {
+        return [{
+                reason: "next-role",
+                card: {
+                    kind: "handoff",
+                    title: `Handoff to ${policy.nextRole} after ${card.id}`,
+                    status: "assigned",
+                    ownerRole: policy.nextRole,
+                    targetRole: policy.nextRole,
+                    sourceId: card.id,
+                    dependsOn: [card.id],
+                    detail: `Auto-routed from ${owner} to ${policy.nextRole} after ${card.id}.`
+                }
+            }];
+    }
+    return [];
+}

package/dist/src/team-workflow.d.ts

@@ -0,0 +1,78 @@
+export type KingRoleTemplateId = "planner" | "builder" | "reviewer" | "tester" | "ops" | "researcher" | "doc-writer" | "summarizer";
+export type KingRoutingMode = "one-of-us" | "each" | "review-required" | "human-decision";
+export type KingWorkflowObjectType = "initiative" | "task" | "handoff" | "review" | "decision" | "artifact";
+export type KingTeamPermissionAction = "assign-task" | "claim-task" | "create-artifact" | "create-decision" | "approve-decision" | "close-task" | "change-scope" | "deploy-release" | "view-audit" | "manage-queue" | "view-cost";
+export interface KingRoleTemplate {
+    id: KingRoleTemplateId;
+    name: string;
+    responsibility: string;
+    defaultRoutingMode: KingRoutingMode;
+    capabilityHints: string[];
+}
+export interface KingTeamRole {
+    id: string;
+    template: KingRoleTemplateId;
+    responsibility: string;
+    capabilities: string[];
+    handoffPolicy: KingHandoffPolicy;
+}
+export interface KingHandoffPolicy {
+    mode: KingRoutingMode;
+    nextRole?: string;
+    reviewerRole?: string;
+    escalation?: "human" | "coordinator" | "none";
+    acceptanceRequired: boolean;
+}
+export interface KingTeamSpec {
+    id: string;
+    name: string;
+    roles: KingTeamRole[];
+    routingPolicy: KingRoutingPolicy;
+    permissionPolicy: KingTeamPermissionPolicy;
+}
+export interface KingRoutingPolicy {
+    defaultMode: KingRoutingMode;
+    capabilityFirst: boolean;
+    reviewRequiredFor: string[];
+    humanDecisionFor: string[];
+}
+export interface KingTeamPermissionRule {
+    role: string;
+    allow: KingTeamPermissionAction[];
+    requireHumanDecision?: KingTeamPermissionAction[];
+    requireReviewBy?: string;
+}
+export interface KingTeamPermissionPolicy {
+    defaultDecision: "deny";
+    rules: KingTeamPermissionRule[];
+}
+export interface KingScenarioTemplate {
+    id: "repo-takeover" | "bug-investigation" | "product-design" | "release-check" | "research-brief";
+    name: string;
+    goal: string;
+    team: KingTeamSpec;
+    acceptance: string[];
+    tasks: Array<{
+        title: string;
+        ownerRole: string;
+        reviewerRole?: string;
+        dependsOn?: string[];
+        acceptance: string[];
+    }>;
+}
+export interface KingAgentRoleLike {
+    id?: string;
+    name?: string;
+    role?: string;
+}
+export declare const KING_AI_ROLE_TEMPLATES: KingRoleTemplate[];
+export declare function defaultTeamSpec(id?: string, name?: string): KingTeamSpec;
+export declare function checkTeamPermission(team: KingTeamSpec, role: string, action: KingTeamPermissionAction): {
+    decision: "allow" | "deny" | "human-decision";
+    rule?: KingTeamPermissionRule;
+};
+export declare function normalizeTeamRoleId(role: string): string;
+export declare function roleTemplateForAgent(agent: KingAgentRoleLike): KingRoleTemplateId;
+export declare function requiredCapabilitiesForText(text: string): string[];
+export declare function roleTemplateById(id: KingRoleTemplateId): KingRoleTemplate;
+export declare function scenarioTemplate(id: KingScenarioTemplate["id"]): KingScenarioTemplate;