@deksden-com/dd-flow-cli 0.9.0-beta.136 → 0.9.0-beta.137

package/dist/cli/completion-cli.js

@@ -1,70 +0,0 @@
-import { completionCandidates } from "./completion.js";
-import { prepareCommandRoute } from "./command-inputs.js";
-import { parseOutputOptions } from "./output-options.js";
-import { writePreparationError } from "./error-output.js";
-import { AppError, errorRecord } from "../shared/errors.js";
-import { prepareResponseDestination, writeResponseFile } from "./response-file.js";
-export function completionScript(shell) {
-    if (shell === "bash")
-        return `# dd-flow completion: bash
-_dd_flow_complete() {
-  local candidate
-  COMPREPLY=()
-  while IFS= read -r candidate; do
-    [ -n "$candidate" ] && COMPREPLY+=("$candidate")
-  done < <("${"$"}{COMP_WORDS[0]}" completion candidates -- "${"$"}{COMP_WORDS[@]:1:COMP_CWORD}")
-}
-complete -o default -F _dd_flow_complete dd-flow
-`;
-    if (shell === "zsh")
-        return `#compdef dd-flow
-_dd_flow_complete() {
-  local -a replies
-  replies=("${"$"}{(@f)$("${"$"}{words[1]}" completion candidates -- "${"$"}{(@)words[2,CURRENT]}")}")
-  if (( ${"$"}{#replies} )) && [[ -n "$replies[1]" ]]; then
-    compadd -a replies
-  else
-    _files
-  fi
-}
-compdef _dd_flow_complete dd-flow
-`;
-    if (shell === "fish")
-        return `function __dd_flow_candidates
-  set -l tokens (commandline -opc)
-  set -l prefix (commandline -ct)
-  set -l arguments
-  if test (count $tokens) -gt 1
-    set arguments $tokens[2..-1]
-  end
-  $tokens[1] completion candidates -- $arguments "$prefix"
-end
-complete -c dd-flow -a '(__dd_flow_candidates)'
-`;
-    throw new AppError("usage", "Supported completion shells: bash, zsh, fish", 2, { effect: "no_effect" });
-}
-/** Completion is grammar-only: never constructs an AppContext or writes a home. */
-export function runCompletionCli(args, io = { stdout: process.stdout, stderr: process.stderr }) {
-    let json = false;
-    try {
-        const output = parseOutputOptions(args);
-        json = output.json;
-        if (output.responseFile)
-            prepareResponseDestination(output.responseFile);
-        const route = prepareCommandRoute(output.args);
-        if (route.key === "completion candidates") {
-            const candidates = completionCandidates(route.parsed.positional);
-            io.stdout.write(json ? `${JSON.stringify(writeResponseFile({ candidates }, output))}\n` : candidates.map(value => `${value}\n`).join(""));
-        }
-        else {
-            const script = completionScript(route.command);
-            io.stdout.write(json ? `${JSON.stringify(writeResponseFile({ shell: route.command, script }, output))}\n` : script);
-        }
-        return 0;
-    }
-    catch (error) {
-        const record = errorRecord(error);
-        writePreparationError(io, args, record);
-        return record.exitCode;
-    }
-}

package/dist/cli/completion.js

