@deksden-com/dd-flow-cli 0.8.0 → 0.9.0-beta.0

package/dist/services/lifecycle-command.js

@@ -0,0 +1,288 @@
+import path from "node:path";
+import { parse, quote } from "shell-quote";
+const controlOperators = new Set(["&&", "||", ";", "|", "|&", "&", "(", ")", "<(", ">("]);
+const redirectionOperators = new Set(["<", ">", ">>", ">|", "<&", ">&", "<<<"]);
+/** Parse the deliberately small direct-command surface accepted by lifecycle hooks. */
+export function parseLifecycleCommand(command) {
+    return parseLifecycleCommandInner(command, false);
+}
+/** Preserve the historical Desktop contract: execute the payload, not its one-command shell wrapper. */
+export function unwrapShellCommand(command) {
+    let entries;
+    try {
+        entries = parse(command, (name) => `$${name}`);
+    }
+    catch {
+        return command;
+    }
+    if (!entries.every((entry) => typeof entry === "string"))
+        return command;
+    const words = entries;
+    let index = 0;
+    while (index < words.length && assignment(words[index]))
+        index += 1;
+    const executable = path.basename(words[index] ?? "");
+    if (!new Set(["bash", "sh", "zsh"]).has(executable))
+        return command;
+    if (!new Set(["-c", "-lc", "-cl"]).has(words[index + 1] ?? "") || words.length !== index + 3)
+        return command;
+    return words[index + 2] ?? command;
+}
+function parseLifecycleCommandInner(command, wrapped) {
+    const heredoc = stripHeredocBodies(command);
+    let entries;
+    try {
+        entries = parse(heredoc.command, (name) => `$${name}`);
+    }
+    catch {
+        // A command that cannot be tokenized cannot create a trusted claim. The
+        // real lifecycle CLI will consequently fail its binding requirement.
+        return { kind: "none" };
+    }
+    const { segments, composed } = commandSegments(entries);
+    const found = [];
+    const exportedEnv = {};
+    for (const segment of segments) {
+        Object.assign(exportedEnv, exportedAssignments(segment));
+        const direct = invocationFromSegment(segment, heredoc.present, wrapped, exportedEnv);
+        if (direct) {
+            found.push({ invocation: direct, nestedCompound: segment.dynamic });
+            continue;
+        }
+        const nested = wrappedInvocationFromSegment(segment);
+        if (nested && nested.kind !== "none")
+            found.push({ invocation: { ...nested.invocation, heredoc: nested.invocation.heredoc || heredoc.present, rewriteSafe: false, wrapped: true }, nestedCompound: nested.kind === "compound" });
+    }
+    if (!found.length)
+        return { kind: "none" };
+    const first = found[0];
+    if (found.length !== 1 || composed || first.nestedCompound) {
+        return {
+            kind: "compound",
+            invocation: { ...first.invocation, rewriteSafe: false },
+            reason: found.length !== 1 ? "multiple_lifecycle_invocations" : first.nestedCompound ? "nested_compound_invocation" : "shell_composition"
+        };
+    }
+    return { kind: "standalone", invocation: first.invocation };
+}
+function commandSegments(entries) {
+    const segments = [];
+    let words = [];
+    let dynamic = false;
+    let composed = false;
+    const flush = () => {
+        if (words.length || dynamic)
+            segments.push({ words, dynamic });
+        words = [];
+        dynamic = false;
+    };
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (typeof entry === "string") {
+            words.push(entry);
+            continue;
+        }
+        if ("comment" in entry)
+            break;
+        if (!("op" in entry) || typeof entry.op !== "string") {
+            dynamic = true;
+            continue;
+        }
+        const operator = entry.op;
+        if (operator === "glob") {
+            dynamic = true;
+            words.push("pattern" in entry && typeof entry.pattern === "string" ? entry.pattern : "");
+            continue;
+        }
+        if (controlOperators.has(operator)) {
+            composed = true;
+            flush();
+            continue;
+        }
+        if (redirectionOperators.has(operator)) {
+            const target = entries[index + 1];
+            if (typeof target === "string" || (target && typeof target === "object" && "op" in target && target.op === "glob"))
+                index += 1;
+            continue;
+        }
+        dynamic = true;
+    }
+    flush();
+    return { segments, composed };
+}
+function invocationFromSegment(segment, heredoc, wrapped, inheritedEnv) {
+    let index = 0;
+    const env = { ...inheritedEnv };
+    while (index < segment.words.length && assignment(segment.words[index])) {
+        addAssignment(env, segment.words[index]);
+        index += 1;
+    }
+    if (path.basename(segment.words[index] ?? "") === "env") {
+        index += 1;
+        if (segment.words[index]?.startsWith("-"))
+            return null;
+        while (index < segment.words.length && assignment(segment.words[index])) {
+            addAssignment(env, segment.words[index]);
+            index += 1;
+        }
+    }
+    const executable = segment.words[index];
+    if (!executable || path.basename(executable) !== "dd-flow")
+        return null;
+    const argv = segment.words.slice(index + 1);
+    const operation = lifecycleOperation(argv);
+    if (!operation)
+        return null;
+    return {
+        operation,
+        executable,
+        argv,
+        env,
+        args: parseCommandArgs(argv.slice(2)),
+        command: quote(segment.words),
+        rewriteSafe: !heredoc && !wrapped && !segment.dynamic,
+        wrapped,
+        heredoc
+    };
+}
+function exportedAssignments(segment) {
+    const result = {};
+    if (segment.words[0] !== "export")
+        return result;
+    for (const word of segment.words.slice(1)) {
+        if (!assignment(word))
+            return {};
+        addAssignment(result, word);
+    }
+    return result;
+}
+function wrappedInvocationFromSegment(segment) {
+    let index = 0;
+    while (index < segment.words.length && assignment(segment.words[index]))
+        index += 1;
+    const executable = path.basename(segment.words[index] ?? "");
+    if (!new Set(["bash", "sh", "zsh"]).has(executable))
+        return null;
+    const flag = segment.words[index + 1];
+    const payload = segment.words[index + 2];
+    if (!payload || !new Set(["-c", "-lc", "-cl"]).has(flag ?? "") || segment.words.length !== index + 3)
+        return null;
+    return parseLifecycleCommandInner(payload, true);
+}
+function lifecycleOperation(argv) {
+    const key = `${argv[0] ?? ""} ${argv[1] ?? ""}`;
+    if (key === "session register")
+        return "session_register";
+    if (key === "stage start")
+        return "stage_start";
+    if (key === "stage resume")
+        return "stage_resume";
+    if (key === "work start")
+        return "work_start";
+    return null;
+}
+export function parseCommandArgs(argv) {
+    const positional = [];
+    const options = new Map();
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value?.startsWith("--")) {
+            const key = value.slice(2);
+            const next = argv[index + 1];
+            const optionValue = !next || next.startsWith("--") ? "__dd_flow_flag__" : next;
+            options.set(key, [...(options.get(key) ?? []), optionValue]);
+            if (optionValue !== "__dd_flow_flag__")
+                index += 1;
+        }
+        else if (value)
+            positional.push(value);
+    }
+    return { positional, options };
+}
+export function commandOption(invocation, name) {
+    const values = invocation.args.options.get(name);
+    const value = values?.[values.length - 1];
+    return value === "__dd_flow_flag__" ? undefined : value;
+}
+export function commandHasOption(invocation, name) {
+    return invocation.args.options.has(name);
+}
+export function commandPosition(invocation, index) {
+    return invocation.args.positional[index];
+}
+function assignment(word) {
+    return /^[A-Za-z_][A-Za-z0-9_]*=/.test(word);
+}
+function addAssignment(env, word) {
+    const separator = word.indexOf("=");
+    env[word.slice(0, separator)] = word.slice(separator + 1);
+}
+function stripHeredocBodies(command) {
+    const lines = command.split(/\r?\n/);
+    const output = [];
+    const pending = [];
+    let active;
+    let present = false;
+    for (const line of lines) {
+        if (active) {
+            const candidate = active.stripTabs ? line.replace(/^\t+/, "") : line;
+            if (candidate === active.delimiter)
+                active = pending.shift();
+            continue;
+        }
+        if (line.trim())
+            output.push(line);
+        const found = heredocDelimiters(line);
+        if (found.length) {
+            present = true;
+            active = found[0];
+            pending.push(...found.slice(1));
+        }
+    }
+    return { command: output.join(" ; "), present };
+}
+function heredocDelimiters(line) {
+    const result = [];
+    let quoteState = null;
+    let escaped = false;
+    for (let index = 0; index < line.length - 1; index += 1) {
+        const char = line[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\" && quoteState !== "'") {
+            escaped = true;
+            continue;
+        }
+        if (quoteState) {
+            if (char === quoteState)
+                quoteState = null;
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quoteState = char;
+            continue;
+        }
+        if (char !== "<" || line[index + 1] !== "<" || line[index + 2] === "<")
+            continue;
+        index += 2;
+        const stripTabs = line[index] === "-";
+        if (stripTabs)
+            index += 1;
+        while (/\s/.test(line[index] ?? ""))
+            index += 1;
+        const delimiterQuote = line[index] === "'" || line[index] === '"' ? line[index++] : null;
+        const start = index;
+        if (delimiterQuote)
+            while (index < line.length && line[index] !== delimiterQuote)
+                index += 1;
+        else
+            while (index < line.length && !/[\s;&|<>]/.test(line[index]))
+                index += 1;
+        const delimiter = line.slice(start, index);
+        if (delimiter)
+            result.push({ delimiter, stripTabs });
+    }
+    return result;
+}

