@use-the-fork/spindle 0.0.0-stage → 0.0.1

package/build/SubagentDrivenDevelopment/Services/SubmissionService.js

@@ -0,0 +1,299 @@
+import matter from "gray-matter";
+import { Service } from "../../Foundation/Service.js";
+import { validateAuthor, validateTicketId, } from "../Policies/InputValidation.js";
+export class SubmissionService extends Service {
+    gitEvidence;
+    reportEvidence;
+    ticketRepository;
+    ledgerRepository;
+    workspaceTransaction;
+    checkPolicy;
+    reviewPolicy;
+    workflowPolicy;
+    deliverySubmissionService;
+    featureInspectionService;
+    constructor(app, gitEvidence, reportEvidence, ticketRepository, ledgerRepository, workspaceTransaction, checkPolicy, reviewPolicy, workflowPolicy, deliverySubmissionService, featureInspectionService) {
+        super(app);
+        this.gitEvidence = gitEvidence;
+        this.reportEvidence = reportEvidence;
+        this.ticketRepository = ticketRepository;
+        this.ledgerRepository = ledgerRepository;
+        this.workspaceTransaction = workspaceTransaction;
+        this.checkPolicy = checkPolicy;
+        this.reviewPolicy = reviewPolicy;
+        this.workflowPolicy = workflowPolicy;
+        this.deliverySubmissionService = deliverySubmissionService;
+        this.featureInspectionService = featureInspectionService;
+    }
+    submit(options) {
+        if (options.scope === "delivery") {
+            if (options.ticket)
+                throw new Error("--ticket and --scope delivery are mutually exclusive.");
+            if (options.role === "implementation")
+                return this.deliverySubmissionService.submitDeliveryImplementation(options);
+            return this.deliverySubmissionService.submitDeliveryReview(options);
+        }
+        if (options.scope !== undefined)
+            throw new Error("--scope must be 'delivery'.");
+        if (!options.ticket)
+            throw new Error("Submit requires --ticket or --scope delivery.");
+        validateTicketId(options.ticket);
+        validateAuthor(options.author);
+        if (options.role === "review")
+            return this.submitReview(options);
+        if (options.role !== "implementation") {
+            throw new Error("Submit role must be implementation or review.");
+        }
+        if (options.assignment !== undefined ||
+            options.result !== undefined ||
+            options.noFindings ||
+            options.findings !== undefined) {
+            throw new Error("Review assignment, result, and no-findings options require role review.");
+        }
+        if (options.unavailable && !options.details?.trim()) {
+            throw new Error("--details is required when the implementation report is unavailable.");
+        }
+        if (options.unavailable && options.report !== undefined) {
+            throw new Error("--report cannot be combined with --unavailable.");
+        }
+        if (!options.unavailable && options.details !== undefined) {
+            throw new Error("--details is only valid with --unavailable.");
+        }
+        const feature = this.featureInspectionService.resolveFeature(options.spec);
+        return this.workspaceTransaction.run(feature.workspace, () => {
+            const ledger = this.ledgerRepository.readLedger(feature);
+            const ticket = this.ticketRepository.requireTicket(this.ticketRepository.readTickets(feature.workspace), options.ticket);
+            const progress = this.workflowPolicy.requireProgress(ledger, options.ticket);
+            const identity = this.gitEvidence.contentIdentity(feature, ticket, progress.baseSha, progress.checks);
+            const assignment = progress.assignment;
+            if (!assignment || assignment.role !== options.role) {
+                throw new Error("No matching implementation assignment is pending for this ticket.");
+            }
+            if (progress.owner !== options.author.trim() ||
+                assignment.controller !== options.author.trim()) {
+                throw new Error("Only the current controller may submit this implementation report.");
+            }
+            if (options.unavailable) {
+                const details = options.details.trim();
+                if (assignment.status === "unavailable" && assignment.unavailableDetails === details) {
+                    return {
+                        ticket: options.ticket,
+                        execution: progress.execution,
+                        assignment,
+                        unavailable: true,
+                        idempotent: true,
+                        ...identity,
+                    };
+                }
+                if (assignment.status !== "pending" || progress.execution !== "implementing") {
+                    throw new Error("The implementation assignment is no longer awaiting a report.");
+                }
+                assignment.status = "unavailable";
+                assignment.unavailableDetails = details;
+                const afterTicket = matter.stringify(this.ticketRepository.appendAudit(ticket.body, options.author, `Implementation report unavailable for assignment ${assignment.id}: ${details}. Work remains pending.`), this.ticketRepository.metadata(ticket));
+                this.workspaceTransaction.writeWorkflowState(feature, ticket, afterTicket, ledger);
+                return {
+                    ticket: options.ticket,
+                    execution: progress.execution,
+                    assignment,
+                    unavailable: true,
+                    ...identity,
+                };
+            }
+            if (assignment.status === "submitted") {
+                const currentPath = this.reportEvidence.submissionReportPath(feature, assignment, options.report);
+                const digest = this.reportEvidence.readReportDigest(feature, currentPath);
+                if (digest !== assignment.reportSha256) {
+                    throw new Error("The registered implementation report changed after submission.");
+                }
+                return {
+                    ticket: options.ticket,
+                    execution: progress.execution,
+                    assignment,
+                    report: assignment.report,
+                    reportSha256: digest,
+                    idempotent: true,
+                    ...identity,
+                };
+            }
+            if ((assignment.status !== "pending" && assignment.status !== "unavailable") ||
+                progress.execution !== "implementing") {
+                throw new Error("The implementation assignment is not awaiting a report.");
+            }
+            const reportPath = this.reportEvidence.submissionReportPath(feature, assignment, options.report);
+            let reportSha256;
+            try {
+                reportSha256 = this.reportEvidence.readReportDigest(feature, reportPath);
+            }
+            catch (error) {
+                if (typeof error === "object" &&
+                    error !== null &&
+                    "code" in error &&
+                    error.code === "ENOENT") {
+                    throw new Error(`Implementation report is missing or unavailable at ${assignment.report}; the assignment remains pending.`);
+                }
+                throw error;
+            }
+            assignment.status = "submitted";
+            assignment.reportSha256 = reportSha256;
+            assignment.submittedAt = new Date().toISOString();
+            assignment.submittedBy = options.author.trim();
+            delete assignment.unavailableDetails;
+            if (assignment.action === "correct") {
+                const attempt = progress.correctionAttempts?.find((candidate) => candidate.number === assignment.attempt);
+                if (!attempt || attempt.assignmentId !== assignment.id) {
+                    throw new Error("Corrective assignment has no matching persisted attempt.");
+                }
+                attempt.assignment = assignment;
+            }
+            progress.execution = "reviewing";
+            const afterTicket = matter.stringify(this.ticketRepository.appendAudit(ticket.body, options.author, `Implementation report submitted for assignment ${assignment.id}: ${assignment.report} (sha256 ${reportSha256}).`), this.ticketRepository.metadata(ticket));
+            this.workspaceTransaction.writeWorkflowState(feature, ticket, afterTicket, ledger);
+            return {
+                ticket: options.ticket,
+                execution: progress.execution,
+                assignment,
+                report: assignment.report,
+                reportSha256,
+                ...identity,
+            };
+        });
+    }
+    submitReview(options) {
+        if (!options.assignment?.trim()) {
+            throw new Error("Review submission requires --assignment.");
+        }
+        if (!options.report)
+            throw new Error("Review submission requires --report.");
+        if (!options.result)
+            throw new Error("Review submission requires explicit --result.");
+        if (!["passed", "failed", "unavailable"].includes(options.result)) {
+            throw new Error(`Invalid review result: ${options.result}.`);
+        }
+        const findingIds = options.findingIds?.map((id) => id.trim());
+        if (options.noFindings === true && findingIds !== undefined) {
+            throw new Error("--findings and --no-findings cannot be combined.");
+        }
+        if (findingIds !== undefined &&
+            (findingIds.length === 0 ||
+                findingIds.some((id) => !/^F-\d{4,}$/.test(id)) ||
+                new Set(findingIds).size !== findingIds.length)) {
+            throw new Error("--findings must contain unique canonical finding IDs.");
+        }
+        if (options.noFindings !== true && findingIds === undefined) {
+            throw new Error("Review submission requires either --findings or exclusive --no-findings.");
+        }
+        if (options.unavailable) {
+            throw new Error("Use --result unavailable, not --unavailable, for review submissions.");
+        }
+        if (options.result === "passed" && options.details !== undefined) {
+            throw new Error("--details is only valid for failed or unavailable review results.");
+        }
+        if (options.result !== "passed" && !options.details?.trim()) {
+            throw new Error("--details is required for failed or unavailable reviews.");
+        }
+        const feature = this.featureInspectionService.resolveFeature(options.spec);
+        return this.workspaceTransaction.run(feature.workspace, () => {
+            const ledger = this.ledgerRepository.readLedger(feature);
+            const ticket = this.ticketRepository.requireTicket(this.ticketRepository.readTickets(feature.workspace), options.ticket);
+            const progress = this.workflowPolicy.requireProgress(ledger, options.ticket);
+            if (!["reviewing", "changes-requested"].includes(progress.execution) || !progress.owner) {
+                throw new Error(`Ticket ${options.ticket} is not awaiting review submission.`);
+            }
+            if (progress.owner !== options.author.trim()) {
+                throw new Error("Only the current controller may submit a review result.");
+            }
+            const correctionAttempt = progress.correctionAttempts?.find((attempt) => attempt.reviewAssignments?.some((candidate) => candidate.id === options.assignment));
+            const assignment = correctionAttempt?.reviewAssignments?.find((candidate) => candidate.id === options.assignment) ?? progress.reviewAssignments?.find((candidate) => candidate.id === options.assignment);
+            if (!assignment || assignment.role !== "review") {
+                throw new Error(`No review assignment matches ID ${options.assignment}.`);
+            }
+            if (progress.execution === "changes-requested" && assignment.status !== "submitted") {
+                throw new Error(`Ticket ${options.ticket} is awaiting a controller correction decision.`);
+            }
+            if (!progress.baseSha)
+                throw new Error("Review assignment has no recorded Git baseline.");
+            const identity = this.gitEvidence.contentIdentity(feature, ticket, progress.baseSha, progress.checks);
+            const checkBlockers = this.checkPolicy.reviewCheckBlockers(feature, ticket, progress, identity);
+            if (checkBlockers.length > 0)
+                throw new Error(checkBlockers.join("\n"));
+            const snapshotBlocker = this.reviewPolicy.reviewSnapshotBlocker(feature, progress, assignment, identity);
+            if (snapshotBlocker)
+                throw new Error(snapshotBlocker);
+            const reportPath = this.reportEvidence.submissionReportPath(feature, assignment, options.report);
+            const reportSha256 = this.reportEvidence.readReportDigest(feature, reportPath);
+            const registeredFromReport = (progress.findings ?? [])
+                .filter((finding) => finding.provenance.some((source) => source.report === assignment.report && source.snapshot === assignment.snapshot))
+                .map((finding) => finding.id);
+            if (options.noFindings === true && registeredFromReport.length > 0) {
+                throw new Error(`Review report has registered findings and cannot declare --no-findings: ${registeredFromReport.join(", ")}.`);
+            }
+            if (findingIds !== undefined) {
+                const missing = registeredFromReport.filter((id) => !findingIds.includes(id));
+                const unknown = findingIds.filter((id) => !registeredFromReport.includes(id));
+                if (missing.length > 0 || unknown.length > 0) {
+                    throw new Error(`--findings must exactly list canonical findings registered from this report and snapshot; missing=${missing.join(",") || "none"}; invalid provenance=${unknown.join(",") || "none"}.`);
+                }
+            }
+            if (assignment.status === "submitted") {
+                if (assignment.result === options.result &&
+                    assignment.noFindings === (options.noFindings === true ? true : undefined) &&
+                    JSON.stringify(assignment.findingIds) === JSON.stringify(findingIds) &&
+                    assignment.submittedBy === options.author.trim() &&
+                    assignment.details === options.details?.trim()) {
+                    return {
+                        ticket: options.ticket,
+                        execution: progress.execution,
+                        assignment,
+                        report: assignment.report,
+                        reportSha256,
+                        idempotent: true,
+                        ...identity,
+                    };
+                }
+                throw new Error("The review assignment already has a different submitted result.");
+            }
+            const confirmedTicket = this.ticketRepository.requireTicket(this.ticketRepository.readTickets(feature.workspace), options.ticket);
+            const confirmedIdentity = this.gitEvidence.contentIdentity(feature, confirmedTicket, progress.baseSha, progress.checks);
+            const confirmedInventory = this.gitEvidence.changedPaths(progress.baseSha);
+            const confirmedReportDigest = this.reportEvidence.readReportDigest(feature, reportPath);
+            if (confirmedIdentity.snapshot !== identity.snapshot ||
+                JSON.stringify(confirmedInventory) !== JSON.stringify(assignment.inventory) ||
+                confirmedReportDigest !== reportSha256) {
+                throw new Error("Review inputs changed while submitting; retry against the frozen assignment.");
+            }
+            assignment.status = "submitted";
+            assignment.result = options.result;
+            if (options.noFindings === true)
+                assignment.noFindings = true;
+            else
+                delete assignment.noFindings;
+            if (findingIds !== undefined)
+                assignment.findingIds = findingIds;
+            else
+                delete assignment.findingIds;
+            assignment.reportSha256 = reportSha256;
+            assignment.submittedAt = new Date().toISOString();
+            assignment.submittedBy = options.author.trim();
+            if (options.details?.trim())
+                assignment.details = options.details.trim();
+            const submittedFindings = (assignment.findingIds ?? [])
+                .map((id) => progress.findings?.find((finding) => finding.id === id))
+                .filter((finding) => finding !== undefined);
+            if (assignment.result !== "passed" ||
+                submittedFindings.some((finding) => finding.blocking && finding.status !== "fixed" && finding.status !== "dismissed")) {
+                progress.execution = "changes-requested";
+            }
+            const afterTicket = matter.stringify(this.ticketRepository.appendAudit(ticket.body, options.author, `Review report submitted for assignment ${assignment.id}: result=${assignment.result}${assignment.noFindings === true ? "; no-findings explicitly declared" : `; findings=${(assignment.findingIds ?? []).join(",")}`}; report=${assignment.report} (sha256 ${reportSha256}).`), this.ticketRepository.metadata(ticket));
+            this.workspaceTransaction.writeWorkflowState(feature, ticket, afterTicket, ledger);
+            return {
+                ticket: options.ticket,
+                execution: progress.execution,
+                assignment,
+                report: assignment.report,
+                reportSha256,
+                ...identity,
+            };
+        });
+    }
+}