@@ -1,57 +0,0 @@
-import { commandInputs } from "./command-inputs.js";
-import { globalOptionDocumentation, optionsForCommandTree } from "./command-metadata.js";
-const globalSwitches = globalOptionDocumentation.filter(option => option.kind === "switch").map(option => `--${option.name}`);
-const globalValues = globalOptionDocumentation.filter(option => option.kind === "value").map(option => `--${option.name}`);
-/** Read-only completion grammar. Last word is the cursor's unfinished token. */
-export function completionCandidates(words) {
-    const prefix = words.at(-1) ?? "";
-    const completed = words.slice(0, -1);
-    if (completed.includes("--"))
-        return [];
-    const positions = [];
-    let awaiting;
-    let routeKey;
-    const keys = Object.keys(commandInputs).filter(key => !commandInputs[key].retired);
-    const select = () => keys.filter(key => key.split(" ").every((part, index) => positions[index] === part))
-        .sort((left, right) => right.split(" ").length - left.split(" ").length)[0];
-    for (const word of completed) {
-        if (awaiting) {
-            awaiting = undefined;
-            continue;
-        }
-        if (word.startsWith("--")) {
-            const name = word.slice(2).split("=")[0];
-            const input = routeKey ? commandInputs[routeKey] : undefined;
-            const values = input?.values ?? [...new Set(Object.values(commandInputs).flatMap(item => item.values))];
-            if (!word.includes("=") && (values.includes(name) || globalValues.includes(`--${name}`)))
-                awaiting = name;
-            continue;
-        }
-        if (word === "-h")
-            continue;
-        positions.push(word);
-        routeKey = select();
-    }
-    const input = routeKey ? commandInputs[routeKey] : undefined;
-    let candidates;
-    const inline = prefix.match(/^--([^=]+)=(.*)$/);
-    if (awaiting || inline) {
-        const option = awaiting ?? inline[1];
-        candidates = option === "option" ? optionsForCommandTree(routeKey ?? positions.join(" ")).map(item => item.name)
-            : [...(input?.enums[option] ?? [])];
-        if (option === "option" && (inline?.[2] ?? prefix).startsWith("--"))
-            candidates = candidates.map(name => `--${name}`);
-        if (inline)
-            return candidates.filter(value => value.startsWith(inline[2])).map(value => `--${option}=${value}`).sort();
-    }
-    else if (prefix.startsWith("-")) {
-        candidates = [...globalSwitches, ...globalValues, ...(input ? [...input.values, ...input.switches].map(name => `--${name}`) : [])];
-    }
-    else {
-        candidates = keys.filter(key => {
-            const tokens = key.split(" ");
-            return positions.every((part, index) => tokens[index] === part) && tokens.length > positions.length;
-        }).map(key => key.split(" ")[positions.length]);
-    }
-    return [...new Set(candidates)].filter(value => value.startsWith(prefix)).sort();
-}

package/dist/cli/error-output.js

@@ -1,52 +0,0 @@
-import { hasHelpIntent } from "./help.js";
-import { commandHelpTopic } from "./command-metadata.js";
-import { writeJson } from "../shared/json.js";
-export function writePreparationError(io, args, error) {
-    const literal = args.indexOf("--");
-    const options = literal < 0 ? args : args.slice(0, literal);
-    const payload = { ok: false, error };
-    const help = hasHelpIntent(args);
-    let json = false;
-    for (let index = 0; index < options.length; index++) {
-        if (help && options[index] === "--option") {
-            index++;
-            continue;
-        }
-        if (options[index] === "--json")
-            json = true;
-    }
-    // Retain the hook's machine-only contract even when transport validation fails.
-    if (json || args.slice(0, 3).join(" ") === "codex hook handle")
-        writeJson(io.stderr, payload);
-    else
-        io.stderr.write(renderHumanError(payload, args));
-}
-export function renderHumanError(payload, args) {
-    const lines = [`dd-flow: ${payload.error.message}`];
-    const details = recordObject(payload.error.details);
-    const compatibility = recordObject(details?.compatibility);
-    const remediation = recordObject(details?.remediation);
-    if (compatibility) {
-        lines.push(`Compatibility: ${String(compatibility.verdict ?? "unknown")} (${String(compatibility.engine_resolution ?? "unknown")})`);
-        if (compatibility.blocked_operation)
-            lines.push(`Blocked operation: ${String(compatibility.blocked_operation)}`);
-        if (compatibility.install_hint)
-            lines.push(`Install compatible engine: ${String(compatibility.install_hint)}`);
-    }
-    if (remediation?.mb_upgrade_mode)
-        lines.push(`Upgrade mode: ${String(remediation.mb_upgrade_mode)}`);
-    if (details?.preferred_command)
-        lines.push(`Preferred command: ${String(details.preferred_command)}`);
-    const related = Array.isArray(details?.related_commands) ? details.related_commands.map(String) : [];
-    if (related.length > 0) {
-        lines.push("", "Related commands:");
-        for (const command of related)
-            lines.push(`  ${command}`);
-    }
-    const topic = commandHelpTopic(args, "");
-    lines.push(`See: dd-flow${topic ? ` ${topic}` : ""} --help`);
-    return `${lines.join("\n")}\n`;
-}
-function recordObject(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
-}

