@backburner/cli 0.1.0

package/dist/src/retrospectives/derive.js

@@ -0,0 +1,169 @@
+import { workflowRegistry } from "../workflows/registry.js";
+const RETROSPECTIVE_TASK_KINDS = [
+    "extract_retrospective_problems",
+    "investigate_learning_opportunity",
+    "draft_management_learning_proposal",
+];
+export function deriveRetrospectiveTasks(input) {
+    const { existingTasks, candidates, problems, opportunities, agents, contextBuilder, now, } = input;
+    const resultTasks = [];
+    const resultCandidates = [...candidates];
+    const resultProblems = [...problems];
+    const resultOpportunities = [...opportunities];
+    const blocked = [];
+    // 1. Check idleness
+    const hasPendingOperationalTasks = existingTasks.some((t) => (t.status === "pending" || t.status === "dispatched") &&
+        !RETROSPECTIVE_TASK_KINDS.includes(t.kind) &&
+        t.relevant);
+    if (hasPendingOperationalTasks) {
+        return {
+            tasks: [],
+            candidates: resultCandidates,
+            problems: resultProblems,
+            opportunities: resultOpportunities,
+            blocked: [],
+        };
+    }
+    // 2. Check if we already have a retrospective task in flight
+    const hasInFlightRetrospectiveTask = existingTasks.some((t) => (t.status === "pending" || t.status === "dispatched") &&
+        RETROSPECTIVE_TASK_KINDS.includes(t.kind));
+    if (hasInFlightRetrospectiveTask) {
+        return {
+            tasks: [],
+            candidates: resultCandidates,
+            problems: resultProblems,
+            opportunities: resultOpportunities,
+            blocked: [],
+        };
+    }
+    // 3. Check for retrospective agent role
+    const hasRetrospectiveAgent = agents.some((a) => a.enabled && a.modelClass === "strong" && a.roles.includes("retrospective"));
+    const NO_AGENT_REASON = 'No enabled strong agent is configured for role "retrospective".';
+    // 4. Derivation in priority order: Extraction > Investigation > Proposal
+    // A. Candidate to Extraction
+    const eligibleCandidates = resultCandidates
+        .filter((c) => c.status === "new" || c.status === "blocked")
+        .sort((a, b) => a.detectedAt.localeCompare(b.detectedAt) || a.id.localeCompare(b.id));
+    for (const candidate of eligibleCandidates) {
+        if (!hasRetrospectiveAgent) {
+            candidate.status = "blocked";
+            candidate.skipReason = NO_AGENT_REASON;
+            candidate.updatedAt = now;
+            blocked.push({ sourceId: candidate.id, reason: NO_AGENT_REASON });
+            continue;
+        }
+        const taskId = `extract_retrospective_problems:${candidate.id}`;
+        if (existingTasks.some((t) => t.id === taskId))
+            continue;
+        const task = createTask(taskId, "extract_retrospective_problems", "retrospective_candidate", candidate.id, candidate.url || `https://github.com/${candidate.repoSlug}`, candidate.repoId, candidate.repoSlug, `Extracting problems from candidate ${candidate.id}`, contextBuilder, now, candidate);
+        candidate.status = "extracting";
+        candidate.updatedAt = now;
+        return {
+            tasks: [task],
+            candidates: resultCandidates,
+            problems: resultProblems,
+            opportunities: resultOpportunities,
+            blocked: [],
+        };
+    }
+    // B. Problem to Investigation
+    const eligibleProblems = resultProblems
+        .filter((p) => (p.status === "pending" || p.status === "blocked") && p.thresholdDecision === "pass")
+        .sort((a, b) => a.detectedAt.localeCompare(b.detectedAt) || a.id.localeCompare(b.id));
+    for (const problem of eligibleProblems) {
+        if (!hasRetrospectiveAgent) {
+            problem.status = "blocked";
+            problem.decisionReason = NO_AGENT_REASON;
+            problem.updatedAt = now;
+            blocked.push({ sourceId: problem.id, reason: NO_AGENT_REASON });
+            continue;
+        }
+        const taskId = `investigate_learning_opportunity:${problem.id}`;
+        if (existingTasks.some((t) => t.id === taskId))
+            continue;
+        const candidate = resultCandidates.find(c => c.id === problem.candidateId);
+        const repoId = candidate?.repoId || problem.affectedRepoIds[0] || "unknown";
+        const repoSlug = candidate?.repoSlug || problem.affectedRepoIds[0] || "unknown";
+        const task = createTask(taskId, "investigate_learning_opportunity", "retrospective_problem", problem.id, `https://github.com/${repoSlug}`, repoId, repoSlug, `Investigating learning opportunity for problem ${problem.id}`, contextBuilder, now, undefined, problem);
+        problem.status = "investigating";
+        problem.updatedAt = now;
+        return {
+            tasks: [task],
+            candidates: resultCandidates,
+            problems: resultProblems,
+            opportunities: resultOpportunities,
+            blocked: [],
+        };
+    }
+    // C. Opportunity to Proposal
+    const eligibleOpportunities = resultOpportunities
+        .filter((o) => (o.status === "investigated" || o.status === "blocked"))
+        .sort((a, b) => a.detectedAt.localeCompare(b.detectedAt) || a.id.localeCompare(b.id));
+    for (const opportunity of eligibleOpportunities) {
+        // Check if proposal already exists
+        if (input.proposals.some(p => p.opportunityId === opportunity.id))
+            continue;
+        if (!hasRetrospectiveAgent) {
+            opportunity.status = "blocked";
+            opportunity.decisionReason = NO_AGENT_REASON;
+            opportunity.updatedAt = now;
+            blocked.push({ sourceId: opportunity.id, reason: NO_AGENT_REASON });
+            continue;
+        }
+        const taskId = `draft_management_learning_proposal:${opportunity.id}`;
+        if (existingTasks.some((t) => t.id === taskId))
+            continue;
+        // We need a repo for the task. We use the one from the problem/candidate if possible.
+        const problem = problems.find(p => p.id === opportunity.problemId);
+        const candidate = resultCandidates.find(c => c.id === problem?.candidateId);
+        const repoId = candidate?.repoId || problem?.affectedRepoIds[0] || "unknown";
+        const repoSlug = candidate?.repoSlug || problem?.affectedRepoIds[0] || "unknown";
+        const task = createTask(taskId, "draft_management_learning_proposal", "learning_opportunity", opportunity.id, `https://github.com/${repoSlug}`, repoId, repoSlug, `Drafting learning proposal for opportunity ${opportunity.id}`, contextBuilder, now, undefined, undefined, opportunity);
+        return {
+            tasks: [task],
+            candidates: resultCandidates,
+            problems: resultProblems,
+            opportunities: resultOpportunities,
+            blocked: [],
+        };
+    }
+    return {
+        tasks: [],
+        candidates: resultCandidates,
+        problems: resultProblems,
+        opportunities: resultOpportunities,
+        blocked,
+    };
+}
+function createTask(id, kind, sourceKind, sourceId, sourceUrl, repoId, repoSlug, summary, contextBuilder, now, candidate, problem, opportunity) {
+    const policy = workflowRegistry.resolveTaskExecutionPolicy(kind);
+    const context = contextBuilder.build({
+        taskKind: kind,
+        repoIdentifier: repoSlug,
+        sourceKind,
+        sourceUrl,
+        labels: [],
+        ...(candidate ? { retrospectiveCandidate: candidate } : {}),
+        ...(problem ? { retrospectiveProblem: problem } : {}),
+        ...(opportunity ? { learningOpportunity: opportunity } : {}),
+    });
+    return {
+        id,
+        kind,
+        status: "pending",
+        executionPermission: policy.executionPermission,
+        handoffPolicy: policy.handoffPolicy,
+        repoId,
+        repoName: repoSlug,
+        repoSlug,
+        sourceKind,
+        sourceId,
+        sourceUrl,
+        relevant: true,
+        reason: "Idle retrospective work",
+        summary,
+        context,
+        createdAt: now,
+        updatedAt: now,
+    };
+}

