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

package/build/Foundation/Service.js

@@ -0,0 +1,23 @@
+const bootedServices = new WeakSet();
+export class Service {
+    _app;
+    constructor(app) {
+        this._app = app;
+    }
+    get app() {
+        return this._app;
+    }
+    get isBooted() {
+        return bootedServices.has(this);
+    }
+    assertApplicationBooted() {
+        if (!this._app.hasBeenBooted) {
+            throw new Error("Application services can only run after the application has booted.");
+        }
+    }
+    async boot() { }
+}
+export async function bootService(service) {
+    await service.boot();
+    bootedServices.add(service);
+}

package/build/Foundation/ServiceProvider.js

@@ -0,0 +1,12 @@
+export class ServiceProvider {
+    _app;
+    constructor(app) {
+        this._app = app;
+    }
+    get app() {
+        return this._app;
+    }
+    static commands() {
+        return [];
+    }
+}

package/build/Git/GitServiceProvider.js

@@ -0,0 +1,8 @@
+import { GitService } from "./Services/GitService.js";
+import { ServiceProvider } from "../Foundation/ServiceProvider.js";
+export class GitServiceProvider extends ServiceProvider {
+    register() {
+        this.app.singleton(GitService);
+    }
+    async boot() { }
+}

package/build/Git/Services/GitService.js

@@ -0,0 +1,26 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { Service } from "../../Foundation/Service.js";
+export class GitService extends Service {
+    discoverRoot(startingDirectory) {
+        let root;
+        try {
+            root = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+                cwd: startingDirectory,
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+            }).trim();
+        }
+        catch {
+            throw this.discoveryError();
+        }
+        if (!root)
+            throw this.discoveryError();
+        return root;
+    }
+    run(args, options) {
+        return spawnSync("git", args, options);
+    }
+    discoveryError() {
+        return new Error("Unable to discover the Git working-tree root. Ensure Git is available and run Spindle inside a Git working tree.");
+    }
+}

package/build/Project/ProjectServiceProvider.js

@@ -0,0 +1,8 @@
+import { ServiceProvider } from "../Foundation/ServiceProvider.js";
+import { ProjectService } from "./Services/ProjectService.js";
+export class ProjectServiceProvider extends ServiceProvider {
+    register() {
+        this.app.singleton(ProjectService, (app) => new ProjectService(app));
+    }
+    async boot() { }
+}

package/build/Project/Services/ProjectService.js

