open-multi-agent-kit 0.78.0

package/dist/runtime/context-capsule.d.ts

@@ -0,0 +1,81 @@
+/**
+ * ContextCapsule — bounded per-node context for agent runtimes.
+ *
+ * OMK memory = canonical (graph-state.json, .omk/runs/).
+ * Kimi memory = disposable (isolated HOME per node).
+ */
+import type { DagNode } from "../orchestration/dag.js";
+export interface FileSlice {
+    readonly path: string;
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly content: string;
+}
+export type MemoryFactKind = "project_constraint" | "architecture_decision" | "file_responsibility" | "api_contract" | "failure_pattern" | "successful_fix" | "user_preference" | "provider_behavior";
+export interface MemoryFact {
+    readonly id?: string;
+    readonly kind: MemoryFactKind;
+    readonly subject: string;
+    readonly predicate: string;
+    readonly object: string;
+    readonly confidence: number;
+    readonly sourceRunId?: string;
+    readonly sourceNodeId?: string;
+    readonly createdAt?: string;
+    readonly expiresAt?: string;
+    /** Backward compat: derived from subject+predicate if not set */
+    readonly key: string;
+    /** Backward compat: derived from object if not set */
+    readonly value: string;
+    /** Backward compat: derived from kind if not set */
+    readonly category: string;
+}
+export interface AttemptDigest {
+    readonly attempt: number;
+    readonly provider: string;
+    readonly status: "done" | "failed";
+    readonly durationMs?: number;
+    readonly failureSummary?: string;
+}
+export interface EvidenceSpec {
+    readonly gate: string;
+    readonly ref?: string;
+    readonly required: boolean;
+}
+export interface ContextBudget {
+    readonly maxInputTokens: number;
+    readonly reservedOutputTokens: number;
+    readonly maxFileTokens: number;
+    readonly maxToolResultTokens: number;
+    readonly maxMemoryFacts: number;
+    readonly compression: "none" | "lossless-ish" | "summary" | "aggressive";
+}
+export declare const DEFAULT_CONTEXT_BUDGET: ContextBudget;
+export declare const CONTEXT_BUDGET_PRESETS: Record<string, ContextBudget>;
+export interface ContextCapsule {
+    readonly runId: string;
+    readonly nodeId: string;
+    readonly goal: string;
+    readonly system: string;
+    readonly task: string;
+    readonly dependencySummaries: readonly string[];
+    readonly relevantFiles: readonly FileSlice[];
+    readonly graphMemory: readonly MemoryFact[];
+    readonly priorAttempts: readonly AttemptDigest[];
+    readonly evidenceRequirements: readonly EvidenceSpec[];
+    readonly budget: ContextBudget;
+    readonly node: DagNode;
+}
+export declare function estimateCapsuleTokens(capsule: ContextCapsule): number;
+export interface CapsuleTokenBreakdown {
+    readonly system: number;
+    readonly task: number;
+    readonly goal: number;
+    readonly dependencies: number;
+    readonly files: number;
+    readonly memory: number;
+    readonly evidence: number;
+    readonly priorAttempts: number;
+    readonly total: number;
+}
+export declare function breakdownCapsuleTokens(capsule: ContextCapsule): CapsuleTokenBreakdown;

package/dist/runtime/context-capsule.js

