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

package/dist/workflow-services.js

@@ -1,27 +1,30 @@
 import { randomUUID } from "node:crypto";
 import path from "node:path";
-import { readdir, readFile } from "node:fs/promises";
 import { FILES } from "./constants.js";
-import { exists, ensureDir, readJson, resolveWorkflowPath, updateJsonFile, writeJson, } from "./fs-utils.js";
+import { removeUndefined } from "./command-utils.js";
+import { ensureDir, readJson, resolveWorkflowPath, updateJsonFile, writeJson, } from "./fs-utils.js";
 import { assertProviderAllowed, assertVendorFallbackAllowed, createModelProvider, FakeModelProvider, InMemoryModelProviderRegistry, summarizeConfiguredProviders, } from "./model-providers.js";
 import { appendEvent, loadWorkspace, readEvents, writeArtifact, } from "./workspace.js";
-import { normalizeEvidenceType, normalizeReviewRole, validateEvidenceInput, validateReadiness, validateReviewInput, } from "./validation.js";
+import { validateReadiness } from "./validation.js";
 import { getWorkflowGate } from "./workflow-gates.js";
-import { analyzePullRequestReview } from "./pr-review.js";
 import { planSkillsForTask } from "./skills.js";
 import { getTelemetryConsent } from "./telemetry.js";
 import { latestDelegationDecision } from "./delegation-decision.js";
 import { listAutonomousRuns } from "./autonomous-workflow.js";
-import { persistRun, readAutonomousRun } from "./autonomous-run-store.js";
-import { AUTONOMOUS_PHASE_SEQUENCE } from "./autonomous-workflow-constants.js";
 import { readEstimate } from "./benchmark.js";
-import { notifyWorkflowLifecycle, } from "./notifications.js";
 import { handoffFlowRequirements, recommendCollaborationFlow, } from "./collaboration-flows.js";
 import { queryMemory, recordMemoryEvent } from "./memory.js";
+import { applyContextBudget, DEFAULT_CONTEXT_TOKEN_BUDGET, } from "./context-budget.js";
 import { selectWorkflowTemplates } from "./workflow-templates.js";
+import { findStoredApprovalForProposal } from "./workflow-approval-service.js";
+import { aggregateUsage, aggregateUsageBy, budgetEstimateWarningsForBudgets, budgetViolations, emptyUsageBreakdown, projectUsageCost, } from "./workflow-budget-utils.js";
 import { SIZING_LABELS } from "./types.js";