package/dist/src/retrospectives/ingest.js

@@ -0,0 +1,321 @@
+import { normalizeRetrospectiveScopes } from "./scopes.js";
+export async function ingestRetrospectiveExecutions(input) {
+    const { tasks, executions, candidates, problems, opportunities, proposals, readArtifact, now, } = input;
+    const resultCandidates = [...candidates];
+    const resultProblems = [...problems];
+    const resultOpportunities = [...opportunities];
+    const resultProposals = [...proposals];
+    const consumedExecutionIds = [];
+    const declined = [];
+    // Filter for retrospective tasks and completed executions
+    const retrospectiveTasks = tasks.filter((t) => [
+        "extract_retrospective_problems",
+        "investigate_learning_opportunity",
+        "draft_management_learning_proposal",
+    ].includes(t.kind));
+    const completedExecutions = executions.filter((e) => e.taskStatus === "completed" &&
+        retrospectiveTasks.some((t) => t.id === e.taskId));
+    for (const execution of completedExecutions) {
+        const task = retrospectiveTasks.find((t) => t.id === execution.taskId);
+        // Skip if already consumed
+        if (isExecutionConsumed(execution.id, resultCandidates, resultProblems, resultOpportunities, resultProposals)) {
+            continue;
+        }
+        try {
+            const stdout = await readArtifact(execution.stdoutArtifactPath);
+            const json = extractJson(stdout);
+            if (!json) {
+                throw new Error("No valid JSON found in stdout");
+            }
+            switch (task.kind) {
+                case "extract_retrospective_problems":
+                    await ingestExtraction(json, execution, task, resultCandidates, resultProblems, now);
+                    break;
+                case "investigate_learning_opportunity":
+                    await ingestInvestigation(json, execution, task, resultProblems, resultOpportunities, now);
+                    break;
+                case "draft_management_learning_proposal":
+                    await ingestProposal(json, execution, task, resultOpportunities, resultProposals, now);
+                    break;
+            }
+            consumedExecutionIds.push(execution.id);
+        }
+        catch (err) {
+            const reason = err.message;
+            declined.push({ executionId: execution.id, taskId: execution.taskId, reason });
+            handleIngestionFailure(execution, task, resultCandidates, resultProblems, resultOpportunities, resultProposals, reason, now);
+        }
+    }
+    return {
+        candidates: resultCandidates,
+        problems: resultProblems,
+        opportunities: resultOpportunities,
+        proposals: resultProposals,
+        consumedExecutionIds,
+        declined,
+    };
+}
+function isExecutionConsumed(executionId, candidates, problems, opportunities, proposals) {
+    return (candidates.some((c) => c.sourceExecutionId === executionId) ||
+        problems.some((p) => p.sourceExecutionId === executionId) ||
+        opportunities.some((o) => o.sourceExecutionId === executionId) ||
+        proposals.some((p) => p.sourceExecutionId === executionId));
+}
+function extractJson(stdout) {
+    const match = stdout.match(/\{[\s\S]*\}/);
+    if (!match)
+        return null;
+    try {
+        return JSON.parse(match[0]);
+    }
+    catch {
+        return null;
+    }
+}
+async function ingestExtraction(json, execution, task, candidates, problems, now) {
+    const problemsArray = json.problems;
+    let sourceItems;
+    let explicitEmpty = false;
+    if (problemsArray !== undefined) {
+        if (!Array.isArray(problemsArray)) {
+            throw new Error("Field 'problems' must be an array");
+        }
+        sourceItems = problemsArray;
+        if (sourceItems.length === 0) {
+            explicitEmpty = true;
+        }
+    }
+    else {
+        // Fallback: treat the whole object as a single problem result
+        sourceItems = [json];
+    }
+    // Validate all items if not explicitly empty
+    if (!explicitEmpty) {
+        for (const [index, prob] of sourceItems.entries()) {
+            if (!validateExtractionProblem(prob, task.sourceId)) {
+                const location = problemsArray !== undefined ? `at index ${index}` : "at top-level";
+                throw new Error(`Invalid problem record ${location}`);
+            }
+        }
+        // All valid, ingest them
+        for (const prob of sourceItems) {
+            const { semanticScopes, candidateLearningScopes } = normalizeRetrospectiveScopes({
+                rawSuggestedScopes: prob.suggestedScopes,
+                affectedRepoIds: prob.affectedRepos,
+                roles: prob.affectedRoles,
+                taskKinds: prob.affectedTaskKinds,
+                providers: prob.affectedProviders,
+            });
+            const problemRecord = {
+                id: `retrospective-problem:${prob.candidateId}:${hashProse(prob.problemSummary).slice(0, 8)}`,
+                candidateId: prob.candidateId,
+                status: "pending",
+                evidenceReferences: prob.evidenceReferences,
+                affectedRepoIds: prob.affectedRepos,
+                roles: prob.affectedRoles,
+                taskKinds: prob.affectedTaskKinds,
+                providers: prob.affectedProviders,
+                confidence: prob.confidence,
+                impact: prob.impact,
+                transferability: prob.transferability,
+                improvementLikelihood: prob.improvementLikelihood,
+                overfittingRisk: prob.overfittingRisk,
+                suggestedScopes: candidateLearningScopes,
+                rawSuggestedScopes: prob.suggestedScopes,
+                semanticSuggestedScopes: semanticScopes,
+                detectedAt: now,
+                updatedAt: now,
+                sourceTaskId: task.id,
+                sourceExecutionId: execution.id,
+                structuredObservations: prob.problemSummary + "\n\n" + prob.reasonItMightRecur,
+            };
+            problems.push(problemRecord);
+        }
+    }
+    const candidate = candidates.find((c) => c.id === task.sourceId);
+    if (candidate) {
+        candidate.status = explicitEmpty ? "skipped" : "extracted";
+        if (explicitEmpty) {
+            candidate.skipReason = "Agent reported no problems found";
+        }
+        else {
+            delete candidate.skipReason;
+        }
+        candidate.sourceExecutionId = execution.id;
+        candidate.sourceTaskId = task.id;
+        candidate.updatedAt = now;
+    }
+}
+function validateExtractionProblem(prob, expectedCandidateId) {
+    return (prob.candidateId === expectedCandidateId &&
+        typeof prob.problemSummary === "string" &&
+        Array.isArray(prob.evidenceReferences) &&
+        Array.isArray(prob.affectedRepos) &&
+        Array.isArray(prob.affectedRoles) &&
+        Array.isArray(prob.affectedTaskKinds) &&
+        Array.isArray(prob.affectedProviders) &&
+        Array.isArray(prob.suggestedScopes) &&
+        typeof prob.reasonItMightRecur === "string");
+}
+async function ingestInvestigation(json, execution, task, problems, opportunities, now) {
+    if (!validateInvestigation(json, task.sourceId)) {
+        throw new Error("Invalid investigation JSON");
+    }
+    const opportunityRecord = {
+        id: `learning-opportunity:${json.problemId}`,
+        problemId: json.problemId,
+        status: "investigated",
+        investigationSummary: json.investigationSummary,
+        investigationResult: json.investigationResult,
+        selectedScope: json.selectedScope,
+        evidenceReferences: json.evidenceReferences,
+        detectedAt: now,
+        updatedAt: now,
+        sourceTaskId: task.id,
+        sourceExecutionId: execution.id,
+    };
+    opportunities.push(opportunityRecord);
+    const problem = problems.find((p) => p.id === task.sourceId);
+    if (problem) {
+        problem.status = "completed";
+        problem.sourceExecutionId = execution.id;
+        problem.sourceTaskId = task.id;
+        problem.updatedAt = now;
+    }
+}
+function validateInvestigation(json, expectedProblemId) {
+    return (json.problemId === expectedProblemId &&
+        typeof json.investigationSummary === "string" &&
+        typeof json.investigationResult === "string" &&
+        Array.isArray(json.evidenceReferences) &&
+        validateLearningScopeStructure(json.selectedScope));
+}
+async function ingestProposal(json, execution, task, opportunities, proposals, now) {
+    if (!validateProposal(json, task.sourceId)) {
+        throw new Error("Invalid proposal JSON");
+    }
+    // Avoid duplicate proposals for the same opportunity
+    if (proposals.some(p => p.opportunityId === json.opportunityId)) {
+        return;
+    }
+    const proposalRecord = {
+        id: `learning-proposal:${json.opportunityId}`,
+        opportunityId: json.opportunityId,
+        problemId: json.problemId,
+        status: "pending",
+        selectedScope: json.selectedScope,
+        proposedEditMode: json.proposedEditMode,
+        proposedGuidanceText: json.proposedGuidanceText,
+        rationale: json.rationale,
+        expectedBehaviorChange: json.expectedBehaviorChange,
+        detectedAt: now,
+        updatedAt: now,
+        sourceTaskId: task.id,
+        sourceExecutionId: execution.id,
+    };
+    proposals.push(proposalRecord);
+    // Mark execution as consumed on the opportunity to prevent re-derivation
+    const opportunity = opportunities.find(o => o.id === task.sourceId);
+    if (opportunity) {
+        opportunity.sourceExecutionId = execution.id;
+        opportunity.sourceTaskId = task.id;
+        opportunity.updatedAt = now;
+    }
+}
+function validateProposal(json, expectedOpportunityId) {
+    const validEditModes = ["append", "refine", "supersede", "create"];
+    return (json.opportunityId === expectedOpportunityId &&
+        validateLearningScopeStructure(json.selectedScope) &&
+        validEditModes.includes(json.proposedEditMode) &&
+        typeof json.proposedGuidanceText === "string" &&
+        json.proposedGuidanceText.trim().length > 0 &&
+        typeof json.rationale === "string" &&
+        json.rationale.trim().length > 0 &&
+        typeof json.expectedBehaviorChange === "string" &&
+        json.expectedBehaviorChange.trim().length > 0);
+}
+function handleIngestionFailure(execution, task, candidates, problems, opportunities, proposals, reason, now) {
+    switch (task.kind) {
+        case "extract_retrospective_problems":
+            const candidate = candidates.find((c) => c.id === task.sourceId);
+            if (candidate) {
+                candidate.status = "failed";
+                candidate.skipReason = `Ingestion failed: ${reason}`;
+                candidate.sourceExecutionId = execution.id;
+                candidate.sourceTaskId = task.id;
+                candidate.updatedAt = now;
+            }
+            break;
+        case "investigate_learning_opportunity":
+            const problem = problems.find((p) => p.id === task.sourceId);
+            if (problem) {
+                problem.status = "failed";
+                problem.decisionReason = `Ingestion failed: ${reason}`;
+                problem.sourceExecutionId = execution.id;
+                problem.sourceTaskId = task.id;
+                problem.updatedAt = now;
+            }
+            break;
+        case "draft_management_learning_proposal":
+            const opportunity = opportunities.find((o) => o.id === task.sourceId);
+            if (opportunity) {
+                opportunity.status = "declined";
+                opportunity.decisionReason = `Ingestion failed: ${reason}`;
+                opportunity.sourceExecutionId = execution.id;
+                opportunity.sourceTaskId = task.id;
+                opportunity.updatedAt = now;
+            }
+            // Also persist a declined proposal record if it doesn't already exist
+            if (!proposals.some(p => p.opportunityId === task.sourceId)) {
+                proposals.push({
+                    id: `learning-proposal:${task.sourceId}`,
+                    opportunityId: task.sourceId,
+                    status: "declined",
+                    declineReason: `Ingestion failed: ${reason}`,
+                    detectedAt: now,
+                    updatedAt: now,
+                    sourceTaskId: task.id,
+                    sourceExecutionId: execution.id,
+                });
+            }
+            break;
+    }
+}
+function validateLearningScopeStructure(scope) {
+    if (!scope || typeof scope !== "object" || Array.isArray(scope))
+        return false;
+    if (typeof scope.kind !== "string")
+        return false;
+    switch (scope.kind) {
+        case "global":
+            return true;
+        case "provider":
+            return typeof scope.provider === "string" && scope.provider.length > 0;
+        case "role":
+            return typeof scope.role === "string" && scope.role.length > 0;
+        case "task_kind":
+            return typeof scope.taskKind === "string" && scope.taskKind.length > 0;
+        case "repo":
+            return typeof scope.repoId === "string" && scope.repoId.length > 0;
+        case "repo_provider":
+            return (typeof scope.repoId === "string" && scope.repoId.length > 0 &&
+                typeof scope.provider === "string" && scope.provider.length > 0);
+        case "repo_role":
+            return (typeof scope.repoId === "string" && scope.repoId.length > 0 &&
+                typeof scope.role === "string" && scope.role.length > 0);
+        case "repo_task_kind":
+            return (typeof scope.repoId === "string" && scope.repoId.length > 0 &&
+                typeof scope.taskKind === "string" && scope.taskKind.length > 0);
+        default:
+            return false;
+    }
+}
+function hashProse(text) {
+    let hash = 0;
+    for (let i = 0; i < text.length; i++) {
+        const char = text.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return Math.abs(hash).toString(16);
+}