@@ -0,0 +1,46 @@
+/**
+ * ContextCapsule — bounded per-node context for agent runtimes.
+ *
+ * OMK memory = canonical (graph-state.json, .omk/runs/).
+ * Kimi memory = disposable (isolated HOME per node).
+ */
+export const DEFAULT_CONTEXT_BUDGET = {
+    maxInputTokens: 8192,
+    reservedOutputTokens: 4096,
+    maxFileTokens: 4096,
+    maxToolResultTokens: 2048,
+    maxMemoryFacts: 10,
+    compression: "lossless-ish",
+};
+export const CONTEXT_BUDGET_PRESETS = {
+    tiny: { maxInputTokens: 4096, reservedOutputTokens: 2048, maxFileTokens: 2048, maxToolResultTokens: 1024, maxMemoryFacts: 5, compression: "aggressive" },
+    small: DEFAULT_CONTEXT_BUDGET,
+    normal: { maxInputTokens: 16384, reservedOutputTokens: 8192, maxFileTokens: 8192, maxToolResultTokens: 4096, maxMemoryFacts: 20, compression: "lossless-ish" },
+};
+export function estimateCapsuleTokens(capsule) {
+    const b = breakdownCapsuleTokens(capsule);
+    return b.total;
+}
+export function breakdownCapsuleTokens(capsule) {
+    const system = Math.ceil(capsule.system.length / 4);
+    const task = Math.ceil(capsule.task.length / 4);
+    const goal = Math.ceil(capsule.goal.length / 4);
+    let dependencies = 0;
+    for (const s of capsule.dependencySummaries)
+        dependencies += Math.ceil(s.length / 4);
+    let files = 0;
+    for (const f of capsule.relevantFiles)
+        files += Math.ceil(f.content.length / 4);
+    let memory = 0;
+    for (const m of capsule.graphMemory)
+        memory += Math.ceil((m.key.length + m.value.length) / 4);
+    let evidence = 0;
+    for (const e of capsule.evidenceRequirements)
+        evidence += Math.ceil((e.gate.length + (e.ref?.length ?? 0)) / 4);
+    let priorAttempts = 0;
+    for (const a of capsule.priorAttempts) {
+        priorAttempts += Math.ceil((String(a.attempt).length + a.provider.length + a.status.length + (a.failureSummary?.length ?? 0)) / 4);
+    }
+    const total = system + task + goal + dependencies + files + memory + evidence + priorAttempts;
+    return { system, task, goal, dependencies, files, memory, evidence, priorAttempts, total };
+}

package/dist/runtime/contracts/command-envelope.d.ts

@@ -0,0 +1,99 @@
+/**
+ * CommandEnvelope — normalized CLI input.
+ * Represents any input to the OMK pipeline: slash commands, direct chat, piped input.
+ */
+export type CommandKind = "chat" | "run" | "status" | "model" | "memory" | "theme" | "doctor" | "slash" | "pipe" | "resume" | "system";
+export type CommandSource = "cli" | "stdin" | "api" | "hook";
+export interface CommandEnvelope {
+    readonly kind: CommandKind;
+    readonly source: CommandSource;
+    readonly rawText: string;
+    readonly providerPolicy?: string;
+    readonly outputProfile?: OutputProfile;
+    readonly debug?: boolean;
+    readonly timestamp?: string;
+}
+/**
+ * OutputProfile — controls how results are rendered to the user.
+ */
+export type OutputFormat = "theme" | "nlp" | "json" | "jsonl" | "markdown" | "silent";
+export type StdoutMode = "human" | "machine" | "theme" | "nlp" | "raw" | "json";
+export interface OutputProfile {
+    readonly format: OutputFormat;
+    readonly progress: "none" | "live" | "compact" | "jsonl";
+    readonly color: "auto" | "always" | "never";
+    readonly rawProvider: boolean;
+    readonly explainRouting: boolean;
+    readonly stdoutMode: StdoutMode;
+}
+/**
+ * OmkEvent — normalized events flowing through the pipeline.
+ * ProviderEventNormalizer converts raw provider events to these.
+ */
+export type OmkEventType = "turn_started" | "progress" | "mcp_status" | "warning" | "result" | "error" | "turn_finished";
+export interface OmkEvent {
+    readonly type: OmkEventType;
+    readonly timestamp: string;
+    readonly turnId?: string;
+    readonly data?: OmkEventData;
+}
+export type OmkEventData = {
+    readonly kind: "turn_started";
+    readonly intent: string;
+    readonly provider: string;
+} | {
+    readonly kind: "progress";
+    readonly message: string;
+    readonly percent?: number;
+} | {
+    readonly kind: "mcp_status";
+    readonly server: string;
+    readonly status: "connected" | "failed" | "skipped";
+} | {
+    readonly kind: "warning";
+    readonly message: string;
+    readonly code?: string;
+} | {
+    readonly kind: "result";
+    readonly content: string;
+    readonly format: OutputFormat;
+} | {
+    readonly kind: "error";
+    readonly message: string;
+    readonly code?: string;
+    readonly recoverable: boolean;
+} | {
+    readonly kind: "turn_finished";
+    readonly durationMs: number;
+    readonly tokenUsage?: {
+        readonly input: number;
+        readonly output: number;
+    };
+};
+/**
+ * CapabilityInventory — what's available (not what's activated).
+ */
+export interface CapabilityInventory {
+    readonly mcp: readonly McpServerStatus[];
+    readonly skills: readonly string[];
+    readonly hooks: readonly string[];
+    readonly toolsEnabled: boolean;
+}
+export interface McpServerStatus {
+    readonly name: string;
+    readonly connected: boolean;
+    readonly failed: boolean;
+    readonly error?: string;
+}
+/**
+ * CapabilityPlan — what gets activated for this turn.
+ */
+export type FailurePolicy = "required-only" | "strict" | "lenient";
+export interface CapabilityPlan {
+    readonly availableMcp: readonly string[];
+    readonly requiredMcp: readonly string[];
+    readonly optionalMcp: readonly string[];
+    readonly disabledMcp: readonly string[];
+    readonly selectedSkills: readonly string[];
+    readonly failurePolicy: FailurePolicy;
+}

