@bussolabs/closeyourit-cli 0.18.0 → 0.20.0

package/dist/lib/alert-events.js

@@ -1,7 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ALERT_EVENT_TYPES = void 0;
-/** Event types accepted by alert rules — mirror of the backend enum (Alerting::Rule). */
+/**
+ * Event types accepted by alert rules — mirror of the backend enum (Alerting::Rule).
+ *
+ * CYRA-519: the list had stopped at the first fifteen, so `--event-type` rejected every type added
+ * since (containers, replication, inodes, automation, vulnerabilities…) — the flag looked broken
+ * while the backend accepted them. Keep this in the same order as the backend enum: appending there
+ * means appending here.
+ */
 exports.ALERT_EVENT_TYPES = [
     'error_new',
     'error_regression',
@@ -18,4 +25,33 @@ exports.ALERT_EVENT_TYPES = [
     'server_temp',
     'server_service_failed',
     'server_smart_failing',
+    'error_spike',
+    'log_alert',
+    'server_db_down',
+    'server_db_connections',
+    'server_replication_lag',
+    'agents_stalled',
+    'server_container_down',
+    'agents_host_failing',
+    'uptime_slow',
+    'analytics_traffic_drop',
+    'analytics_traffic_spike',
+    'idea_created',
+    'idea_commented',
+    'workload_due_soon',
+    'dataset_training_completed',
+    'dataset_training_failed',
+    'agents_host_stale',
+    'vulnerability_new',
+    'runtime_eol',
+    'embedding_down',
+    'server_container_up',
+    'server_db_connection_usage',
+    'server_data_volume_disk',
+    'server_inode',
+    'server_replication_down',
+    'server_replication_up',
+    'server_container_restart_loop',
+    'server_container_stable',
+    'seo_issue_new',
 ];

package/dist/lib/limits.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Tetti di lunghezza dei campi di testo, come li applica il server (CYCL-32).
+ *
+ * Prima erano scoperti solo sbagliando: l'aiuto non li nominava e il rifiuto arrivava dopo aver
+ * scritto tutto. Qui vivono i numeri — copia dichiarata di `Knowledge::Constants`,
+ * `Ticketing::Constants` e `App::Constants::COMMENT_MAX_CHARS` — che le descrizioni dei flag
+ * mostrano e che i comandi verificano prima di spedire, così i campi troppo lunghi si scoprono
+ * tutti insieme e senza chiamare il server.
+ */
+export declare const LENGTH_LIMITS: {
+    /** Titolo di un ticket e di una pagina di conoscenza. */
+    readonly title: 255;
+    readonly description: 4000;
+    readonly technicalAnalysis: 1500;
+    readonly comment: 240;
+    readonly report: 20000;
+    readonly pageBody: 4000;
+    readonly techSpec: 1500;
+    readonly reviewNote: 240;
+};
+/** Un campo da misurare: il flag come lo scrive chi usa il comando, il valore e il suo tetto. */
+export interface LengthCheck {
+    flag: string;
+    value: unknown;
+    max: number;
+    /** Valore attualmente sul server, quando il comando lo ha letto (vedi `tooLongMessage`). */
+    previous?: unknown;
+    /** Campo che il server corregge in ortografia italiana prima di misurarlo (vedi `exceeds`). */
+    orthography?: boolean;
+}
+/**
+ * Caratteri di un testo contati come li conta il server (Ruby `String#length`, cioè per code point).
+ * La `.length` di JS conta unità UTF-16: un'emoji o qualunque carattere fuori dal BMP ne vale due, e
+ * la lunghezza mostrata divergerebbe da quella su cui il server misura il suo limite.
+ */
+export declare function charCount(value: unknown): number;
+/**
+ * Lunghezza sulla quale il server decide: il testo passa dalle sue normalizzazioni prima di essere
+ * misurato — CRLF ridotti a un solo a capo (`LengthBudget.normalize_newlines`) e spazi ai bordi via
+ * (`strip`). Senza questo un file con 100 righe scritto su Windows "peserebbe" 100 caratteri in più
+ * qui che là, e il comando rifiuterebbe un testo che il server accetta.
+ *
+ * `trim()` non è `String#strip`: toglie anche gli spazi Unicode che Ruby lascia (lo spazio unificatore
+ * in testa a una riga, per dire). Va nella direzione innocua — misura al più quanto il server, mai di
+ * più — quindi al massimo lascia partire una chiamata che il server rifiuterà, mai il contrario.
+ */
+export declare function serverLength(value: unknown): number;
+/**
+ * Il messaggio che elenca TUTTI i campi oltre il tetto, in un colpo solo — il punto della
+ * lavorazione: sistemarne uno e scoprire il successivo al tentativo dopo è esattamente ciò che
+ * questa funzione toglie di mezzo. `undefined` quando è tutto in regola.
+ *
+ * `previous` porta la clausola di salvaguardia del server (`LengthBudget`): un testo già oltre il
+ * tetto resta salvabile finché non si allunga, così chi ha in archivio una pagina o un ticket
+ * scritti prima del limite può ancora correggerli e accorciarli per gradi. I comandi che leggono lo
+ * stato attuale prima di scrivere lo passano; chi non lo conosce (una creazione, o `--replace`) lo
+ * lascia fuori e il tetto vale pieno.
+ */
+export declare function tooLongMessage(checks: LengthCheck[]): string | undefined;

package/dist/lib/limits.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LENGTH_LIMITS = void 0;
+exports.charCount = charCount;
+exports.serverLength = serverLength;
+exports.tooLongMessage = tooLongMessage;
+/**
+ * Tetti di lunghezza dei campi di testo, come li applica il server (CYCL-32).
+ *
+ * Prima erano scoperti solo sbagliando: l'aiuto non li nominava e il rifiuto arrivava dopo aver
+ * scritto tutto. Qui vivono i numeri — copia dichiarata di `Knowledge::Constants`,
+ * `Ticketing::Constants` e `App::Constants::COMMENT_MAX_CHARS` — che le descrizioni dei flag
+ * mostrano e che i comandi verificano prima di spedire, così i campi troppo lunghi si scoprono
+ * tutti insieme e senza chiamare il server.
+ */
+exports.LENGTH_LIMITS = {
+    /** Titolo di un ticket e di una pagina di conoscenza. */
+    title: 255,
+    description: 4_000,
+    technicalAnalysis: 1_500,
+    comment: 240,
+    report: 20_000,
+    pageBody: 4_000,
+    techSpec: 1_500,
+    reviewNote: 240,
+};
+/**
+ * Caratteri di un testo contati come li conta il server (Ruby `String#length`, cioè per code point).
+ * La `.length` di JS conta unità UTF-16: un'emoji o qualunque carattere fuori dal BMP ne vale due, e
+ * la lunghezza mostrata divergerebbe da quella su cui il server misura il suo limite.
+ */
+function charCount(value) {
+    return [...String(value ?? '')].length;
+}
+/**
+ * Lunghezza sulla quale il server decide: il testo passa dalle sue normalizzazioni prima di essere
+ * misurato — CRLF ridotti a un solo a capo (`LengthBudget.normalize_newlines`) e spazi ai bordi via
+ * (`strip`). Senza questo un file con 100 righe scritto su Windows "peserebbe" 100 caratteri in più
+ * qui che là, e il comando rifiuterebbe un testo che il server accetta.
+ *
+ * `trim()` non è `String#strip`: toglie anche gli spazi Unicode che Ruby lascia (lo spazio unificatore
+ * in testa a una riga, per dire). Va nella direzione innocua — misura al più quanto il server, mai di
+ * più — quindi al massimo lascia partire una chiamata che il server rifiuterà, mai il contrario.
+ */
+function serverLength(value) {
+    return charCount(String(value ?? '').replaceAll('\r\n', '\n').trim());
+}
+/**
+ * Quanto la correzione ortografica italiana del server può ancora accorciare il testo (CYCL-32).
+ *
+ * `Text::ItalianOrthography.correct` gira sui campi dei ticket e sul resoconto prima della misura, e
+ * sostituisce forme note con la loro versione accentata: «gia» → «già» non cambia la lunghezza,
+ * «perche'» → «perché» ne toglie una, perché assorbe l'apostrofo. Il dizionario non vive qui e non
+ * deve: il taglio massimo possibile è comunque UN carattere per apostrofo presente nel testo.
+ *
+ * Serve a non rifiutare in locale ciò che il server accetterebbe — un testo appena sopra il tetto e
+ * pieno di apostrofi da correggere ci rientra da solo. Sotto quel margine la misura resta al server.
+ */
+function orthographyMargin(value) {
+    return (value.match(/['’]/g) ?? []).length;
+}
+/**
+ * Il messaggio che elenca TUTTI i campi oltre il tetto, in un colpo solo — il punto della
+ * lavorazione: sistemarne uno e scoprire il successivo al tentativo dopo è esattamente ciò che
+ * questa funzione toglie di mezzo. `undefined` quando è tutto in regola.
+ *
+ * `previous` porta la clausola di salvaguardia del server (`LengthBudget`): un testo già oltre il
+ * tetto resta salvabile finché non si allunga, così chi ha in archivio una pagina o un ticket
+ * scritti prima del limite può ancora correggerli e accorciarli per gradi. I comandi che leggono lo
+ * stato attuale prima di scrivere lo passano; chi non lo conosce (una creazione, o `--replace`) lo
+ * lascia fuori e il tetto vale pieno.
+ */
+function tooLongMessage(checks) {
+    const over = checks.filter((check) => exceeds(check));
+    if (over.length === 0)
+        return undefined;
+    const list = over.map((check) => `${check.flag} is ${serverLength(check.value)} characters (max ${check.max})`);
+    return `Too long for the server: ${list.join('; ')}. Shorten ${over.length === 1 ? 'it' : 'them'} and run the command again.`;
+}
+/**
+ * Vero solo quando il rifiuto è CERTO: si misura la lunghezza più corta che il testo può avere una
+ * volta arrivato al server (correzione ortografica inclusa, dove il server la applica) e si tiene
+ * conto della salvaguardia sul valore attuale. Nel dubbio si tace e decide il server.
+ */
+function exceeds(check) {
+    const length = serverLength(check.value);
+    const shortest = check.orthography ? length - orthographyMargin(String(check.value ?? '')) : length;
+    if (shortest <= check.max)
+        return false;
+    const previous = serverLength(check.previous);
+    return !(previous > check.max && length <= previous);
+}

package/dist/lib/stdin.d.ts

@@ -1,3 +1,2 @@
-/** Read a whole stream (default: process.stdin) into a UTF-8 string. Used by `secrets import` to accept
- * piped input, e.g. `doppler secrets download --format json | cyi secrets import --format json`. */
+/** Read a whole stream (default: process.stdin) into a UTF-8 string for `secrets import`. */
 export declare function readStream(stream?: AsyncIterable<Buffer | string>): Promise<string>;

package/dist/lib/stdin.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readStream = readStream;
-/** Read a whole stream (default: process.stdin) into a UTF-8 string. Used by `secrets import` to accept
- * piped input, e.g. `doppler secrets download --format json | cyi secrets import --format json`. */
+/** Read a whole stream (default: process.stdin) into a UTF-8 string for `secrets import`. */
 async function readStream(stream = process.stdin) {
     const chunks = [];
     for await (const chunk of stream)

package/dist/lib/subprocess.d.ts

@@ -1,6 +1,6 @@
 /**
  * Run a child process inheriting stdio, resolving with its exit code. Unlike `openUrl` (browser.ts)
  * this is NOT detached/unref'd: `cyi run` must stay attached and propagate the child's exit code
- * (like `doppler run`). A terminating signal maps to a non-zero code.
+ * and propagate the child's exit code. A terminating signal maps to a non-zero code.
  */
 export declare function runCommand(command: string, args: string[], env: NodeJS.ProcessEnv): Promise<number>;

package/dist/lib/subprocess.js

@@ -5,7 +5,7 @@ const node_child_process_1 = require("node:child_process");
 /**
  * Run a child process inheriting stdio, resolving with its exit code. Unlike `openUrl` (browser.ts)
  * this is NOT detached/unref'd: `cyi run` must stay attached and propagate the child's exit code
- * (like `doppler run`). A terminating signal maps to a non-zero code.
+ * and propagate the child's exit code. A terminating signal maps to a non-zero code.
  */
 function runCommand(command, args, env) {
     return new Promise((resolve, reject) => {

package/dist/lib/ticket-body.d.ts

@@ -1,4 +1,11 @@
+import { type LengthCheck } from './limits';
 export declare const ticketBodyFlags: {
+    'assignee-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    'milestone-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    'parent-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    'platform-id': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    status: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    priority: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     description: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     'technical-analysis': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     scenarios: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
@@ -9,12 +16,10 @@ export declare const ticketBodyFlags: {
     condition: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     weight: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     'due-at': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-    'status-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-    'priority-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-    'assignee-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-    'milestone-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-    'parent-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-    'platform-id': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+};
+export declare const CLEARABLE_FIELDS: Record<string, string>;
+export declare const clearFlag: {
+    clear: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
 };
 type BodyFlags = Record<string, unknown>;
 export declare function scenariosFromFlags(flags: BodyFlags): Array<Record<string, unknown>> | undefined;
@@ -22,4 +27,15 @@ export declare function conditionsFromFlags(flags: BodyFlags): Array<{
     text: string;
 }> | undefined;
 export declare function applyTicketBody(body: BodyFlags, flags: BodyFlags): void;
+/**
+ * I campi del corpo che il server misura, pronti per `tooLongMessage` (CYCL-32): titolo, descrizione
+ * e analisi tecnica. Scenari e condizioni non ci sono — non hanno tetto.
+ *
+ * `current` è il ticket com'è adesso, per i comandi che lo leggono prima di scrivere: fa da
+ * salvaguardia, così un testo scritto prima che il tetto esistesse resta correggibile finché non si
+ * allunga. Chi non lo conosce lo omette e il tetto vale pieno.
+ */
+export declare function ticketLengthChecks(flags: BodyFlags, current?: BodyFlags): LengthCheck[];
+/** Marca come vuoti i campi elencati da `--clear`: null, o lista vuota per le piattaforme. */
+export declare function applyTicketClears(body: BodyFlags, fields: string[] | undefined): void;
 export {};

package/dist/lib/ticket-body.js

@@ -1,17 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ticketBodyFlags = void 0;
+exports.clearFlag = exports.CLEARABLE_FIELDS = exports.ticketBodyFlags = void 0;
 exports.scenariosFromFlags = scenariosFromFlags;
 exports.conditionsFromFlags = conditionsFromFlags;
 exports.applyTicketBody = applyTicketBody;
+exports.ticketLengthChecks = ticketLengthChecks;
+exports.applyTicketClears = applyTicketClears;
 const core_1 = require("@oclif/core");
+const limits_1 = require("./limits");
+const ticket_lookup_1 = require("./ticket-lookup");
 // Flag del corpo ticket condivisi da `tickets create` e `tickets update`: descrizione (sommario
 // human-simple) + N scenari BDD + N condizioni DoD + analisi tecnica (registro tecnico separato) +
 // metadati. Gli scenari si passano come JSON (--scenarios) oppure, per un SINGOLO scenario, con le
 // scorciatoie --step-*. Le condizioni DoD sono --condition (ripetibile). Parità piena col form web.
 exports.ticketBodyFlags = {
-    description: core_1.Flags.string({ description: 'Free-form description (human-simple summary)' }),
-    'technical-analysis': core_1.Flags.string({ description: 'Technical analysis (stack, cause) — kept out of the human-simple body' }),
+    description: core_1.Flags.string({
+        description: `Free-form description (human-simple summary, max ${limits_1.LENGTH_LIMITS.description} characters)`,
+    }),
+    'technical-analysis': core_1.Flags.string({
+        description: `Technical analysis (stack, cause) — kept out of the human-simple body (max ${limits_1.LENGTH_LIMITS.technicalAnalysis} characters)`,
+    }),
     scenarios: core_1.Flags.string({
         description: 'BDD scenarios as a JSON array: [{"title","step_given","step_when","step_then","step_expected"}]',
     }),
@@ -22,13 +30,34 @@ exports.ticketBodyFlags = {
     condition: core_1.Flags.string({ description: 'Definition-of-Done line (repeatable)', multiple: true }),
     weight: core_1.Flags.string({ description: 'Story points (positive integer)' }),
     'due-at': core_1.Flags.string({ description: 'Due date (ISO 8601)' }),
-    'status-id': core_1.Flags.string({ description: 'Status lookup id' }),
-    'priority-id': core_1.Flags.string({ description: 'Priority lookup id' }),
+    // Stato e priorità si indicano per code, etichetta o id, e il comando li risolve (CYCL-34).
+    ...ticket_lookup_1.ticketLookupFlags,
     'assignee-id': core_1.Flags.string({ description: 'Assignee account id' }),
     'milestone-id': core_1.Flags.string({ description: 'Milestone id (of this project)' }),
     'parent-id': core_1.Flags.string({ description: 'Parent epic id (of this project) — pass an empty string to detach' }),
     'platform-id': core_1.Flags.string({ description: 'Affected platform id (repeatable)', multiple: true }),
 };
+// Campi che `tickets update` svuota solo se glielo si chiede (`--clear <campo>`): nome del flag che
+// li imposta → chiave del corpo. Svuotarli è una richiesta a sé, mai l'effetto collaterale di un
+// campo omesso (CYCL-30). Scenari e condizioni non ci sono: il backend li sostituisce quando il
+// corpo ne porta di nuovi, li lascia intatti quando li omette, e un array vuoto non li cancella.
+exports.CLEARABLE_FIELDS = {
+    description: 'description',
+    'technical-analysis': 'technical_analysis',
+    weight: 'weight',
+    'due-at': 'due_at',
+    assignee: 'assignee_id',
+    milestone: 'milestone_id',
+    parent: 'parent_id',
+    platforms: 'platform_ids',
+};
+exports.clearFlag = {
+    clear: core_1.Flags.string({
+        description: `Empty a field on purpose (repeatable): ${Object.keys(exports.CLEARABLE_FIELDS).join(', ')}`,
+        multiple: true,
+        options: Object.keys(exports.CLEARABLE_FIELDS),
+    }),
+};
 const STEP_KEYS = [
     ['step-given', 'step_given'],
     ['step-when', 'step_when'],
@@ -64,6 +93,8 @@ function conditionsFromFlags(flags) {
     return conditions.map((text) => ({ text }));
 }
 // Popola `body` coi campi del corpo presenti nei flag (chiavi snake_case attese dall'API CLI).
+// Stato e priorità restano fuori: vanno risolti in id contro le lookup dell'organizzazione, cioè
+// con una chiamata, e ogni comando li aggiunge dopo — con o senza predefinito (CYCL-34).
 function applyTicketBody(body, flags) {
     if (flags.description !== undefined)
         body.description = flags.description;
@@ -73,10 +104,6 @@ function applyTicketBody(body, flags) {
         body.weight = flags.weight;
     if (flags['due-at'] !== undefined)
         body.due_at = flags['due-at'];
-    if (flags['status-id'] !== undefined)
-        body.status_id = flags['status-id'];
-    if (flags['priority-id'] !== undefined)
-        body.priority_id = flags['priority-id'];
     if (flags['assignee-id'] !== undefined)
         body.assignee_id = flags['assignee-id'];
     if (flags['milestone-id'] !== undefined)
@@ -92,3 +119,38 @@ function applyTicketBody(body, flags) {
     if (conditions !== undefined)
         body.conditions_attributes = conditions;
 }
+/**
+ * I campi del corpo che il server misura, pronti per `tooLongMessage` (CYCL-32): titolo, descrizione
+ * e analisi tecnica. Scenari e condizioni non ci sono — non hanno tetto.
+ *
+ * `current` è il ticket com'è adesso, per i comandi che lo leggono prima di scrivere: fa da
+ * salvaguardia, così un testo scritto prima che il tetto esistesse resta correggibile finché non si
+ * allunga. Chi non lo conosce lo omette e il tetto vale pieno.
+ */
+function ticketLengthChecks(flags, current = {}) {
+    // `orthography`: il server corregge l'ortografia italiana di questi tre campi prima di misurarli.
+    return [
+        { flag: '--title', value: flags.title, max: limits_1.LENGTH_LIMITS.title, previous: current.title, orthography: true },
+        {
+            flag: '--description',
+            value: flags.description,
+            max: limits_1.LENGTH_LIMITS.description,
+            previous: current.description,
+            orthography: true,
+        },
+        {
+            flag: '--technical-analysis',
+            value: flags['technical-analysis'],
+            max: limits_1.LENGTH_LIMITS.technicalAnalysis,
+            previous: current.technical_analysis,
+            orthography: true,
+        },
+    ];
+}
+/** Marca come vuoti i campi elencati da `--clear`: null, o lista vuota per le piattaforme. */
+function applyTicketClears(body, fields) {
+    for (const field of fields ?? []) {
+        const key = exports.CLEARABLE_FIELDS[field];
+        body[key] = key === 'platform_ids' ? [] : null;
+    }
+}

package/dist/lib/ticket-lookup.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Le due lookup d'organizzazione che ogni ticket si porta addosso: stato e priorità (CYCL-34).
+ *
+ * Il server le pretende entrambe alla creazione (R422-TICKET-001 "Status must exist and Priority
+ * must exist") mentre l'aiuto della CLI le dava per opzionali, e i loro id andavano cercati prima
+ * con `tickets statuses`/`tickets priorities` e incollati come UUID. Qui vivono l'endpoint da
+ * leggere, il code che vale quando il ticket nasce senza che li si sia indicati, e come si chiama
+ * il campo nei messaggi.
+ */
+export interface TicketLookup {
+    /** Lookup d'organizzazione (non di progetto): gli id valgono per un ticket di qualunque progetto. */
+    path: string;
+    /** Nome del campo nei messaggi d'errore. */
+    name: string;
+    /** Il flag che lo imposta. */
+    flag: string;
+    /** Il code che vale quando il ticket nasce e non lo si è indicato. */
+    fallback: string;
+    errorCode: string;
+}
+export declare const TICKET_STATUS: TicketLookup;
+export declare const TICKET_PRIORITY: TicketLookup;
+/**
+ * `--status`/`--priority` di un comando che modifica un ticket già esistente. `--status-id` e
+ * `--priority-id` restano come alias: erano l'unico modo di indicarli, e gli script che li usano
+ * continuano a funzionare senza riscritture.
+ */
+export declare const ticketLookupFlags: {
+    status: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    priority: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+};
+/** Gli stessi due flag su un comando che crea il ticket, dove ometterli ha un valore predefinito. */
+export declare const newTicketLookupFlags: {
+    status: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    priority: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+};
+/**
+ * Le voci che corrispondono al riferimento scritto a mano: prima il code, poi l'etichetta, senza
+ * badare alle maiuscole. Il code ha la precedenza perché è il nome esatto della voce: senza,
+ * l'etichetta di un'altra ("Urgent" su `high`) farebbe concorrenza al code di quella cercata
+ * (`urgent`) e una scelta legittima diventerebbe un'ambiguità da rifiutare.
+ */
+export declare function matchTicketLookup(rows: unknown, value: string): Array<{
+    id: string;
+}>;
+/**
+ * Il rifiuto di un riferimento che non si risolve: dice cos'è stato cercato, come si scrive il flag
+ * e quali voci esistono davvero — così scoprirle non costa un secondo comando.
+ */
+export declare function ticketLookupErrorMessage(lookup: TicketLookup, wanted: string, rows: unknown, { matched, isDefault }: {
+    matched: number;
+    isDefault: boolean;
+}): string;

package/dist/lib/ticket-lookup.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newTicketLookupFlags = exports.ticketLookupFlags = exports.TICKET_PRIORITY = exports.TICKET_STATUS = void 0;
+exports.matchTicketLookup = matchTicketLookup;
+exports.ticketLookupErrorMessage = ticketLookupErrorMessage;
+const core_1 = require("@oclif/core");
+const error_codes_1 = require("../errors/error-codes");
+exports.TICKET_STATUS = {
+    path: '/cli/v1/types/ticket_statuses',
+    name: 'Status',
+    flag: '--status',
+    fallback: 'open',
+    errorCode: error_codes_1.ErrorCodes.TicketStatus.notFound,
+};
+exports.TICKET_PRIORITY = {
+    path: '/cli/v1/types/ticket_priorities',
+    name: 'Priority',
+    flag: '--priority',
+    fallback: 'medium',
+    errorCode: error_codes_1.ErrorCodes.TicketPriority.notFound,
+};
+/**
+ * `--status`/`--priority` di un comando che modifica un ticket già esistente. `--status-id` e
+ * `--priority-id` restano come alias: erano l'unico modo di indicarli, e gli script che li usano
+ * continuano a funzionare senza riscritture.
+ */
+exports.ticketLookupFlags = {
+    status: core_1.Flags.string({
+        aliases: ['status-id'],
+        description: 'Status code, label or id (e.g. open, "In Progress") — unchanged when omitted',
+    }),
+    priority: core_1.Flags.string({
+        aliases: ['priority-id'],
+        description: 'Priority code, label or id (e.g. medium, High) — unchanged when omitted',
+    }),
+};
+/** Gli stessi due flag su un comando che crea il ticket, dove ometterli ha un valore predefinito. */
+exports.newTicketLookupFlags = {
+    status: core_1.Flags.string({
+        aliases: ['status-id'],
+        description: `Status code, label or id (e.g. open, "In Progress") — default: ${exports.TICKET_STATUS.fallback}`,
+    }),
+    priority: core_1.Flags.string({
+        aliases: ['priority-id'],
+        description: `Priority code, label or id (e.g. medium, High) — default: ${exports.TICKET_PRIORITY.fallback}`,
+    }),
+};
+/**
+ * Le voci che corrispondono al riferimento scritto a mano: prima il code, poi l'etichetta, senza
+ * badare alle maiuscole. Il code ha la precedenza perché è il nome esatto della voce: senza,
+ * l'etichetta di un'altra ("Urgent" su `high`) farebbe concorrenza al code di quella cercata
+ * (`urgent`) e una scelta legittima diventerebbe un'ambiguità da rifiutare.
+ */
+function matchTicketLookup(rows, value) {
+    const wanted = value.trim().toLowerCase();
+    const list = (Array.isArray(rows) ? rows : []);
+    const identified = list.filter((row) => typeof row.id === 'string' && row.id !== '');
+    const sameAs = (field) => typeof field === 'string' && field.trim().toLowerCase() === wanted;
+    const byCode = identified.filter((row) => sameAs(row.code));
+    return byCode.length > 0 ? byCode : identified.filter((row) => sameAs(row.label));
+}
+/**
+ * Il rifiuto di un riferimento che non si risolve: dice cos'è stato cercato, come si scrive il flag
+ * e quali voci esistono davvero — così scoprirle non costa un secondo comando.
+ */
+function ticketLookupErrorMessage(lookup, wanted, rows, { matched, isDefault }) {
+    const known = (Array.isArray(rows) ? rows : [])
+        .map((row) => (typeof row.code === 'string' && row.code !== '' ? row.code : String(row.label ?? '')))
+        .filter((name) => name !== '')
+        .join(', ');
+    const hint = `Pass ${lookup.flag} with a code, a label or an id${known === '' ? '' : ` — known: ${known}`}.`;
+    if (matched > 1)
+        return `${lookup.name} "${wanted}" matches ${matched} entries. ${hint}`;
+    if (isDefault) {
+        return `This organization has no ${lookup.name.toLowerCase()} "${wanted}", the default for a new ticket. ${hint}`;
+    }
+    return `${lookup.name} not found: "${wanted}". ${hint}`;
+}

package/dist/lib/ticket-report.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Una versione del resoconto di lavorazione: intestazione coi metadati + il testo per intero
+ * (CYCL-31). Il corpo passa da `sanitizeMultiline` e non da `renderRecord`: quest'ultimo appiattisce
+ * ogni valore con `sanitize`, che trasforma gli a capo in spazi — su un resoconto di migliaia di
+ * caratteri significherebbe stamparlo come un muro di testo su una riga sola.
+ */
+export declare function renderReport(report: Record<string, unknown>): string;

package/dist/lib/ticket-report.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderReport = renderReport;
+const output_1 = require("./output");
+/**
+ * Una versione del resoconto di lavorazione: intestazione coi metadati + il testo per intero
+ * (CYCL-31). Il corpo passa da `sanitizeMultiline` e non da `renderRecord`: quest'ultimo appiattisce
+ * ogni valore con `sanitize`, che trasforma gli a capo in spazi — su un resoconto di migliaia di
+ * caratteri significherebbe stamparlo come un muro di testo su una riga sola.
+ */
+function renderReport(report) {
+    const header = `── version ${(0, output_1.sanitize)(report.version ?? '?')} · ${(0, output_1.sanitize)(report.author ?? '?')} · ${(0, output_1.sanitize)(report.source ?? '-')} · ${(0, output_1.sanitize)(report.created_at ?? '-')}`;
+    return `${header}\n${(0, output_1.sanitizeMultiline)(report.body ?? '')}`;
+}