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

package/dist/types/metrics.d.ts

@@ -0,0 +1,114 @@
+import type { BenchmarkPhaseDuration } from "./workflow-run.js";
+export type SizingLabel = "xs" | "s" | "m" | "l" | "xl";
+export declare const SIZING_LABELS: SizingLabel[];
+export type EstimateConfidence = "low" | "medium" | "high";
+export interface EstimateRecord {
+    id: string;
+    taskId: string;
+    sizingLabel: SizingLabel;
+    soloEstimateDays: number;
+    aiUnguidedEstimateDays: number;
+    confidence: EstimateConfidence;
+    declaredBy: string;
+    declaredAt: string;
+}
+export interface EstimateInput {
+    taskId: string;
+    sizingLabel: SizingLabel;
+    soloEstimateDays: number;
+    aiUnguidedEstimateDays: number;
+    confidence: EstimateConfidence;
+    declaredBy: string;
+}
+export interface BenchmarkQualitySignals {
+    reviewCount: number;
+    blockingReviews: number;
+    evidenceCount: number;
+    gateBlockCount: number;
+    lessonCount: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    estimatedCostUsd: number;
+}
+export interface BenchmarkResult {
+    taskId: string;
+    sizingLabel: SizingLabel;
+    soloEstimateDays: number;
+    aiUnguidedEstimateDays: number;
+    actualDays: number | null;
+    vsSoloPct: number | null;
+    vsAiUnguidedPct: number | null;
+    qaIterations: number;
+    phaseDurations: BenchmarkPhaseDuration[];
+    quality: BenchmarkQualitySignals;
+    status: "pending" | "complete";
+}
+export interface BenchmarkSummary {
+    stories: BenchmarkResult[];
+    totalWithActuals: number;
+    avgVsSoloPct: number | null;
+    avgVsAiUnguidedPct: number | null;
+}
+export interface VelocityWeek {
+    week: string;
+    storiesCompleted: number;
+    pointsCompleted: number;
+}
+export interface VelocityReport {
+    totalStoriesCompleted: number;
+    totalPointsCompleted: number;
+    avgActualDaysPerStory: number | null;
+    avgVsSoloPct: number | null;
+    avgVsAiUnguidedPct: number | null;
+    weeks: VelocityWeek[];
+    trend: "improving" | "stable" | "declining" | "insufficient_data";
+}
+export interface SprintRecord {
+    id: string;
+    taskIds: string[];
+    status: "active" | "closed";
+    startedAt: string;
+    closedAt: string | null;
+}
+export interface SprintVelocity {
+    sprintId: string;
+    taskIds: string[];
+    storiesCompleted: number;
+    pointsCompleted: number;
+}
+export interface SprintVelocityReport {
+    sprints: SprintVelocity[];
+    trend: "improving" | "stable" | "declining" | "insufficient_data";
+}
+export interface CalibrationRoleReport {
+    role: string;
+    stories: number;
+    avgDeclaredDays: number;
+    avgActualDays: number;
+    avgErrorPct: number;
+    bias: "over" | "under" | "balanced" | "insufficient_data";
+    lessonRecorded: boolean;
+}
+export interface CalibrationReport {
+    roles: CalibrationRoleReport[];
+}
+export interface BurndownPoint {
+    day: number;
+    remaining: number;
+    completedTaskIds?: string[];
+}
+export interface TaskEstimateBreakdown {
+    taskId: string;
+    architectPoints: number | null;
+    developerPoints: number | null;
+    resolvedPoints: number;
+    completedAt: string | null;
+}
+export interface BurndownSeries {
+    sprintTaskIds: string[];
+    totalPoints: number;
+    idealLine: BurndownPoint[];
+    actualLine: BurndownPoint[];
+    taskBreakdown: TaskEstimateBreakdown[];
+    warnings: string[];
+}

package/dist/types/metrics.js

@@ -0,0 +1,2 @@
+export const SIZING_LABELS = ["xs", "s", "m", "l", "xl"];
+//# sourceMappingURL=metrics.js.map

package/dist/types/metrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.js","sourceRoot":"","sources":["../../src/types/metrics.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,MAAM,aAAa,GAAkB,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC"}

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":""}