package/dist/runtime/contracts/command-envelope.js

@@ -0,0 +1,5 @@
+/**
+ * CommandEnvelope — normalized CLI input.
+ * Represents any input to the OMK pipeline: slash commands, direct chat, piped input.
+ */
+export {};

package/dist/runtime/contracts/reasoning-trace.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Reasoning Trace Engine (RTE) — 검증 가능한 작업 추론 흔적
+ *
+ * NOT raw CoT. Stores structured evidence of what the agent did and why.
+ * Dataset export: redacted trajectory opt-in only.
+ *
+ * Key rule: "모델에게는 작은 NLP prompt만. 런타임에는 sidecar만.
+ *            사용자에게는 theme/NLG만. 데이터셋에는 opt-in redacted trace만."
+ */
+import type { RequestIntent } from "../debloat-nlp.js";
+export interface ReasoningTrace {
+    readonly id: string;
+    readonly turnId: string;
+    readonly timestamp: string;
+    readonly userIntent: TraceIntent;
+    readonly plan: TracePlan;
+    readonly execution: TraceExecution;
+    readonly evidence: TraceEvidence;
+    readonly result: TraceResult;
+    readonly privacy: TracePrivacy;
+}
+export interface TraceIntent {
+    readonly raw: string;
+    readonly classified: RequestIntent;
+    readonly risk: string;
+    readonly confidence: number;
+}
+export interface TracePlan {
+    readonly summary: string;
+    readonly steps: readonly string[];
+    readonly toolsSelected: readonly string[];
+    readonly mcpSelected: readonly string[];
+    readonly skillsSelected: readonly string[];
+}
+export interface TraceExecution {
+    readonly toolSequence: readonly TraceToolCall[];
+    readonly decisionRecords: readonly TraceDecision[];
+    readonly durationMs: number;
+    readonly retries: number;
+}
+export interface TraceToolCall {
+    readonly name: string;
+    readonly args?: string;
+    readonly resultSummary: string;
+    readonly success: boolean;
+    readonly durationMs: number;
+}
+export interface TraceDecision {
+    readonly point: string;
+    readonly chosen: string;
+    readonly alternatives: readonly string[];
+    readonly reason: string;
+}
+export interface TraceEvidence {
+    readonly testResult?: TraceTestResult;
+    readonly diffSummary?: string;
+    readonly filesChanged: readonly string[];
+    readonly commandsRun: readonly string[];
+    readonly screenshots: readonly string[];
+}
+export interface TraceTestResult {
+    readonly passed: number;
+    readonly failed: number;
+    readonly skipped: number;
+    readonly duration: string;
+    readonly failures: readonly string[];
+}
+export interface TraceResult {
+    readonly status: "success" | "partial" | "failed" | "blocked";
+    readonly summary: string;
+    readonly failureReason?: string;
+    readonly acceptReject: "accept" | "reject" | "pending";
+    readonly confidence: number;
+}
+export interface TracePrivacy {
+    readonly level: "l0" | "l1" | "l2" | "l3";
+    readonly redacted: boolean;
+    readonly includedInDataset: boolean;
+    readonly consentGiven: boolean;
+    readonly redactionRules: readonly string[];
+}
+export interface TraceStoreOptions {
+    readonly baseDir?: string;
+    readonly maxTraces?: number;
+    readonly autoRedact?: boolean;
+}
+export interface TraceSearchResult {
+    readonly trace: ReasoningTrace;
+    readonly relevance: number;
+}
+export interface ReasoningTraceStore {
+    append(trace: ReasoningTrace): Promise<void>;
+    load(traceId: string): Promise<ReasoningTrace | undefined>;
+    search(query: string, limit?: number): Promise<readonly TraceSearchResult[]>;
+    list(limit?: number): Promise<readonly ReasoningTrace[]>;
+    clear(): Promise<void>;
+    exportRedacted(level: TracePrivacy["level"]): Promise<readonly ReasoningTrace[]>;
+}
+export interface TraceSummary {
+    readonly intent: string;
+    readonly planSummary: string;
+    readonly toolsUsed: readonly string[];
+    readonly testResult?: string;
+    readonly outcome: string;
+    readonly duration: string;
+    readonly confidence: number;
+}
+export interface ConsentAwareNlgInput {
+    readonly trace: ReasoningTrace;
+    readonly consentLevel: TracePrivacy["level"];
+    readonly language: "ko" | "en";
+    readonly includeFiles: boolean;
+    readonly includeCommands: boolean;
+}
+export interface ConsentAwareNlgOutput {
+    readonly summary: TraceSummary;
+    readonly report: string;
+    readonly redactedFields: readonly string[];
+    readonly eligibleForDataset: boolean;
+}

