rl-workspaces 0.5.0 → 0.7.0

package/dist/agent-launch.js

@@ -53,7 +53,7 @@ export async function main(argv) {
         if (extra.length ||
             values.prompt !== undefined ||
             (values.stdout && values.output !== undefined))
-            throw new Error("Usage: rl handoff [agent] [--stdout | --output path]");
+            throw new Error("Usage: rl agent handoff [agent] [--stdout | --output path]");
         const text = await handoff(context.store, name, target.path);
         if (typeof values.output === "string")
             fs.writeFileSync(values.output, text, { flag: "wx", mode: 0o600 });

package/dist/agent-presets.js

@@ -1,45 +1,70 @@
 export const PRESET = {
+    defaultWorkflow: "writer-reviewer-dry",
     agents: {
-        behavior: {
+        writer: {
             provider: "inherit",
             reasoning: "high",
-            description: "Runtime correctness, user journeys, persistence and security",
-            instructions: "Investigate supported end-to-end user journeys: input, validation, serialization, persistence, queries, subscriptions, caches, rendering and downstream consumers. Own runtime bugs, regressions, concurrency, error behavior, tenant isolation and demonstrable runtime performance failures. Check current code and intended behavior; history and old comments are leads, not proof. Distinguish current defects from fixed regressions, intentional boundaries and unverified hypotheses. Findings need prerequisites, reproducible steps, expected versus actual behavior, and evidence; label code-inferred reproductions. Do not review type hygiene without runtime impact, test design, debug cleanup, duplication or structural simplification. Attach regression advice to the corresponding bug rather than filing duplicate missing-test findings.",
+            access: "workspace-write",
+            description: "Implement scoped changes and submit review checkpoints",
+            instructions: "Own implementation in the assigned workspace and files. You are not alone: preserve other people's work and coordinate changes with the parent. Start alongside the reviewer and DRY peer; do not spawn replacement reviewers or searchers. Follow the workflow's configured consultation rules. By default, before adding any new function consult the existing DRY peer using event new_function and a precise subject such as src/file.ts#functionName, then wait for its answer and reuse existing behavior when appropriate. Submit bounded, stable file groups to the reviewer with all newFunctions declared. Freeze submitted files while a review is pending; you may continue on unrelated files. Address feedback and resubmit until the configured rating and policy requirements pass. Report actual checks, remaining work and limitations honestly. Do not close your stage until current changes have accepted reviews and your consultations are answered.",
         },
-        reuse: {
+        reviewer: {
             provider: "inherit",
             reasoning: "high",
-            description: "Reuse, duplicated behavior and avoidable complexity",
-            instructions: "Search the repository for existing components, hooks, services, utilities, dependencies and alternate implementations before judging a new capability. Own duplicated business behavior, unnecessary abstractions/features, redundant state and misplaced responsibilities with concrete maintenance cost. Prefer reuse, extension, composition, then a small focused implementation. Cite both the reviewed implementation and existing counterpart, the behavioral overlap and a viable smaller solution. For pure simplification, name removable machinery and explain how requirements are preserved. Small duplication and different presentations can be justified. Do not investigate runtime/security bugs, type-only duplication, logging cleanup or test quality. Labels such as DRY, YAGNI and code smell are not evidence.",
+            access: "read-only",
+            description: "Review writer submissions and return evidence-backed ratings",
+            instructions: "Stay read-only and available alongside the writer and DRY peer. Review each writer submission against its saved checkpoint, surrounding source, intended behavior and the separate policy. Assess correctness, authorization, persistence, concurrency, type contracts and meaningful validation. Return a rating and rationale using the configured rating scale, with structured findings, coverage limitations and required fixes. Follow the workflow's configured consultation rules. By default, if you suspect duplication consult the existing DRY peer using event suspected_duplicate and a precise subject before returning the review. Declare every duplicateSuspicions subject. Incorporate its evidence rather than treating similarity as proof. Send actionable feedback to the writer, re-review resubmissions, and never equate missing evidence with a clean result. Do not edit code, silently replace peers, or finish before the writer and all submitted work are settled.",
         },
-        quality: {
+        dry: {
             provider: "inherit",
             reasoning: "high",
-            description: "Type contracts, static checks, debug leftovers and test quality",
-            instructions: "Own unjustified any, casts and suppressions, overly broad contracts, failure to reuse applicable types, accidental debug leftovers, attributable static-check failures, and tests that cannot protect their claimed behavior. Distinguish safe unknown narrowing and justified dependency escape hatches from weakened checking. Preserve intentional operational logging. For test findings name a specific material contract and a useful assertion, not a coverage percentage. Do not review runtime correctness/security, architecture or duplicated business behavior. A test failure is not automatically a product bug. Request configured checks from the coordinator instead of running duplicate commands. Omit style preferences and broad cleanup of existing code.",
+            access: "read-only",
+            description: "Shared reuse and duplication specialist for writer and reviewer",
+            instructions: "Stay read-only and available as the single DRY peer for both writer and reviewer. You may map relevant existing utilities while waiting for requests. Answer new_function consultations from the writer before it adds behavior, and suspected_duplicate consultations from the reviewer before it returns a rating. Search current source for existing functions, components, services, types and dependencies. Cite concrete paths/symbols, behavioral overlap, relevant differences and a viable reuse approach; state explicitly when no suitable implementation was found or coverage is incomplete. Small or superficial similarity alone is not evidence of harmful duplication. Respond to the requesting peer through its consultation record; do not edit files, assign ratings, create more agents, or close while requests or either peer remain active.",
         },
     },
     policies: {
         review: {
-            instructions: "Report only evidence-backed problems caused or materially worsened by the reviewed changes. Separate required fixes from optional quick wins with reasons. Critical means security exposure, destructive data loss or outage; high means broken core behavior or substantial structural cost; medium means a contained defect or worthwhile required quality fix; low means an optional quick win. Do not block on stylistic preference, tiny duplication, justified type escape hatches, intentional operational logging, speculative flexibility or generic demands for tests. Missing dependencies, unverified critical paths and unresolved material questions are coverage limitations. Do not invent findings or treat a score as a probability of correctness.",
+            instructions: "Report evidence-backed defects caused or materially worsened by the submitted work. Separate required fixes from optional improvements, and explain prerequisites, expected behavior and observed or inferred failures. Evaluate reuse against concrete alternatives. Avoid style-only blockers and invented findings. Missing checks, dependencies and unverified material paths are coverage limitations. Review ratings are judgments supported by evidence; RL's policy score is calculated separately and is not a probability of correctness.",
             weights: { critical: 50, high: 20, medium: 10, low: 2 },
             minimumScore: 0,
             blockRequired: true,
+            rating: {
+                min: 0,
+                max: 100,
+                minimum: 90,
+                instructions: "Rate each submission from 0 to 100. 90–100 means ready with verified material behavior and no required fixes; 70–89 needs contained corrections or validation; below 70 needs substantial corrections. Explain the rating and uncertainty. A high rating never overrides required fixes, failed checks or incomplete coverage.",
+            },
         },
     },
     workflows: {
-        "triple-review": {
-            description: "Three independent reviewers, owner follow-ups and a policy-based verdict",
+        "writer-reviewer-dry": {
+            description: "Parallel writer, reviewer and DRY peers with rated review checkpoints",
             policy: "review",
             concurrency: 3,
             retries: 1,
-            timeoutSeconds: 600,
-            triggers: [{ event: "before_finish", changes: true }],
+            timeoutSeconds: 3600,
+            triggers: [{ event: "task_planned" }, { event: "before_edit" }],
             steps: [
-                { id: "behavior", agent: "behavior", after: [] },
-                { id: "reuse", agent: "reuse", after: [] },
-                { id: "quality", agent: "quality", after: [] },
+                { id: "writer", agent: "writer", after: [] },
+                { id: "reviewer", agent: "reviewer", after: [] },
+                { id: "dry", agent: "dry", after: [] },
             ],
+            collaboration: {
+                writer: "writer",
+                reviewer: "reviewer",
+                dry: "dry",
+                maxRounds: 5,
+                rules: [
+                    { from: "writer", event: "new_function", to: "dry", required: true },
+                    {
+                        from: "reviewer",
+                        event: "suspected_duplicate",
+                        to: "dry",
+                        required: true,
+                    },
+                ],
+            },
         },
     },
 };

package/dist/agent-resume.js

@@ -19,7 +19,7 @@ export async function resumeSessions(store, kind, options = {}) {
                 : a.agent.localeCompare(b.agent) || a.id.localeCompare(b.id);
     });
     if (!choices.length)
-        throw new Error(`No ${kind ? `${kind} ` : ""}session recorded for ${data.id}. Use 'rl session save' to save a session first`);
+        throw new Error(`No ${kind ? `${kind} ` : ""}session recorded for ${data.id}. Use 'rl agent save' to save a session first`);
     let selected = choices[0];
     if (choices.length > 1 && !options.latest) {
         const visible = (value) => stripVTControlCharacters(value).replace(/[\x00-\x1f\x7f-\x9f]/g, " ");
@@ -70,7 +70,7 @@ export async function resumeAgent(store, kind, options = {}) {
             ? sessions.find((item) => item.id === sessionId(options.sessionId))
             : sessions.reduce((a, b) => !a || timestamp(b.lastUsedAt) > timestamp(a.lastUsedAt) ? b : a, undefined);
         if (!item)
-            throw new Error(`No ${kind} session recorded for ${data.id}. Use 'rl session save ${kind}${kind === "claude" ? " <UUID>" : ""}'`);
+            throw new Error(`No ${kind} session recorded for ${data.id}. Use 'rl agent save ${kind}${kind === "claude" ? " <UUID>" : ""}'`);
         return [file, data, sessionId(item.id)];
     });
     const stamp = now();

package/dist/agent-runner.js

@@ -6,6 +6,7 @@ import { readJsonObject } from "./json.js";
 import { validateAutomation, } from "./automation-config.js";
 import { evaluate, validateResult, } from "./review-policy.js";
 import { agentAdapter } from "./agent-registry.js";
+import { collaborationAssessment, initializeCollaboration, validateCollaborationState, } from "./workflow-collaboration.js";
 export function captureScope(cwd, base) {
     if (!base || base.startsWith("-") || /[\x00-\x20\x7f]/.test(base))
         throw new Error("Expected a literal base ref");
@@ -126,6 +127,8 @@ function load(directory) {
     if (!Object.hasOwn(raw.config.workflows, raw.workflow))
         throw new Error("Invalid saved workflow");
     const definition = raw.config.workflows[raw.workflow];
+    if (definition.collaboration)
+        validateCollaborationState(raw.collaboration);
     const seen = new Set();
     for (const stage of raw.stages) {
         if (!object(stage) ||
@@ -213,11 +216,14 @@ export function evaluation(run, policy = run.config.policies[run.config.workflow
         stage.result !== undefined &&
         currentScope(stage))
         .map((stage) => ({ owner: stage.id, result: stage.result }));
+    const collaboration = collaborationAssessment(run);
+    reports.push(...collaboration.reports);
     const limitations = run.stages
         .filter((stage) => stage.status !== "completed")
         .map((stage) => `${stage.id}: ${stage.error ?? stage.status}`);
     if (run.status !== "completed")
         limitations.push(`Run ${run.status}`);
+    limitations.push(...collaboration.limitations);
     for (const stage of run.stages.filter((stage) => stage.status === "completed" && !currentScope(stage))) {
         if (stage.agent &&
             run.config.agents[stage.agent].access === "workspace-write")
@@ -269,6 +275,19 @@ export function runMetrics(run) {
         outputTokens: total("outputTokens"),
         costUsd: total("costUsd"),
         usageCoverage: `${reported.length}/${run.stages.filter((step) => step.agent && step.attempts).length} agent stages`,
+        ...(run.collaboration
+            ? {
+                collaboration: {
+                    consultations: run.collaboration.consultations.length,
+                    awaitingAnswers: run.collaboration.consultations.filter((item) => !item.answer).length,
+                    submissions: run.collaboration.submissions.length,
+                    accepted: run.collaboration.submissions.filter((item) => !item.supersededBy && item.review?.accepted).length,
+                    latestRating: [...run.collaboration.submissions]
+                        .reverse()
+                        .find((item) => item.review)?.review?.rating ?? null,
+                },
+            }
+            : {}),
         stages: run.stages.map(({ id, status, attempts, durationMs, usage }) => ({
             id,
             status,
@@ -326,6 +345,7 @@ export function createRunLocked(store, config, workflow, base, prompt) {
             durationMs: 0,
         })),
     };
+    initializeCollaboration(run);
     fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
     fs.writeFileSync(path.join(directory, "scope.json"), context, {
         mode: 0o600,

package/dist/agent-workflows.js

@@ -3,7 +3,7 @@ import fs from "node:fs";
 import { stripVTControlCharacters } from "node:util";
 import { args, arity, json } from "./common.js";
 import { commandContext, contextOptions } from "./command-context.js";
-import { CONFIG_FILES, initAutomation, readAutomation, setAutomation, } from "./automation-config.js";
+import { CONFIG_FILES, initAutomation, readAutomation, setAutomation, defaultWorkflow, } from "./automation-config.js";
 import { controlRun, planRun, readRun, rescoreRun, runMetrics, } from "./agent-runner.js";
 import { callWorkflowTool, resumeNativeRun } from "./session-workflows.js";
 import { parseJsonObject } from "./json.js";
@@ -17,6 +17,12 @@ function report(run, asJson) {
     console.log(`\n${visible(run.workflow)} · ${run.status}\nRun: ${run.id}\nWorkspace: ${visible(run.workspace)}\nScope: ${visible(run.scope.base)} → ${run.scope.head.slice(0, 12)} · ${run.scope.files.length} changed files\n`);
     for (const stage of run.stages)
         console.log(`  ${stage.id.padEnd(22)} ${stage.status.padEnd(10)} ${stage.attempts} attempt(s) · ${(stage.durationMs / 1000).toFixed(1)}s${stage.error ? ` · ${visible(stage.error)}` : ""}`);
+    if (run.collaboration) {
+        const rating = run.config.policies[run.config.workflows[run.workflow].policy].rating;
+        for (const submission of run.collaboration.submissions.filter((item) => !item.supersededBy))
+            console.log(`  Review ${submission.id.slice(0, 8)} · round ${submission.round} · ${submission.review ? `${submission.review.rating}/${rating.max} · ${submission.review.accepted ? "accepted" : "changes required"}` : "awaiting reviewer"}`);
+        console.log(`  DRY: ${run.collaboration.consultations.filter((item) => !item.answer).length} unanswered consultation(s)`);
+    }
     if (run.evaluation) {
         const result = run.evaluation;
         console.log(`\n${result.score === null ? "Not scored" : `Score: ${result.score}/100`} · ${result.verdict}${result.verdict === "incomplete" && result.score !== null ? " (provisional)" : ""}`);
@@ -44,7 +50,8 @@ export async function main(argv) {
         "session",
         "step",
         "request",
-    ], ["json", "dry-run"]);
+        "claim",
+    ], ["json", "dry-run", "default"]);
     const context = commandContext(values);
     const [namespace, action, ...rest] = positionals;
     arity(rest, 0, 1);
@@ -52,6 +59,9 @@ export async function main(argv) {
     const asJson = !!values.json;
     if (values.file && values.instructions)
         throw new Error("Choose --file or --instructions, not both");
+    if (values.default &&
+        !(namespace === "workflow" && ["add", "set"].includes(action)))
+        throw new Error("--default requires workflow add/set");
     if ((values.description || values.model || values.reasoning) &&
         !(namespace === "agent" &&
             ["add", "set"].includes(action) &&
@@ -89,16 +99,27 @@ export async function main(argv) {
     if ((namespace === "agent" || namespace === "workflow") &&
         ["add", "set"].includes(action)) {
         arity(rest, 1);
-        const value = namespace === "agent" && values.instructions !== undefined
-            ? {
-                provider: "inherit",
-                description: String(values.description ?? rest[0]),
-                instructions: fs.readFileSync(values.instructions === "-" ? 0 : String(values.instructions), "utf8"),
-                ...(values.model ? { model: values.model } : {}),
-                ...(values.reasoning ? { reasoning: values.reasoning } : {}),
-            }
-            : loadInput();
-        await context.store.locked(() => setAutomation(data.worktree, namespace === "agent" ? "agents" : "workflows", rest[0], value, action === "add"));
+        const instructions = namespace === "agent" && values.instructions !== undefined
+            ? fs.readFileSync(values.instructions === "-" ? 0 : String(values.instructions), "utf8")
+            : undefined;
+        const input = instructions === undefined ? loadInput() : undefined;
+        const value = await context.store.locked(() => {
+            const previous = namespace === "agent" && action === "set"
+                ? readAutomation(data.worktree).agents[rest[0]]
+                : undefined;
+            const profile = instructions === undefined
+                ? input
+                : {
+                    provider: "inherit",
+                    ...previous,
+                    description: String(values.description ?? previous?.description ?? rest[0]),
+                    instructions,
+                    ...(values.model ? { model: values.model } : {}),
+                    ...(values.reasoning ? { reasoning: values.reasoning } : {}),
+                };
+            setAutomation(data.worktree, namespace === "agent" ? "agents" : "workflows", rest[0], profile, action === "add", !!values.default);
+            return profile;
+        });
         await context.store.adopt(data.worktree);
         if (asJson)
             json(value);
@@ -111,8 +132,25 @@ export async function main(argv) {
         ...(values.session ? { sessionId: values.session } : {}),
     };
     if (namespace === "workflow" &&
-        ["context", "pending", "event", "claim", "report", "dismiss"].includes(action)) {
-        const input = action === "report" || action === "dismiss" || action === "event"
+        [
+            "context",
+            "pending",
+            "event",
+            "claim",
+            "report",
+            "dismiss",
+            "bind",
+            "inbox",
+            "consult",
+            "answer",
+            "submit",
+            "review",
+        ].includes(action)) {
+        const input = action === "report" ||
+            action === "dismiss" ||
+            action === "event" ||
+            ["bind", "consult", "answer", "submit", "review"].includes(action) ||
+            values.file
             ? loadInput()
             : {};
         const result = await callWorkflowTool(context.store, `rl_workflow_${action}`, {
@@ -120,6 +158,7 @@ export async function main(argv) {
             ...parent,
             ...(rest[0] ? { run: rest[0] } : {}),
             ...(values.step ? { step: values.step } : {}),
+            ...(values.claim ? { claim: values.claim } : {}),
         });
         if (asJson || action !== "context")
             json(result);
@@ -166,7 +205,7 @@ export async function main(argv) {
     const name = rest[0];
     if (action === "run") {
         const config = configuration();
-        const workflow = name ?? "triple-review", base = String(values.base ?? context.defaultBase);
+        const workflow = name ?? defaultWorkflow(config), base = String(values.base ?? context.defaultBase);
         if (values["dry-run"]) {
             const plan = planRun(context.store, config, workflow, base);
             if (asJson)
@@ -215,7 +254,12 @@ export async function main(argv) {
         else {
             console.log(`Metrics: ${run.id}`);
             for (const [key, value] of Object.entries(metrics))
-                if (key !== "stages")
+                if (key === "collaboration" && metrics.collaboration) {
+                    const team = metrics.collaboration;
+                    console.log(`Reviews: ${team.accepted} accepted · ${team.submissions} submissions · latest rating ${team.latestRating ?? "not reported"}`);
+                    console.log(`Consultations: ${team.consultations} total · ${team.awaitingAnswers} awaiting answers`);
+                }
+                else if (key !== "stages")
                     console.log(`${key}: ${value ?? "not reported"}`);
         }
         return 0;

package/dist/automation-config.js

@@ -35,7 +35,7 @@ function integer(value, min, max) {
         throw new Error(`Expected an integer from ${min} to ${max}`);
 }
 export function validateAutomation(value) {
-    fields(value, ["agents", "policies", "workflows"]);
+    fields(value, ["agents", "policies", "workflows", "defaultWorkflow"], ["agents", "policies", "workflows"]);
     for (const kind of ["agents", "policies", "workflows"]) {
         const entries = value[kind];
         if (!object(entries) ||
@@ -79,7 +79,8 @@ export function validateAutomation(value) {
                     "weights",
                     "minimumScore",
                     "blockRequired",
-                ]);
+                    "rating",
+                ], ["instructions", "weights", "minimumScore", "blockRequired"]);
                 nonempty(item.instructions);
                 fields(item.weights, [...SEVERITIES]);
                 for (const weight of Object.values(item.weights))
@@ -87,6 +88,16 @@ export function validateAutomation(value) {
                 integer(item.minimumScore, 0, 100);
                 if (typeof item.blockRequired !== "boolean")
                     throw new Error("blockRequired must be boolean");
+                if (item.rating !== undefined) {
+                    fields(item.rating, ["min", "max", "minimum", "instructions"]);
+                    for (const key of ["min", "max", "minimum"])
+                        integer(item.rating[key], 0, 1000);
+                    if (Number(item.rating.max) <= Number(item.rating.min) ||
+                        Number(item.rating.minimum) < Number(item.rating.min) ||
+                        Number(item.rating.minimum) > Number(item.rating.max))
+                        throw new Error("Invalid reviewer rating range");
+                    nonempty(item.rating.instructions);
+                }
             }
             else {
                 fields(item, [
@@ -97,6 +108,7 @@ export function validateAutomation(value) {
                     "timeoutSeconds",
                     "steps",
                     "triggers",
+                    "collaboration",
                 ], [
                     "description",
                     "policy",
@@ -176,9 +188,77 @@ export function validateAutomation(value) {
                         done.add(id);
                     }
                 }
+                if (item.collaboration !== undefined) {
+                    const collaboration = item.collaboration;
+                    fields(collaboration, [
+                        "writer",
+                        "reviewer",
+                        "dry",
+                        "maxRounds",
+                        "rules",
+                    ]);
+                    const roles = [
+                        collaboration.writer,
+                        collaboration.reviewer,
+                        collaboration.dry,
+                    ];
+                    if (new Set(roles).size !== 3 || Number(item.concurrency) < 3)
+                        throw new Error("Collaborative roles require three distinct steps and concurrency of at least three");
+                    for (const role of roles) {
+                        identifier(role);
+                        const step = item.steps.find((step) => step.id === role);
+                        if (!step?.agent || step.after.length)
+                            throw new Error("Collaborative roles must be agent steps ready together at startup");
+                        const profile = object(value.agents)
+                            ? value.agents[step.agent]
+                            : undefined;
+                        if (role === collaboration.writer &&
+                            object(profile) &&
+                            profile.access !== "workspace-write")
+                            throw new Error("Collaborative writer must have workspace-write access");
+                        if (role !== collaboration.writer &&
+                            object(profile) &&
+                            profile.access === "workspace-write")
+                            throw new Error("Reviewer and DRY roles must be read-only");
+                    }
+                    integer(collaboration.maxRounds, 1, 20);
+                    const policy = object(value.policies)
+                        ? value.policies[item.policy]
+                        : undefined;
+                    if (!object(policy) || !object(policy.rating))
+                        throw new Error("Collaborative workflows require a reviewer rating policy");
+                    if (!Array.isArray(collaboration.rules) ||
+                        collaboration.rules.length > 32)
+                        throw new Error("Expected up to 32 collaboration rules");
+                    const routes = new Set();
+                    for (const rule of collaboration.rules) {
+                        fields(rule, ["from", "event", "to", "required"]);
+                        if (!roles.includes(rule.from) ||
+                            !roles.includes(rule.to) ||
+                            rule.from === rule.to ||
+                            typeof rule.required !== "boolean")
+                            throw new Error("Invalid collaboration route");
+                        identifier(rule.event);
+                        if (rule.required &&
+                            !((rule.from === collaboration.writer &&
+                                rule.event === "new_function") ||
+                                (rule.from === collaboration.reviewer &&
+                                    rule.event === "suspected_duplicate")))
+                            throw new Error("Required consultations support writer new_function and reviewer suspected_duplicate; use required: false for additional message routes");
+                        const key = `${rule.from}:${rule.event}:${rule.to}`;
+                        if (routes.has(key))
+                            throw new Error("Duplicate collaboration rule");
+                        routes.add(key);
+                    }
+                }
             }
         }
     }
+    if (value.defaultWorkflow !== undefined &&
+        (!object(value.workflows) ||
+            typeof value.defaultWorkflow !== "string" ||
+            !Object.hasOwn(value.workflows, value.defaultWorkflow)))
+        throw new Error("Unknown default workflow");
 }
 function configPath(root, relative) {
     const directory = path.join(root, ".rl"), file = path.join(root, relative);
@@ -191,16 +271,68 @@ export function readAutomation(root) {
     const result = {};
     for (const [kind, relative] of Object.entries(CONFIG_FILES)) {
         const file = configPath(root, relative);
-        if (!fs.existsSync(file))
+        if (!fs.existsSync(file)) {
             result[kind] = structuredClone(PRESET[kind]);
+            if (kind === "workflows")
+                result.defaultWorkflow = PRESET.defaultWorkflow;
+        }
         else {
             const data = readJsonObject(file);
-            fields(data, ["version", kind]);
+            fields(data, kind === "workflows" ? ["version", kind, "default"] : ["version", kind], ["version", kind]);
             if (data.version !== 1)
                 throw new Error("Unsupported agent configuration version");
             result[kind] = data[kind];
+            if (kind === "workflows")
+                result.defaultWorkflow =
+                    data.default === undefined
+                        ? object(data.workflows)
+                            ? Object.keys(data.workflows)[0]
+                            : undefined
+                        : data.default;
         }
     }
+    // Older add/set commands could write just one configuration file. Supply
+    // the roles/rating needed by the inherited workflow without replacing any
+    // explicit profile or changing the user's files.
+    if (!fs.existsSync(configPath(root, CONFIG_FILES.workflows))) {
+        if (object(result.agents))
+            result.agents = { ...structuredClone(PRESET.agents), ...result.agents };
+        if (object(result.policies) &&
+            object(result.policies.review) &&
+            result.policies.review.rating === undefined)
+            result.policies.review = {
+                ...result.policies.review,
+                rating: structuredClone(PRESET.policies.review.rating),
+            };
+    }
+    else if (!fs.existsSync(configPath(root, CONFIG_FILES.agents)) &&
+        object(result.workflows) &&
+        object(result.agents)) {
+        const legacy = {
+            behavior: {
+                ...PRESET.agents.reviewer,
+                description: "Review runtime correctness and security",
+                instructions: "Independently review the supplied scope for runtime correctness, authorization, persistence and concurrency defects. Stay read-only; report concrete evidence and coverage limitations using the supplied result schema.",
+            },
+            reuse: {
+                ...PRESET.agents.dry,
+                description: "Review reuse and complexity",
+                instructions: "Independently search existing source and dependencies for concrete reuse opportunities in the supplied scope. Stay read-only; distinguish behavioral overlap from superficial similarity and report paths, symbols, findings and coverage limitations using the supplied result schema.",
+            },
+            quality: {
+                ...PRESET.agents.reviewer,
+                description: "Review implementation quality and validation",
+                instructions: "Independently review the supplied scope for type contracts, maintainability, failure handling and meaningful validation. Stay read-only; report evidence-backed findings and coverage limitations using the supplied result schema.",
+            },
+        };
+        for (const workflow of Object.values(result.workflows))
+            if (object(workflow) && Array.isArray(workflow.steps))
+                for (const step of workflow.steps)
+                    if (object(step) &&
+                        typeof step.agent === "string" &&
+                        Object.hasOwn(legacy, step.agent))
+                        result.agents[step.agent] = structuredClone(legacy[step.agent]);
+    }
     validateAutomation(result);
     return result;
 }
@@ -218,12 +350,13 @@ export function initAutomation(root, provider) {
         writeJson(configPath(root, relative), {
             version: 1,
             [kind]: preset[kind],
+            ...(kind === "workflows" ? { default: preset.defaultWorkflow } : {}),
         });
 }
 export function hasAutomation(root) {
     return Object.values(CONFIG_FILES).some((relative) => fs.existsSync(configPath(root, relative)));
 }
-export function setAutomation(root, kind, name, value, addOnly = false) {
+export function setAutomation(root, kind, name, value, addOnly = false, makeDefault = false) {
     identifier(name);
     const config = readAutomation(root);
     if (addOnly && Object.hasOwn(config[kind], name))
@@ -234,9 +367,15 @@ export function setAutomation(root, kind, name, value, addOnly = false) {
         writable: true,
         configurable: true,
     });
+    if (makeDefault)
+        config.defaultWorkflow = name;
     validateAutomation(config);
     writeJson(configPath(root, CONFIG_FILES[kind]), {
         version: 1,
         [kind]: config[kind],
+        ...(kind === "workflows" ? { default: config.defaultWorkflow } : {}),
     });
 }
+export function defaultWorkflow(config) {
+    return config.defaultWorkflow ?? Object.keys(config.workflows)[0];
+}

package/dist/bootstrap.js

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { findExecutable, setupDependencies } from "./dependencies.js";
+import { installRl } from "./install.js";
+import { explicitHelp } from "./help.js";
+const argv = process.argv.slice(2);
+const selected = argv[0] === "--repo"
+    ? argv.slice(2)
+    : argv[0]?.startsWith("--repo=")
+        ? argv.slice(1)
+        : argv;
+if (selected[0] === "setup" &&
+    ["dependencies", "install"].includes(selected[1])) {
+    try {
+        if (selected.includes("--help") || selected.includes("-h"))
+            console.log(explicitHelp(selected));
+        else
+            process.exitCode =
+                selected[1] === "install"
+                    ? await installRl(selected.slice(2))
+                    : await setupDependencies(selected.slice(2));
+    }
+    catch (error) {
+        console.error(`rl: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    }
+}
+else if (argv[0] === "--version" || argv[0] === "-V") {
+    console.log(JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8")).version);
+}
+else {
+    const zsh = findExecutable("zsh");
+    if (!zsh) {
+        console.error("rl: zsh is required. Run 'rl setup dependencies' to install the RL toolchain.");
+        process.exitCode = 1;
+    }
+    else {
+        const child = spawn(zsh, [
+            "-f",
+            fileURLToPath(new URL("../lib/entry.zsh", import.meta.url)),
+            ...argv,
+        ], {
+            stdio: "inherit",
+            env: {
+                ...process.env,
+                PATH: `${process.env.PATH ? process.env.PATH + path.delimiter : ""}${path.dirname(process.execPath)}`,
+            },
+        });
+        const interrupt = () => child.kill("SIGINT");
+        const terminate = () => child.kill("SIGTERM");
+        process.on("SIGINT", interrupt);
+        process.on("SIGTERM", terminate);
+        await new Promise((resolve) => {
+            const cleanup = () => {
+                process.off("SIGINT", interrupt);
+                process.off("SIGTERM", terminate);
+            };
+            child.on("error", (error) => {
+                cleanup();
+                console.error(`rl: ${error.message}`);
+                process.exitCode = 1;
+                resolve();
+            });
+            child.on("close", (code, signal) => {
+                cleanup();
+                process.exitCode =
+                    code ?? (signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : 1);
+                resolve();
+            });
+        });
+    }
+}

package/dist/cli.js

@@ -10,6 +10,7 @@ import { main as git } from "./git-workflow.js";
 import { main as pr } from "./pr-workflow.js";
 import { main as agent } from "./agent-launch.js";
 import { main as mcp } from "./mcp.js";
+import { main as mcpSetup } from "./mcp-setup.js";
 import { main as task } from "./task.js";
 import { main as storage } from "./storage.js";
 import { main as prUpdate } from "./pr-update.js";
@@ -25,6 +26,7 @@ const commands = {
     pr,
     agent,
     mcp,
+    "mcp-setup": mcpSetup,
     task,
     storage,
     "pr-update": prUpdate,

package/dist/command-context.js

@@ -49,7 +49,7 @@ export function resolveWorkspace(context, selector) {
         const [root, branch] = context.store.worktree(context.repo);
         return { path: root, name: "@", branch };
     }
-    const choices = candidates(context.repo, context.managedDir);
+    const choices = candidates(context.repo, context.managedDir, context.store);
     const matches = choices.filter((item) => item.name === selector ||
         item.branch === selector ||
         (path.isAbsolute(selector) && item.path === canonical(selector)));