package/build/SubagentDrivenDevelopment/Services/TicketService.js

@@ -0,0 +1,186 @@
+import { readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import matter from "gray-matter";
+import { templateCatalog } from "../../Assets/Templates/Catalog.js";
+import { Service } from "../../Foundation/Service.js";
+import { TICKET_ID, TRACKER_STATUSES, } from "../Models/Workflow.js";
+import { lstatIfPresent } from "../Persistence/FileSystem.js";
+import { validateAuthor, validateTicketId, validateCategory, } from "../Policies/InputValidation.js";
+import { resolveRenderContext } from "../../TemplateRendering/Computed/ResolveRenderContext.js";
+import { renderText } from "../../TemplateRendering/Rendering/RenderText.js";
+const templates = fileURLToPath(new URL("../../Assets/Templates/", import.meta.url));
+export class TicketService extends Service {
+    ticketRepository;
+    ledgerRepository;
+    pathSafety;
+    workspaceTransaction;
+    featureInspectionService;
+    constructor(app, ticketRepository, ledgerRepository, pathSafety, workspaceTransaction, featureInspectionService) {
+        super(app);
+        this.ticketRepository = ticketRepository;
+        this.ledgerRepository = ledgerRepository;
+        this.pathSafety = pathSafety;
+        this.workspaceTransaction = workspaceTransaction;
+        this.featureInspectionService = featureInspectionService;
+    }
+    ticketCreate(options) {
+        this.ticketRepository.validateTicketCreateOptions(options);
+        const feature = this.featureInspectionService.resolveFeature(options.spec);
+        return this.workspaceTransaction.run(feature.workspace, () => {
+            const ledger = this.ledgerRepository.readLedger(feature);
+            const tickets = this.ticketRepository.readTickets(feature.workspace);
+            this.ticketRepository.validateDependencyGraph(tickets);
+            let highest = 0n;
+            for (const candidate of [
+                ...tickets.map((item) => item.id),
+                ...ledger.tickets.map((item) => item.id),
+            ]) {
+                const match = TICKET_ID.exec(candidate);
+                if (match && BigInt(match[1]) > highest)
+                    highest = BigInt(match[1]);
+            }
+            const id = `T-${String(highest + 1n).padStart(4, "0")}`;
+            const path = join(feature.workspace, "tickets", `${id}.md`);
+            if (lstatIfPresent(path))
+                throw new Error(`Ticket already exists: ${id}.`);
+            this.pathSafety.assertTicketPath(feature.workspace, path);
+            const ticket = {
+                id,
+                title: options.title.trim(),
+                reporter: options.reporter.trim(),
+                category: options.category,
+                status: "open",
+                blockedBy: [],
+            };
+            const context = resolveRenderContext(this.app, {
+                variables: {
+                    title: options.title.trim(),
+                    reporter: options.reporter.trim(),
+                    category: options.category,
+                    author: options.author.trim(),
+                },
+            });
+            const template = renderText(readFileSync(join(templates, templateCatalog.sdd.ticket), "utf8"), context);
+            const document = matter.stringify(this.ticketRepository.appendAudit(template, options.author, "Ticket created."), { id });
+            ledger.tickets.push({
+                ...ticket,
+                execution: "unstarted",
+            });
+            this.workspaceTransaction.applyWrites(feature.workspace, [
+                { path: relative(feature.workspace, path), before: null, after: document },
+                {
+                    path: "sdd.json",
+                    before: readFileSync(feature.ledger, "utf8"),
+                    after: `${JSON.stringify(ledger, null, 2)}\n`,
+                },
+            ]);
+            return { ticket: id, path };
+        });
+    }
+    ticketUpdate(options) {
+        validateTicketId(options.ticket);
+        validateAuthor(options.author);
+        if (options.title === undefined &&
+            options.reporter === undefined &&
+            options.category === undefined &&
+            options.status === undefined &&
+            options.blocker === undefined &&
+            !options.clearBlocker &&
+            options.blockedBy === undefined &&
+            !options.clearBlockedBy) {
+            throw new Error("Provide ticket fields, status, blocker, or dependency options to update.");
+        }
+        if (options.clearBlockedBy && options.blockedBy !== undefined) {
+            throw new Error("--clear-blocked-by cannot be combined with --blocked-by.");
+        }
+        if (options.clearBlocker && options.blocker !== undefined) {
+            throw new Error("--clear-blocker cannot be combined with --blocker.");
+        }
+        if (options.title !== undefined && !options.title.trim())
+            throw new Error("Title must not be empty.");
+        if (options.reporter !== undefined && !options.reporter.trim()) {
+            throw new Error("Reporter must not be empty.");
+        }
+        if (options.category !== undefined)
+            validateCategory(options.category);
+        if (options.status !== undefined &&
+            !TRACKER_STATUSES.some((status) => status === options.status)) {
+            throw new Error(`Ticket status must be one of: ${TRACKER_STATUSES.join(", ")}.`);
+        }
+        if (options.blocker !== undefined && !options.blocker.trim()) {
+            throw new Error("Blocker reason must not be empty.");
+        }
+        const feature = this.featureInspectionService.resolveFeature(options.spec);
+        return this.workspaceTransaction.run(feature.workspace, () => {
+            const ledger = this.ledgerRepository.readLedger(feature);
+            const tickets = this.ticketRepository.readTickets(feature.workspace);
+            const current = this.ticketRepository.requireTicket(tickets, options.ticket);
+            const updated = { ...current };
+            const progress = ledger.tickets.find((item) => item.id === current.id);
+            if (!progress)
+                throw new Error(`Ticket ${current.id} has no ledger record.`);
+            const structured = ledger.tickets.find((item) => item.id === current.id);
+            if (options.title !== undefined)
+                structured.title = updated.title = options.title.trim();
+            if (options.reporter !== undefined)
+                structured.reporter = updated.reporter = options.reporter.trim();
+            if (options.category !== undefined) {
+                structured.category = options.category;
+                updated.category = structured.category;
+            }
+            if (options.status !== undefined) {
+                structured.status = options.status;
+                updated.status = structured.status;
+            }
+            if (options.blocker !== undefined) {
+                structured.blocker = options.blocker.trim();
+                updated.blocker = structured.blocker;
+            }
+            if (options.clearBlocker) {
+                delete structured.blocker;
+                delete updated.blocker;
+            }
+            if (options.blockedBy !== undefined) {
+                const blockedBy = this.ticketRepository.normalizeDependencies(options.blockedBy);
+                updated.blocked_by = blockedBy;
+                structured.blockedBy = blockedBy;
+            }
+            if (options.clearBlockedBy) {
+                updated.blocked_by = [];
+                structured.blockedBy = [];
+            }
+            if (structured.status === "closed" && structured.blocker) {
+                throw new Error("Cannot close a blocked ticket; clear its blocker first.");
+            }
+            const changed = this.ticketRepository.serializeTicket(updated, this.ticketRepository.appendAudit(current.body, options.author, "Ticket fields updated."));
+            const candidate = tickets.map((item) => item.id === current.id ? { ...updated, raw: changed, body: matter(changed).content } : item);
+            this.ticketRepository.validateDependencyGraph(candidate);
+            this.workspaceTransaction.applyWrites(feature.workspace, [
+                { path: relative(feature.workspace, current.path), before: current.raw, after: changed },
+                {
+                    path: "sdd.json",
+                    before: readFileSync(feature.ledger, "utf8"),
+                    after: `${JSON.stringify(ledger, null, 2)}\n`,
+                },
+            ]);
+            return { ticket: options.ticket, path: current.path };
+        });
+    }
+    ticketComment(options) {
+        validateTicketId(options.ticket);
+        validateAuthor(options.author);
+        if (!options.details.trim())
+            throw new Error("Comment details must not be empty.");
+        const feature = this.featureInspectionService.resolveFeature(options.spec);
+        return this.workspaceTransaction.run(feature.workspace, () => {
+            this.ledgerRepository.readLedger(feature);
+            const current = this.ticketRepository.requireTicket(this.ticketRepository.readTickets(feature.workspace), options.ticket);
+            const after = matter.stringify(this.ticketRepository.appendAudit(current.body, options.author, options.details.trim()), this.ticketRepository.metadata(current));
+            this.workspaceTransaction.applyWrites(feature.workspace, [
+                { path: relative(feature.workspace, current.path), before: current.raw, after },
+            ]);
+            return { ticket: options.ticket, path: current.path };
+        });
+    }
+}

package/build/SubagentDrivenDevelopment/SubagentDrivenDevelopmentServiceProvider.js

@@ -0,0 +1,113 @@
+import { ServiceProvider } from "../Foundation/ServiceProvider.js";
+import { GitService } from "../Git/Services/GitService.js";
+import { ChecksRecordCommand } from "./Commands/ChecksRecordCommand.js";
+import { ChecksRequireCommand } from "./Commands/ChecksRequireCommand.js";
+import { ClaimCommand } from "./Commands/ClaimCommand.js";
+import { CorrectCommand } from "./Commands/CorrectCommand.js";
+import { CreateCommand } from "./Commands/CreateCommand.js";
+import { FindingCreateCommand } from "./Commands/FindingCreateCommand.js";
+import { FindingUpdateCommand } from "./Commands/FindingUpdateCommand.js";
+import { FinishCommand } from "./Commands/FinishCommand.js";
+import { ImplementCommand } from "./Commands/ImplementCommand.js";
+import { NextCommand } from "./Commands/NextCommand.js";
+import { ReadyCommand } from "./Commands/ReadyCommand.js";
+import { RequirementsDecideCommand } from "./Commands/RequirementsDecideCommand.js";
+import { ResumeCommand } from "./Commands/ResumeCommand.js";
+import { ReviewCommand } from "./Commands/ReviewCommand.js";
+import { ReviewRequireCommand } from "./Commands/ReviewRequireCommand.js";
+import { StatusCommand } from "./Commands/StatusCommand.js";
+import { SubmitCommand } from "./Commands/SubmitCommand.js";
+import { TicketCommentCommand } from "./Commands/TicketCommentCommand.js";
+import { TicketCreateCommand } from "./Commands/TicketCreateCommand.js";
+import { TicketUpdateCommand } from "./Commands/TicketUpdateCommand.js";
+import { GitEvidence } from "./Evidence/GitEvidence.js";
+import { ReportEvidence } from "./Evidence/ReportEvidence.js";
+import { FeatureWorkspace } from "./Persistence/FeatureWorkspace.js";
+import { LedgerRepository } from "./Persistence/LedgerRepository.js";
+import { PathSafety } from "./Persistence/PathSafety.js";
+import { ReadinessReader } from "./Persistence/ReadinessReader.js";
+import { TicketRepository } from "./Persistence/TicketRepository.js";
+import { WorkspaceTransaction } from "./Persistence/WorkspaceTransaction.js";
+import { AcceptancePolicy } from "./Policies/AcceptancePolicy.js";
+import { AssignmentPolicy } from "./Policies/AssignmentPolicy.js";
+import { CheckPolicy } from "./Policies/CheckPolicy.js";
+import { FindingPolicy } from "./Policies/FindingPolicy.js";
+import { ReadinessPolicy } from "./Policies/ReadinessPolicy.js";
+import { ReviewPolicy } from "./Policies/ReviewPolicy.js";
+import { WorkflowPolicy } from "./Policies/WorkflowPolicy.js";
+import { AssignmentService } from "./Services/AssignmentService.js";
+import { ChecksService } from "./Services/ChecksService.js";
+import { CorrectionService } from "./Services/CorrectionService.js";
+import { DeliveryCorrectionService } from "./Services/DeliveryCorrectionService.js";
+import { DeliveryFindingService } from "./Services/DeliveryFindingService.js";
+import { DeliveryService } from "./Services/DeliveryService.js";
+import { DeliverySubmissionService } from "./Services/DeliverySubmissionService.js";
+import { FeatureCreationService } from "./Services/FeatureCreationService.js";
+import { FeatureInspectionService } from "./Services/FeatureInspectionService.js";
+import { FindingService } from "./Services/FindingService.js";
+import { IntegrationService } from "./Services/IntegrationService.js";
+import { ReadinessService } from "./Services/ReadinessService.js";
+import { RequirementsService } from "./Services/RequirementsService.js";
+import { ReviewService } from "./Services/ReviewService.js";
+import { SubmissionService } from "./Services/SubmissionService.js";
+import { TicketService } from "./Services/TicketService.js";
+export class SubagentDrivenDevelopmentServiceProvider extends ServiceProvider {
+    static commands() {
+        return [
+            CreateCommand,
+            TicketCreateCommand,
+            TicketUpdateCommand,
+            TicketCommentCommand,
+            ReadyCommand,
+            ClaimCommand,
+            ChecksRequireCommand,
+            ChecksRecordCommand,
+            ImplementCommand,
+            CorrectCommand,
+            ReviewCommand,
+            ReviewRequireCommand,
+            FindingCreateCommand,
+            FindingUpdateCommand,
+            RequirementsDecideCommand,
+            SubmitCommand,
+            FinishCommand,
+            ResumeCommand,
+            NextCommand,
+            StatusCommand,
+        ];
+    }
+    register() {
+        this.app.singleton(ReadinessReader, async (app) => new ReadinessReader(app, await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(PathSafety)));
+        this.app.singleton(ReadinessPolicy, async (app) => new ReadinessPolicy(app, await app.make(TicketRepository)));
+        this.app.singleton(FeatureCreationService, async (app) => new FeatureCreationService(app, await app.make(FeatureWorkspace), await app.make(PathSafety), await app.make(WorkspaceTransaction), await app.make(GitEvidence)));
+        this.app.singleton(FeatureInspectionService, async (app) => new FeatureInspectionService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(FeatureWorkspace), await app.make(TicketRepository), await app.make(AcceptancePolicy), await app.make(AssignmentPolicy), await app.make(CheckPolicy), await app.make(FindingPolicy), await app.make(ReviewPolicy)));
+        this.app.singleton(TicketService, async (app) => new TicketService(app, await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(PathSafety), await app.make(WorkspaceTransaction), await app.make(FeatureInspectionService)));
+        this.app.singleton(ReadinessService, async (app) => new ReadinessService(app, await app.make(FeatureInspectionService), await app.make(ReadinessReader), await app.make(ReadinessPolicy), await app.make(PathSafety)));
+        this.app.singleton(AssignmentService, async (app) => new AssignmentService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(AssignmentPolicy), await app.make(CheckPolicy), await app.make(ReviewPolicy), await app.make(WorkflowPolicy), await app.make(FeatureInspectionService)));
+        this.app.singleton(CorrectionService, async (app) => new CorrectionService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(WorkflowPolicy), await app.make(DeliveryCorrectionService), await app.make(FeatureInspectionService)));
+        this.app.singleton(DeliveryCorrectionService, async (app) => new DeliveryCorrectionService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(FeatureInspectionService)));
+        this.app.singleton(ChecksService, async (app) => new ChecksService(app, await app.make(GitEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(WorkflowPolicy), await app.make(FeatureInspectionService)));
+        this.app.singleton(ReviewService, async (app) => new ReviewService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(AssignmentPolicy), await app.make(CheckPolicy), await app.make(ReviewPolicy), await app.make(WorkflowPolicy), await app.make(FeatureInspectionService)));
+        this.app.singleton(FindingService, async (app) => new FindingService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(CheckPolicy), await app.make(FindingPolicy), await app.make(ReviewPolicy), await app.make(WorkflowPolicy), await app.make(DeliveryFindingService), await app.make(FeatureInspectionService)));
+        this.app.singleton(DeliveryFindingService, async (app) => new DeliveryFindingService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(CheckPolicy), await app.make(FindingPolicy), await app.make(ReviewPolicy), await app.make(FeatureInspectionService)));
+        this.app.singleton(RequirementsService, async (app) => new RequirementsService(app, await app.make(GitEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(WorkflowPolicy), await app.make(FeatureInspectionService)));
+        this.app.singleton(SubmissionService, async (app) => new SubmissionService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(CheckPolicy), await app.make(ReviewPolicy), await app.make(WorkflowPolicy), await app.make(DeliverySubmissionService), await app.make(FeatureInspectionService)));
+        this.app.singleton(DeliverySubmissionService, async (app) => new DeliverySubmissionService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(CheckPolicy), await app.make(ReviewPolicy), await app.make(FeatureInspectionService)));
+        this.app.singleton(IntegrationService, async (app) => new IntegrationService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(AcceptancePolicy), await app.make(WorkflowPolicy), await app.make(FeatureInspectionService)));
+        this.app.singleton(DeliveryService, async (app) => new DeliveryService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(CheckPolicy), await app.make(FindingPolicy), await app.make(ReviewPolicy), await app.make(FeatureInspectionService)));
+        this.app.singleton(FeatureWorkspace, async (app) => new FeatureWorkspace(app, await app.make(LedgerRepository), await app.make(PathSafety)));
+        this.app.singleton(LedgerRepository, async (app) => new LedgerRepository(app));
+        this.app.singleton(TicketRepository, async (app) => new TicketRepository(app, await app.make(PathSafety), await app.make(LedgerRepository)));
+        this.app.singleton(WorkspaceTransaction, async (app) => new WorkspaceTransaction(app, await app.make(PathSafety)));
+        this.app.singleton(PathSafety, async (app) => new PathSafety(app, await app.make(GitService)));
+        this.app.singleton(GitEvidence, async (app) => new GitEvidence(app, await app.make(GitService), await app.make(LedgerRepository)));
+        this.app.singleton(ReportEvidence, async (app) => new ReportEvidence(app, await app.make(PathSafety)));
+        this.app.singleton(CheckPolicy, async (app) => new CheckPolicy(app, await app.make(GitEvidence)));
+        this.app.singleton(ReviewPolicy, async (app) => new ReviewPolicy(app, await app.make(GitEvidence), await app.make(ReportEvidence)));
+        this.app.singleton(FindingPolicy, async (app) => new FindingPolicy(app, await app.make(ReviewPolicy)));
+        this.app.singleton(AcceptancePolicy, async (app) => new AcceptancePolicy(app, await app.make(AssignmentPolicy), await app.make(CheckPolicy), await app.make(FindingPolicy), await app.make(ReviewPolicy)));
+        this.app.singleton(AssignmentPolicy, async (app) => new AssignmentPolicy(app, await app.make(ReportEvidence)));
+        this.app.singleton(WorkflowPolicy, async (app) => new WorkflowPolicy(app));
+    }
+    async boot() { }
+}

package/build/Support/Records.js

@@ -0,0 +1,5 @@
+export class Records {
+    static isRecord(value) {
+        return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+}