@jterrats/open-orchestra 0.4.2-beta.2 → 0.5.0-beta.0

package/dist/types/model-config.d.ts

@@ -0,0 +1,212 @@
+import type { RuntimeExecutionPolicy } from "./runtime.js";
+export interface ToolConfig {
+    enabled?: boolean;
+    command: string;
+    args: string[];
+    cwd: string;
+    allowedRoles: string[];
+    timeoutMs: number;
+    evidence: string;
+    risk: string;
+}
+export interface ModelProviderCapabilities {
+    streaming: boolean;
+    tools: boolean;
+    vision: boolean;
+    jsonMode: boolean;
+    maxContextTokens: number;
+    timeoutMs: number;
+}
+export interface ModelMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+}
+export interface ModelRequest {
+    messages: ModelMessage[];
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+    jsonMode?: boolean;
+    tools?: unknown[];
+    timeoutMs?: number;
+}
+export interface ModelResponse {
+    id: string;
+    provider: string;
+    model: string;
+    content: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    finishReason: "stop" | "length" | "tool_call" | "error";
+}
+export interface ModelStreamEvent {
+    type: "content" | "tool_call" | "done" | "error";
+    content?: string;
+    error?: string;
+}
+export interface ModelProviderError {
+    provider: string;
+    code: string;
+    message: string;
+    retryable: boolean;
+}
+export interface ProviderFallbackResult {
+    provider: string;
+    model: string;
+    response: ModelResponse;
+    fallbackUsed: boolean;
+    failedProviders: {
+        provider: string;
+        reason: string;
+    }[];
+}
+export interface ModelProvenanceInput {
+    task: string;
+    role: string;
+    provider: string;
+    model: string;
+    promptId: string;
+    responseId: string;
+    inputTokens: number;
+    outputTokens: number;
+    estimatedCostUsd: number;
+    finishReason: ModelResponse["finishReason"];
+}
+export interface ModelProvenanceRecord extends ModelProvenanceInput {
+    timestamp: string;
+}
+export type PhaseOutcome = {
+    kind: "done";
+    notes: string;
+} | {
+    kind: "gate_pause";
+    reviewArtifact: string;
+} | {
+    kind: "qa_fail";
+    notes: string;
+};
+export type PhaseExecutionMode = "deterministic" | "llm";
+export interface PhaseExecutorPhase {
+    phase: string;
+    role: string;
+    summary: string;
+}
+export interface PhaseStructuredOutput {
+    summary: string;
+    notes: string;
+    verdict: "pass" | "fail";
+    findings: string[];
+    decisions: string[];
+    evidence: string[];
+    handoff: string;
+    sizing?: string;
+}
+export interface PhaseLlmResult {
+    mode: PhaseExecutionMode;
+    outcome: PhaseOutcome;
+    artifact?: string;
+    output?: PhaseStructuredOutput;
+}
+export interface ModelProvider {
+    id: string;
+    capabilities: ModelProviderCapabilities;
+    complete(request: ModelRequest): Promise<ModelResponse>;
+    stream?(request: ModelRequest): AsyncIterable<ModelStreamEvent>;
+}
+export interface ConfiguredProviderSummary {
+    scope: string;
+    provider: string;
+    model: string;
+    fallbacks: string[];
+    maxTokens: number;
+    maxCostUsd: number;
+    timeoutMs: number;
+    retries: number;
+    requiredCapabilities: string[];
+}
+export interface ProviderRouting {
+    provider: string;
+    model: string;
+    fallbacks: string[];
+    maxTokens: number;
+    maxCostUsd: number;
+    timeoutMs: number;
+    retries: number;
+    requiredCapabilities: string[];
+}
+export interface WorkflowProvidersConfig {
+    defaults: ProviderRouting;
+    byRole: Record<string, ProviderRouting>;
+}
+export interface ProviderPolicyConfig {
+    allowedProviders?: string[];
+    blockedProviders?: string[];
+    allowVendorFallbackWithoutApproval?: boolean;
+}
+export interface BudgetLimit {
+    maxRequests?: number;
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+    maxTotalTokens?: number;
+    maxEstimatedCostUsd?: number;
+}
+export interface BudgetPolicy {
+    defaults?: BudgetLimit;
+    byRole: Record<string, BudgetLimit>;
+    byTask: Record<string, BudgetLimit>;
+}
+export type TelemetryLevel = "off" | "metadata" | "prompt-summary" | "prompt-sample" | "eval-dataset";
+export interface TelemetryConsentState {
+    enabled: boolean;
+    level: TelemetryLevel;
+    policyVersion: string;
+    actor: string;
+    updatedAt?: string;
+}
+export interface GitHubConfig {
+    autoCreatePr?: boolean;
+    baseBranch?: string;
+}
+export interface NotificationChannelResult {
+    channel: "slack" | "github";
+    status: "sent" | "skipped" | "failed";
+    detail: string;
+}
+export interface SlackNotificationConfig {
+    webhookUrl?: string;
+    webhookUrlEnv?: string;
+}
+export interface GitHubNotificationConfig {
+    issueComment?: boolean;
+}
+export interface NotificationsConfig {
+    slack?: SlackNotificationConfig;
+    github?: GitHubNotificationConfig;
+}
+export interface WorkflowConfig {
+    version: number;
+    providers: WorkflowProvidersConfig;
+    budgets?: BudgetPolicy;
+    workflow?: {
+        phaseSequence?: string[];
+        phaseTimeoutMinutes?: number;
+    };
+    tools: Record<string, ToolConfig>;
+    telemetry?: TelemetryConsentState;
+    github?: GitHubConfig;
+    notifications?: NotificationsConfig;
+    providerPolicy?: ProviderPolicyConfig;
+    runtimePolicy?: RuntimeExecutionPolicy;
+    staticAnalysis: {
+        preCommit: {
+            required: boolean;
+            checks: string[];
+            disallowNoVerifyWithoutApproval: boolean;
+        };
+        ci: {
+            checks: string[];
+        };
+    };
+}

