akm-cli 0.9.0-rc.1 → 0.9.0-rc.13

package/dist/output/text/proposal/producer.js

@@ -1,9 +1,11 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-// Output text formatters for `akm reflect` / `akm propose` (#226).
+// Output text formatters for `akm reflect` / `akm proposal new` (#226; the
+// latter formerly the top-level `akm propose`, moved in the 0.9 CLI
+// overhaul, S8).
 import { formatProposalProducerPlain } from "../helpers.js";
 export const proposalProducerFormatters = [
     { command: "reflect", handler: (r) => formatProposalProducerPlain("reflect", r) },
-    { command: "propose", handler: (r) => formatProposalProducerPlain("propose", r) },
+    { command: "proposal-new", handler: (r) => formatProposalProducerPlain("proposal new", r) },
 ];

package/dist/output/text/proposal-format.js

@@ -0,0 +1,202 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Plain-text renderers for `akm proposal *` commands.
+ *
+ * Split out of `helpers.ts` (formerly 1418 lines / 59 fns) as its own
+ * sibling module: proposal listing/show share the gate-decision summary
+ * helpers. (`akm distill` has no registered top-level command — its former
+ * plain-text renderer, `formatDistillPlain`, was dead code; removed per
+ * R-063/B5.)
+ */
+export function formatProposalProducerPlain(command, r) {
+    if (r.ok === false) {
+        const reason = String(r.reason);
+        const error = typeof r.error === "string" ? r.error : "";
+        const lines = [`${command}: failed (${reason})`];
+        if (error)
+            lines.push(`  error: ${error}`);
+        if (r.ref)
+            lines.push(`  ref: ${String(r.ref)}`);
+        if (r.exitCode !== undefined && r.exitCode !== null) {
+            lines.push(`  exitCode: ${String(r.exitCode)}`);
+        }
+        return lines.join("\n");
+    }
+    const proposal = r.proposal;
+    const id = String(proposal.id);
+    const ref = String(r.ref);
+    const status = String(proposal.status);
+    return `${command}: queued proposal ${id} (${ref}) [${status}]`;
+}
+/**
+ * Render a one-line gate-decision summary for the proposal list / show surfaces
+ * (#577), e.g. `gate=deferred:max-diff-lines (210 > 200)`. Returns the empty
+ * string when no well-formed decision is present.
+ */
+export function formatGateDecisionSummary(raw) {
+    if (typeof raw !== "object" || raw === null)
+        return "";
+    const d = raw;
+    const outcome = typeof d.outcome === "string" ? d.outcome : undefined;
+    if (!outcome)
+        return "";
+    const reason = typeof d.reason === "string" && d.reason.length > 0 ? `:${d.reason}` : "";
+    const cmp = formatGateThresholdComparison(d);
+    return `gate=${outcome}${reason}${cmp ? ` (${cmp})` : ""}`;
+}
+/**
+ * Reconstruct the drain threshold comparison when both operands are present.
+ * Returns the empty string when the decision lacks either operand.
+ */
+function formatGateThresholdComparison(d) {
+    const thresholds = (typeof d.thresholds === "object" && d.thresholds !== null ? d.thresholds : {});
+    const measured = typeof d.measured === "number" ? d.measured : undefined;
+    if (measured === undefined)
+        return "";
+    if (typeof thresholds.maxDiffLines === "number") {
+        return `${measured} > ${thresholds.maxDiffLines}`;
+    }
+    if (typeof thresholds.minContentLines === "number") {
+        return `${measured} < ${thresholds.minContentLines}`;
+    }
+    return "";
+}
+export function formatProposalListPlain(r) {
+    const proposals = r.proposals;
+    const total = r.totalCount;
+    if (proposals.length === 0) {
+        // NEW-1: `akm reflect` and `akm distill` are internal improve-pipeline
+        // process names (src/commands/improve/{reflect,distill}.ts), not
+        // registered top-level commands (see the subCommands map in src/cli.ts) —
+        // an agent following this hint would run a command that does not exist.
+        // The real ways to queue a proposal are `akm improve <ref>` (which runs
+        // the reflect/distill/consolidate pipeline internally) and
+        // `akm proposal new`.
+        return `${total} proposal(s).\nNo proposals.\nGenerate one with \`akm improve <ref>\` or \`akm proposal new <type> <name> --task ...\`.`;
+    }
+    const lines = [`${total} proposal(s)`, ""];
+    for (const p of proposals) {
+        const id = String(p.id);
+        const ref = String(p.ref);
+        const status = String(p.status);
+        const source = String(p.source);
+        const created = String(p.createdAt);
+        // #577: surface the gate verdict inline so the queue explains itself.
+        const gate = formatGateDecisionSummary(p.gateDecision);
+        const gateSuffix = gate ? `  ${gate}` : "";
+        lines.push(`${id}  [${status}] ${ref}  source=${source}  ${created}${gateSuffix}`);
+    }
+    return lines.join("\n").trimEnd();
+}
+export function formatProposalShowPlain(r) {
+    const p = r.proposal;
+    const lines = [];
+    lines.push(`# proposal ${String(p.id)}`);
+    lines.push(`ref: ${String(p.ref)}`);
+    lines.push(`status: ${String(p.status)}`);
+    lines.push(`source: ${String(p.source)}`);
+    if (p.sourceRun)
+        lines.push(`sourceRun: ${String(p.sourceRun)}`);
+    if (p.createdAt)
+        lines.push(`createdAt: ${String(p.createdAt)}`);
+    if (p.updatedAt)
+        lines.push(`updatedAt: ${String(p.updatedAt)}`);
+    if (typeof p.confidence === "number")
+        lines.push(`confidence: ${p.confidence.toFixed(2)}`);
+    // #577: gate decision (auto-accepted / deferred / auto-rejected + reason +
+    // thresholds), when this proposal has passed through a gate.
+    const gate = p.gateDecision;
+    if (gate && typeof gate.outcome === "string") {
+        lines.push(`gate.decision: ${String(gate.outcome)}`);
+        lines.push(`gate.reason: ${String(gate.reason)}`);
+        const cmp = formatGateThresholdComparison(gate);
+        if (cmp)
+            lines.push(`gate.thresholds: ${cmp}`);
+        if (gate.gate)
+            lines.push(`gate.by: ${String(gate.gate)}`);
+        if (gate.decidedAt)
+            lines.push(`gate.decidedAt: ${String(gate.decidedAt)}`);
+    }
+    const review = p.review;
+    if (review) {
+        lines.push(`review.outcome: ${String(review.outcome ?? "?")}`);
+        if (review.reason)
+            lines.push(`review.reason: ${String(review.reason)}`);
+        if (review.decidedAt)
+            lines.push(`review.decidedAt: ${String(review.decidedAt)}`);
+    }
+    const validation = r.validation;
+    if (validation) {
+        const findings = Array.isArray(validation.findings) ? validation.findings : [];
+        // Partition findings by severity. `severity: "warn"` findings are
+        // non-blocking (the validator reports `ok: true` for a warn-only proposal),
+        // so they must read as advisory — a distinct icon/label from blocking errors.
+        const warnings = findings.filter((f) => f.severity === "warn");
+        const errors = findings.filter((f) => f.severity !== "warn");
+        lines.push("");
+        if (errors.length > 0) {
+            const warnSuffix = warnings.length > 0 ? `, ${warnings.length} warning(s)` : "";
+            lines.push(`✗ invalid (${errors.length} error(s)${warnSuffix})`);
+        }
+        else if (warnings.length > 0) {
+            lines.push(`✓ valid (${warnings.length} warning(s))`);
+        }
+        else {
+            lines.push("✓ valid");
+        }
+        // Errors first (blocking), then warnings (advisory, non-blocking).
+        for (const f of errors) {
+            lines.push(`  ✗ error  [${String(f.kind)}] ${String(f.message)}`);
+        }
+        for (const f of warnings) {
+            lines.push(`  ⚠ warning  [${String(f.kind)}] ${String(f.message)} (non-blocking)`);
+        }
+    }
+    const payload = p.payload;
+    if (payload && typeof payload.content === "string") {
+        lines.push("");
+        lines.push("payload:");
+        lines.push(payload.content);
+    }
+    return lines.join("\n").trimEnd();
+}
+export function formatProposalAcceptPlain(r) {
+    return `Accepted proposal ${String(r.id)} → ${String(r.ref)} at ${String(r.assetPath)}`;
+}
+export function formatProposalRejectPlain(r) {
+    const reason = r.reason ? ` (${String(r.reason)})` : "";
+    return `Rejected proposal ${String(r.id)} (${String(r.ref)})${reason}`;
+}
+export function formatProposalDrainPlain(r) {
+    const policy = String(r.policy ?? "?");
+    const applyMode = String(r.applyMode ?? "queue");
+    const promoted = Array.isArray(r.promoted) ? r.promoted : [];
+    const rejected = Array.isArray(r.rejected) ? r.rejected : [];
+    const deferred = Array.isArray(r.deferred) ? r.deferred : [];
+    const skippedByCap = Array.isArray(r.skippedByCap) ? r.skippedByCap : [];
+    const staged = Array.isArray(r.staged) ? r.staged : [];
+    const prefix = r.dryRun === true ? "[dry-run] " : "";
+    const lines = [
+        `${prefix}Drained proposal queue (strategy=${String(r.strategy ?? "?")}, policy=${policy}, applyMode=${applyMode})`,
+        `  promoted: ${promoted.length}`,
+        `  rejected: ${rejected.length}`,
+        `  deferred: ${deferred.length}`,
+        `  skippedByCap: ${skippedByCap.length}`,
+        `  staged: ${staged.length}`,
+    ];
+    for (const d of deferred) {
+        lines.push(`    - ${String(d.id ?? "?")} (${String(d.reason ?? "?")})`);
+    }
+    return lines.join("\n").trimEnd();
+}
+export function formatProposalDiffPlain(r) {
+    const header = r.isNew
+        ? `# proposal ${String(r.id)} (new asset: ${String(r.ref)})`
+        : `# proposal ${String(r.id)} (update: ${String(r.ref)})`;
+    const unified = typeof r.unified === "string" ? r.unified : "";
+    if (!unified)
+        return `${header}\n(no changes)`;
+    return `${header}\n${unified}`;
+}

