rl-workspaces 0.5.0 → 0.6.0

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/git-workflow.js

@@ -1,116 +1,22 @@
 import path from "node:path";
-import { randomUUID } from "node:crypto";
-import { args, arity, canonical, execute, git, gitRaw, locked, required, } from "./common.js";
+import { args, arity, canonical, execute, git, locked, required, } from "./common.js";
 import { commandContext, contextOptions, resolveWorkspace, } from "./command-context.js";
 import { worktrees } from "./repos.js";
 import { assertReady, GIT_WORKFLOW_DIRECTORY, GIT_WORKFLOW_LOCK, } from "./git-safety.js";
-const BACKUP_PREFIX = "refs/rl/backups/";
-const READ_OPTIONS = new Set([
-    "--stat",
-    "--name-only",
-    "--name-status",
-    "--numstat",
-    "--patch",
-    "--oneline",
-    "--graph",
-    "--decorate",
-    "--all",
-]);
 function revision(root, ref) {
     return git(root, "rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`);
 }
 export async function main(argv) {
-    const separator = argv.indexOf("--");
-    const trailing = separator < 0 ? [] : argv.slice(separator + 1);
-    const { values, positionals } = args(separator < 0 ? argv : argv.slice(0, separator), [...contextOptions, "base", "message"], ["all", "squash", "cleanup", "dry-run"], { message: "m" });
-    const context = commandContext(values);
+    const { values, positionals } = args(argv, [...contextOptions, "message"], ["squash", "cleanup", "dry-run"], { message: "m" });
     const [command, ...rest] = positionals;
+    if (command !== "merge")
+        throw new Error("Unknown Git workflow command");
+    arity(rest, 0, 1);
+    if (values.message && !values.squash)
+        throw new Error("Invalid merge options");
+    const context = commandContext(values);
     const source = resolveWorkspace(context);
-    if (command === "diff" || command === "log") {
-        arity(rest, 0);
-        if (values.all ||
-            values.squash ||
-            values.cleanup ||
-            values.message ||
-            values["dry-run"])
-            throw new Error("Invalid display options");
-        const pathSeparator = trailing.indexOf("--");
-        const flags = pathSeparator < 0 ? trailing : trailing.slice(0, pathSeparator);
-        const paths = pathSeparator < 0 ? [] : trailing.slice(pathSeparator + 1);
-        for (const flag of flags)
-            if (!READ_OPTIONS.has(flag) && !/^(-\d+|--max-count=\d+)$/.test(flag))
-                throw new Error(`Unsupported display option: ${flag}`);
-        const base = revision(source.path, String(values.base ?? context.defaultBase));
-        const range = command === "diff"
-            ? git(source.path, "merge-base", base, "HEAD")
-            : `${base}..HEAD`;
-        process.stdout.write(gitRaw(source.path, "--no-pager", command, "--no-ext-diff", "--no-textconv", ...(command === "log" ? ["--oneline"] : []), ...flags, range, "--", ...paths));
-        return 0;
-    }
-    if (trailing.length)
-        throw new Error("Extra arguments are only supported by diff and log");
     return locked(path.join(context.store.root, GIT_WORKFLOW_DIRECTORY), GIT_WORKFLOW_LOCK, async () => {
-        if (command === "step") {
-            arity(rest, 1);
-            const [action] = rest;
-            if (!["commit", "rebase", "squash"].includes(action))
-                throw new Error("Usage: rl step commit|rebase|squash");
-            if (values.cleanup ||
-                values.squash ||
-                (values.all && action !== "commit"))
-                throw new Error("Invalid step options");
-            assertReady(source.path, action !== "commit", source.branch);
-            if (action === "commit") {
-                if (values.base)
-                    throw new Error("commit does not accept --base");
-                const commitMessage = required(values, "message");
-                if (values["dry-run"]) {
-                    const changes = git(source.path, "diff", "--name-only", ...(values.all ? ["HEAD"] : ["--cached"]));
-                    if (!changes)
-                        throw new Error("No changes to commit");
-                    console.log(`Would commit ${values.all ? "tracked" : "staged"} changes in ${source.branch}: ${commitMessage}\n${changes}`);
-                    return 0;
-                }
-                console.log(git(source.path, "commit", ...(values.all ? ["--all"] : []), "-m", required(values, "message")));
-                return 0;
-            }
-            if (action === "rebase" && values.message)
-                throw new Error("rebase does not accept --message");
-            const base = revision(source.path, String(values.base ?? context.defaultBase));
-            if (action === "rebase") {
-                if (values["dry-run"]) {
-                    console.log(`Would rebase ${source.branch} onto ${base}`);
-                    return 0;
-                }
-                const result = await execute(["git", "-C", source.path, "rebase", base], source.path);
-                process.stdout.write(result.stdout);
-                if (result.code)
-                    throw new Error(`${result.stderr.trim()}\nRebase did not complete. Resolve conflicts and run git rebase --continue, or git rebase --abort in ${source.path}`);
-                return 0;
-            }
-            const message = required(values, "message");
-            const head = revision(source.path, "HEAD");
-            const baseCommit = git(source.path, "merge-base", base, head);
-            if (baseCommit === head)
-                throw new Error("No feature commits to squash");
-            if (values["dry-run"]) {
-                console.log(`Would squash commits after ${baseCommit} in ${source.branch}: ${message}`);
-                return 0;
-            }
-            const tree = git(source.path, "rev-parse", `${head}^{tree}`);
-            const backup = BACKUP_PREFIX + randomUUID();
-            const squashed = git(source.path, "commit-tree", tree, "-p", baseCommit, "-m", message);
-            git(source.path, "update-ref", backup, head);
-            // CAS leaves concurrent branch changes untouched; the worktree and index never change.
-            git(source.path, "update-ref", "-m", "rl step squash", `refs/heads/${source.branch}`, squashed, head);
-            console.log(`Squashed feature commits. Original HEAD retained at ${backup}`);
-            return 0;
-        }
-        if (command !== "merge")
-            throw new Error("Unknown Git workflow command");
-        arity(rest, 0, 1);
-        if (values.all || values.base || (values.message && !values.squash))
-            throw new Error("Invalid merge options");
         const selected = rest[0] ?? context.defaultBase.replace(/^origin\//, "");
         const targetRecord = worktrees(context.repo).find((record) => record.branch === `refs/heads/${selected}`);
         if (!targetRecord)

package/dist/help.js

@@ -149,6 +149,9 @@ const topics = {
     "agent set": {
         description: "Save an agent profile",
         usage: "rl agent set <name> --file <profile.json|->",
+        notes: [
+            "Use --instructions <file|-> to change instructions while preserving the profile's access, model and other settings.",
+        ],
     },
     "agent show": {
         description: "Inspect a workflow agent profile",
@@ -196,7 +199,7 @@ const topics = {
         notes: [
             "Creates .rl/agents.json, .rl/policies.json and .rl/agent-workflows.json.",
             "Existing configuration is never overwritten.",
-            "Roles inherit the current session by default. The preset queues a review before finishing changed work.",
+            "Adopted workspaces use built-in writer/reviewer/DRY roles immediately. Init writes editable copies of their profiles, policy and workflow.",
         ],
     },
     "workflow list": {
@@ -220,18 +223,18 @@ const topics = {
             "--request <UUID>     Start a queued workflow request instead of choosing a name",
         ],
         notes: [
-            "Default workflow: triple-review. RL never launches workflow agent or check processes.",
+            "Default workflow: writer-reviewer-dry. The parent spawns all three native peers in parallel and binds their handles; RL never launches agent processes.",
             "The parent claims ready steps, spawns native subagents and reports evidence. RL applies the policy; provider usage is parent-reported.",
         ],
         examples: ["rl workflow run --base origin/test --dry-run"],
     },
     "workflow add": {
         description: "Add a workflow with dependencies and spawn triggers",
-        usage: "rl workflow add <name> --file <workflow.json|->",
+        usage: "rl workflow add <name> --file <workflow.json|-> [--default]",
     },
     "workflow set": {
         description: "Save a workflow definition and trigger rules",
-        usage: "rl workflow set <name> --file <workflow.json|->",
+        usage: "rl workflow set <name> --file <workflow.json|-> [--default]",
     },
     "workflow context": {
         description: "Discover profiles, policies, workflows and trigger rules",
@@ -257,6 +260,30 @@ const topics = {
         description: "Dismiss an unavailable workflow with a reason",
         usage: "rl workflow dismiss --file <dismissal.json|-> [--agent codex|claude] [--session <UUID>]",
     },
+    "workflow bind": {
+        description: "Bind a role to the native peer spawned by this session",
+        usage: "rl workflow bind <run> --file <binding.json|-> [--agent codex|claude] [--session <UUID>]",
+    },
+    "workflow inbox": {
+        description: "Read a peer's requests, review checkpoints and ratings",
+        usage: "rl workflow inbox <run> --step <step> --claim <token> [--agent codex|claude] [--session <UUID>]",
+    },
+    "workflow consult": {
+        description: "Ask an existing peer through a configured workflow route",
+        usage: "rl workflow consult <run> --file <consultation.json|-> [--agent codex|claude] [--session <UUID>]",
+    },
+    "workflow answer": {
+        description: "Return reuse or duplication evidence to a requesting peer",
+        usage: "rl workflow answer <run> --file <answer.json|-> [--agent codex|claude] [--session <UUID>]",
+    },
+    "workflow submit": {
+        description: "Submit writer work to the existing reviewer",
+        usage: "rl workflow submit <run> --file <submission.json|-> [--agent codex|claude] [--session <UUID>]",
+    },
+    "workflow review": {
+        description: "Return a rating and evidence for a stable writer checkpoint",
+        usage: "rl workflow review <run> --file <review.json|-> [--agent codex|claude] [--session <UUID>]",
+    },
     "workflow status": {
         description: "Inspect a saved run",
         usage: "rl workflow status [UUID|latest] [--json]",
@@ -338,33 +365,9 @@ const topics = {
     },
     git: {
         group: "Code and reviews",
-        description: "Inspect and integrate branch changes",
+        description: "Integrate changes across workspaces",
         usage: "rl git <command>",
     },
-    "git diff": {
-        description: "Show workspace changes against the base",
-        usage: "rl git diff [--base <ref>] [-- <display options> [-- paths...]]",
-        examples: ["rl git diff -- --stat"],
-    },
-    "git log": {
-        description: "Show feature commits",
-        usage: "rl git log [--base <ref>] [-- <display options>]",
-        examples: ["rl git log -- --graph"],
-    },
-    "git commit": {
-        description: "Commit staged changes",
-        usage: "rl git commit -m <message> [--all] [--dry-run]",
-        notes: ["--all includes modified tracked files."],
-    },
-    "git rebase": {
-        description: "Rebase onto the base branch",
-        usage: "rl git rebase [--base <ref>] [--dry-run]",
-    },
-    "git squash": {
-        description: "Squash feature commits",
-        usage: "rl git squash -m <message> [--base <ref>] [--dry-run]",
-        notes: ["The original HEAD is retained under a printed backup ref."],
-    },
     "git merge": {
         description: "Integrate into a checked-out base branch",
         usage: "rl git merge [target] [--squash -m <message>] [--cleanup] [--dry-run]",
@@ -551,9 +554,6 @@ const topics = {
     },
 };
 const aliases = [
-    [["step"], ["git"]],
-    [["diff"], ["git", "diff"]],
-    [["log"], ["git", "log"]],
     [["merge"], ["git", "merge"]],
     [["clean"], ["storage", "clean"]],
     [["summary"], ["notes", "summary"]],