package/dist/runtime/contracts/reasoning-trace.js

@@ -0,0 +1,10 @@
+/**
+ * Reasoning Trace Engine (RTE) — 검증 가능한 작업 추론 흔적
+ *
+ * NOT raw CoT. Stores structured evidence of what the agent did and why.
+ * Dataset export: redacted trajectory opt-in only.
+ *
+ * Key rule: "모델에게는 작은 NLP prompt만. 런타임에는 sidecar만.
+ *            사용자에게는 theme/NLG만. 데이터셋에는 opt-in redacted trace만."
+ */
+export {};

package/dist/runtime/contracts/shared.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared runtime contracts used by both AgentRuntime and RuntimeAdapter.
+ *
+ * AgentRuntime — internal runtime implementation interface (src/runtime/agent-runtime.ts)
+ *   Used by concrete runtimes (KimiApi, DeepSeek, Codex, WireProtocol, etc.)
+ *   Operates on ContextCapsule and supports optional execute()/health() hooks.
+ *
+ * RuntimeAdapter — provider-routing interface (src/runtime/adapter.ts)
+ *   Used by the provider routing layer to select and dispatch to runtimes.
+ *   Operates on AgentRunRequest and requires mandatory health()/supports()/runNode().
+ */
+export type RuntimeId = string;
+export type RuntimeKind = "cli" | "api" | "mcp" | "local" | "composite";
+export type RuntimeAuthority = "read" | "write" | "shell" | "mcp" | "patch" | "review" | "merge" | "vision";
+export interface RuntimeCapabilities {
+    read: boolean;
+    write: boolean;
+    shell: boolean;
+    mcp: boolean;
+    patch: boolean;
+    review: boolean;
+    merge: boolean;
+    vision: boolean;
+    maxContextTokens?: number;
+    supportsStreaming?: boolean;
+    supportsStructuredOutput?: boolean;
+    supportsToolCalling?: boolean;
+}
+export interface RuntimeHealth {
+    runtimeId: RuntimeId;
+    available: boolean;
+    reason?: string;
+    checkedAt: string;
+}