package/dist/output/text/registry-commands.js

@@ -2,11 +2,10 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 // Output text formatters for `akm registry *` commands.
-import { formatRegistryAddPlain, formatRegistryBuildIndexPlain, formatRegistryListPlain, formatRegistryRemovePlain, formatRegistrySearchPlain, } from "./helpers.js";
+import { formatRegistryAddPlain, formatRegistryListPlain, formatRegistryRemovePlain, formatRegistrySearchPlain, } from "./helpers.js";
 export const registryCommandFormatters = [
     { command: "registry-list", handler: (r) => formatRegistryListPlain(r) },
     { command: "registry-add", handler: (r) => formatRegistryAddPlain(r) },
     { command: "registry-remove", handler: (r) => formatRegistryRemovePlain(r) },
     { command: "registry-search", handler: (r, detail) => formatRegistrySearchPlain(r, detail) },
-    { command: "registry-build-index", handler: (r) => formatRegistryBuildIndexPlain(r) },
 ];

package/dist/output/text/registry.js

@@ -1,7 +1,15 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-const TEXT_FORMATTER_REGISTRY = new Map();
+/**
+ * Plain-text formatter registry.
+ *
+ * Separated from `text.ts` so per-command formatter modules can import
+ * `registerTextFormatter` without creating a circular dependency back into
+ * the main text module.
+ */
+import { createCommandRegistry } from "../command-registry.js";
+const TEXT_FORMATTER_REGISTRY = createCommandRegistry();
 /**
  * Register a plain-text formatter for a command name.
  *
@@ -13,7 +21,7 @@ const TEXT_FORMATTER_REGISTRY = new Map();
  * ```
  */
 export function registerTextFormatter(command, handler) {
-    TEXT_FORMATTER_REGISTRY.set(command, handler);
+    TEXT_FORMATTER_REGISTRY.register(command, handler);
 }
 /**
  * Register a batch of {@link TextFormatterEntry} definitions in iteration order.
@@ -23,15 +31,13 @@ export function registerTextFormatter(command, handler) {
  * with no reliance on module import order.
  */
 export function registerTextFormatters(entries) {
-    for (const { command, handler } of entries) {
-        TEXT_FORMATTER_REGISTRY.set(command, handler);
-    }
+    TEXT_FORMATTER_REGISTRY.registerAll(entries);
 }
 /**
  * Remove a previously-registered text formatter. Test-only utility.
  */
 export function deregisterTextFormatter(command) {
-    TEXT_FORMATTER_REGISTRY.delete(command);
+    TEXT_FORMATTER_REGISTRY.deregister(command);
 }
 /**
  * Look up a registered text formatter by command name.

package/dist/output/text/show-directives.js

@@ -0,0 +1,117 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * `akm show` agent-directive emission.
+ *
+ * Extracted from `formatShowPlain` (formerly the largest function in
+ * `helpers.ts`): once the base show content is assembled, this module
+ * appends the REC-01/REC-09 APPLY / show-loop / workflow-active directive
+ * blocks that tell the calling agent how to act on the rendered asset.
+ * Directive strings are byte-identical to the pre-extraction version —
+ * only the seam moved.
+ */
+import { conceptIdFromTypeName } from "../../core/asset/resolve-ref.js";
+/**
+ * Append the type-specific agent directive block to an in-progress
+ * `formatShowPlain` render. Mutates `lines` in place (matches the original
+ * inline behavior — push/unshift/splice all operate on the same array the
+ * caller continues to join afterward).
+ */
+export function appendShowDirectives(lines, r) {
+    // REC-01 / REC-09: Append a type-specific directive so agents apply the
+    // content rather than substituting training-data approximations.
+    const assetType = typeof r.type === "string" ? r.type : null;
+    // 0.9.0 (Q-02 / R-002): the retired `type:name` colon grammar is gone —
+    // build the slash conceptId the same way the workflow branch below does
+    // (`workflows/${name}`), via the entry's own already-computed `ref` when
+    // present (it carries correct bundle-qualification), falling back to a
+    // type-derived conceptId for callers that don't set `ref`.
+    const assetRef = typeof r.ref === "string"
+        ? r.ref
+        : typeof r.name === "string" && assetType
+            ? conceptIdFromTypeName(assetType, r.name)
+            : null;
+    // Show-loop detection: if the agent has shown this asset 3+ times without
+    // writing anything, surface a warning so it stops cycling and acts.
+    const showLoopCount = typeof r.showLoopWarning === "number" ? r.showLoopWarning : 0;
+    if (showLoopCount >= 3) {
+        lines.push("");
+        lines.push(`WARNING: You have shown this asset ${showLoopCount} times without completing the task.`);
+        lines.push("Stop re-reading — you have the information you need. Act on it now:");
+        lines.push("  - Write your output file using the content above.");
+        lines.push(`  - If this asset does not contain what you need, run \`akm feedback '${assetRef ?? "<ref>"}' --negative\` and search for a different asset.`);
+    }
+    if (assetType === "skill" || assetType === "knowledge") {
+        const activeRun = r.activeRun;
+        if (activeRun) {
+            // Active workflow: redirect agent to workflow commands instead of direct apply
+            lines.unshift(`  akm workflow complete '${activeRun.runId}'${activeRun.stepId ? ` --step '${activeRun.stepId}'` : ""}`);
+            lines.unshift("Read this schema, then follow your workflow step's instructions to edit the workspace file. When done, mark the step complete:");
+            lines.unshift(`WORKFLOW ACTIVE — schema shown as reference (run: ${activeRun.runId})`);
+            lines.unshift("---");
+            lines.unshift("");
+            // Still show feedback line at the end but skip the APPLY directive
+            lines.push("");
+            lines.push(`Run \`akm feedback ${assetRef ? `'${assetRef}'` : "<ref>"} --positive\` if the step succeeds, or \`--negative\` if this schema did not help.`);
+        }
+        else {
+            // No active workflow: show the APPLY directive. Branch on whether this
+            // skill primarily teaches CLI commands (shell output) vs YAML schema.
+            const preApplyLines = [...lines];
+            lines.push("");
+            lines.push("---");
+            if (isCommandOutputSkill(preApplyLines)) {
+                lines.push("APPLY (only if no workflow step is required for this task):");
+                lines.push("  1. Identify the output file from README.md (typically commands.txt).");
+                lines.push("  2. Write the exact command syntax from the code blocks above — replace every placeholder (`<name>`, `<value>`) with a real, concrete value from your task context. Do not write placeholder text.");
+                lines.push("  3. Each command should be on a single line (no backslash line continuation unless the verifier expects it).");
+                lines.push(`Run \`akm feedback ${assetRef ? `'${assetRef}'` : "<ref>"} --positive\` after the task succeeds, or \`--negative\` if this reference did not contain the needed command syntax.`);
+            }
+            else {
+                lines.push("APPLY (only if no workflow step is required for this task):");
+                lines.push("  1. Identify the target file from README.md — write or edit it. If the file does not yet exist, CREATE it with the full structure from this schema.");
+                lines.push("  2. Add/edit the fields shown above using the exact field names from this schema.");
+                lines.push("  3. COPY the exact YAML structure and field names from the code blocks above — do not substitute synonyms or invent nesting. Replace every placeholder value with a real, concrete value from your task context. Do not leave any field as null, empty, or a placeholder.");
+                lines.push(`Run \`akm feedback ${assetRef ? `'${assetRef}'` : "<ref>"} --positive\` after the task succeeds, or \`--negative\` if the task fails after following this guidance.`);
+            }
+        }
+    }
+    else if (assetType === "workflow") {
+        const workflowName = typeof r.name === "string" ? r.name : null;
+        const workflowRef = workflowName ? `workflows/${workflowName}` : "<ref>";
+        // Insert action directive BEFORE the workflow content by prepending to lines at the
+        // separator position. We find where the header ends and insert after the first `---`.
+        // Since lines already contain the full content at this point, we locate the insertion
+        // index: right after the first `---` separator if present, otherwise after the header.
+        const separatorIdx = lines.indexOf("---");
+        const insertIdx = separatorIdx >= 0 ? separatorIdx + 1 : r.type || r.name ? 1 : 0;
+        const actionDirective = [
+            `ACTION REQUIRED: Do not execute steps manually from this output.`,
+            `Run \`akm workflow next '${workflowRef}'\` to get your current step with exact instructions.`,
+            "---",
+        ];
+        lines.splice(insertIdx, 0, "", ...actionDirective);
+        lines.push("");
+        lines.push("---");
+        lines.push(`NEXT STEP: Run \`akm workflow next '${workflowRef}'\` to see the current workflow step.`);
+        lines.push("Do not edit workspace files before completing each step with `akm workflow complete`.");
+    }
+}
+/**
+ * Detect whether a skill's rendered content primarily teaches CLI commands
+ * rather than YAML schema. Used to select the right APPLY directive variant.
+ *
+ * Heuristic: count code-block lines that start with known shell command
+ * prefixes vs lines that look like YAML key-value pairs. If CLI lines
+ * outnumber YAML lines (and there is at least one CLI line), treat the
+ * skill as command-output.
+ */
+function isCommandOutputSkill(lines) {
+    const codeLines = lines.filter((l) => l.startsWith("  ") || l.startsWith("\t") || /^`/.test(l));
+    const cliPattern = /^(az |kubectl |docker |git |helm |terraform |aws |gcloud )/;
+    const yamlPattern = /^\s+\w+:/;
+    const cliCount = codeLines.filter((l) => cliPattern.test(l.trim())).length;
+    const yamlCount = codeLines.filter((l) => yamlPattern.test(l)).length;
+    return cliCount > yamlCount && cliCount > 0;
+}

package/dist/output/text/show-format.js

@@ -0,0 +1,103 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { appendShowDirectives } from "./show-directives.js";
+export function formatShowPlain(r, detail) {
+    const lines = [];
+    if (r.type || r.name) {
+        lines.push(`# ${String(r.type ?? "asset")}: ${String(r.name ?? "unknown")}`);
+    }
+    if (r.path && r.editable !== false) {
+        lines.push(`file: ${String(r.path)}`);
+    }
+    if (r.origin !== undefined)
+        lines.push(`# origin: ${String(r.origin)}`);
+    if (r.action)
+        lines.push(`# ${String(r.action)}`);
+    if (r.description)
+        lines.push(`description: ${String(r.description)}`);
+    if (r.workflowTitle)
+        lines.push(`workflowTitle: ${String(r.workflowTitle)}`);
+    if (r.agent)
+        lines.push(`agent: ${String(r.agent)}`);
+    if (Array.isArray(r.parameters) && r.parameters.length > 0)
+        lines.push(`parameters: ${r.parameters.join(", ")}`);
+    if (Array.isArray(r.workflowParameters) && r.workflowParameters.length > 0) {
+        lines.push("workflowParameters:");
+        for (const parameter of r.workflowParameters) {
+            const name = typeof parameter.name === "string" ? parameter.name : "unknown";
+            const description = typeof parameter.description === "string" && parameter.description.trim() ? `: ${parameter.description}` : "";
+            lines.push(`  - ${name}${description}`);
+        }
+    }
+    if (r.modelHint != null)
+        lines.push(`modelHint: ${String(r.modelHint)}`);
+    if (r.toolPolicy != null)
+        lines.push(`toolPolicy: ${JSON.stringify(r.toolPolicy)}`);
+    if (r.run)
+        lines.push(`run: ${String(r.run)}`);
+    if (r.setup)
+        lines.push(`setup: ${String(r.setup)}`);
+    if (r.cwd)
+        lines.push(`cwd: ${String(r.cwd)}`);
+    if (detail === "full") {
+        if (r.path)
+            lines.push(`path: ${String(r.path)}`);
+        if (r.editable !== undefined)
+            lines.push(`editable: ${String(r.editable)}`);
+        if (r.editHint)
+            lines.push(`editHint: ${String(r.editHint)}`);
+        if (r.schemaVersion !== undefined)
+            lines.push(`schemaVersion: ${String(r.schemaVersion)}`);
+    }
+    const related = typeof r.related === "object" && r.related !== null ? r.related : undefined;
+    const relatedHits = related && Array.isArray(related.hits) ? related.hits : [];
+    if (related) {
+        lines.push("");
+        lines.push(`related: ${String(related.total ?? relatedHits.length)}`);
+        for (const hit of relatedHits) {
+            lines.push(`  - ${String(hit.type ?? "?")}: ${formatRelatedLabel(hit)}`);
+            const shared = Array.isArray(hit.sharedEntities) ? hit.sharedEntities.map(String) : [];
+            if (shared.length > 0)
+                lines.push(`    shared: ${shared.join(", ")}`);
+            lines.push(`    relationCount: ${String(hit.relationCount ?? 0)}`);
+        }
+    }
+    const payloads = [r.content, r.template, r.prompt].filter((value) => value != null).map(String);
+    if (Array.isArray(r.steps) && r.steps.length > 0) {
+        if (lines.length > 0)
+            lines.push("");
+        lines.push("steps:");
+        for (const [index, step] of r.steps.entries()) {
+            const title = typeof step.title === "string" ? step.title : "Untitled step";
+            const id = typeof step.id === "string" ? step.id : "unknown";
+            lines.push(`  ${index + 1}. ${title} [${id}]`);
+            if (typeof step.instructions === "string" && step.instructions.trim()) {
+                const instrLines = step.instructions.trim().split("\n");
+                lines.push(`     instructions: ${instrLines[0]}`);
+                for (const instrLine of instrLines.slice(1))
+                    lines.push(`       ${instrLine}`);
+            }
+            if (Array.isArray(step.completionCriteria) && step.completionCriteria.length > 0) {
+                lines.push("     completion:");
+                for (const criterion of step.completionCriteria) {
+                    lines.push(`       - ${String(criterion)}`);
+                }
+            }
+        }
+    }
+    if (payloads.length > 0) {
+        if (lines.length > 0)
+            lines.push("");
+        lines.push(...payloads);
+    }
+    appendShowDirectives(lines, r);
+    return lines.length > 0 ? lines.join("\n") : null;
+}
+function formatRelatedLabel(hit) {
+    const ref = typeof hit.ref === "string" ? hit.ref : undefined;
+    if (ref)
+        return ref;
+    const pathValue = typeof hit.path === "string" ? hit.path : "?";
+    return pathValue.split("/").pop() ?? pathValue;
+}

package/dist/output/text/sync.js

@@ -0,0 +1,5 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { formatSyncPlain } from "./helpers.js";
+export const syncFormatters = [{ command: "sync", handler: (r) => formatSyncPlain(r) }];