@astrosheep/keiyaku 2.9.4 → 2.9.6

package/build/cli/commands/task/task/meta.js

@@ -3,7 +3,7 @@ export const meta = {
     command: "task",
     summary: "Manage lightweight repository tasks",
     usage: ["keiyaku task <subcommand>"],
-    stdin: "none",
+    stdin: { mode: "argument" },
     flags: [],
     purpose: "Manage the file-backed task board.",
     subcommands: TASK_SUBCOMMANDS,

package/build/cli/commands/task/update/handler.js

@@ -1,10 +1,9 @@
 import { updateTask } from "../../../../core/task/index.js";
 import { runTaskMutationCommand } from "../shared.js";
-export const handler = async (stdin, flags, _signal, positional) => {
-    const body = flags.taskBody === "-" ? stdin : flags.taskBody;
+export const handler = async (_stdin, flags, _signal, positional) => {
     return runTaskMutationCommand(flags, (repository) => updateTask(repository, positional[0], {
         ...(flags.taskTitle === undefined ? {} : { title: flags.taskTitle }),
-        ...(body === undefined ? {} : { body }),
+        ...(flags.taskBody === undefined ? {} : { body: flags.taskBody }),
         ...(flags.taskPri === undefined ? {} : { pri: flags.taskPri }),
         ...(flags.taskNeeds === undefined ? {} : { addNeeds: flags.taskNeeds }),
         ...(flags.taskDropNeeds === undefined ? {} : { dropNeeds: flags.taskDropNeeds }),

package/build/cli/commands/task/update/meta.js

@@ -2,7 +2,10 @@ export const meta = {
     command: "task update",
     summary: "Update task facts",
     usage: ["keiyaku task update [-C|--cwd DIR] ID [--title TEXT] [--body TEXT|-] [--pri 0-3] [--needs ID] [--drop-needs ID] [--parent ID|--no-parent] [--from ID]"],
-    stdin: "none",
+    stdin: {
+        mode: "argument",
+        selector: { kind: "flag", name: "taskBody", required: false, rejectBlank: false },
+    },
     flags: ["cwd", "title", "body", "pri", "needs", "drop-needs", "parent", "no-parent", "from"],
     purpose: "Change mutable task facts.",
 };

package/build/cli/completion.js

@@ -2,6 +2,7 @@ import { assertSettingsKnobUsable } from "../config/settings/disease.js";
 import { loadKeiyakuSettings } from "../config/settings/loader.js";
 import { loadAkumaCatalog } from "../config/akuma-loader.js";
 import { listContractIds } from "../core/ledger.js";
+import { TASK_FILTER_COMPLETION } from "../core/task/query.js";
 import { allCommandMetadata, getCommandMetadata } from "./commands/metadata.js";
 function topLevelCommands() {
     return allCommandMetadata()
@@ -46,6 +47,9 @@ export async function renderCompletionCandidates(input) {
     if (input.previous === "task") {
         return filterPrefix(subcommandsFor("task"), word).join("\n");
     }
+    if (input.previous === "--filter") {
+        return filterPrefix([TASK_FILTER_COMPLETION], word).join("\n");
+    }
     return filterPrefix(topLevelCommands(), word).join("\n");
 }
 export function renderCompletionScript(shell = "bash") {
@@ -54,7 +58,7 @@ export function renderCompletionScript(shell = "bash") {
             "#compdef keiyaku",
             "_keiyaku() {",
             "  local -a candidates",
-            "  candidates=(${(f)\"$(keiyaku completion --complete --word \"${words[CURRENT]}\" --previous \"${words[CURRENT-1]}\" 2>/dev/null)\"})",
+            "  candidates=(${(f)\"$(keiyaku completion --complete --word=\"${words[CURRENT]}\" --previous=\"${words[CURRENT-1]}\" 2>/dev/null)\"})",
             "  compadd -- $candidates",
             "}",
             "_keiyaku \"$@\"",
@@ -65,7 +69,10 @@ export function renderCompletionScript(shell = "bash") {
         "  local cur prev",
         "  cur=\"${COMP_WORDS[COMP_CWORD]}\"",
         "  prev=\"${COMP_WORDS[COMP_CWORD-1]}\"",
-        "  COMPREPLY=( $(compgen -W \"$(keiyaku completion --complete --word \"$cur\" --previous \"$prev\" 2>/dev/null)\" -- \"$cur\") )",
+        "  COMPREPLY=()",
+        "  while IFS= read -r candidate; do",
+        "    COMPREPLY+=(\"$candidate\")",
+        "  done < <(keiyaku completion --complete --word=\"$cur\" --previous=\"$prev\" 2>/dev/null)",
         "}",
         "complete -F _keiyaku_completion keiyaku",
     ].join("\n");

package/build/cli/flags.js

@@ -1,4 +1,5 @@
 import { ACTOR_IDENTITY } from "../keiyaku.js";
+import { TASK_FILTER_GRAMMAR } from "../core/task/query.js";
 export const HELP_FLAGS = new Set(["--help", "-h"]);
 export const FLAG_SPECS = {
     cwd: {
@@ -118,10 +119,10 @@ export const FLAG_SPECS = {
         kind: "boolean",
         description: "Preview bind input or petition preflight without mutation.",
     },
-    waive: {
+    "append-scope": {
         kind: "value",
-        placeholder: "PATH",
-        description: "Allow one explicit out-of-scope path for this seal. May be repeated.",
+        placeholder: "PATTERN",
+        description: "Append one ordered scope pattern to the contract before audit. May be repeated.",
     },
     resolve: {
         kind: "boolean",
@@ -167,10 +168,25 @@ export const FLAG_SPECS = {
         kind: "boolean",
         description: "Render task data as JSON.",
     },
+    "diff-budget": {
+        kind: "value",
+        placeholder: "BYTES",
+        description: "Set the audit raw-diff presentation budget in bytes.",
+    },
     done: {
         kind: "boolean",
         description: "Show terminal tasks.",
     },
+    filter: {
+        kind: "value",
+        placeholder: TASK_FILTER_GRAMMAR,
+        description: "Filter structured task facts. Repeat --filter for AND; comma values or | terms are OR.",
+    },
+    sort: {
+        kind: "value",
+        placeholder: "KEY[,KEY...]",
+        description: "Sort by priority ascending, modified descending, or created descending.",
+    },
     pri: {
         kind: "value",
         placeholder: "0-3",

package/build/cli/help.js

@@ -62,9 +62,9 @@ export function renderCliHelp(version) {
         "",
         "Input:",
         "  <> means required; [] means optional.",
-        "  bind, arc, and amend read Markdown from stdin.",
-        "  call and tell require literal BODY or `-`; only literal `-` opens stdin.",
-        "  revive accepts an artifact plus optional BODY or `-`; only literal `-` opens stdin.",
+        "  bind, arc, amend, and petition read document stdin only when literal `-` selects it.",
+        "  call and tell require literal BODY or `-`; literal `-` selects stdin.",
+        "  revive accepts an artifact plus optional BODY or `-`; unselected stdin is ignored.",
         "",
         "Configuration:",
         "  Akuma profiles  <KEIYAKU_HOME>/akuma/*.md or .keiyaku/akuma/*.md",

package/build/cli/index.js

@@ -5,16 +5,19 @@ import { compileBindDraftFlags } from "../core/draft.js";
 import { handleCliError } from "./render/errors.js";
 import { FLAG_SPECS } from "./flags.js";
 import { renderCliCommandHelp as renderCliCommandHelpText, renderCliHelp as renderCliHelpText, } from "./help.js";
-import { commandUsesPromptInput, isCallCommand, isPetitionDryRunInvocation, parseCliArgs } from "./parse.js";
+import { isPetitionDryRunInvocation, parseCliArgs } from "./parse.js";
 import { getCommandMetadata } from "./commands/metadata.js";
 import { loadCommandHandler } from "./commands/registry.js";
 import { shellQuote } from "./render/format.js";
 import { writeSuccessResponse } from "./render/success-response.js";
+import { writeCliOutput } from "./output-stream-error-policy.js";
 function commandRequiresStdin(command) {
-    return getCommandMetadata(command).stdin === "required";
+    const stdin = getCommandMetadata(command).stdin;
+    return stdin.mode === "document" && stdin.selector.required;
 }
 function commandAcceptsOptionalStdin(command) {
-    return getCommandMetadata(command).stdin === "optional";
+    const stdin = getCommandMetadata(command).stdin;
+    return stdin.mode === "document" && !stdin.selector.required;
 }
 function commandSavesFailedStdin(command) {
     return (commandRequiresStdin(command) || commandAcceptsOptionalStdin(command)) && command !== "call";
@@ -67,8 +70,6 @@ function prepareBindInput(stdin, flags) {
     return stdin;
 }
 async function readStdin() {
-    if (process.stdin.isTTY)
-        return "";
     let data = "";
     process.stdin.setEncoding("utf-8");
     for await (const chunk of process.stdin)
@@ -129,12 +130,12 @@ function retryHint(input) {
     if (input.command === "bind") {
         const flagTokens = bindRetryFlagTokens(input.flags);
         const flagPart = flagTokens.length > 0 ? ` ${flagTokens.join(" ")}` : "";
-        return `Retry: keiyaku bind${flagPart} < ${draftArg}`;
+        return `Retry: keiyaku bind${flagPart} - < ${draftArg}`;
     }
     if (input.flags.cwd === undefined) {
-        return `Retry: keiyaku ${input.command} < ${shellQuote(input.draftPath)}`;
+        return `Retry: keiyaku ${input.command} - < ${shellQuote(input.draftPath)}`;
     }
-    return `Retry: keiyaku ${input.command} --cwd ${shellQuote(input.flags.cwd)} < ${draftArg}`;
+    return `Retry: keiyaku ${input.command} --cwd ${shellQuote(input.flags.cwd)} - < ${draftArg}`;
 }
 async function printFailure(error, cwd) {
     const response = await handleCliError({
@@ -142,14 +143,14 @@ async function printFailure(error, cwd) {
         cwd,
         logLabel: "cli",
     });
-    process.stderr.write(`${responseText(response)}\n`);
+    await writeCliOutput(process.stderr, `${responseText(response)}\n`);
 }
 function failureExitCode(error) {
     return error instanceof Error && error.name === "AbortError" ? 130 : 1;
 }
 async function handleFailureAfterStdin(input) {
     if (input.response) {
-        process.stderr.write(`${responseText(input.response)}\n`);
+        await writeCliOutput(process.stderr, `${responseText(input.response)}\n`);
     }
     else {
         await printFailure(input.error ?? new Error("Unknown CLI failure"), input.cwd);
@@ -164,7 +165,7 @@ async function handleFailureAfterStdin(input) {
             content: input.stdin,
         });
         if (draftPath) {
-            process.stderr.write(`\nSaved stdin input to ${draftPath}.\n${retryHint({
+            await writeCliOutput(process.stderr, `\nSaved stdin input to ${draftPath}.\n${retryHint({
                 command: input.command,
                 draftPath,
                 cwd: input.cwd,
@@ -173,7 +174,7 @@ async function handleFailureAfterStdin(input) {
         }
     }
     catch (draftError) {
-        process.stderr.write(`\nFailed to save stdin input: ${asMessage(draftError)}\n`);
+        await writeCliOutput(process.stderr, `\nFailed to save stdin input: ${asMessage(draftError)}\n`);
     }
     return 1;
 }
@@ -182,38 +183,42 @@ async function runResponse(command, flags, stdin, positional) {
     const handler = await loadCommandHandler(command);
     return await handler(stdin, flags, signal, positional);
 }
-function bodyToken(command, positional) {
-    if (isCallCommand(command))
-        return positional[0];
-    if (command === "tell")
-        return positional[1];
-    if (command === "revive")
-        return positional[1];
-    return undefined;
-}
-async function readBodyInput(command, positional, cwd) {
-    if (!commandUsesPromptInput(command))
-        return undefined;
-    const token = bodyToken(command, positional);
-    if (token === undefined) {
-        if (command === "revive")
-            return "";
-        await printFailure(new FlowError("EMPTY_PARAM", `${command} body cannot be empty`), cwd);
-        return undefined;
-    }
-    if (token !== "-") {
-        if (!token.trim()) {
-            await printFailure(new FlowError("EMPTY_PARAM", `${command} body cannot be empty`), cwd);
-            return undefined;
-        }
-        return token;
-    }
-    const stdin = await readStdin();
-    if (!stdin.trim()) {
-        await printFailure(new FlowError("EMPTY_PARAM", `${command} body cannot be empty`), cwd);
+function selectedArgument(parsed) {
+    const stdin = getCommandMetadata(parsed.command).stdin;
+    if (stdin.selector === undefined)
         return undefined;
-    }
-    return stdin;
+    if (stdin.selector.kind === "positional") {
+        return { token: parsed.positional[stdin.selector.index], replace: () => parsed.flags };
+    }
+    const flagName = stdin.selector.name;
+    return {
+        token: parsed.flags[flagName],
+        replace: (value) => ({ ...parsed.flags, [flagName]: value }),
+    };
+}
+async function resolveCliInput(parsed) {
+    const stdinMeta = getCommandMetadata(parsed.command).stdin;
+    const selected = selectedArgument(parsed);
+    const token = selected?.token;
+    const selectsStdin = token === "-";
+    if (selectsStdin && process.stdin.isTTY) {
+        throw new FlowError("EMPTY_PARAM", `${parsed.command} literal '-' requires piped stdin`);
+    }
+    const piped = selectsStdin ? await readStdin() : "";
+    const input = selectsStdin ? piped : token ?? "";
+    if (stdinMeta.selector?.required && token === undefined) {
+        const message = stdinMeta.mode === "document"
+            ? `${parsed.command} requires literal '-' to read Markdown from stdin`
+            : `${parsed.command} body cannot be empty`;
+        throw new FlowError("EMPTY_PARAM", message);
+    }
+    if (token !== undefined && stdinMeta.selector?.rejectBlank && !input.trim()) {
+        const message = stdinMeta.mode === "document"
+            ? `No Markdown input received on stdin.\n\nExample:\n  ${usageExample(parsed.command)}`
+            : `${parsed.command} body cannot be empty`;
+        throw new FlowError("EMPTY_PARAM", message);
+    }
+    return { stdin: input, flags: selected?.replace(input) ?? parsed.flags };
 }
 function usageExample(command) {
     const meta = getCommandMetadata(command);
@@ -229,40 +234,19 @@ export async function runCliCommand(tokens) {
         return isPetitionDryRunInvocation(tokens) ? 2 : 1;
     }
     if (parsed.helpRequested) {
-        process.stdout.write(`${renderCliCommandHelp(resolveCliHelpCommand(parsed.command))}\n`);
+        await writeCliOutput(process.stdout, `${renderCliCommandHelp(resolveCliHelpCommand(parsed.command))}\n`);
         return 0;
     }
     const cwd = parsed.flags.cwd ?? process.cwd();
-    let stdin = "";
-    if (parsed.command === "task add") {
-        if (parsed.positional[0] === "-")
-            stdin = await readStdin();
-        if (!(parsed.positional[0] === "-" ? stdin : parsed.positional[0]).trim()) {
-            await printFailure(new FlowError("EMPTY_PARAM", "task add input cannot be blank"), cwd);
-            return 1;
-        }
-    }
-    else if (parsed.command === "task update" && parsed.flags.taskBody === "-") {
-        stdin = await readStdin();
-    }
-    else if (commandRequiresStdin(parsed.command)) {
-        stdin = await readStdin();
-        if (!stdin.trim()) {
-            await printFailure(new FlowError("EMPTY_PARAM", `No Markdown input received on stdin.\n\nExample:\n  ${usageExample(parsed.command)}`), cwd);
-            return 1;
-        }
-    }
-    else if (commandAcceptsOptionalStdin(parsed.command)) {
-        // Optional stdin: bind prepares domain flags or blank-stdin errors itself;
-        // petition lets an empty body reach the oath gate as OATH_MISSING.
-        stdin = await readStdin();
+    let stdin;
+    try {
+        const resolved = await resolveCliInput(parsed);
+        stdin = resolved.stdin;
+        parsed = { ...parsed, flags: resolved.flags };
     }
-    else {
-        const body = await readBodyInput(parsed.command, parsed.positional, cwd);
-        if (body === undefined && commandUsesPromptInput(parsed.command)) {
-            return 1;
-        }
-        stdin = body ?? "";
+    catch (error) {
+        await printFailure(error, cwd);
+        return 1;
     }
     // Bind dry-run must compile and return before repository/cwd resolution or filesystem effects.
     if (parsed.command === "bind") {
@@ -296,7 +280,7 @@ export async function runCliCommand(tokens) {
     }
     const success = !response.payload || !("error" in response.payload);
     if (success) {
-        writeSuccessResponse(parsed.command, parsed.flags, response);
+        await writeSuccessResponse(parsed.command, parsed.flags, response);
         return response.exitCode ?? 0;
     }
     if (commandRequiresStdin(parsed.command) || (parsed.command === "bind" && !parsed.flags.dryRun)) {
@@ -309,7 +293,7 @@ export async function runCliCommand(tokens) {
             saveStdin: !(parsed.command === "bind" && hasBindDomainFlags(parsed.flags)),
         });
     }
-    process.stderr.write(`${responseText(response)}\n`);
+    await writeCliOutput(process.stderr, `${responseText(response)}\n`);
     return 1;
 }
 export function renderCliCommandHelp(command) {

package/build/cli/output-stream-error-policy.js

@@ -1,3 +1,21 @@
+export function isBrokenPipeError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "EPIPE");
+}
+/** Resolve only after Node reports that this chunk has been flushed. */
+export function writeCliOutput(stream, chunk) {
+    return new Promise((resolve, reject) => {
+        stream.write(chunk, (error) => {
+            if (error && !isBrokenPipeError(error)) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
 /**
  * Install a process-level broken-pipe policy on each supplied stream.
  * EPIPE is silent; every other emitted value is rethrown unchanged.
@@ -5,12 +23,8 @@
 export function installCliOutputStreamErrorPolicy(...streams) {
     for (const stream of streams) {
         stream.on("error", (error) => {
-            if (typeof error === "object" &&
-                error !== null &&
-                "code" in error &&
-                error.code === "EPIPE") {
+            if (isBrokenPipeError(error))
                 return;
-            }
             throw error;
         });
     }

package/build/cli/parse-flags.js

@@ -99,8 +99,8 @@ export function assignFlag(flags, name, value) {
         case "dry-run":
             flags.dryRun = Boolean(value);
             return;
-        case "waive":
-            flags.waivePaths = [...(flags.waivePaths ?? []), String(value)];
+        case "append-scope":
+            flags.appendScope = [...(flags.appendScope ?? []), String(value)];
             return;
         case "resolve":
             flags.renewResolve = Boolean(value);
@@ -138,9 +138,26 @@ export function assignFlag(flags, name, value) {
         case "json":
             flags.json = Boolean(value);
             return;
+        case "diff-budget": {
+            const parsed = Number(String(value));
+            if (!Number.isSafeInteger(parsed) || parsed < 0) {
+                throw new FlowError("EMPTY_PARAM", "option --diff-budget requires a non-negative safe integer byte count");
+            }
+            flags.auditDiffBudgetBytes = parsed;
+            return;
+        }
         case "done":
             flags.done = Boolean(value);
             return;
+        case "filter":
+            flags.taskFilters = [...(flags.taskFilters ?? []), String(value)];
+            return;
+        case "sort":
+            if (flags.taskSort !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --sort may only be specified once");
+            }
+            flags.taskSort = String(value);
+            return;
         case "pri": {
             const raw = String(value);
             if (!/^[0-3]$/.test(raw)) {

package/build/cli/parse-metadata.js

@@ -1,6 +1,6 @@
 import { FlowError } from "../flow-error.js";
 import { HELP_FLAGS, SHORT_FLAG_ALIASES, VALUE_FLAGS } from "./flags.js";
-import { commandParseOrder, getCommandMetadata } from "./commands/metadata.js";
+import { commandParseOrder } from "./commands/metadata.js";
 import { TASK_SUBCOMMANDS } from "./types.js";
 export function normalizeContractAddress(raw) {
     const value = raw.startsWith("@") ? raw.slice(1) : raw;
@@ -42,9 +42,6 @@ export function isPetitionDryRunInvocation(tokens) {
     }
     return false;
 }
-export function commandUsesPromptInput(command) {
-    return isCallCommand(command) || command === "tell" || command === "revive";
-}
 export function parseWaitTimeout(value) {
     const matched = /^(?<amount>[1-9][0-9]*)(?<unit>[smh])$/.exec(value);
     if (!matched?.groups) {
@@ -97,9 +94,6 @@ export function commandPositionalRange(command) {
     }
     return { min: 0, max: 0 };
 }
-export function commandRequiresStdin(command) {
-    return getCommandMetadata(command).stdin === "required";
-}
 export function resolveCommand(tokens) {
     if (tokens[0] === "petition" && (tokens[1] === "claim" || tokens[1] === "forfeit")) {
         throw new FlowError("UNKNOWN_COMMAND", `unknown command: petition ${tokens[1]}`);

package/build/cli/parse-selectors.js

@@ -12,6 +12,7 @@ const COMMISSION_SELECTOR_COMMANDS = new Set([
     "renew",
     "petition",
     "forfeit",
+    "audit",
 ]);
 function formatSelectorList(items) {
     if (items.length <= 1) {

package/build/cli/parse.js

@@ -2,11 +2,12 @@ import { FlowError } from "../flow-error.js";
 import { agentNameSchema } from "../config/settings/schema.js";
 import { isResponseArtifactId } from "../core/response-artifact-id.js";
 import { HELP_FLAGS } from "./flags.js";
+import { getCommandMetadata } from "./commands/metadata.js";
 import { assertAllowedFlag, assignFlag, BOOLEAN_FLAGS, CONTROL_FLAGS, parseFlagName, readValueFlag, SHORT_FLAG_ALIASES, VALUE_FLAGS, } from "./parse-flags.js";
-import { commandPositionalRange, commandRequiresStdin, isCallCommand, resolveCommand, splitAtLiteralBoundary, TASK_SUBCOMMANDS, } from "./parse-metadata.js";
+import { commandPositionalRange, isCallCommand, resolveCommand, splitAtLiteralBoundary, TASK_SUBCOMMANDS, } from "./parse-metadata.js";
 import { applyCommissionSelector, assertCommissionSelectorAllowed, assertProjectionSelectorPresent, } from "./parse-selectors.js";
 import { WAIT_SET_SELECTION_ERROR } from "./commands/projection/wait/meta.js";
-export { commandPositionalRange, commandUsesPromptInput, isCallCommand, isPetitionDryRunInvocation, normalizeContractAddress, parseWaitTimeout, } from "./parse-metadata.js";
+export { commandPositionalRange, isCallCommand, isPetitionDryRunInvocation, normalizeContractAddress, parseWaitTimeout, } from "./parse-metadata.js";
 export function parseCliArgs(tokens) {
     const { head, payload } = splitAtLiteralBoundary(tokens);
     const flags = {};
@@ -135,13 +136,16 @@ export function parseCliArgs(tokens) {
     if (command === "petition" && flags.json && !flags.dryRun) {
         throw new FlowError("EMPTY_PARAM", "petition --json requires --dry-run");
     }
+    if (command === "petition" && flags.dryRun && (flags.appendScope?.length ?? 0) > 0) {
+        throw new FlowError("EMPTY_PARAM", "petition --dry-run does not accept --append-scope");
+    }
     if (command === "renew") {
         const recoveryModes = [flags.renewResolve, flags.renewContinue, flags.renewAbort].filter(Boolean).length;
         if (recoveryModes > 1) {
             throw new FlowError("EMPTY_PARAM", "renew accepts only one of --resolve, --continue, or --abort");
         }
-        if (flags.renewAbort && (flags.waivePaths?.length ?? 0) > 0) {
-            throw new FlowError("EMPTY_PARAM", "renew --abort does not accept --waive");
+        if (flags.renewAbort && (flags.appendScope?.length ?? 0) > 0) {
+            throw new FlowError("EMPTY_PARAM", "renew --abort does not accept --append-scope");
         }
     }
     assertCommissionSelectorAllowed(command, flags);
@@ -184,9 +188,14 @@ export function parseCliArgs(tokens) {
     if (positional.length < positionalRange.min) {
         throw new FlowError("EMPTY_PARAM", `${command} requires ${positionalRange.label ?? "an argument"}`);
     }
-    if (positional.length > positionalRange.max) {
-        const message = commandRequiresStdin(command)
-            ? `${command} reads Markdown from stdin; file path arguments are not supported`
+    const stdin = getCommandMetadata(command).stdin;
+    const documentStdinSelector = stdin.mode === "document"
+        && stdin.selector.kind === "positional"
+        && positional.length === stdin.selector.index + 1
+        && positional[stdin.selector.index] === "-";
+    if (positional.length > positionalRange.max && !documentStdinSelector) {
+        const message = stdin.mode === "document"
+            ? `${command} reads Markdown only through literal '-'; file path arguments are not supported`
             : `${command} does not accept positional arguments`;
         throw new FlowError("EMPTY_PARAM", message);
     }

package/build/cli/projection-address.js

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { AddressResolutionError, buildObjectResolutionAttempt, } from "../core/addressing.js";
-import { resolveProjectionCoordinate } from "../core/projection/index.js";
+import { assertProjectionTellable, resolveProjectionCoordinate } from "../core/projection/index.js";
 import { isProjectionId, projectionDir } from "../core/projection/index.js";
 import { isProjectionAlias, readProjectionAlias } from "../core/projection/index.js";
 import { readProjectionIdentity } from "../core/projection/index.js";
@@ -80,6 +80,11 @@ export async function resolveProjectionAddress(input) {
         const subject = alias ? `projection alias ${alias} points to missing projection ${id}` : `projection ${id}`;
         throw new AddressResolutionError("EMPTY_PARAM", `${subject} has no match ${suffix}`, attempt);
     }
+    // Historical projection storage has no current identity to resolve. Tell
+    // still reaches its typed no-mutation refusal instead of exposing storage
+    // parser details or creating a mailbox row.
+    if (input.verb === "tell")
+        assertProjectionTellable(directory);
     let identity;
     try {
         identity = readProjectionIdentity(directory);