package/dist/cli/executor-onboarding.js

@@ -1,71 +0,0 @@
-import { createInterface } from "node:readline";
-import { AppError } from "../shared/errors.js";
-import { prepareOperatorProfile, prepareProfileCreation, readOperatorProfileInput } from "../services/operator-profiles.js";
-/** One explicit choice; prompts go to stderr so stdout remains machine-readable. */
-export async function askExecutorChoice(settings, io) {
-    const ids = settings.profiles.map(entry => entry.id);
-    io.stderr.write(`Executor profiles: ${ids.length ? ids.join(", ") : "none configured"}\n`);
-    io.stderr.write("Choose a profile ID/alias, file:/absolute/profile.json, create, or skip. No model is selected automatically.\n");
-    const terminal = createInterface({ input: io.stdin, output: io.stderr });
-    const lines = terminal[Symbol.asyncIterator]();
-    const cancelled = () => new AppError("onboarding_cancelled", "Executor onboarding was cancelled", 1, { effect: "no_effect" });
-    terminal.on("SIGINT", () => terminal.close());
-    const ask = async (prompt) => {
-        io.stderr.write(prompt);
-        const line = await lines.next();
-        if (line.done)
-            throw cancelled();
-        const answer = line.value.trim();
-        if (answer.length > 4096)
-            throw new AppError("usage", "Executor choice exceeds the input limit", 2, { effect: "no_effect" });
-        return answer;
-    };
-    try {
-        const answer = await ask("Executor: ");
-        if (answer === "skip")
-            return { skip: true };
-        if (answer === "create") {
-            io.stderr.write("Enter explicit profile settings; this does not probe providers or verify model access. Nothing is saved by this dialog.\n");
-            const input = { schema_id: "dd-flow/agent-profile@1" };
-            for (const [key, prompt] of [
-                ["id", "Profile ID: "], ["harness", "Harness (codex/zcode/agy/opencode/grok/droid): "],
-                ["provider", "Provider ID: "], ["model", "Model ID: "], ["reasoning", "Reasoning setting: "],
-                ["mode", "Mode setting: "], ["permission", "Permission (allow/deny): "]
-            ])
-                input[key] = await ask(prompt);
-            const profile = prepareOperatorProfile(input);
-            if (settings.profiles.some(entry => entry.id === profile.id) || Object.hasOwn(settings.aliases, profile.id)) {
-                throw new AppError("profile_id_conflict", "New profile ID collides with an existing profile or alias", 2, { effect: "no_effect" });
-            }
-            if (await ask("Use this profile for this operation? Type yes: ") !== "yes")
-                throw cancelled();
-            const save = await ask("Save this profile globally during installation? Type yes or no: ");
-            if (save !== "yes" && save !== "no")
-                throw cancelled();
-            if (save === "yes") {
-                const defaultChoice = await ask("Set it as global default? Type yes or no: ");
-                if (defaultChoice !== "yes" && defaultChoice !== "no")
-                    throw cancelled();
-                return { profile, profileCreation: prepareProfileCreation(settings, profile, defaultChoice === "yes") };
-            }
-            return { profile };
-        }
-        if (answer.startsWith("file:")) {
-            const file = answer.slice(5);
-            if (!file.startsWith("/") && !/^[A-Za-z]:[\\/]/.test(file))
-                throw new AppError("usage", "Profile file must be an absolute path", 2, { effect: "no_effect" });
-            return { profile: readOperatorProfileInput(file) };
-        }
-        if (!answer)
-            throw new AppError("agent_profile_missing", "An explicit executor choice is required", 1, { effect: "no_effect" });
-        return { profileId: answer };
-    }
-    catch (error) {
-        if (error instanceof AppError)
-            throw error;
-        throw cancelled();
-    }
-    finally {
-        terminal.close();
-    }
-}