@@ -0,0 +1,124 @@
+import { randomUUID } from "node:crypto";
+import { chmodSync, constants, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { join, relative } from "node:path";
+import { templateCatalog } from "../../Assets/Templates/Catalog.js";
+import { LoadProjectConfiguration } from "../../Foundation/Bootstrap/LoadProjectConfiguration.js";
+import { Service } from "../../Foundation/Service.js";
+import { ToolingService } from "../../Tooling/Services/ToolingService.js";
+export class ProjectService extends Service {
+    static configPath = ".github/spindle.json";
+    static copilotInstructionsPath = ".github/copilot-instructions.md";
+    async initialize() {
+        this.assertApplicationBooted();
+        const workspace = realpathSync(this.app.workspacePath());
+        const absolute = (path) => join(workspace, path);
+        const configFile = absolute(ProjectService.configPath);
+        this.assertRegularFileOrMissing(configFile, ProjectService.configPath);
+        const state = LoadProjectConfiguration.current(this.app);
+        if (state.status === "invalid")
+            throw new Error(state.reason, { cause: state.error });
+        if (state.status === "absent" || state.data.stacks.length === 0) {
+            throw new Error("Install at least one Blueprint stack with `spindle init` before initializing project guidance.");
+        }
+        const configuration = state.data;
+        const created = [];
+        const preserved = [];
+        const updated = [];
+        for (const directory of ["docs", "docs/adr", ".scratch", "docs/agents", ".github"]) {
+            const wasCreated = this.ensureDirectory(workspace, directory);
+            (wasCreated ? created : preserved).push(directory);
+        }
+        for (const { source, destination } of templateCatalog.project) {
+            const target = absolute(destination);
+            this.assertRegularFileOrMissing(target, destination);
+            if (destination === ProjectService.copilotInstructionsPath) {
+                const status = this.initializeCopilotInstructions(this.absoluteAsset(source), target);
+                if (status === "created")
+                    created.push(destination);
+                else if (status === "updated")
+                    updated.push(destination);
+                else
+                    preserved.push(destination);
+                continue;
+            }
+            if (existsSync(target)) {
+                preserved.push(destination);
+            }
+            else {
+                copyFileSync(this.absoluteAsset(source), target, constants.COPYFILE_EXCL);
+                created.push(destination);
+            }
+        }
+        const tooling = await (await this.app.make(ToolingService)).initialize(configuration);
+        created.push(...tooling.created);
+        updated.push(...tooling.updated);
+        return { workspace, created, preserved, updated };
+    }
+    absoluteAsset(path) {
+        return join(this.app.appPath("Assets/Templates"), path);
+    }
+    initializeCopilotInstructions(source, destination) {
+        const existingStat = lstatSync(destination, { throwIfNoEntry: false });
+        if (!existingStat) {
+            copyFileSync(source, destination, constants.COPYFILE_EXCL);
+            return "created";
+        }
+        if (!existingStat.isFile()) {
+            throw new Error(`${ProjectService.copilotInstructionsPath} must be a regular file, not a directory or symlink.`);
+        }
+        const existing = readFileSync(destination, "utf8");
+        const template = readFileSync(source, "utf8");
+        if (existing.includes(template))
+            return "preserved";
+        const temporary = this.writeTemporary(destination, `${template}\n${existing}`);
+        try {
+            chmodSync(temporary, existingStat.mode & 0o777);
+            renameSync(temporary, destination);
+        }
+        finally {
+            this.removeTemporary(temporary);
+        }
+        return "updated";
+    }
+    writeTemporary(path, content) {
+        const temporary = `${path}.${randomUUID()}.tmp`;
+        writeFileSync(temporary, content, { flag: "wx" });
+        return temporary;
+    }
+    removeTemporary(path) {
+        try {
+            unlinkSync(path);
+        }
+        catch (error) {
+            if (!this.isMissing(error))
+                throw error;
+        }
+    }
+    ensureDirectory(workspace, path) {
+        let current = workspace;
+        let created = false;
+        for (const segment of path.split("/")) {
+            current = join(current, segment);
+            const entry = lstatSync(current, { throwIfNoEntry: false });
+            if (entry) {
+                if (!entry.isDirectory()) {
+                    throw new Error(`${relative(workspace, current)} must be a real directory.`);
+                }
+            }
+            else {
+                mkdirSync(current);
+                created = true;
+            }
+        }
+        return created;
+    }
+    assertRegularFileOrMissing(path, relativePath) {
+        const entry = lstatSync(path, { throwIfNoEntry: false });
+        if (entry && !entry.isFile()) {
+            throw new Error(`${relativePath} must be a regular file, not a directory or symlink.`);
+        }
+    }
+    isMissing(error) {
+        return (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT");
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/ChecksRecordCommand.js

@@ -0,0 +1,35 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { ChecksService } from "../Services/ChecksService.js";
+export class ChecksRecordCommand extends Command {
+    static register(root, createApp) {
+        group(root, "checks")
+            .command("record")
+            .description("Record an externally executed check against a current snapshot.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .option("--ticket <id>", "Ticket ID", CommandOptions.once("--ticket"))
+            .option("--scope <scope>", "Workflow scope: delivery")
+            .requiredOption("--snapshot <snapshot>", "CLI-returned content snapshot identity", CommandOptions.once("--snapshot"))
+            .requiredOption("--command <command>", "Exact required command", CommandOptions.once("--command"))
+            .requiredOption("--result <result>", "Check result: passed, failed, unavailable", CommandOptions.once("--result"))
+            .option("--details <details>", "Failure or unavailability details")
+            .option("--paths <paths...>", "Paths whose content this check explicitly covers")
+            .requiredOption("--author <author>", "Acting controller", CommandOptions.once("--author"))
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            if (options.scope !== undefined && options.scope !== "delivery") {
+                throw new Error("--scope must be 'delivery'.");
+            }
+            if (Boolean(options.ticket) === (options.scope === "delivery")) {
+                throw new Error("checks record needs exactly one of --ticket or --scope delivery.");
+            }
+            const command = await (await createApp()).make(ChecksRecordCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(ChecksService)).checksRecord(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/ChecksRequireCommand.js

@@ -0,0 +1,33 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { ChecksService } from "../Services/ChecksService.js";
+export class ChecksRequireCommand extends Command {
+    static register(root, createApp) {
+        group(root, "checks")
+            .command("require")
+            .description("Add or remove a required external check.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .option("--ticket <id>", "Ticket ID", CommandOptions.once("--ticket"))
+            .option("--scope <scope>", "Workflow scope: delivery")
+            .requiredOption("--command <command>", "Exact externally executed command", CommandOptions.once("--command"))
+            .option("--remove", "Remove the requirement; requires --details rationale")
+            .option("--details <details>", "Removal rationale")
+            .requiredOption("--author <author>", "Acting controller", CommandOptions.once("--author"))
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            if (options.scope !== undefined && options.scope !== "delivery") {
+                throw new Error("--scope must be 'delivery'.");
+            }
+            if (Boolean(options.ticket) === (options.scope === "delivery")) {
+                throw new Error("checks require needs exactly one of --ticket or --scope delivery.");
+            }
+            const command = await (await createApp()).make(ChecksRequireCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(ChecksService)).checksRequire(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/ClaimCommand.js

@@ -0,0 +1,23 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { AssignmentService } from "../Services/AssignmentService.js";
+export class ClaimCommand extends Command {
+    static register(root, createApp) {
+        group(root)
+            .command("claim")
+            .description("Claim a ready ticket from a clean Git checkout.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .requiredOption("--ticket <id>", "Ticket ID", CommandOptions.once("--ticket"))
+            .requiredOption("--author <author>", "Controller author", CommandOptions.once("--author"))
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            const command = await (await createApp()).make(ClaimCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(AssignmentService)).claim(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/CorrectCommand.js

@@ -0,0 +1,37 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { CorrectionService } from "../Services/CorrectionService.js";
+export class CorrectCommand extends Command {
+    static register(root, createApp) {
+        group(root)
+            .command("correct")
+            .description("Persist a ticket-scoped or delivery-scoped correction attempt and return its fix assignment.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .option("--ticket <id>", "Ticket ID", CommandOptions.once("--ticket"))
+            .option("--scope <scope>", "Workflow scope: delivery")
+            .option("--findings <ids...>", "Selected actionable canonical finding IDs")
+            .option("--check-failure <command>", "Exact non-mechanical failed check command")
+            .requiredOption("--details <details>", "Correction objective or adjudication rationale", CommandOptions.once("--details"))
+            .option("--decision <decision>", "Continuation decision: continue or pause")
+            .option("--assessment <assessment>", "Recorded progress assessment for the prior attempt")
+            .option("--assessment-result <result>", "Progress result: productive")
+            .option("--reason <reason>", "Pause reason: no-progress, repeated-failure, recurring-blocker, requirements-disagreement, worker-blocked")
+            .requiredOption("--author <author>", "Controller author", CommandOptions.once("--author"))
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            if (options.scope !== undefined && options.scope !== "delivery") {
+                throw new Error("--scope must be 'delivery'.");
+            }
+            if (Boolean(options.ticket) === (options.scope === "delivery")) {
+                throw new Error("correct needs exactly one of --ticket or --scope delivery.");
+            }
+            const command = await (await createApp()).make(CorrectCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(CorrectionService)).correct(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/CreateCommand.js

@@ -0,0 +1,26 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { validateCreateOptions } from "../Policies/InputValidation.js";
+import { FeatureCreationService } from "../Services/FeatureCreationService.js";
+export class CreateCommand extends Command {
+    static register(root, createApp) {
+        group(root)
+            .command("create")
+            .description("Create a numbered SDD feature workspace with spec template and initial ledger.")
+            .requiredOption("--title <title>", "Feature title", CommandOptions.once("--title"))
+            .requiredOption("--author <author>", "Creation author", CommandOptions.once("--author"))
+            .option("--require-retrospective", "Require a retrospective when finishing this feature")
+            .option("--with-design", "Copy the design template into the feature workspace")
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            validateCreateOptions(options);
+            const command = await (await createApp()).make(CreateCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(FeatureCreationService)).create(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/FindingCreateCommand.js

@@ -0,0 +1,39 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { FindingService } from "../Services/FindingService.js";
+export class FindingCreateCommand extends Command {
+    static register(root, createApp) {
+        group(root, "finding")
+            .command("create")
+            .description("Register a review finding with its report and snapshot provenance.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .option("--ticket <id>", "Ticket ID", CommandOptions.once("--ticket"))
+            .option("--scope <scope>", "Workflow scope: delivery")
+            .option("--related-ticket <id>", "Ticket to reopen for a blocking feature finding")
+            .requiredOption("--source <path>", "Assigned review report containing the finding", CommandOptions.once("--source"))
+            .requiredOption("--snapshot <snapshot>", "Reviewed snapshot returned by the CLI", CommandOptions.once("--snapshot"))
+            .requiredOption("--severity <severity>", "Finding severity: high, medium, low", CommandOptions.once("--severity"))
+            .option("--blocking", "Mark the finding as blocking")
+            .option("--non-blocking", "Mark the finding as non-blocking")
+            .option("--link <id>", "Explicitly link this observation to a canonical finding")
+            .requiredOption("--summary <summary>", "Concise finding summary", CommandOptions.once("--summary"))
+            .requiredOption("--details <details>", "Full finding details", CommandOptions.once("--details"))
+            .requiredOption("--author <author>", "Finding registration author", CommandOptions.once("--author"))
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            if (options.scope !== undefined && options.scope !== "delivery") {
+                throw new Error("--scope must be 'delivery'.");
+            }
+            if (Boolean(options.ticket) === (options.scope === "delivery")) {
+                throw new Error("finding create needs exactly one of --ticket or --scope delivery.");
+            }
+            const command = await (await createApp()).make(FindingCreateCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(FindingService)).findingCreate(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/FindingUpdateCommand.js

@@ -0,0 +1,36 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { FindingService } from "../Services/FindingService.js";
+export class FindingUpdateCommand extends Command {
+    static register(root, createApp) {
+        group(root, "finding")
+            .command("update")
+            .description("Record an explicit, attributed finding disposition.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .option("--ticket <id>", "Ticket ID", CommandOptions.once("--ticket"))
+            .option("--scope <scope>", "Workflow scope: delivery")
+            .requiredOption("--finding <id>", "Canonical finding ID", CommandOptions.once("--finding"))
+            .requiredOption("--status <status>", "Finding status: open, confirmed, fixed, dismissed, deferred")
+            .option("--details <details>", "Ruling explanation or rationale")
+            .option("--follow-up <reference>", "Required follow-up reference for a deferral")
+            .option("--requirements-decision <id>", "Approved requirements decision covering a scope change")
+            .option("--evidence <snapshot>", "Current CLI snapshot with passing verification checks")
+            .requiredOption("--author <author>", "Ruling author", CommandOptions.once("--author"))
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            if (options.scope !== undefined && options.scope !== "delivery") {
+                throw new Error("--scope must be 'delivery'.");
+            }
+            if (Boolean(options.ticket) === (options.scope === "delivery")) {
+                throw new Error("finding update needs exactly one of --ticket or --scope delivery.");
+            }
+            const command = await (await createApp()).make(FindingUpdateCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(FindingService)).findingUpdate(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/FinishCommand.js

@@ -0,0 +1,23 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { DeliveryService } from "../Services/DeliveryService.js";
+export class FinishCommand extends Command {
+    static register(root, createApp) {
+        group(root)
+            .command("finish")
+            .description("Complete feature delivery after all tickets are closed and required checks and reviews pass.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .option("--report <path>", "Optional or policy-required Markdown report inside feature reports/", CommandOptions.once("--report"))
+            .requiredOption("--author <author>", "Controller author", CommandOptions.once("--author"))
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            const command = await (await createApp()).make(FinishCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(DeliveryService)).finish(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/ImplementCommand.js

@@ -0,0 +1,23 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { AssignmentService } from "../Services/AssignmentService.js";
+export class ImplementCommand extends Command {
+    static register(root, createApp) {
+        group(root)
+            .command("implement")
+            .description("Persist and return an implementation assignment.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .requiredOption("--ticket <id>", "Ticket ID", CommandOptions.once("--ticket"))
+            .requiredOption("--author <author>", "Controller author", CommandOptions.once("--author"))
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            const command = await (await createApp()).make(ImplementCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(AssignmentService)).implement(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/NextCommand.js

@@ -0,0 +1,21 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { DeliveryService } from "../Services/DeliveryService.js";
+export class NextCommand extends Command {
+    static register(root, createApp) {
+        group(root)
+            .command("next")
+            .description("Show permitted ticket and whole-spec delivery actions without changing state.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            const command = await (await createApp()).make(NextCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(DeliveryService)).next(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/ReadyCommand.js

@@ -0,0 +1,21 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { ReadinessService } from "../Services/ReadinessService.js";
+export class ReadyCommand extends Command {
+    static register(root, createApp) {
+        group(root)
+            .command("ready")
+            .description("List ready tickets and tickets waiting on dependencies.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            const command = await (await createApp()).make(ReadyCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(ReadinessService)).ready(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/RequirementsDecideCommand.js

@@ -0,0 +1,33 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { RequirementsService } from "../Services/RequirementsService.js";
+export class RequirementsDecideCommand extends Command {
+    static register(root, createApp) {
+        group(root, "requirements")
+            .command("decide")
+            .description("Approve or reject a requirements change and invalidate prior review.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .option("--ticket <id>", "Ticket ID", CommandOptions.once("--ticket"))
+            .option("--scope <scope>", "Workflow scope: delivery")
+            .requiredOption("--finding <id>", "Finding affected by the requirements decision", CommandOptions.once("--finding"))
+            .requiredOption("--decision <decision>", "Decision: approved or rejected")
+            .requiredOption("--details <details>", "Decision rationale", CommandOptions.once("--details"))
+            .requiredOption("--author <author>", "Decision author", CommandOptions.once("--author"))
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            if (options.scope !== undefined && options.scope !== "delivery") {
+                throw new Error("--scope must be 'delivery'.");
+            }
+            if (Boolean(options.ticket) === (options.scope === "delivery")) {
+                throw new Error("requirements decide needs exactly one of --ticket or --scope delivery.");
+            }
+            const command = await (await createApp()).make(RequirementsDecideCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(RequirementsService)).requirementsDecide(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/ResumeCommand.js

@@ -0,0 +1,31 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { AssignmentService } from "../Services/AssignmentService.js";
+export class ResumeCommand extends Command {
+    static register(root, createApp) {
+        group(root)
+            .command("resume")
+            .description("Restore the recorded ticket or delivery gate and assignment.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .option("--ticket <id>", "Ticket ID", CommandOptions.once("--ticket"))
+            .option("--scope <scope>", "Workflow scope: delivery")
+            .requiredOption("--author <author>", "Controller author", CommandOptions.once("--author"))
+            .option("--confirm-handoff", "Confirm the previous controller has stopped editing")
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            if (options.scope !== undefined && options.scope !== "delivery") {
+                throw new Error("--scope must be 'delivery'.");
+            }
+            if (Boolean(options.ticket) === (options.scope === "delivery")) {
+                throw new Error("resume needs exactly one of --ticket or --scope delivery.");
+            }
+            const command = await (await createApp()).make(ResumeCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(AssignmentService)).resume(options);
+    }
+}