package/dist/types/model-config.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=model-config.js.map

package/dist/types/model-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-config.js","sourceRoot":"","sources":["../../src/types/model-config.ts"],"names":[],"mappings":""}

package/dist/types/runtime.d.ts

@@ -0,0 +1,93 @@
+import type { ContextBudgetMetadata } from "./context.js";
+import type { SkillRenderTarget } from "./skills.js";
+export type RuntimeAdapterKind = "llm" | "ide" | "cli";
+export type RuntimeExecutionId = "claude-cli" | "codex-cli" | "cursor-cli" | "vscode-agent" | "windsurf-agent" | "generic-runtime";
+export type RuntimeDelegationMode = "runtime-native" | "brief-only";
+export interface RuntimeAdapter {
+    target: SkillRenderTarget;
+    label: string;
+    kind: RuntimeAdapterKind;
+    defaultInstructionFiles: string[];
+    supportsStructuredPayload: boolean;
+    supportsManagedBlocks: boolean;
+    supportsImports: boolean;
+    guidance: string;
+}
+export interface RuntimeExecutionCapabilities {
+    nonInteractive: boolean;
+    promptInjection: boolean;
+    structuredOutput: boolean;
+    fileEdits: boolean;
+    testExecution: boolean;
+    evidenceReturn: boolean;
+    requiresTty: boolean;
+    requiresUserApproval: boolean;
+    resumeSession: boolean;
+}
+export interface RuntimeSubagentCapabilities {
+    runtimeNative: boolean;
+    parallel: boolean;
+    namedRoles: boolean;
+    forkedContext: boolean;
+    structuredHandoff: boolean;
+    fileOwnership: boolean;
+    requiresParentApproval: boolean;
+}
+export interface RuntimeExecutionAdapter {
+    id: RuntimeExecutionId;
+    target: SkillRenderTarget;
+    label: string;
+    kind: RuntimeAdapterKind;
+    summary: string;
+    execution: RuntimeExecutionCapabilities;
+    subagents: RuntimeSubagentCapabilities;
+    briefOnlyFallback: boolean;
+    directProviderApiAllowed: false;
+    guidance: string;
+}
+export interface RuntimeExecutorConfig {
+    executor?: RuntimeExecutionId;
+}
+export interface RuntimeDelegationPolicy {
+    mode: RuntimeDelegationMode;
+    allowDirectProviderApi: boolean;
+}
+export interface RuntimeExecutionPolicy {
+    defaults?: RuntimeExecutorConfig;
+    byRole: Record<string, RuntimeExecutorConfig>;
+    byTask: Record<string, RuntimeExecutorConfig>;
+    delegation: RuntimeDelegationPolicy;
+}
+export interface RuntimeSelection {
+    taskId: string;
+    role: string;
+    runtime: RuntimeExecutionAdapter;
+    source: "explicit" | "task" | "role" | "default" | "fallback";
+    directProviderApiAllowed: false;
+}
+export interface RuntimeDelegationAssignment {
+    role: string;
+    paths: string[];
+    allowedCommands: string[];
+    expectedArtifacts: string[];
+}
+export interface RuntimeBrief {
+    taskId: string;
+    runtime: RuntimeExecutionId;
+    artifact: string;
+    content: string;
+    mode: "brief-only";
+    directProviderApiAllowed: false;
+    contextBudget: ContextBudgetMetadata;
+}
+export interface RuntimeDelegationPacket {
+    taskId: string;
+    runtime: RuntimeExecutionId;
+    artifact: string;
+    content: string;
+    mode: RuntimeDelegationMode;
+    directProviderApiAllowed: false;
+    assignments: RuntimeDelegationAssignment[];
+    requiresApproval: boolean;
+    contextBudget: ContextBudgetMetadata;
+}