package/dist/cli/harnesses.js

@@ -1,84 +0,0 @@
-import { prepareCommandRoute } from "./command-inputs.js";
-import { writePreparationError } from "./error-output.js";
-import { parseOutputOptions } from "./output-options.js";
-import { optionalOption, optionalPositiveNumber } from "./argument-values.js";
-import { discoverHarnesses, harnessCatalog } from "../services/harness-discovery.js";
-import { AppError, errorRecord } from "../shared/errors.js";
-import { probeHarnessVersion } from "../services/harness-version-probe.js";
-import { probeHarnessDoctor } from "../services/harness-doctor.js";
-import { prepareResponseDestination, writeResponseFile } from "./response-file.js";
-import path from "node:path";
-import { validateModelScope } from "../services/model-discovery.js";
-/** Home-free ingress: process diagnostics require explicit effect admission. */
-export async function runHarnessesCli(args, env, io = { stdout: process.stdout, stderr: process.stderr }) {
-    let json = false;
-    try {
-        const output = parseOutputOptions(args);
-        json = output.json;
-        if (output.responseFile)
-            prepareResponseDestination(output.responseFile);
-        const route = prepareCommandRoute(output.args);
-        const family = route.key === "harnesses show" ? route.parsed.positional[0] : optionalOption(route.parsed, "harness");
-        if (family && !harnessCatalog.entries.some(entry => entry.id === family))
-            throw new AppError("usage", "Unknown harness; see dd-flow harnesses --help", 2, { effect: "no_effect" });
-        const provider = optionalOption(route.parsed, "provider"), account = optionalOption(route.parsed, "account-sha256");
-        const observationFile = optionalOption(route.parsed, "model-observation-file");
-        let modelScope;
-        if (provider !== undefined || account !== undefined || observationFile !== undefined) {
-            if (!provider || !account)
-                throw new AppError("usage", "Doctor model observations require both --provider and --account-sha256", 2, { effect: "no_effect", help: "harnesses doctor" });
-            modelScope = { harness: family, provider, account_sha256: account };
-            validateModelScope(modelScope);
-            if (observationFile) {
-                if (output.responseFile && path.resolve(observationFile) === path.resolve(output.responseFile))
-                    throw new AppError("usage", "Model observation and command response destinations must differ", 2, { effect: "no_effect" });
-                prepareResponseDestination(observationFile);
-            }
-        }
-        const discovery = discoverHarnesses({ env, ...(family ? { harness: family } : {}),
-            ...(optionalOption(route.parsed, "executable") ? { executable: optionalOption(route.parsed, "executable") } : {}) });
-        let probe;
-        let modelObservation;
-        let observationPublication;
-        if (route.key === "harnesses doctor") {
-            const selected = discovery.entries[0]?.candidates.find(candidate => candidate.selected);
-            if (!selected)
-                throw new AppError("harness_selection_required", "Doctor requires one installed executable; use --executable for ambiguous installations", 1, { effect: "no_effect" });
-            const stateDir = optionalOption(route.parsed, "state-dir"), nativeExecutable = optionalOption(route.parsed, "native-executable");
-            const timeoutMs = optionalPositiveNumber(route.parsed, "timeout-ms", true);
-            probe = await probeHarnessDoctor({ harness: family, executable: selected.path, env,
-                ...(stateDir !== undefined ? { stateDir } : {}), ...(nativeExecutable !== undefined ? { nativeExecutable } : {}),
-                ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-                scope: { processes: route.parsed.options.has("allow-processes"), services: route.parsed.options.has("allow-services"),
-                    credentials: route.parsed.options.has("allow-credentials"), writes: route.parsed.options.has("allow-writes") } });
-            if (modelScope) {
-                modelObservation = { scope: modelScope, observed_at: new Date().toISOString(),
-                    status: probe.reported_models.length ? "listed" : "unavailable", complete: false, models: [...probe.reported_models] };
-                if (observationFile) {
-                    const published = writeResponseFile(modelObservation, { responseFile: observationFile });
-                    observationPublication = { path: observationFile, status: published.response_file_error ? "unknown" : "published",
-                        ...(published.response_file_error ? { error: published.response_file_error } : {}) };
-                }
-            }
-        }
-        else if (route.key === "harnesses probe-version") {
-            const selected = discovery.entries[0]?.candidates.find(candidate => candidate.selected);
-            if (!selected)
-                throw new AppError("harness_selection_required", "Version probe requires one installed executable; use --executable for ambiguous installations", 1, { effect: "no_effect" });
-            probe = await probeHarnessVersion({ harness: family, executable: selected.path, env,
-                ...(optionalPositiveNumber(route.parsed, "timeout-ms", true) === undefined ? {} : { timeoutMs: optionalPositiveNumber(route.parsed, "timeout-ms", true) }),
-                scope: { processes: route.parsed.options.has("allow-processes"), services: false,
-                    credentials: route.parsed.options.has("allow-credentials"), writes: route.parsed.options.has("allow-writes") } });
-        }
-        const result = { ok: true, action: route.key.replaceAll(" ", "_"), catalog: harnessCatalog, discovery, ...(probe ? { probe } : {}),
-            ...(modelObservation ? { model_observation: modelObservation, observation_scope_binding: "operator_declared_unverified" } : {}),
-            ...(observationPublication ? { model_observation_publication: observationPublication } : {}) };
-        io.stdout.write(`${JSON.stringify(writeResponseFile(result, output), null, json ? undefined : 2)}\n`);
-        return 0;
-    }
-    catch (error) {
-        const record = errorRecord(error);
-        writePreparationError(io, args, record);
-        return record.exitCode;
-    }
-}