package/dist/runtime/contracts/shared.js

@@ -0,0 +1,12 @@
+/**
+ * Shared runtime contracts used by both AgentRuntime and RuntimeAdapter.
+ *
+ * AgentRuntime — internal runtime implementation interface (src/runtime/agent-runtime.ts)
+ *   Used by concrete runtimes (KimiApi, DeepSeek, Codex, WireProtocol, etc.)
+ *   Operates on ContextCapsule and supports optional execute()/health() hooks.
+ *
+ * RuntimeAdapter — provider-routing interface (src/runtime/adapter.ts)
+ *   Used by the provider routing layer to select and dispatch to runtimes.
+ *   Operates on AgentRunRequest and requires mandatory health()/supports()/runNode().
+ */
+export {};

package/dist/runtime/core-verified-preset.d.ts

@@ -0,0 +1,37 @@
+interface OmkRuntimePresetBase {
+    name: string;
+    description: string;
+    skills: string[];
+    hooks: string[];
+    mcpServers: string[];
+    purpose: string;
+}
+export interface OmkCoreVerifiedPreset extends OmkRuntimePresetBase {
+    id: "omk-core-verified";
+}
+export interface OmkTsProductPreset extends OmkRuntimePresetBase {
+    id: "omk-ts-product";
+}
+export interface OmkWorktreeTeamPreset extends OmkRuntimePresetBase {
+    id: "omk-worktree-team";
+}
+export interface OmkReleaseGuardPreset extends OmkRuntimePresetBase {
+    id: "omk-release-guard";
+}
+export interface OmkParallelOrchestratorPreset extends OmkRuntimePresetBase {
+    id: "omk-parallel-orchestrator";
+}
+export type OmkRuntimePreset = OmkCoreVerifiedPreset | OmkTsProductPreset | OmkWorktreeTeamPreset | OmkReleaseGuardPreset | OmkParallelOrchestratorPreset;
+export declare const OMK_TOP_PRIORITY_SKILLS: readonly ["omk-context-broker", "omk-repo-explorer", "omk-industrial-control-loop", "omk-plan-first", "omk-quality-gate", "omk-test-debug-loop", "omk-code-review", "omk-security-review", "omk-secret-guard", "omk-typescript-strict", "omk-python-typing", "omk-worktree-team"];
+export declare const OMK_CORE_VERIFIED_PRESET: OmkCoreVerifiedPreset;
+export declare const OMK_TS_PRODUCT_PRESET: OmkTsProductPreset;
+export declare const OMK_WORKTREE_TEAM_PRESET: OmkWorktreeTeamPreset;
+export declare const OMK_RELEASE_GUARD_PRESET: OmkReleaseGuardPreset;
+export declare const OMK_PARALLEL_ORCHESTRATOR_PRESET: OmkParallelOrchestratorPreset;
+export declare const OMK_RUNTIME_PRESETS: readonly OmkRuntimePreset[];
+export declare function isParallelOrchestratorIntent(intent: string, text: string): boolean;
+export declare function isCoreVerifiedIntent(intent: string): boolean;
+export declare function isTsProductIntent(intent: string, text: string): boolean;
+export declare function isWorktreeTeamIntent(intent: string, text: string): boolean;
+export declare function isReleaseGuardIntent(intent: string, text: string): boolean;
+export {};

package/dist/runtime/core-verified-preset.js