+export { addEvidence, addPlaywrightEvidence, listEvidence, listReviews, recordReview, } from "./workflow-evidence-service.js";
+export { generatePlaywrightTestPlan, generatePullRequestSummary, getWorkflowSummary, } from "./workflow-summary-service.js";
+export { approveApproval, approveWorkflowGate, listApprovals, rejectApproval, showApproval, } from "./workflow-approval-service.js";
 export async function getWorkflowStatus(root = process.cwd()) {
     const workspace = await loadWorkspace(root);
+    const config = await readJson(resolveWorkflowPath(root, FILES.config), {});
     const counts = Object.create(null);
     const blocked = [];
     for (const task of workspace.tasks) {
@@ -35,6 +38,7 @@ export async function getWorkflowStatus(root = process.cwd()) {
         }
     }
     return {
+        ...(config.mode ? { mode: config.mode } : {}),
         tasks: {
             total: workspace.tasks.length,
             byStatus: counts,
@@ -487,17 +491,7 @@ export async function checkReadiness(taskId, root = process.cwd()) {
     return { task, report };
 }
 export async function evaluateWorkflowGate(gateId, taskId, root = process.cwd()) {
-    const workspace = await loadWorkspace(root);
-    const task = workspace.tasks.find((candidate) => candidate.id === taskId);
-    if (!task) {
-        throw new Error(`unknown task: ${taskId}`);
-    }
-    const gate = getWorkflowGate(gateId);
-    const result = gate.evaluate({
-        task,
-        events: await readEvents(root),
-        locks: workspace.locks,
-    });
+    const result = await previewWorkflowGate(gateId, taskId, root);
     await appendEvent(root, {
         type: result.passed ? "GATE_PASSED" : "GATE_BLOCKED",
         taskId,
@@ -512,6 +506,20 @@ export async function evaluateWorkflowGate(gateId, taskId, root = process.cwd())
     });
     return result;
 }
+export async function previewWorkflowGate(gateId, taskId, root = process.cwd()) {
+    const workspace = await loadWorkspace(root);
+    const task = workspace.tasks.find((candidate) => candidate.id === taskId);
+    if (!task) {
+        throw new Error(`unknown task: ${taskId}`);
+    }
+    const gate = getWorkflowGate(gateId);
+    const result = gate.evaluate({
+        task,
+        events: await readEvents(root),
+        locks: workspace.locks,
+    });
+    return result;
+}
 export async function createHandoff(input, root = process.cwd()) {
     const workspace = await loadWorkspace(root);
     if (!workspace.roleIds.has(input.from) || !workspace.roleIds.has(input.to)) {
@@ -611,7 +619,7 @@ export async function recordDecision(input, root = process.cwd()) {
 export async function listDecisions(taskId, root = process.cwd()) {
     return filterEvents("DECISION_RECORDED", taskId, root);
 }
-export async function getTaskContext(taskId, root = process.cwd()) {
+export async function getTaskContext(taskId, root = process.cwd(), options = {}) {
     const workspace = await loadWorkspace(root);
     const task = workspace.tasks.find((candidate) => candidate.id === taskId);
     if (!task) {
@@ -622,10 +630,11 @@ export async function getTaskContext(taskId, root = process.cwd()) {
     const memory = await queryMemory({
         taskId,
         hook: "before_implementation",
+        role: task.ownerRole,
         root,
     });
     await recordMemoryEvent(root, memory, "MEMORY_QUERIED");
-    return removeUndefined({
+    const context = removeUndefined({
         task,
         dependencies: await checkTaskDependencies(taskId, root),
         locks: workspace.locks.filter((lock) => lock.taskId === taskId),
@@ -643,6 +652,7 @@ export async function getTaskContext(taskId, root = process.cwd()) {
         collaborationFlow: recommendCollaborationFlow(task, taskEvents),
         workflowTemplates: selectWorkflowTemplates(task, taskEvents),
     });
+    return applyContextBudget(context, options.tokenBudget ?? DEFAULT_CONTEXT_TOKEN_BUDGET);
 }
 export async function generateExecutionPlan(taskId, root = process.cwd()) {
     const context = await getTaskContext(taskId, root);
@@ -955,128 +965,6 @@ function pathsConflict(taskPath, lockPath) {
 function normalizePath(value) {
     return value.replaceAll("\\", "/").replace(/\/+$/, "");
 }
-export async function listApprovals(taskId, root = process.cwd()) {
-    const approvalDir = resolveWorkflowPath(root, "approvals");
-    const fileNames = (await exists(approvalDir))
-        ? (await readdir(approvalDir)).filter((fileName) => fileName.endsWith(".md"))
-        : [];
-    const events = await readEvents(root);
-    const records = fileNames.map((fileName) => approvalRecordForArtifact(path.join(".agent-workflow", "approvals", fileName), events));
-    records.push(...gateApprovalRecords(events));
-    const filtered = taskId
-        ? records.filter((record) => record.taskId === taskId)
-        : records;
-    return filtered.sort((left, right) => left.id.localeCompare(right.id));
-}
-export async function approveWorkflowGate(input, root = process.cwd()) {
-    const run = await readAutonomousRun(root, input.runId);
-    if (!run) {
-        throw new Error(`workflow run not found: ${input.runId}`);
-    }
-    const phaseIndex = run.phases.findLastIndex((phase) => phase.status === "gate_paused");
-    if (phaseIndex < 0) {
-        throw new Error(`workflow run ${input.runId} has no paused gate`);
-    }
-    const phase = run.phases[phaseIndex];
-    const gateId = phase.gateId ?? gateIdForPhase(run, phaseIndex);
-    if (input.gateId !== gateId) {
-        throw new Error(`wrong gate id: ${input.gateId}. Expected gate: ${gateId}`);
-    }
-    if (phase.approvedBy && phase.approvedAt) {
-        return {
-            run,
-            gateId,
-            approver: phase.approvedBy,
-            approvedAt: phase.approvedAt,
-            alreadyApproved: true,
-        };
-    }
-    const approvedAt = new Date().toISOString();
-    const approvedPhase = {
-        ...phase,
-        gateId,
-        approvedBy: input.approver,
-        approvedAt,
-        approvalRationale: input.rationale,
-    };
-    const updatedRun = {
-        ...run,
-        phases: run.phases.map((candidate, index) => index === phaseIndex ? approvedPhase : candidate),
-        updatedAt: approvedAt,
-    };
-    await persistRun(root, updatedRun);
-    await appendEvent(root, removeUndefined({
-        type: "GATE_APPROVED",
-        taskId: run.taskId,
-        actor: "parent",
-        summary: `Gate approved: ${gateId}`,
-        artifacts: phase.reviewArtifact ? [phase.reviewArtifact] : undefined,
-        metadata: {
-            runId: run.id,
-            gateId,
-            approver: input.approver,
-            rationale: input.rationale,
-            approvedAt,
-        },
-    }));
-    return {
-        run: updatedRun,
-        gateId,
-        approver: input.approver,
-        approvedAt,
-        alreadyApproved: false,
-    };
-}
-export async function showApproval(id, root = process.cwd()) {
-    const record = await getApprovalRecord(id, root);
-    const content = await readFile(path.join(root, record.artifact), "utf8");
-    return { ...record, content };
-}
-export async function approveApproval(input, root = process.cwd()) {
-    return recordApprovalDecision(input, "approved", root);
-}
-export async function rejectApproval(input, root = process.cwd()) {
-    return recordApprovalDecision(input, "rejected", root);
-}
-export async function recordReview(input, root = process.cwd(), notificationTransports = {}) {
-    const workspace = await loadWorkspace(root);
-    const reviewInput = removeUndefined({
-        ...input,
-        role: normalizeReviewRole(input.role, workspace.roleIds) ?? input.role,
-    });
-    validateReviewInput(reviewInput, workspace.roleIds);
-    const fileName = `${reviewInput.task}-${reviewInput.role}-review.md`;
-    const content = [
-        `# Review ${reviewInput.task}: ${reviewInput.role}`,
-        "",
-        `- Result: ${reviewInput.result}`,
-        `- Severity: ${reviewInput.severity}`,
-        `- Findings: ${reviewInput.findings}`,
-        `- Recommendation: ${reviewInput.recommendation}`,
-        "",
-    ].join("\n");
-    const artifact = await writeArtifact(root, "reviews", fileName, content);
-    await appendEvent(root, {
-        type: "REVIEW_RECORDED",
-        taskId: reviewInput.task,
-        actor: reviewInput.role,
-        summary: `Review recorded: ${reviewInput.result}`,
-        artifacts: [artifact],
-        metadata: { result: reviewInput.result, severity: reviewInput.severity },
-    });
-    if (reviewInput.result === "block" && reviewInput.severity === "critical") {
-        await notifyWorkflowLifecycle({
-            root,
-            taskId: reviewInput.task,
-            kind: "critical_blocking_review",
-            actor: reviewInput.role,
-            detail: reviewInput.findings,
-            artifact,
-            idempotencyKey: `critical_blocking_review:${reviewInput.task}:${artifact}`,
-        }, notificationTransports);
-    }
-    return { artifact, content };
-}
 function riskReviewSteps(impactAreas) {
     const roleByImpact = {
         security: "security",
@@ -1145,117 +1033,6 @@ async function writeTaskGraphBatchArtifact(root, batch) {
         "",
     ].join("\n"));
 }
-export async function listReviews(taskId, root = process.cwd()) {
-    return filterEvents("REVIEW_RECORDED", taskId, root);
-}
-export async function addEvidence(input, root = process.cwd()) {
-    const evidenceInput = removeUndefined({
-        ...input,
-        type: normalizeEvidenceType(input.type) ?? input.type,
-    });
-    const workspace = await loadWorkspace(root);
-    validateEvidenceInput(evidenceInput, workspace.roleIds);
-    if (typeof evidenceInput.path === "string" &&
-        !(await exists(path.resolve(root, evidenceInput.path)))) {
-        throw new Error(`evidence path does not exist: ${evidenceInput.path}`);
-    }
-    const fileName = `${evidenceInput.task}-${Date.now()}-${randomUUID()}-${evidenceInput.type}.md`;
-    const content = [
-        `# Evidence ${evidenceInput.task}: ${evidenceInput.type}`,
-        "",
-        `- Role: ${evidenceInput.role}`,
-        `- Summary: ${evidenceInput.summary}`,
-        `- Path: ${evidenceInput.path ?? "not applicable"}`,
-        `- Command: ${evidenceInput.command ?? "not applicable"}`,
-        `- Exit code: ${evidenceInput.exitCode ?? "not applicable"}`,
-        "",
-    ].join("\n");
-    const artifact = await writeArtifact(root, "evidence", fileName, content);
-    await appendEvent(root, {
-        type: "EVIDENCE_ADDED",
-        taskId: evidenceInput.task,
-        actor: evidenceInput.role,
-        summary: evidenceInput.summary,
-        artifacts: [artifact],
-        metadata: { type: evidenceInput.type },
-    });
-    return { artifact, content };
-}
-export async function listEvidence(taskId, root = process.cwd()) {
-    return filterEvents("EVIDENCE_ADDED", taskId, root);
-}
-export async function getWorkflowSummary(root = process.cwd()) {
-    const workspace = await loadWorkspace(root);
-    const events = await readEvents(root);
-    return {
-        tasks: workspace.tasks,
-        locks: workspace.locks,
-        reviews: events.filter((event) => event.type === "REVIEW_RECORDED"),
-        evidence: events.filter((event) => event.type === "EVIDENCE_ADDED"),
-        blockers: workspace.tasks.filter((task) => task.status === "blocked"),
-        eventCount: events.length,
-    };
-}
-export async function generatePullRequestSummary(taskId, root = process.cwd()) {
-    const workspace = await loadWorkspace(root);
-    const task = workspace.tasks.find((candidate) => candidate.id === taskId);
-    if (!task) {
-        throw new Error(`unknown task: ${taskId}`);
-    }
-    const events = await readEvents(root);
-    const taskEvents = events.filter((event) => event.taskId === taskId);
-    const handoffs = taskEvents.filter((event) => event.type === "HANDOFF_READY");
-    const reviews = taskEvents.filter((event) => event.type === "REVIEW_RECORDED");
-    const evidence = taskEvents.filter((event) => event.type === "EVIDENCE_ADDED");
-    const gates = taskEvents.filter((event) => event.type === "GATE_PASSED" || event.type === "GATE_BLOCKED");
-    const locks = workspace.locks.filter((lock) => lock.taskId === taskId);
-    return {
-        task,
-        handoffs,
-        reviews,
-        evidence,
-        gates,
-        locks,
-        risks: task.risks ?? [],
-        rollout: "Use the project release process after required gates pass.",
-        rollback: "Revert the related commit or disable the changed behavior.",
-        review: analyzePullRequestReview({ task, reviews, evidence, gates, locks }),
-    };
-}
-export async function generatePlaywrightTestPlan(taskId, root = process.cwd()) {
-    const workspace = await loadWorkspace(root);
-    const task = workspace.tasks.find((candidate) => candidate.id === taskId);
-    if (!task) {
-        throw new Error(`unknown task: ${taskId}`);
-    }
-    const criteria = task.acceptanceCriteria && task.acceptanceCriteria.length > 0
-        ? task.acceptanceCriteria
-        : [task.goal ?? task.title];
-    return {
-        taskId: task.id,
-        title: task.title,
-        targetUser: "end user",
-        scenarios: criteria.map((criterion, index) => ({
-            name: `Scenario ${index + 1}: ${criterion}`,
-            source: criterion,
-            pageObject: `${toPascalCase(task.id)}Page`,
-            selectors: [
-                "Use role, label, and test-id selectors before CSS selectors",
-                "Keep selectors in page object methods",
-            ],
-            assertions: [
-                `Verify user-visible outcome: ${criterion}`,
-                "Verify no blocking error state is shown",
-            ],
-            evidence: ["screenshot", "trace-on-failure"],
-        })),
-        fixtures: ["authenticated user when the flow requires identity"],
-        notes: [
-            "Prefer mobile-first viewport coverage before desktop expansion",
-            "Attach trace, screenshot, or video when failures occur",
-        ],
-    };
-}
 export async function getWorkflowConfig(root = process.cwd()) {
     return readJson(resolveWorkflowPath(root, FILES.config), {});
 }
@@ -1489,224 +1266,6 @@ async function createBudgetFallbackProposal(taskId, budget, root) {
         artifact,
     };
 }
-async function getApprovalRecord(id, root) {
-    const artifact = approvalArtifactForId(id);
-    if (!(await exists(path.join(root, artifact)))) {
-        throw new Error(`unknown approval: ${id}`);
-    }
-    const events = await readEvents(root);
-    return approvalRecordForArtifact(artifact, events);
-}
-async function findStoredApprovalForProposal(proposal, root) {
-    if (!proposal.artifact) {
-        return undefined;
-    }
-    const events = await readEvents(root);
-    return approvalRecordForArtifact(proposal.artifact, events);
-}
-async function recordApprovalDecision(input, status, root) {
-    const current = await getApprovalRecord(input.id, root);
-    const requested = approvalEventsForArtifact(await readEvents(root), current.artifact).find((event) => event.type === "BUDGET_ESCALATION_REQUESTED");
-    await appendEvent(root, removeUndefined({
-        type: status === "approved"
-            ? "BUDGET_ESCALATION_APPROVED"
-            : "BUDGET_ESCALATION_REJECTED",
-        taskId: current.taskId,
-        actor: "parent",
-        summary: `Budget escalation ${status}: ${input.id}`,
-        artifacts: [current.artifact],
-        metadata: {
-            approvalId: input.id,
-            proposal: requested?.metadata.proposal,
-            approver: input.approver,
-            rationale: input.rationale,
-        },
-    }));
-    return getApprovalRecord(input.id, root);
-}
-function approvalRecordForArtifact(artifact, events) {
-    const id = approvalIdForArtifact(artifact);
-    const related = approvalEventsForArtifact(events, artifact);
-    const requested = related.find((event) => event.type === "BUDGET_ESCALATION_REQUESTED");
-    const decision = [...related]
-        .reverse()
-        .find((event) => ["BUDGET_ESCALATION_APPROVED", "BUDGET_ESCALATION_REJECTED"].includes(event.type));
-    const status = decisionStatus(decision);
-    return removeUndefined({
-        id,
-        taskId: String(requested?.taskId ?? decision?.taskId ?? "") || undefined,
-        artifact,
-        status,
-        summary: requested?.summary ?? `Approval proposal ${id}`,
-        requestedAt: requested?.timestamp,
-        decidedAt: decision?.timestamp,
-        approver: typeof decision?.metadata.approver === "string"
-            ? decision.metadata.approver
-            : undefined,
-        rationale: typeof decision?.metadata.rationale === "string"
-            ? decision.metadata.rationale
-            : undefined,
-    });
-}
-function gateApprovalRecords(events) {
-    return events
-        .filter((event) => event.type === "GATE_APPROVED")
-        .map((event) => {
-        const runId = typeof event.metadata.runId === "string" ? event.metadata.runId : "run";
-        const gateId = typeof event.metadata.gateId === "string"
-            ? event.metadata.gateId
-            : "gate";
-        return removeUndefined({
-            id: `gate-${runId}-${gateId}`.replace(/[^a-zA-Z0-9._-]/g, "-"),
-            taskId: event.taskId ?? undefined,
-            artifact: event.artifacts?.[0] ?? "events.jsonl",
-            status: "approved",
-            summary: event.summary,
-            requestedAt: event.timestamp,
-            decidedAt: typeof event.metadata.approvedAt === "string"
-                ? event.metadata.approvedAt
-                : event.timestamp,
-            approver: typeof event.metadata.approver === "string"
-                ? event.metadata.approver
-                : undefined,
-            rationale: typeof event.metadata.rationale === "string"
-                ? event.metadata.rationale
-                : undefined,
-        });
-    });
-}
-function gateIdForPhase(run, phaseIndex) {
-    const phase = run.phases[phaseIndex]?.phase;
-    const sequenceIndex = AUTONOMOUS_PHASE_SEQUENCE.findIndex((candidate) => candidate.phase === phase);
-    const next = AUTONOMOUS_PHASE_SEQUENCE[sequenceIndex + 1]?.phase ?? "end";
-    return `${phase}->${next}`;
-}
-function approvalEventsForArtifact(events, artifact) {
-    return events.filter((event) => event.artifacts?.includes(artifact));
-}
-function decisionStatus(decision) {
-    if (decision?.type === "BUDGET_ESCALATION_APPROVED") {
-        return "approved";
-    }
-    if (decision?.type === "BUDGET_ESCALATION_REJECTED") {
-        return "rejected";
-    }
-    return "pending";
-}
-function approvalArtifactForId(id) {
-    if (!/^[a-zA-Z0-9._-]+$/.test(id)) {
-        throw new Error(`invalid approval id: ${id}`);
-    }
-    return path.join(".agent-workflow", "approvals", `${id}.md`);
-}
-function approvalIdForArtifact(artifact) {
-    return path.basename(artifact, ".md");
-}
-export async function addPlaywrightEvidence(input, root = process.cwd()) {
-    return addEvidence(removeUndefined({
-        task: input.task,
-        role: "qa",
-        type: input.kind,
-        summary: input.summary,
-        path: input.path,
-        command: input.runId,
-    }), root);
-}
-function aggregateUsage(key, records) {
-    const inputTokens = records.reduce((sum, record) => sum + record.inputTokens, 0);
-    const outputTokens = records.reduce((sum, record) => sum + record.outputTokens, 0);
-    const estimatedCostUsd = records.reduce((sum, record) => sum + record.estimatedCostUsd, 0);
-    return {
-        key,
-        requests: records.length,
-        inputTokens,
-        outputTokens,
-        totalTokens: inputTokens + outputTokens,
-        estimatedCostUsd,
-    };
-}
-function aggregateUsageBy(records, keyFor) {
-    const groups = new Map();
-    for (const record of records) {
-        const key = keyFor(record);
-        groups.set(key, [...(groups.get(key) ?? []), record]);
-    }
-    return [...groups.entries()].map(([key, group]) => aggregateUsage(key, group));
-}
-function budgetViolations(scope, usage, budget) {
-    return [
-        budgetViolation(scope, "requests", usage.requests, budget.maxRequests),
-        budgetViolation(scope, "inputTokens", usage.inputTokens, budget.maxInputTokens),
-        budgetViolation(scope, "outputTokens", usage.outputTokens, budget.maxOutputTokens),
-        budgetViolation(scope, "totalTokens", usage.totalTokens, budget.maxTotalTokens),
-        budgetViolation(scope, "estimatedCostUsd", usage.estimatedCostUsd, budget.maxEstimatedCostUsd),
-    ].filter((violation) => Boolean(violation));
-}
-function budgetViolation(scope, metric, actual, limit) {
-    if (limit === undefined || actual <= limit) {
-        return undefined;
-    }
-    return {
-        scope,
-        metric,
-        actual,
-        limit,
-    };
-}
-function projectUsageCost(usage, ownerRole, estimatedCostUsd) {
-    const byRole = [...usage.byRole];
-    const roleIndex = byRole.findIndex((entry) => entry.key === ownerRole);
-    if (roleIndex >= 0) {
-        const roleUsage = byRole[roleIndex] ?? emptyUsageBreakdown(ownerRole);
-        byRole[roleIndex] = addEstimatedCost(roleUsage, estimatedCostUsd);
-    }
-    else {
-        byRole.push(addEstimatedCost(emptyUsageBreakdown(ownerRole), estimatedCostUsd));
-    }
-    return {
-        ...usage,
-        totals: addEstimatedCost(usage.totals, estimatedCostUsd),
-        byRole,
-    };
-}
-function addEstimatedCost(usage, estimatedCostUsd) {
-    return {
-        ...usage,
-        estimatedCostUsd: usage.estimatedCostUsd + estimatedCostUsd,
-    };
-}
-function emptyUsageBreakdown(key) {
-    return {
-        key,
-        requests: 0,
-        inputTokens: 0,
-        outputTokens: 0,
-        totalTokens: 0,
-        estimatedCostUsd: 0,
-    };
-}
-function budgetEstimateWarningsForBudgets(taskId, ownerRole, usage, budgets) {
-    const warnings = [];
-    pushCostWarning(warnings, "defaults", usage.totals, budgets?.defaults);
-    pushCostWarning(warnings, `task:${taskId}`, usage.totals, budgets?.byTask?.[taskId]);
-    pushCostWarning(warnings, `role:${ownerRole}`, usage.byRole.find((roleUsage) => roleUsage.key === ownerRole) ??
-        emptyUsageBreakdown(ownerRole), budgets?.byRole?.[ownerRole]);
-    return warnings;
-}
-function pushCostWarning(warnings, scope, usage, budget) {
-    const thresholdPercent = 80;
-    const limit = budget?.maxEstimatedCostUsd;
-    if (limit !== undefined &&
-        usage.estimatedCostUsd >= limit * (thresholdPercent / 100)) {
-        warnings.push({
-            scope,
-            metric: "estimatedCostUsd",
-            actual: usage.estimatedCostUsd,
-            limit,
-            thresholdPercent,
-        });
-    }
-}
 async function writeBudgetEscalationProposal(root, taskId, proposal) {
     const content = [
         `# Budget Escalation Proposal: ${taskId}`,
@@ -1777,14 +1336,4 @@ function flowRequirementLines(requirements) {
 function createLockId() {
     return `lock-${Date.now()}-${randomUUID()}`;
 }
-function removeUndefined(value) {
-    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
-}
-function toPascalCase(value) {
-    return value
-        .split(/[^a-zA-Z0-9]+/)
-        .filter(Boolean)
-        .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
-        .join("");
-}
 //# sourceMappingURL=workflow-services.js.map