package/dist/cli/models.js

@@ -1,39 +0,0 @@
-import { prepareCommandRoute } from "./command-inputs.js";
-import { optionalOption } from "./argument-values.js";
-import { parseOutputOptions } from "./output-options.js";
-import { prepareResponseDestination, writeResponseFile } from "./response-file.js";
-import { listOperatorModels } from "../services/model-catalog.js";
-import { AppError, errorRecord } from "../shared/errors.js";
-import { writePreparationError } from "./error-output.js";
-/** Model listing never opens an AppContext, starts a probe or reads credentials. */
-export function runModelsCli(args, io = process) {
-    let json = false;
-    try {
-        const output = parseOutputOptions(args);
-        json = output.json;
-        if (output.responseFile)
-            prepareResponseDestination(output.responseFile);
-        const route = prepareCommandRoute(output.args);
-        if (!["models list", "models show"].includes(route.key))
-            throw new AppError("usage", "Unknown models command; see dd-flow models --help", 2, { effect: "no_effect" });
-        const input = {};
-        for (const [option, field] of [["harness", "harness"], ["provider", "provider"], ["account-sha256", "accountSha256"],
-            ["seed-file", "seedFile"], ["observation-file", "observationFile"]]) {
-            const value = optionalOption(route.parsed, option);
-            if (value !== undefined)
-                input[field] = value;
-        }
-        if (route.key === "models show")
-            input.model = route.parsed.positional[0];
-        const models = listOperatorModels(input);
-        if (route.key === "models show" && models.entries.length === 0)
-            throw new AppError("model_not_found", "Model is absent from the selected seed and scoped observation", 1, { effect: "no_effect", help: "models" });
-        io.stdout.write(`${JSON.stringify(writeResponseFile({ ok: true, action: route.key.replaceAll(" ", "_"), ...models }, output), null, json ? undefined : 2)}\n`);
-        return 0;
-    }
-    catch (error) {
-        const record = errorRecord(error);
-        writePreparationError(io, args, record);
-        return record.exitCode;
-    }
-}