@@ -0,0 +1,205 @@
+export const OMK_TOP_PRIORITY_SKILLS = [
+    "omk-context-broker",
+    "omk-repo-explorer",
+    "omk-industrial-control-loop",
+    "omk-plan-first",
+    "omk-quality-gate",
+    "omk-test-debug-loop",
+    "omk-code-review",
+    "omk-security-review",
+    "omk-secret-guard",
+    "omk-typescript-strict",
+    "omk-python-typing",
+    "omk-worktree-team",
+];
+export const OMK_CORE_VERIFIED_PRESET = {
+    id: "omk-core-verified",
+    name: "OMK Core Verified",
+    description: "Default safe execution loop for general coding, refactor, and debugging work.",
+    skills: [
+        "omk-repo-explorer",
+        "omk-context-broker",
+        "omk-industrial-control-loop",
+        "omk-plan-first",
+        "omk-quality-gate",
+        "omk-test-debug-loop",
+        "omk-code-review",
+        "omk-secret-guard",
+        "omk-python-typing",
+    ],
+    hooks: [
+        "pre-shell-guard.sh",
+        "protect-secrets.sh",
+        "stop-verify.sh",
+    ],
+    mcpServers: [
+        "omk-project",
+    ],
+    purpose: "Baseline conservative orchestration loop with project-local MCP, minimal hooks, and only the core skills needed for bounded planning, repo context, verification, and secret protection.",
+};
+export const OMK_TS_PRODUCT_PRESET = {
+    id: "omk-ts-product",
+    name: "OMK TS Product",
+    description: "High-efficiency preset for TypeScript, Next.js, NestJS, React, and product UI/API work.",
+    skills: [
+        "omk-typescript-strict",
+        "matt-pocock-skills",
+        "omk-backend-api-review",
+        "omk-frontend-implementation",
+        "omk-frontend-ui-review",
+        "react-doctor",
+        "omk-design-system",
+    ],
+    hooks: ["post-format.sh", "typecheck-after-edit.sh", "eslint-after-edit.sh", "stop-verify.sh"],
+    mcpServers: ["context7", "playwright", "github", "omk-project"],
+    purpose: "Strict TypeScript product loop for React/Next UI, Nest/API boundaries, DTO/domain/persistence separation, and UI verification.",
+};
+export const OMK_WORKTREE_TEAM_PRESET = {
+    id: "omk-worktree-team",
+    name: "OMK Worktree Team",
+    description: "Parallel worker-lane preset for isolated Git worktrees and merge-before-verify workflows.",
+    skills: [
+        "omk-worktree-team",
+        "omk-task-router",
+        "omk-context-broker",
+        "omk-quality-gate",
+        "omk-git-commit-pr",
+    ],
+    hooks: ["worktree-create-guard.sh", "subagent-stop-audit.sh", "branch-diff-snapshot.sh", "stop-verify.sh"],
+    mcpServers: ["omk-project", "github", "memory", "filesystem-readonly"],
+    purpose: "Coordinate isolated parallel worker lanes with branch snapshots, subagent audit, and merge-ready quality evidence.",
+};
+export const OMK_RELEASE_GUARD_PRESET = {
+    id: "omk-release-guard",
+    name: "OMK Release Guard",
+    description: "Release and security preset for secret checks, destructive-shell guardrails, and publish evidence.",
+    skills: [
+        "omk-secret-guard",
+        "omk-security-review",
+        "omk-quality-gate",
+        "omk-docs-release",
+        "omk-git-commit-pr",
+        "omk-research-verify",
+    ],
+    hooks: [
+        "protect-secrets.sh",
+        "pre-shell-guard.sh",
+        "release-check-before-stop.sh",
+        "npm-audit-summary.sh",
+        "stop-verify.sh",
+    ],
+    mcpServers: ["github", "omk-project", "fetch", "context7"],
+    purpose: "Guard release and security work with secret scanning, destructive-shell blocks, audit summaries, checklist evidence, and narrow MCP authority because reference MCP servers are advisory examples, not production-ready trust boundaries.",
+};
+export const OMK_PARALLEL_ORCHESTRATOR_PRESET = {
+    id: "omk-parallel-orchestrator",
+    name: "OMK Parallel Orchestrator",
+    description: "Maximum parallelism preset for orchestrating multiple subagents with full MCP, skills, and hooks access.",
+    skills: [
+        "omk-repo-explorer",
+        "omk-context-broker",
+        "omk-industrial-control-loop",
+        "omk-plan-first",
+        "omk-quality-gate",
+        "omk-code-review",
+        "omk-test-debug-loop",
+        "omk-python-typing",
+        "omk-task-router",
+        "multica",
+        "agentmemory",
+    ],
+    hooks: [
+        "pre-shell-guard.sh",
+        "protect-secrets.sh",
+        "stop-verify.sh",
+        "subagent-stop-audit.sh",
+        "post-format.sh",
+    ],
+    mcpServers: [
+        "omk-project",
+        "context7",
+        "github",
+        "fetch",
+        "railway-unofficial",
+        "supabase",
+        "firecrawl",
+        "puppeteer",
+        "playwright",
+        "pdf",
+        "memory",
+        "sequential-thinking",
+        "filesystem-readonly",
+        "git",
+    ],
+    purpose: "Maximum parallelism orchestration with all available MCP servers, skills, and hooks enabled for multi-agent coordination.",
+};
+export const OMK_RUNTIME_PRESETS = [
+    OMK_CORE_VERIFIED_PRESET,
+    OMK_PARALLEL_ORCHESTRATOR_PRESET,
+    OMK_TS_PRODUCT_PRESET,
+    OMK_WORKTREE_TEAM_PRESET,
+    OMK_RELEASE_GUARD_PRESET,
+];
+const CORE_VERIFIED_INTENTS = new Set([
+    "coding",
+    "debugging",
+    "refactor",
+    "review",
+    "test-generation",
+]);
+const TS_PRODUCT_INTENTS = new Set([
+    "coding",
+    "debugging",
+    "refactor",
+    "review",
+    "test-generation",
+    "planning",
+]);
+const WORKTREE_TEAM_INTENTS = new Set([
+    "coding",
+    "debugging",
+    "refactor",
+    "review",
+    "test-generation",
+    "planning",
+]);
+const RELEASE_GUARD_INTENTS = new Set([
+    "coding",
+    "documentation",
+    "planning",
+    "review",
+    "shell-operation",
+]);
+const PARALLEL_ORCHESTRATOR_INTENTS = new Set([
+    "coding",
+    "debugging",
+    "refactor",
+    "review",
+    "test-generation",
+    "planning",
+    "orchestration",
+    "general",
+]);
+export function isParallelOrchestratorIntent(intent, text) {
+    if (!PARALLEL_ORCHESTRATOR_INTENTS.has(intent))
+        return false;
+    return /parallel|worker(?:s)?|lane(?:s)?|multi[- ]?agent|subagent|orchestrat(?:e|ion)|team|coordinate|并发|병렬|并行|エージェント|協調/i.test(text);
+}
+export function isCoreVerifiedIntent(intent) {
+    return CORE_VERIFIED_INTENTS.has(intent);
+}
+export function isTsProductIntent(intent, text) {
+    if (!TS_PRODUCT_INTENTS.has(intent))
+        return false;
+    return /typescript|\bts\b|tsx|next(?:\.js)?|nestjs?|\bnest\b|react|frontend|front-end|ui|component|accessibility|responsive|api|dto|domain|persistence|controller|service/i.test(text);
+}
+export function isWorktreeTeamIntent(intent, text) {
+    if (!WORKTREE_TEAM_INTENTS.has(intent))
+        return false;
+    return /parallel|worker(?:s)?|lane(?:s)?|worktree|multi[- ]?agent|subagent|team|branch|merge|integrat(?:e|ion)|review[- ]?merge|isolated/i.test(text);
+}
+export function isReleaseGuardIntent(intent, text) {
+    if (!RELEASE_GUARD_INTENTS.has(intent))
+        return false;
+    return /release|deploy|publish|version|changelog|tag|npm(?:\s+(?:publish|pack|audit|version))?|provenance|tarball|release[- ]?checklist|secret[- ]?leak|destructive[- ]?shell|security.*release|release.*security/i.test(text);
+}