package/dist/types/runtime.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=runtime.js.map

package/dist/types/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../src/types/runtime.ts"],"names":[],"mappings":""}

package/dist/types/skills.d.ts

@@ -0,0 +1,147 @@
+import type { EvidenceType } from "./tasks.js";
+import type { ContextBudgetMetadata } from "./context.js";
+export type SkillLoadBudget = "small" | "normal" | "large";
+export type SkillRenderTarget = "generic" | "claude" | "cursor" | "codex" | "vscode" | "windsurf";
+export interface Skill {
+    id: string;
+    name: string;
+    summary: string;
+    triggers: string[];
+    roles: string[];
+    capabilities: string[];
+    riskAreas: string[];
+    sourceGroups: string[];
+    entry: string;
+    assets: string[];
+    evidence: EvidenceType[];
+    loadBudget: SkillLoadBudget;
+    instructions: string[];
+}
+export interface SkillPlanItem {
+    skill: Skill;
+    score: number;
+    rationale: string[];
+}
+export interface SkillPlan {
+    taskId: string;
+    selected: SkillPlanItem[];
+    skipped: SkillPlanItem[];
+    sourceGroups: string[];
+}
+export interface SkillValidationReport {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export interface CollaborationFlowStep {
+    from: string;
+    to: string;
+    purpose: string;
+    requiredContext: string[];
+    requiredArtifacts: string[];
+    exitCriteria: string[];
+}
+export interface CollaborationFlow {
+    id: string;
+    name: string;
+    summary: string;
+    triggers: string[];
+    roles: string[];
+    riskAreas: string[];
+    requiredContext: string[];
+    requiredArtifacts: string[];
+    exitCriteria: string[];
+    optionalReviewers: string[];
+    steps: CollaborationFlowStep[];
+}
+export interface CollaborationFlowRecommendation {
+    flow: CollaborationFlow;
+    score: number;
+    rationale: string[];
+    missingArtifacts: string[];
+    requiredHandoffFields: string[];
+    optionalReviewers: string[];
+}
+export interface WorkflowTemplate {
+    id: string;
+    name: string;
+    summary: string;
+    triggers: string[];
+    roles: string[];
+    riskAreas: string[];
+    inputs: string[];
+    outputs: string[];
+    evidenceRequirements: EvidenceType[];
+    gates: string[];
+    compatibleSkills: string[];
+    steps: string[];
+}
+export interface WorkflowTemplateSelection {
+    template: WorkflowTemplate;
+    score: number;
+    rationale: string[];
+    missingEvidence: EvidenceType[];
+}
+export interface RenderedWorkflowTemplate {
+    target: SkillRenderTarget;
+    taskId?: string;
+    selected: WorkflowTemplateSelection[];
+    content: string;
+    contextBudget?: ContextBudgetMetadata;
+}
+export interface AgentLessonInput {
+    taskId?: string;
+    actor: string;
+    operation: string;
+    failedAction: string;
+    errorSignature: string;
+    rootCause: string;
+    fix: string;
+    prevention: string;
+    appliesTo: string[];
+    verifiedBy: string[];
+}
+export interface AgentLesson extends AgentLessonInput {
+    id: string;
+    timestamp: string;
+}
+export type MemoryHookPoint = "before_plan" | "before_implementation" | "before_handoff" | "before_final" | "after_failure";
+export interface MemoryLessonSnippet {
+    type: "lesson";
+    score: number;
+    operation: string;
+    errorSignature: string;
+    fix: string;
+    prevention: string;
+    appliesTo: string[];
+    taskId?: string;
+    timestamp: string;
+}
+export interface MemoryPromptSnippet {
+    type: "prompt";
+    score: number;
+    file: string;
+    artifact: string;
+    summary: string;
+}
+export interface MemorySectionReport {
+    section: "lessons" | "prompts";
+    includedCount: number;
+    omittedCount: number;
+    reason: string;
+}
+export interface MemoryPacket {
+    taskId?: string;
+    role?: string;
+    hook: MemoryHookPoint;
+    queryTerms: string[];
+    tokenBudget: number;
+    estimatedTokens: number;
+    lessons: MemoryLessonSnippet[];
+    prompts: MemoryPromptSnippet[];
+    sections: MemorySectionReport[];
+    redaction: {
+        applied: boolean;
+        patterns: string[];
+    };
+}

package/dist/types/skills.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=skills.js.map

package/dist/types/skills.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.js","sourceRoot":"","sources":["../../src/types/skills.ts"],"names":[],"mappings":""}

package/dist/types/tasks.d.ts

@@ -0,0 +1,171 @@
+export type TaskStatus = "pending" | "ready" | "in_progress" | "blocked" | "review" | "approved" | "rejected" | "done" | "canceled" | "archived";
+export type ReviewResult = "approve" | "block" | "changes";
+export type Severity = "info" | "low" | "medium" | "high" | "critical";
+export type EvidenceType = "command" | "file" | "screenshot" | "trace" | "video" | "log" | "report";
+export interface MechanicalOverride {
+    rationale: string;
+}
+export interface ArchitectureApproval {
+    proposal?: string;
+    userApproved?: boolean;
+    approvedBy?: string;
+    approvedAt?: string;
+}
+export interface QaGateMetadata {
+    plan?: string;
+    executionStatus?: "not_run" | "passed" | "failed" | "deferred";
+    deferredRationale?: string;
+    deferredOwner?: string;
+}
+export type RiskImpactArea = "security" | "sre" | "dba" | "data" | "devops" | "compliance" | "accessibility" | "ux";
+export interface RiskAcceptance {
+    acceptedBy?: string;
+    rationale?: string;
+}
+export interface RiskGateMetadata {
+    impactAreas?: RiskImpactArea[];
+    acceptance?: RiskAcceptance;
+}
+export interface Task {
+    id: string;
+    title: string;
+    ownerRole: string;
+    status: TaskStatus;
+    dependencies: string[];
+    backlogItem?: string;
+    goal?: string;
+    scope?: string;
+    acceptanceCriteria?: string[];
+    definitionOfReady?: string[];
+    definitionOfDone?: string[];
+    assumptions?: string[];
+    risks?: string[];
+    paths?: string[];
+    testStrategy?: string;
+    blockedReason?: string;
+    mechanicalOverride?: MechanicalOverride;
+    architectureApproval?: ArchitectureApproval;
+    qaGate?: QaGateMetadata;
+    riskGate?: RiskGateMetadata;
+    externalRefs?: ExternalTaskReferences;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface ExternalTaskReferences {
+    setupAgents?: SetupAgentsTaskReference;
+}
+export interface SetupAgentsTaskReference {
+    sourceId: string;
+    sourcePath?: string;
+    profileId?: string;
+    mode?: string;
+    contractVersion?: string;
+    acceptanceStatus?: string;
+    acceptedBy?: string;
+    evidenceIds?: string[];
+    handoffIds?: string[];
+}
+export interface LockEntry {
+    id: string;
+    taskId: string;
+    ownerRole: string;
+    path: string;
+    reason: string;
+    createdAt: string;
+    expiresAt?: string;
+}
+export interface EventEntry {
+    id: string;
+    type: string;
+    timestamp: string;
+    actor: string;
+    summary: string;
+    taskId: string | null;
+    artifacts?: string[];
+    metadata: Record<string, unknown>;
+}
+export interface EventInput {
+    type: string;
+    actor: string;
+    summary: string;
+    taskId?: string;
+    artifacts?: string[];
+    metadata?: Record<string, unknown>;
+}
+export type AddTaskInput = Pick<Task, "id" | "title" | "ownerRole" | "dependencies" | "backlogItem" | "goal" | "scope" | "acceptanceCriteria" | "definitionOfReady" | "definitionOfDone" | "assumptions" | "risks" | "paths" | "testStrategy" | "architectureApproval" | "qaGate" | "riskGate" | "externalRefs">;
+export interface UpdateTaskInput {
+    id: string;
+    title?: string;
+    ownerRole?: string;
+    goal?: string;
+    scope?: string;
+    paths?: string[];
+    acceptanceCriteria?: string[];
+    assumptions?: string[];
+    risks?: string[];
+    testStrategy?: string;
+    status?: TaskStatus;
+    blockedReason?: string;
+}
+export interface ClaimLockInput {
+    id?: string;
+    taskId: string;
+    ownerRole: string;
+    path: string;
+    reason: string;
+    expiresAt?: string;
+}
+export interface HandoffInput {
+    task: string;
+    from: string;
+    to: string;
+    changed: string;
+    behavior: string;
+    tests: string;
+    commands: string;
+    status?: string;
+    gaps?: string;
+    risks?: string;
+    playwright?: string;
+    updateOwner?: boolean;
+}
+export interface ReviewInput {
+    task: string;
+    role: string;
+    result: string;
+    severity: string;
+    findings: string;
+    recommendation: string;
+}
+export interface EvidenceInput {
+    task: string;
+    role: string;
+    type: string;
+    summary: string;
+    path?: string | boolean | string[];
+    command?: string | boolean | string[];
+    exitCode?: string | boolean | string[];
+}
+export interface PlaywrightEvidenceInput {
+    task: string;
+    kind: "screenshot" | "trace" | "video" | "report";
+    path: string;
+    summary: string;
+    runId?: string;
+}
+export interface ArtifactResult {
+    artifact: string;
+    content: string;
+}
+export interface DecisionInput {
+    task: string;
+    title: string;
+    context: string;
+    decision: string;
+    consequences: string;
+    status: "proposed" | "accepted" | "superseded";
+    owner: string;
+}
+export interface DecisionRecord extends DecisionInput {
+    artifact: string;
+}

package/dist/types/tasks.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tasks.js.map

package/dist/types/tasks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks.js","sourceRoot":"","sources":["../../src/types/tasks.ts"],"names":[],"mappings":""}