package/dist/cli/operator-profiles.js

@@ -1,61 +0,0 @@
-import { requiredOption, optionalOption } from "./argument-values.js";
-import { AppError } from "../shared/errors.js";
-import { errorRecord } from "../shared/errors.js";
-import { prepareCommandRoute } from "./command-inputs.js";
-import { parseOutputOptions } from "./output-options.js";
-import { writePreparationError } from "./error-output.js";
-import { resolveDdFlowHome } from "../storage/paths.js";
-import { prepareResponseDestination, writeResponseFile } from "./response-file.js";
-import { readOperatorProfiles, resolveOperatorProfile, mutateOperatorProfiles, readOperatorProfileInput } from "../services/operator-profiles.js";
-/** Home-only entrypoint; does not create AppContext, project registration or runtime DB. */
-export function dispatchOperatorProfiles(home, route) {
-    const action = route.command, parsed = route.parsed;
-    if (action === "list")
-        return { ok: true, action: "profiles_list", settings: readOperatorProfiles(home) };
-    if (action === "show") {
-        const settings = readOperatorProfiles(home), id = parsed.positional[0];
-        return { ok: true, action: "profiles_show", selected: id, revision: settings.revision, profile: resolveOperatorProfile(settings, id) };
-    }
-    let mutation;
-    if (action === "create")
-        mutation = { action, profile: readOperatorProfileInput(requiredOption(parsed, "file")), setDefault: parsed.options.has("set-default") };
-    else if (action === "edit")
-        mutation = { action, profile: readOperatorProfileInput(requiredOption(parsed, "file")) };
-    else if (action === "remove")
-        mutation = { action, id: parsed.positional[0] };
-    else if (action === "alias") {
-        const target = optionalOption(parsed, "target"), remove = parsed.options.has("remove");
-        if (Boolean(target) === remove)
-            throw new AppError("usage", "Use exactly one of --target ID or --remove; see dd-flow profiles alias --help", 2, { effect: "no_effect" });
-        mutation = { action, alias: parsed.positional[0], target: target ?? null };
-    }
-    else if (action === "set-default") {
-        const id = parsed.positional[0], clear = parsed.options.has("clear");
-        if (Boolean(id) === clear)
-            throw new AppError("usage", "Select one profile ID or --clear; see dd-flow profiles set-default --help", 2, { effect: "no_effect" });
-        mutation = { action, id: id ?? null };
-    }
-    else
-        throw new AppError("usage", "Unknown profiles command; use dd-flow profiles --help", 2, { effect: "no_effect" });
-    const settings = mutateOperatorProfiles(home, requiredOption(parsed, "expected-revision"), mutation);
-    return { ok: true, action: `profiles_${action}`, effect: "committed", settings };
-}
-/** Lightweight executable ingress; never imports the project/runtime business router. */
-export function runOperatorProfilesCli(args, env, io = { stdout: process.stdout, stderr: process.stderr }) {
-    let json = false;
-    try {
-        const output = parseOutputOptions(args);
-        json = output.json;
-        if (output.responseFile)
-            prepareResponseDestination(output.responseFile);
-        const route = prepareCommandRoute(output.args);
-        const result = dispatchOperatorProfiles(resolveDdFlowHome(env), route);
-        io.stdout.write(`${JSON.stringify(writeResponseFile(result, output), null, json ? undefined : 2)}\n`);
-        return 0;
-    }
-    catch (error) {
-        const record = errorRecord(error);
-        writePreparationError(io, args, record);
-        return record.exitCode;
-    }
-}