package/dist/services/merge-server.js

@@ -0,0 +1,124 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { AppError } from "../shared/errors.js";
+import { flowCommand } from "./stage-pause.js";
+import { validateSchema } from "./schema-validation.js";
+import { adapterSessionId, runHarnessAdapter } from "./harness-adapter.js";
+/** A deterministic dispatcher; only the launched harness Session performs agent work. */
+export async function serveMergeRequests(context, input) {
+    const running = context.db.get("SELECT server_id, pid FROM merge_servers WHERE status IN ('running','stopping') ORDER BY started_at LIMIT 1");
+    if (running && processAlive(running.pid))
+        throw new AppError("merge_server_already_running", "Only one merge-server may run in one DD_FLOW_HOME", 1, { server_id: running.server_id });
+    if (running)
+        context.db.run("UPDATE merge_servers SET status = 'failed', stopped_at = ?, heartbeat_at = ? WHERE server_id = ?", [context.now(), context.now(), running.server_id]);
+    const profile = loadProfile(context, input.profileId);
+    const serverId = `MSV-${crypto.randomUUID()}`;
+    const root = path.join(context.ddFlowHome, "merge-servers", serverId);
+    fs.mkdirSync(root, { recursive: true });
+    const journal = path.join(root, "events.jsonl");
+    const now = context.now();
+    reconcileExpiredDispatches(context);
+    context.db.run("INSERT INTO merge_servers (server_id, profile_id, status, pid, started_at, heartbeat_at, stopped_at, journal_path) VALUES (?, ?, 'running', ?, ?, ?, NULL, ?)", [serverId, profile.id, process.pid, now, now, journal]);
+    event(journal, { type: "server_started", server_id: serverId, profile, at: now });
+    let handled = 0;
+    try {
+        let running = true;
+        while (running) {
+            const status = context.db.get("SELECT status FROM merge_servers WHERE server_id = ?", [serverId])?.status;
+            if (status === "stopping")
+                break;
+            const requests = nextServerRequests(context, Math.max(1, input.maxParallelProjects ?? 4));
+            context.db.run("UPDATE merge_servers SET heartbeat_at = ? WHERE server_id = ?", [context.now(), serverId]);
+            if (!requests.length) {
+                input.progress?.(`merge-server ${serverId} idle; next poll in ${input.pollSeconds ?? 10} seconds`);
+                if (input.once)
+                    break;
+                await delay((input.pollSeconds ?? 10) * 1000);
+                continue;
+            }
+            const settled = await Promise.allSettled(requests.map((request) => dispatch(context, { serverId, profile, request, root, journal, ...(input.progress ? { progress: input.progress } : {}) })));
+            handled += settled.filter((item) => item.status === "fulfilled").length;
+            const failed = settled.find((item) => item.status === "rejected");
+            if (failed)
+                throw failed.reason;
+            running = !input.once;
+        }
+        context.db.run("UPDATE merge_servers SET status = 'stopped', heartbeat_at = ?, stopped_at = ? WHERE server_id = ?", [context.now(), context.now(), serverId]);
+        event(journal, { type: "server_stopped", server_id: serverId, handled, at: context.now() });
+        return { ok: true, server_id: serverId, profile_id: profile.id, handled, status: "stopped", journal_path: journal };
+    }
+    catch (error) {
+        context.db.run("UPDATE merge_servers SET status = 'failed', heartbeat_at = ?, stopped_at = ? WHERE server_id = ?", [context.now(), context.now(), serverId]);
+        event(journal, { type: "server_failed", server_id: serverId, error: String(error), at: context.now() });
+        throw error;
+    }
+}
+export function mergeServerStatus(context) { return { ok: true, servers: context.db.all("SELECT server_id, profile_id, status, pid, started_at, heartbeat_at, stopped_at, journal_path FROM merge_servers ORDER BY started_at DESC") }; }
+export function stopMergeServer(context, input) { const changed = context.db.run("UPDATE merge_servers SET status = 'stopping', heartbeat_at = ? WHERE server_id = ? AND status = 'running'", [context.now(), input.serverId]); if (changed.changes !== 1)
+    throw new AppError("not_found", "Running merge-server was not found", 1, { server_id: input.serverId }); return { ok: true, server_id: input.serverId, status: "stopping" }; }
+async function dispatch(context, input) {
+    const token = crypto.randomUUID();
+    const leaseUntil = new Date(Date.now() + 120_000).toISOString();
+    const claimed = context.db.run("UPDATE merge_requests SET status = 'dispatching', dispatch_owner = ?, dispatch_lease_token = ?, dispatch_lease_expires_at = ?, updated_at = ? WHERE merge_request_id = ? AND status = 'queued' AND execution_route = 'server'", [input.serverId, token, leaseUntil, context.now(), input.request.merge_request_id]);
+    if (claimed.changes !== 1)
+        return;
+    const stateDir = path.join(input.root, input.request.merge_request_id);
+    fs.mkdirSync(stateDir, { recursive: true });
+    const promptFile = path.join(stateDir, "launch.md");
+    const adapterJournal = path.join(stateDir, "adapter.events.jsonl");
+    const stageCommand = `${flowCommand(context)} stage start ${input.request.run_id} --stage merge --project-root ${JSON.stringify(input.request.target_workspace)} --json --progress-jsonl`;
+    fs.writeFileSync(promptFile, `Start the assigned MERGE stage now. Your first tool call must be this exact standalone command:\n\n${stageCommand}\n\nTrust and follow the complete stage packet it returns. Continue through merge apply and stage finish. Stop only when the stage reaches a terminal result or explicitly requests user/operator action.\n`);
+    event(input.journal, { type: "launch_intent", server_id: input.serverId, request_id: input.request.merge_request_id, token, profile: input.profile, prompt_file: promptFile, at: context.now() });
+    input.progress?.(`launching ${input.request.merge_request_id} with ${input.profile.id}`);
+    const executable = context.env[`DD_FLOW_${input.profile.harness.toUpperCase()}_ADAPTER`] ?? `dd-${input.profile.harness}`;
+    const common = ["--state-dir", stateDir, "--journal", adapterJournal, "--cwd", input.request.target_workspace, "--provider", input.profile.provider, "--model", input.profile.model, "--reasoning", input.profile.reasoning, "--mode", input.profile.mode, "--permission", input.profile.permission, "--project-root", input.request.target_workspace, "--dd-flow-home", context.ddFlowHome, "--json"];
+    try {
+        const adapterCall = (args, timeoutMs, progressMessage) => runHarnessAdapter({ executable, args, env: context.env, ...(timeoutMs ? { timeoutMs } : {}), ...(input.progress ? { progress: input.progress } : {}), ...(progressMessage ? { progressMessage } : {}), onEvidence: (value) => event(input.journal, { type: "adapter_call", ...value }) });
+        await adapterCall(["daemon", "start", ...common]);
+        const created = await adapterCall(["session", "create", ...common]);
+        const sessionId = adapterSessionId(created);
+        if (!sessionId)
+            throw new AppError("merge_adapter_invalid", "Harness adapter did not return a Session id", 1, { harness: input.profile.harness, response: created });
+        const prompted = await adapterCall(["session", "prompt", "--session-id", sessionId, "--prompt-file", promptFile, ...common], 45 * 60 * 1000, `MERGE ${input.request.merge_request_id} Session ${sessionId} is still running`);
+        const request = context.db.get("SELECT status FROM merge_requests WHERE merge_request_id = ?", [input.request.merge_request_id]);
+        context.db.run("UPDATE merge_requests SET adapter_receipt_json = ?, updated_at = ? WHERE merge_request_id = ?", [JSON.stringify({ profile: input.profile, executable, session_id: sessionId, response: prompted }), context.now(), input.request.merge_request_id]);
+        event(input.journal, { type: "adapter_settled", request_id: input.request.merge_request_id, session_id: sessionId, request_status: request?.status ?? null, at: context.now() });
+        if (request?.status === "dispatching")
+            context.db.run("UPDATE merge_requests SET status = 'queued', dispatch_owner = NULL, dispatch_lease_token = NULL, dispatch_lease_expires_at = NULL, last_error_json = ?, updated_at = ? WHERE merge_request_id = ?", [JSON.stringify({ code: "adapter_did_not_start_stage", response: prompted }), context.now(), input.request.merge_request_id]);
+    }
+    catch (error) {
+        const request = context.db.get("SELECT status FROM merge_requests WHERE merge_request_id = ?", [input.request.merge_request_id]);
+        if (request?.status === "dispatching")
+            context.db.run("UPDATE merge_requests SET status = 'queued', dispatch_owner = NULL, dispatch_lease_token = NULL, dispatch_lease_expires_at = NULL, last_error_json = ?, updated_at = ? WHERE merge_request_id = ?", [JSON.stringify({ code: "adapter_launch_failed", error: String(error) }), context.now(), input.request.merge_request_id]);
+        else if (request?.status === "active")
+            context.db.run("UPDATE merge_requests SET status = 'recovery_required', last_error_json = ?, updated_at = ? WHERE merge_request_id = ?", [JSON.stringify({ code: "adapter_lost_after_stage_start", error: String(error) }), context.now(), input.request.merge_request_id]);
+        throw error;
+    }
+}
+function nextServerRequests(context, limit) { const selected = new Set(); return context.db.all("SELECT merge_request_id, project_id, run_id, executor_work_id, target_workspace, execution_route, status, created_at FROM merge_requests WHERE status = 'queued' AND execution_route = 'server' ORDER BY created_at, merge_request_id").filter((request) => { if (selected.has(request.project_id) || context.db.get("SELECT 1 FROM merge_requests WHERE project_id = ? AND status NOT IN ('completed','failed','cancelled') AND (created_at < ? OR (created_at = ? AND merge_request_id < ?)) LIMIT 1", [request.project_id, request.created_at, request.created_at, request.merge_request_id]))
+    return false; selected.add(request.project_id); return true; }).slice(0, limit); }
+function reconcileExpiredDispatches(context) { const expired = context.db.all("SELECT merge_request_id, executor_work_id FROM merge_requests WHERE status = 'dispatching' AND dispatch_lease_expires_at < ?", [context.now()]); for (const request of expired) {
+    const work = context.db.get("SELECT status FROM works WHERE work_id = ?", [request.executor_work_id]);
+    if (work?.status === "created")
+        context.db.run("UPDATE merge_requests SET status = 'queued', dispatch_owner = NULL, dispatch_lease_token = NULL, dispatch_lease_expires_at = NULL, last_error_json = ?, updated_at = ? WHERE merge_request_id = ?", [JSON.stringify({ code: "expired_dispatch_requeued" }), context.now(), request.merge_request_id]);
+    else
+        context.db.run("UPDATE merge_requests SET status = 'recovery_required', last_error_json = ?, updated_at = ? WHERE merge_request_id = ?", [JSON.stringify({ code: "expired_dispatch_with_started_work", work_status: work?.status ?? null }), context.now(), request.merge_request_id]);
+} }
+function loadProfile(context, id) { const file = path.join(context.ddFlowHome, "agent-profiles", `${id}.json`); let value; try {
+    value = JSON.parse(fs.readFileSync(file, "utf8"));
+}
+catch (error) {
+    throw new AppError("agent_profile_missing", "Merge-server agent profile is unavailable", 1, { id, file, cause: String(error) });
+} validateSchema({ schemaName: "agent-profile", file }); if (value.id !== id)
+    throw new AppError("agent_profile_invalid", "Agent profile id does not match its requested filename", 2, { file, expected: id, actual: value.id ?? null }); return value; }
+function event(file, value) { fs.appendFileSync(file, `${JSON.stringify(value)}\n`); }
+function delay(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
+function processAlive(pid) { if (!pid)
+    return false; try {
+    process.kill(pid, 0);
+    return true;
+}
+catch {
+    return false;
+} }

package/dist/services/runs.js

@@ -182,6 +182,9 @@ function snapshotVnextExecutionProfile(projectRoot) {
             stage_session_mode: profile.stage_session_mode,
             plan_review_mode: profile.plan_review_mode,
             code_review_mode: profile.code_review_mode,
+            merge_mode: profile.merge_mode,
+            merge_delivery: profile.merge_delivery,
+            merge_cleanup: profile.merge_cleanup,
             stop_target: profile.stop_target,
             code_bootstrap: profile.code_bootstrap
         }
@@ -925,7 +928,9 @@ function vnextProtocolizeGuidance(run, index) {
     const planReviewDone = index.stage_runs.some((stage) => stage.stage === "plan-review" && stage.status === "done");
     const codeDone = index.stage_runs.some((stage) => stage.stage === "code" && stage.status === "done");
     const codeReviewDone = index.stage_runs.some((stage) => stage.stage === "code-review" && stage.status === "done");
-    const nextStage = !specifyDone ? "specify" : !protocolizeDone ? "protocolize" : !planDone ? "plan" : !planReviewDone ? "plan-review" : !codeDone ? "code" : !codeReviewDone ? "code-review" : null;
+    const mergeDone = index.stage_runs.some((stage) => stage.stage === "merge" && stage.status === "done");
+    const stopTarget = index.execution_profile?.settings.stop_target;
+    const nextStage = !specifyDone ? "specify" : !protocolizeDone ? "protocolize" : !planDone ? "plan" : !planReviewDone ? "plan-review" : !codeDone ? "code" : stopTarget === "code_completed" ? null : !codeReviewDone ? "code-review" : stopTarget === "merge_completed" && !mergeDone ? "merge" : null;
     const currentStage = index.current_stage ?? [...index.stage_runs].reverse().find((stage) => stage.status === "running" || stage.status === "done")?.stage ?? nextStage;
     const terminal = run.status === "done" || run.status === "cancelled" || run.status === "failed" || run.status === "discarded";
     const paused = run.status === "paused";
@@ -936,7 +941,7 @@ function vnextProtocolizeGuidance(run, index) {
         allowed_next_stages: terminal || paused || !nextStage ? [] : [nextStage],
         recommended_next_action: terminal || !nextStage ? "none" : blocked ? "resolve_blocker_then_unblock_same_stage" : paused ? "await_user_answer_then_resume_same_stage" : `start_${nextStage.replace("-", "_")}`,
         recommended_prompt: terminal || !nextStage ? "none" : blocked ? "unblock_command_from_blocker" : paused ? "resume_command_from_pause" : `.memory-bank/dd-flow/vnext/${nextStage}.md`,
-        required_predecessor_evidence: !specifyDone ? [] : !protocolizeDone ? ["01-specify/specify.json"] : !planDone ? ["01-specify/specify.json", "02-protocolize/protocolize-result.json"] : !planReviewDone ? ["03-plan/stage-report.json"] : !codeDone ? ["04-plan-review/stage-report.json"] : ["05-code/stage-report.json"],
+        required_predecessor_evidence: !specifyDone ? [] : !protocolizeDone ? ["01-specify/specify.json"] : !planDone ? ["01-specify/specify.json", "02-protocolize/protocolize-result.json"] : !planReviewDone ? ["03-plan/stage-report.json"] : !codeDone ? ["04-plan-review/stage-report.json"] : !codeReviewDone && stopTarget !== "code_completed" ? ["05-code/stage-report.json"] : stopTarget === "merge_completed" ? ["05-code/stage-report.json", "06-code-review/stage-report.json"] : ["05-code/stage-report.json"],
         guards: [],
         blocked_if_missing: []
     };

package/dist/services/sessions.js

@@ -2,6 +2,7 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import { continuationPolicies, flowKinds } from "../domain/contracts.js";
 import { AppError } from "../shared/errors.js";
+import { commandOption, commandPosition, parseLifecycleCommand } from "./lifecycle-command.js";
 import { parseJsonObject } from "../shared/json.js";
 import { resolveProjectRoot } from "../storage/paths.js";
 import { appendAudit } from "./audit.js";
@@ -185,23 +186,25 @@ export function updateFlowSessionContinuation(context, projectId, sessionId, act
     return nextCount;
 }
 export function flowSessionPayloadFromRegisterCommand(command) {
-    if (/\bdd-flow\s+stage\s+start\b/.test(command))
-        return flowSessionPayloadFromStageStartCommand(command);
-    if (!/\bdd-flow\s+session\s+register\b/.test(command))
+    const invocation = typeof command === "string" ? invocationFromCommand(command) : command;
+    if (!invocation)
         return undefined;
-    const payloadBase64 = optionFromCommand(command, "payload-base64");
-    const payloadJson = optionFromCommand(command, "payload-json");
-    const payloadFile = optionFromCommand(command, "payload-file");
+    if (invocation.operation === "stage_start")
+        return flowSessionPayloadFromStageStartCommand(invocation);
+    if (invocation.operation !== "session_register")
+        return undefined;
+    const payloadBase64 = commandOption(invocation, "payload-base64");
+    const payloadJson = commandOption(invocation, "payload-json");
+    const payloadFile = commandOption(invocation, "payload-file");
     if (!payloadBase64 && !payloadJson && !payloadFile) {
         return undefined;
     }
     return decodeFlowSessionPayload({ payloadBase64, payloadJson, payloadFile });
 }
-function flowSessionPayloadFromStageStartCommand(command) {
-    const projectRoot = optionFromCommand(command, "project-root");
-    const stage = optionFromCommand(command, "stage");
-    const rawRun = command.match(/\bdd-flow\s+stage\s+start\s+("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[^\s]+)/)?.[1];
-    const run = rawRun ? shellArgument(rawRun) : undefined;
+function flowSessionPayloadFromStageStartCommand(invocation) {
+    const projectRoot = commandOption(invocation, "project-root");
+    const stage = commandOption(invocation, "stage");
+    const run = commandPosition(invocation, 0);
     if (!projectRoot || !stage || !run || run.startsWith("--"))
         return undefined;
     return {
@@ -217,6 +220,10 @@ function flowSessionPayloadFromStageStartCommand(command) {
         coverage_units: []
     };
 }
+function invocationFromCommand(command) {
+    const analysis = parseLifecycleCommand(command);
+    return analysis.kind === "none" ? undefined : analysis.invocation;
+}
 function decodeFlowSessionPayload(input) {
     if (input.payloadFile) {
         return normalizeFlowSessionPayload(parseJsonObject(fs.readFileSync(input.payloadFile, "utf8"), "session payload"));
@@ -422,22 +429,6 @@ function releaseMergeLockIfOwned(context, projectRoot, workerId, reason) {
     });
     return { ok: true, released: true, lock_id: lock.id };
 }
-function optionFromCommand(command, key) {
-    const pattern = new RegExp(`--${key}(?:\\s+|=)(?:"([^"]*)"|'([^']*)'|([^\\s]+))`);
-    const match = command.match(pattern);
-    return match?.[1] ?? match?.[2] ?? match?.[3];
-}
-function shellArgument(raw) {
-    if (raw.startsWith('"')) {
-        try {
-            return JSON.parse(raw);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    return raw.startsWith("'") ? raw.slice(1, -1) : raw;
-}
 function sanitizeValue(value) {
     if (Array.isArray(value)) {
         return value.map(sanitizeValue);

package/dist/services/stage-pause.js

@@ -136,6 +136,19 @@ function stageResumeCommand(context, input) {
 }
 export function flowCommand(context) {
     const defaultHome = path.resolve(path.join(os.homedir(), ".dd-flow"));
+    // Desktop/ACP tool processes are not required to inherit the environment of
+    // the adapter that created their Session.  In an isolated runtime, a bare
+    // `dd-flow` can therefore select the host-global router despite a correct
+    // DD_FLOW_HOME.  The runner supplies an absolute executable for that case;
+    // make every generated lifecycle command self-contained.
+    const executable = context.env.DD_FLOW_BIN;
+    if (executable && path.isAbsolute(executable)) {
+        return `DD_FLOW_HOME=${JSON.stringify(context.ddFlowHome)} ${JSON.stringify(executable)}`;
+    }
+    const isolatedExecutable = path.join(context.ddFlowHome, "bin", "dd-flow");
+    if (context.ddFlowHome !== defaultHome && fs.existsSync(isolatedExecutable)) {
+        return `DD_FLOW_HOME=${JSON.stringify(context.ddFlowHome)} ${JSON.stringify(isolatedExecutable)}`;
+    }
     return context.ddFlowHome === defaultHome ? "dd-flow" : `DD_FLOW_HOME=${JSON.stringify(context.ddFlowHome)} dd-flow`;
 }
 function requireRun(context, projectId, id) {