rulereceipt 0.1.52 → 0.1.54

package/README.md

@@ -6,8 +6,10 @@
 [![npm](https://img.shields.io/npm/v/rulereceipt)](https://www.npmjs.com/package/rulereceipt)
 [![provenance](https://img.shields.io/badge/npm-provenance%20signed-blue)](https://www.npmjs.com/package/rulereceipt#provenance)
 
-Checks whether a Claude Code session actually followed the rules in your
-CLAUDE.md / AGENTS.md — with evidence, not just a vibe.
+Checks whether your AI coding agent actually followed your rules — with
+evidence, not just a vibe. Works with Claude Code today (OpenAI Codex CLI
+support is built and in testing), and reads rules from CLAUDE.md, AGENTS.md,
+Cursor (`.cursor/rules`), GitHub Copilot, Windsurf, and Claude Code memory.
 
 Runs entirely on your machine. Plain `rulereceipt check` makes zero network
 calls — [Trust, privacy and licensing](#trust-privacy-and-licensing) has the
@@ -28,11 +30,12 @@ Published and live on npm, actively developed.
 
 ## How it works
 
-1. Reads your CLAUDE.md / AGENTS.md and extracts individual rules —
-   from the current project directory and your global rules file.
-2. Reads your most recent Claude Code session transcript, wherever Claude
-   Code stored it — including hosted or enterprise variants that use a
-   different directory.
+1. Reads your rules and extracts individual ones — from CLAUDE.md / AGENTS.md,
+   Cursor / Copilot / Windsurf rule files, and Claude Code memory, across the
+   current project directory and your global rules file.
+2. Reads your most recent agent session transcript — Claude Code today
+   (including hosted/enterprise variants under a different directory), and
+   OpenAI Codex CLI (in testing); newest session across tools wins.
 3. Routes each rule to the narrowest check that can actually answer it:
    - **Structured checks** read what the session really did — an actual
      git command's branch argument, actual file edits, actual file

package/dist/adapters/codex.d.ts

@@ -0,0 +1,5 @@
+import type { TranscriptEvent } from "../types.js";
+export declare function parseCodexLine(line: string): TranscriptEvent[];
+export declare function parseCodexTranscript(filePath: string): TranscriptEvent[];
+/** Every Codex session recorded for this cwd, newest first. */
+export declare function listCodexSessions(cwd: string): string[];

package/dist/adapters/codex.js

@@ -0,0 +1,263 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * OpenAI Codex CLI session adapter.
+ *
+ * Format VERIFIED 2026-09-26 against the openai/codex repo, a real v0.130.0
+ * rollout dump (dev.to/milkoor reverse-engineering write-up), and a
+ * third-party Go parser struct — NOT assumed. But OpenAI publishes no schema
+ * and the on-disk shape has changed across versions (open request openai/codex
+ * #2288 for a stable trajectory format), so parsing here is deliberately
+ * TOLERANT: an unknown line type or field is ignored, never a crash and never
+ * a fabricated event. Same fail-closed discipline as the Claude parser.
+ *
+ *   Path (GLOBAL, date-partitioned — not per-project):
+ *     ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<uuid>.jsonl
+ *   Line 1 is a `session_meta` record whose payload.cwd names the project the
+ *   session ran in — that is how a global store is filtered to one project.
+ *   Every other line is `{timestamp, type, payload}`; the transcript lives in
+ *   `type:"response_item"` lines, discriminated by `payload.type`:
+ *     - message            -> text (role user/developer/system/assistant)
+ *     - function_call /     -> tool_use  (name, arguments JSON string, call_id)
+ *       local_shell_call /
+ *       custom_tool_call
+ *     - function_call_output-> tool_result (call_id, output)
+ *   `reasoning`, `event_msg`, `turn_context`, `compacted` etc. are ignored.
+ *
+ * NOT YET tested against a real session file on THIS machine — until it is,
+ * this is not advertised as supported on the site/README (see adapters/index).
+ */
+// Codex function-call names that mean "run a shell command" — normalised to
+// the engine's canonical `Bash` tool so the command-scanning checks fire.
+// `local_shell_call` is handled by its payload type, not this list.
+const SHELL_TOOL_NAMES = new Set([
+    "exec_command", "shell", "bash", "sh", "exec", "run_command", "shell_command", "container.exec",
+]);
+/** Turn an argv array into the command string, unwrapping `sh -c "<script>"`. */
+function argvToString(argv) {
+    const parts = argv.map((a) => String(a));
+    if (parts.length >= 3 && /^(?:\/(?:usr\/)?bin\/)?(?:ba|z)?sh$/.test(parts[0]) && /^-[a-z]*c$/.test(parts[1])) {
+        return parts[2]; // the -c/-lc script is the real command
+    }
+    return parts.join(" ");
+}
+/** The shell command string from a tool input, however Codex shaped it. */
+function shellCommandString(input) {
+    if (typeof input === "string")
+        return input;
+    if (Array.isArray(input))
+        return argvToString(input);
+    if (input && typeof input === "object") {
+        const o = input;
+        const action = o.action;
+        const cmd = o.command ?? o.cmd ?? action?.command;
+        if (typeof cmd === "string")
+            return cmd;
+        if (Array.isArray(cmd))
+            return argvToString(cmd);
+    }
+    return null;
+}
+function textFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        // Take `.text` from any part regardless of its inner type
+        // (input_text / output_text / text) — the inner-type names are the one
+        // thing not confirmed against a real user line, so we do not rely on them.
+        return content
+            .map((p) => (p && typeof p === "object" && typeof p.text === "string" ? p.text : ""))
+            .filter(Boolean)
+            .join("\n");
+    }
+    return "";
+}
+function outputText(output) {
+    if (typeof output === "string")
+        return output;
+    if (output && typeof output === "object") {
+        const o = output;
+        if (typeof o.output === "string")
+            return o.output;
+        if (typeof o.text === "string")
+            return o.text;
+        if (typeof o.content === "string")
+            return o.content;
+        try {
+            return JSON.stringify(output);
+        }
+        catch {
+            return "";
+        }
+    }
+    return "";
+}
+/** Best-effort error detection from a tool result, without fabricating one. */
+function outputIsError(output) {
+    if (output && typeof output === "object") {
+        const o = output;
+        const meta = o.metadata;
+        const exit = (o.exit_code ?? meta?.exit_code);
+        if (typeof exit === "number")
+            return exit !== 0;
+        if (o.success === false)
+            return true;
+    }
+    return false;
+}
+export function parseCodexLine(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return [];
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+        return [];
+    const obj = parsed;
+    if (obj.type !== "response_item")
+        return [];
+    const payload = obj.payload;
+    if (typeof payload !== "object" || payload === null)
+        return [];
+    const p = payload;
+    const timestamp = typeof obj.timestamp === "string" ? obj.timestamp : "";
+    if (p.type === "message") {
+        const text = textFromContent(p.content);
+        if (!text)
+            return [];
+        const role = p.role === "assistant" ? "assistant" : "user";
+        return [{ role, kind: "text", text, timestamp }];
+    }
+    if (p.type === "function_call" || p.type === "local_shell_call" || p.type === "custom_tool_call") {
+        const rawName = typeof p.name === "string" ? p.name : "";
+        // `arguments` is a JSON string in Codex; parse when possible so the checks
+        // see structured input, else keep the raw value.
+        let input = p.arguments ?? p.input ?? p.action ?? {};
+        if (typeof input === "string") {
+            try {
+                input = JSON.parse(input);
+            }
+            catch {
+                /* leave as the raw string */
+            }
+        }
+        // NORMALISE shell execution to the engine's canonical shape. Every
+        // command-scanning check (git branch, file lifecycle, attribution,
+        // approval gate, proposed action, deterministic literals) keys on
+        // toolName === "Bash" with input.command as a STRING — Claude's shape.
+        // Codex runs shells under `local_shell_call` and `exec_command`-style
+        // function calls, so without this none of those checks would fire on a
+        // Codex session (found 2026-09-26 when a `git push origin main` in a Codex
+        // rollout produced zero violations). Non-shell tools (a real custom/MCP
+        // tool) keep their own name and input untouched.
+        const isShell = p.type === "local_shell_call" || SHELL_TOOL_NAMES.has(rawName.toLowerCase());
+        if (isShell) {
+            const command = shellCommandString(input);
+            return [
+                {
+                    role: "assistant",
+                    kind: "tool_use",
+                    toolName: "Bash",
+                    input: command !== null ? { command } : input,
+                    timestamp,
+                    toolUseId: typeof p.call_id === "string" ? p.call_id : undefined,
+                },
+            ];
+        }
+        return [
+            {
+                role: "assistant",
+                kind: "tool_use",
+                toolName: rawName || "tool",
+                input,
+                timestamp,
+                toolUseId: typeof p.call_id === "string" ? p.call_id : undefined,
+            },
+        ];
+    }
+    if (p.type === "function_call_output" || p.type === "custom_tool_call_output" || p.type === "local_shell_call_output") {
+        return [
+            {
+                role: "user",
+                kind: "tool_result",
+                content: outputText(p.output),
+                isError: outputIsError(p.output),
+                timestamp,
+                toolUseId: typeof p.call_id === "string" ? p.call_id : undefined,
+            },
+        ];
+    }
+    return []; // reasoning, unknown payload types: ignored, not guessed at
+}
+export function parseCodexTranscript(filePath) {
+    let raw;
+    try {
+        raw = readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const events = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        events.push(...parseCodexLine(line));
+    }
+    return events;
+}
+/** The cwd a rollout file was recorded in, from its first `session_meta` line. */
+function sessionCwd(filePath) {
+    let raw;
+    try {
+        raw = readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    const firstLine = raw.split("\n", 1)[0];
+    if (!firstLine)
+        return null;
+    try {
+        const obj = JSON.parse(firstLine);
+        if (obj.type !== "session_meta")
+            return null;
+        const payload = obj.payload;
+        const cwd = payload?.cwd;
+        return typeof cwd === "string" ? cwd : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Resolved at call time, not module load, so the home dir is read live.
+function codexSessionsRoot() {
+    return join(homedir(), ".codex", "sessions");
+}
+/** Recursively collect rollout-*.jsonl files under the date-partitioned tree. */
+function collectRolloutFiles(dir, out) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory())
+            collectRolloutFiles(full, out);
+        else if (entry.isFile() && entry.name.startsWith("rollout-") && entry.name.endsWith(".jsonl"))
+            out.push(full);
+    }
+}
+/** Every Codex session recorded for this cwd, newest first. */
+export function listCodexSessions(cwd) {
+    const all = [];
+    collectRolloutFiles(codexSessionsRoot(), all);
+    return all
+        .filter((f) => sessionCwd(f) === cwd)
+        .sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs);
+}

package/dist/adapters/index.d.ts

@@ -0,0 +1,82 @@
+import type { TranscriptEvent } from "../types.js";
+/**
+ * A session adapter turns one coding agent's on-disk session log into the
+ * neutral TranscriptEvent[] the rule engine (classify.ts / the checks) already
+ * runs on. The engine is agent-agnostic — it only ever sees text / tool_use /
+ * tool_result — so generalising the tool to new agents is entirely a matter of
+ * adding adapters here; nothing downstream changes.
+ *
+ * Only adapters that have been VERIFIED against a real format are `supported`.
+ * The rest are listed as honest stubs (see UNSUPPORTED_TOOLS) so the tool can
+ * say what it does and does NOT read, rather than silently missing sessions or
+ * pretending to support a format it has not parsed.
+ */
+export interface SessionAdapter {
+    /** Stable tool id, e.g. "claude-code", "codex". */
+    tool: string;
+    /** Every session file for this cwd, newest first (empty when the tool is absent). */
+    listSessions(cwd: string): string[];
+    /** Parse one session file into neutral events. */
+    parse(sessionFile: string): TranscriptEvent[];
+}
+/**
+ * Claude Code — the original and reference adapter. Delegates to the existing
+ * transcriptParser so its behaviour (including subagent transcripts) is
+ * unchanged: for a Claude-only machine the registry picks exactly the file and
+ * events it always did.
+ */
+export declare const claudeCodeAdapter: SessionAdapter;
+/** OpenAI Codex CLI — format verified, parsing tolerant. See adapters/codex.ts. */
+export declare const codexAdapter: SessionAdapter;
+/** Every adapter with a verified, tested-buildable parser. */
+export declare const ADAPTERS: SessionAdapter[];
+/**
+ * Tools deliberately NOT read yet, with the honest reason. Kept as data (not
+ * silence) so the tool — and its docs — can state exactly where the line is
+ * and why, and so adding one later is a visible change here.
+ */
+export declare const UNSUPPORTED_TOOLS: {
+    tool: string;
+    reason: string;
+}[];
+export interface LatestSession {
+    adapter: SessionAdapter;
+    file: string;
+    mtimeMs: number;
+}
+/**
+ * The single most recently modified session across ALL supported tools for
+ * this cwd — the same "newest wins" rule the Claude reader already uses across
+ * `.claude` vs `.claude-office`, now extended across tools. Returns null only
+ * when no supported tool has a session for this project (the caller then asks
+ * or reports "no session found").
+ */
+export declare function findLatestSession(cwd: string): LatestSession | null;
+/** Events from the latest session across all tools (empty when none exists). */
+export declare function readLatestSessionEvents(cwd: string): TranscriptEvent[];
+/**
+ * EVERY session across all supported tools for this cwd, newest first, each
+ * paired with the adapter that can parse it. Used by the multi-session
+ * compliance report so it audits Codex sessions alongside Claude ones, not
+ * just Claude Code's.
+ */
+export declare function listAllSessions(cwd: string): {
+    adapter: SessionAdapter;
+    file: string;
+}[];
+/**
+ * Parse a single session file whose tool is not known ahead of time (a
+ * `--transcript <file>` the user pointed at directly). A Codex rollout opens
+ * with a `session_meta` or `response_item` line; anything else is read as a
+ * Claude transcript. Sniffing the first line beats guessing from the path,
+ * and it fails closed — an unreadable or unrecognised file yields no events,
+ * never a wrong parse presented as right.
+ */
+export declare function parseSessionFile(file: string): TranscriptEvent[];
+/**
+ * A one-line note naming the tool a session came from, when it is NOT the
+ * default Claude Code — so a user running `check` in a Codex project sees that
+ * the report is about their Codex session, not silently. Null for Claude Code
+ * (the default) and when there is no session.
+ */
+export declare function sessionSourceNote(cwd: string): string | null;

package/dist/adapters/index.js

@@ -0,0 +1,133 @@
+import { statSync, readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { listAllSessionFiles, readTranscriptFromFile, findSubagentFiles } from "../parsers/transcriptParser.js";
+import { listCodexSessions, parseCodexTranscript } from "./codex.js";
+/**
+ * Claude Code — the original and reference adapter. Delegates to the existing
+ * transcriptParser so its behaviour (including subagent transcripts) is
+ * unchanged: for a Claude-only machine the registry picks exactly the file and
+ * events it always did.
+ */
+export const claudeCodeAdapter = {
+    tool: "claude-code",
+    listSessions: (cwd) => listAllSessionFiles(cwd),
+    parse: (sessionFile) => {
+        const events = readTranscriptFromFile(sessionFile);
+        for (const sub of findSubagentFiles(sessionFile))
+            events.push(...readTranscriptFromFile(sub));
+        return events;
+    },
+};
+/** OpenAI Codex CLI — format verified, parsing tolerant. See adapters/codex.ts. */
+export const codexAdapter = {
+    tool: "codex",
+    listSessions: (cwd) => listCodexSessions(cwd),
+    parse: (sessionFile) => parseCodexTranscript(sessionFile),
+};
+/** Every adapter with a verified, tested-buildable parser. */
+export const ADAPTERS = [claudeCodeAdapter, codexAdapter];
+/**
+ * Tools deliberately NOT read yet, with the honest reason. Kept as data (not
+ * silence) so the tool — and its docs — can state exactly where the line is
+ * and why, and so adding one later is a visible change here.
+ */
+export const UNSUPPORTED_TOOLS = [
+    { tool: "gemini-cli", reason: "session-log path is known (~/.gemini/tmp/<hash>/chats/*.json) but the per-line JSON schema is unverified — not parsed, to avoid fabricating events" },
+    { tool: "aider", reason: "history is a Markdown transcript (.aider.chat.history.md), not structured events — needs a prose parser, not a field mapping" },
+    { tool: "opencode", reason: "stores sessions in a SQLite DB (opencode.db) since v1.2.0 (per-record JSON before) — needs a SQLite reader, version-dependent" },
+    { tool: "cursor", reason: "IDE-embedded; chat history lives in undocumented internal state that changes across Cursor versions — real ongoing maintenance, out of scope for this pass" },
+    { tool: "github-copilot", reason: "IDE-embedded; no accessible, stable local session log a third-party CLI can read" },
+    { tool: "windsurf", reason: "IDE-embedded; history in undocumented internal state, same as Cursor" },
+];
+/**
+ * The single most recently modified session across ALL supported tools for
+ * this cwd — the same "newest wins" rule the Claude reader already uses across
+ * `.claude` vs `.claude-office`, now extended across tools. Returns null only
+ * when no supported tool has a session for this project (the caller then asks
+ * or reports "no session found").
+ */
+export function findLatestSession(cwd) {
+    let best = null;
+    for (const adapter of ADAPTERS) {
+        const files = adapter.listSessions(cwd); // newest first
+        if (files.length === 0)
+            continue;
+        const file = files[0];
+        let mtimeMs;
+        try {
+            mtimeMs = statSync(file).mtimeMs;
+        }
+        catch {
+            continue;
+        }
+        if (!best || mtimeMs > best.mtimeMs)
+            best = { adapter, file, mtimeMs };
+    }
+    return best;
+}
+/** Events from the latest session across all tools (empty when none exists). */
+export function readLatestSessionEvents(cwd) {
+    const latest = findLatestSession(cwd);
+    return latest ? latest.adapter.parse(latest.file) : [];
+}
+/**
+ * EVERY session across all supported tools for this cwd, newest first, each
+ * paired with the adapter that can parse it. Used by the multi-session
+ * compliance report so it audits Codex sessions alongside Claude ones, not
+ * just Claude Code's.
+ */
+export function listAllSessions(cwd) {
+    const pairs = [];
+    for (const adapter of ADAPTERS) {
+        for (const file of adapter.listSessions(cwd)) {
+            try {
+                pairs.push({ adapter, file, mtimeMs: statSync(file).mtimeMs });
+            }
+            catch {
+                /* unreadable file: skip */
+            }
+        }
+    }
+    pairs.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return pairs.map(({ adapter, file }) => ({ adapter, file }));
+}
+/**
+ * Parse a single session file whose tool is not known ahead of time (a
+ * `--transcript <file>` the user pointed at directly). A Codex rollout opens
+ * with a `session_meta` or `response_item` line; anything else is read as a
+ * Claude transcript. Sniffing the first line beats guessing from the path,
+ * and it fails closed — an unreadable or unrecognised file yields no events,
+ * never a wrong parse presented as right.
+ */
+export function parseSessionFile(file) {
+    let raw;
+    try {
+        raw = readFileSync(file, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const firstLine = raw.split("\n").find((l) => l.trim()) ?? "";
+    try {
+        const obj = JSON.parse(firstLine);
+        if (obj && typeof obj === "object" && (obj.type === "session_meta" || obj.type === "response_item")) {
+            return parseCodexTranscript(file);
+        }
+    }
+    catch {
+        /* first line is not JSON: treat as a Claude transcript below */
+    }
+    return readTranscriptFromFile(file);
+}
+/**
+ * A one-line note naming the tool a session came from, when it is NOT the
+ * default Claude Code — so a user running `check` in a Codex project sees that
+ * the report is about their Codex session, not silently. Null for Claude Code
+ * (the default) and when there is no session.
+ */
+export function sessionSourceNote(cwd) {
+    const latest = findLatestSession(cwd);
+    if (!latest || latest.adapter.tool === "claude-code")
+        return null;
+    return `Read a ${latest.adapter.tool} session (${basename(latest.file)}) — the most recently modified session found for this project.`;
+}

package/dist/checks/attribution.js

@@ -1,5 +1,5 @@
 import { violation } from "../types.js";
-import { withoutHeredocs } from "./shellCommand.js";
+import { segments, leadingCommand } from "./shellCommand.js";
 /**
  * Did the session add an AI-attribution trailer to a commit, PR or comment,
  * against a rule forbidding it?
@@ -38,12 +38,36 @@ const GIT_WRITE = /\bgit\s+(?:\S+\s+){0,4}?commit(?![\w-])|\bgit\s+.*--amend\b|\
  * mark, not merely the word "Claude" (a commit may legitimately say "fix the
  * Claude Code parser"): the co-author trailer, the generated-with line with
  * or without its robot, and the anthropic noreply address used as an author.
+ *
+ * The co-authored-by branch requires the `<email>` that a REAL trailer always
+ * carries. Without it, a commit message that merely DESCRIBES the trailer —
+ * `git commit -m "Add detection for Co-Authored-By: Claude trailer"`, or the
+ * same phrase sitting in a `node -e` string — was flagged as adding one
+ * (live-confirmed false positive, 2026-09-26, on this very repo whose own rule
+ * documents the trailer). A mention has no `<…>`; the injected trailer
+ * (`Co-Authored-By: Claude <noreply@anthropic.com>`) does. The claude/anthropic
+ * requirement keeps a legitimate HUMAN co-author (`… <jane@example.com>`) out.
  */
-const ATTRIBUTION_TRAILER = /co-?authored-by:\s*[^\n]*(?:claude|anthropic)|generated with\s*\[?\s*claude code|🤖\s*generated with|<?noreply@anthropic\.com>?/i;
+const ATTRIBUTION_TRAILER = /co-?authored-by:[^\n]*(?:claude|anthropic)[^\n]*<[^>\n]+>|generated with\s*\[?\s*claude code|🤖\s*generated with|<?noreply@anthropic\.com>?/i;
 function commandText(event) {
     const input = event.input;
     return input && typeof input.command === "string" ? input.command : "";
 }
+/**
+ * Is a git/gh write command actually INVOKED here — not merely quoted inside
+ * another command (a `node -e '…git commit…'` string, a `cat <<EOF` writing an
+ * example)? Requires git/gh to be the LEADING command of a real segment.
+ * Heredoc bodies are stripped first (by `segments`), so a heredoc that writes
+ * an example does not count, while `git commit -F- <<EOF` still does.
+ */
+function invokesGitWrite(rawCommand) {
+    for (const seg of segments(rawCommand)) {
+        const exe = leadingCommand(seg);
+        if ((exe === "git" || exe === "gh") && GIT_WRITE.test(seg))
+            return true;
+    }
+    return false;
+}
 /** The first git-writing command in the session that carries a trailer. */
 function firstOffendingCommand(events) {
     let sawGitWrite = false;
@@ -51,14 +75,11 @@ function firstOffendingCommand(events) {
         if (event.kind !== "tool_use" || event.toolName !== "Bash")
             continue;
         const command = commandText(event);
-        // Prove git is actually INVOKED, not merely quoted: a `cat <<EOF … git
-        // commit … Co-Authored-By … EOF` writes a file that contains the example,
-        // it does not commit. Strip heredoc bodies before testing the invocation,
-        // but match the trailer against the FULL command so a real heredoc that
-        // FEEDS the commit message is still caught.
-        if (!GIT_WRITE.test(withoutHeredocs(command)))
+        if (!invokesGitWrite(command))
             continue;
         sawGitWrite = true;
+        // Trailer matched against the FULL command (heredoc body included) so a
+        // real heredoc that FEEDS the commit message its trailer is still caught.
         if (ATTRIBUTION_TRAILER.test(command))
             return command;
     }