package/dist/cli/output-options.js

@@ -1,35 +0,0 @@
-import { AppError } from "../shared/errors.js";
-/** Shared execution transport grammar. Help resolves before this function. */
-export function parseOutputOptions(args) {
-    const stripped = [];
-    let json = false, progressJsonl = false, responseFile = null;
-    for (let index = 0; index < args.length; index++) {
-        const arg = args[index];
-        if (arg === "--") {
-            stripped.push(...args.slice(index));
-            break;
-        }
-        if (arg === "--json") {
-            json = true;
-            continue;
-        }
-        if (arg === "--progress-jsonl") {
-            progressJsonl = true;
-            continue;
-        }
-        if (arg === "--response-file" || arg.startsWith("--response-file=")) {
-            if (responseFile !== null)
-                throw new AppError("usage", "--response-file may be supplied only once", 2);
-            const file = arg === "--response-file" ? args[++index] : arg.slice("--response-file=".length);
-            if (!file?.trim() || file.startsWith("--"))
-                throw new AppError("usage", "--response-file requires a path", 2);
-            responseFile = file;
-            continue;
-        }
-        stripped.push(arg);
-    }
-    if (responseFile && !json)
-        throw new AppError("usage", "--response-file requires --json", 2);
-    const hookJsonOnly = stripped[0] === "codex" && stripped[1] === "hook" && stripped[2] === "handle";
-    return { json: json || hookJsonOnly, progressJsonl, args: stripped, hookJsonOnly, responseFile };
-}

package/dist/cli/response-file.js

@@ -1,69 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { randomUUID } from "node:crypto";
-import { AppError } from "../shared/errors.js";
-/** Preflight does not create a parent, destination or runtime home. */
-export function prepareResponseDestination(value) {
-    const file = path.resolve(value);
-    try {
-        const inspect = (target) => {
-            try {
-                return fs.lstatSync(target);
-            }
-            catch (error) {
-                if (error.code === "ENOENT")
-                    return null;
-                throw error;
-            }
-        };
-        let parent = path.dirname(file);
-        let parentStat = inspect(parent);
-        while (!parentStat) {
-            const next = path.dirname(parent);
-            if (next === parent)
-                break;
-            parent = next;
-            parentStat = inspect(parent);
-        }
-        const targetStat = inspect(file);
-        if (!parentStat?.isDirectory() || targetStat && !targetStat.isFile())
-            throw new Error();
-    }
-    catch {
-        throw new AppError("response_file_invalid", "Response destination must be a regular file under a directory", 2, { parameter: "response-file", effect: "no_effect" });
-    }
-}
-/** Optional publication failure never changes the accepted operation outcome. */
-export function writeResponseFile(payload, output) {
-    if (!output.responseFile)
-        return payload;
-    const file = path.resolve(output.responseFile), temporary = `${file}.tmp-${randomUUID()}`;
-    const visible = payload && typeof payload === "object" && !Array.isArray(payload) ? { ...payload } : { ok: true, result: payload };
-    let ownsTemporary = false;
-    try {
-        prepareResponseDestination(file);
-        fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
-        const fd = fs.openSync(temporary, "wx", 0o600);
-        ownsTemporary = true;
-        try {
-            fs.writeFileSync(fd, `${JSON.stringify(payload, null, 2)}\n`);
-            fs.fsyncSync(fd);
-        }
-        finally {
-            fs.closeSync(fd);
-        }
-        fs.renameSync(temporary, file);
-    }
-    catch {
-        return { ...visible, response_file: file, response_file_error: "Response publication failed; reconcile the accepted operation before retrying" };
-    }
-    finally {
-        try {
-            if (ownsTemporary && fs.existsSync(temporary))
-                fs.unlinkSync(temporary);
-        }
-        catch { /* Own temporary only; never mask the operation outcome. */ }
-    }
-    delete visible.worker_prompt_markdown;
-    return { ...visible, response_file: file };
-}