@illuminis/comprism 0.1.4 → 0.1.6

package/out/lib/readiness.js

@@ -36,10 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REQUIREMENTS = void 0;
-exports.present = present;
-exports.howToInstall = howToInstall;
-exports.check = check;
+exports.present = exports.howToInstall = exports.check = exports.REQUIREMENTS = void 0;
 exports.systemName = systemName;
 exports.diagnose = diagnose;
 /**
@@ -72,82 +69,16 @@ exports.diagnose = diagnose;
  * is not friction worth trading a customer's trust for.
  */
 const node_child_process_1 = require("node:child_process");
+const needs_1 = require("../machine/runtime/needs");
+Object.defineProperty(exports, "REQUIREMENTS", { enumerable: true, get: function () { return needs_1.REQUIREMENTS; } });
+Object.defineProperty(exports, "check", { enumerable: true, get: function () { return needs_1.check; } });
+Object.defineProperty(exports, "howToInstall", { enumerable: true, get: function () { return needs_1.howToInstall; } });
+Object.defineProperty(exports, "present", { enumerable: true, get: function () { return needs_1.present; } });
 const node_os_1 = __importDefault(require("node:os"));
 const install_1 = require("../commands/install");
 const connection_1 = require("./connection");
 const gateway_1 = require("./gateway");
 const node_fs_1 = __importDefault(require("node:fs"));
-exports.REQUIREMENTS = [
-    {
-        purpose: 'working with a repository',
-        anyOf: ['git'],
-        without: 'reading, branching and committing a project',
-        essential: false,
-    },
-    {
-        purpose: 'reading a PDF you already have',
-        // Three ways to do the same job. The first keeps the layout, the second is
-        // close, the third is usually there on any machine with Python at all.
-        anyOf: ['pdftotext', 'mutool', 'python3'],
-        without: 'reading a specification or a contract that arrived as a PDF',
-        essential: false,
-    },
-];
-/** Is this program on the machine, by name, without running anything of theirs. */
-function present(program) {
-    try {
-        // Windows has no /usr/bin/env, so every program read as missing there.
-        if (node_os_1.default.platform() === 'win32')
-            (0, node_child_process_1.execFileSync)('where', [program], { stdio: 'ignore' });
-        else
-            (0, node_child_process_1.execFileSync)('/usr/bin/env', ['which', program], { stdio: 'ignore' });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * The one command that installs what is missing, for the machine it is on.
- *
- * Named per platform rather than guessed: telling somebody on Ubuntu to run a
- * Homebrew command is worse than saying nothing, because they now have to work
- * out that the instruction was wrong before they can work out what is right.
- */
-function howToInstall(missing) {
-    if (missing.length === 0)
-        return '';
-    const platform = node_os_1.default.platform();
-    const parts = missing.map((m) => (m === 'pdftotext' ? 'poppler' : m));
-    if (platform === 'darwin')
-        return `brew install ${parts.join(' ')}`;
-    if (platform === 'linux') {
-        const apt = missing.map((m) => (m === 'pdftotext' ? 'poppler-utils' : m));
-        return `sudo apt-get install -y ${apt.join(' ')}`;
-    }
-    if (platform === 'win32')
-        return `winget install ${parts.join(' ')}`;
-    return `install: ${parts.join(', ')}`;
-}
-/** What this machine can and cannot do, and how to close the gap. */
-function check() {
-    const lines = [];
-    const missing = [];
-    for (const req of exports.REQUIREMENTS) {
-        const found = req.anyOf.find(present);
-        if (found) {
-            lines.push(`  ready    ${req.purpose}`);
-        }
-        else {
-            // The FIRST of the alternatives is the one named, because a list of three
-            // equivalent programs is a decision nobody wants to make about a thing
-            // they did not know they needed.
-            missing.push(req.anyOf[0]);
-            lines.push(`  missing  ${req.purpose}, so ${req.without} will not work`);
-        }
-    }
-    return { ready: missing.length === 0, lines, fix: howToInstall(missing) };
-}
 /** The system this is, in the words its owner would use. */
 function systemName() {
     try {
@@ -205,7 +136,7 @@ async function diagnose() {
     const major = Number(node.split('.')[0]);
     // The install script and Python installs carry their own Node (manual 1.1),
     // so the line says so rather than asking for a Node nobody installed.
-    const { installMethod, isStandalone } = await Promise.resolve().then(() => __importStar(require('./self')));
+    const { installMethod, isStandalone } = await Promise.resolve().then(() => __importStar(require('../machine/runtime/self')));
     if (isStandalone()) {
         const how = installMethod() === 'script' ? 'the install script' : 'Python (pip)';
         found.push({ ok: true, required: true, line: `installed with ${how}; Node ${node} is built in, nothing else needed` });
@@ -260,17 +191,17 @@ async function diagnose() {
     const git = version('git', ['--version']);
     found.push(git !== null
         ? { ok: true, required: false, line: `git ${git}` }
-        : { ok: false, required: false, line: 'git not found: reading, branching and committing a project will not work',
-            fix: howToInstall(['git']) });
+        : { ok: false, required: false, line: 'git not found: reading, branching and committing a workspace will not work',
+            fix: (0, needs_1.howToInstall)(['git']) });
     const rg = version('rg', ['--version']);
     found.push(rg !== null
         ? { ok: true, required: false, line: `ripgrep ${rg}` }
         : { ok: false, required: false, line: 'ripgrep not found: searches will be slower',
-            fix: howToInstall(['ripgrep']) });
-    const pdf = exports.REQUIREMENTS[1];
-    found.push(pdf.anyOf.some(present)
+            fix: (0, needs_1.howToInstall)(['ripgrep']) });
+    const pdf = needs_1.REQUIREMENTS[1];
+    found.push(pdf.anyOf.some(needs_1.present)
         ? { ok: true, required: false, line: 'a PDF reader' }
         : { ok: false, required: false, line: `no PDF reader: ${pdf.without} will not work`,
-            fix: howToInstall(['pdftotext']) });
+            fix: (0, needs_1.howToInstall)(['pdftotext']) });
     return found;
 }

package/out/lib/servicecommand.d.ts

@@ -0,0 +1,14 @@
+export interface ServiceAnswer {
+    /** False when nobody answered; `lines` then holds nothing. */
+    reached: boolean;
+    /** Whether the service did what was asked. */
+    ok: boolean;
+    lines: string[];
+    /** The one change to this client's own state the service asked for. */
+    action: Record<string, string> | null;
+    message?: string;
+}
+export declare function runServiceCommand(words: string, facts: {
+    cwd: string;
+    current?: string;
+}): Promise<ServiceAnswer>;

package/out/lib/servicecommand.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runServiceCommand = runServiceCommand;
+/**
+ * Ask the service to run a command it owns (web manual 13.2 to 13.5): what was
+ * typed goes up, the service decides what it means and writes every line, and
+ * this answers its one question only this computer can, whether a folder exists.
+ *
+ * Shared by the session and by the commands typed straight at the shell, so a
+ * service command behaves the same wherever it is typed.
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const gateway_1 = require("./gateway");
+async function runServiceCommand(words, facts) {
+    const exists = {};
+    for (let round = 0; round < 4; round += 1) {
+        const reply = await (0, gateway_1.ask)({
+            intent: 'command', prompt: '',
+            payload: { words, cwd: facts.cwd, home: os.homedir(), current: facts.current ?? '', exists },
+        });
+        if (!reply.lines?.length && !reply.data) {
+            return { reached: false, ok: false, lines: [], action: null, message: reply.message ?? undefined };
+        }
+        const data = (reply.data ?? {});
+        const wanted = data.wants?.exists ?? [];
+        if (wanted.length) {
+            for (const p of wanted) {
+                try {
+                    exists[p] = fs.statSync(p).isDirectory();
+                }
+                catch {
+                    exists[p] = false;
+                }
+            }
+            continue;
+        }
+        return { reached: true, ok: reply.granted !== false, lines: reply.lines ?? [], action: data.action ?? null };
+    }
+    return { reached: false, ok: false, lines: [], action: null };
+}

package/out/lib/sessions.js

@@ -51,7 +51,7 @@ const gateway_1 = require("./gateway");
 const out = (s = '') => process.stdout.write(s + '\n');
 /** Ask the service one sessions question, with where this machine is. */
 async function sessions(op, extra = {}, folder) {
-    const { resolveProject, asWire } = await Promise.resolve().then(() => __importStar(require('./project')));
+    const { resolveProject, asWire } = await Promise.resolve().then(() => __importStar(require('../machine/folder/project')));
     const { currentWorkspace } = await Promise.resolve().then(() => __importStar(require('../commands/settings')));
     const facts = resolveProject(folder ?? currentWorkspace().path, []);
     return (0, gateway_1.ask)({
@@ -69,9 +69,9 @@ async function sessions(op, extra = {}, folder) {
 /** Why a sessions question got no answer, in the service's words when it has them. */
 function failure(reply) {
     if (reply.served === false) {
-        return 'Your workspace is running a build without sessions yet.';
+        return 'Your organization is running a build without sessions yet.';
     }
-    return reply.message || 'Your workspace could not be reached.';
+    return reply.message || 'Your organization could not be reached.';
 }
 /** The exit number for a sessions question that got no answer (Appendix B). */
 function exitFor(reply) {

package/out/lib/startcache.d.ts

@@ -0,0 +1,13 @@
+import type { SessionOut } from './gateway';
+import type { CommandList } from './commandlist';
+export interface StartCache {
+    /** Which workspace these answers came from; another workspace's are never used. */
+    url?: string;
+    me?: SessionOut | null;
+    hasKey?: boolean;
+    /** The project line, by project folder. */
+    lines?: Record<string, string>;
+    list?: CommandList | null;
+}
+export declare function readStart(url: string): StartCache;
+export declare function saveStart(url: string, change: Partial<StartCache>): void;

package/out/lib/startcache.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readStart = readStart;
+exports.saveStart = saveStart;
+/**
+ * What the service said the last time a session opened, kept so the next one
+ * can open at once.
+ *
+ * Opening a session asks the service four things (who you are, whether a key
+ * is stored, the project line, the command list). Asked from a laptop whose
+ * database is a region away, each takes seconds, and the prompt waited for all
+ * of them. Now the last answers are drawn immediately and the same questions
+ * are asked again in the background; the fresh answers are kept for next time,
+ * and a change that matters (no key any more) is said as soon as it is known.
+ *
+ * Only the service's own answers are kept, exactly as sent. Nothing here is
+ * decided on this machine, and a missing or unreadable file simply means the
+ * session waits for the service, as it always did.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const config_1 = require("./config");
+function file() {
+    return path.join((0, config_1.ensureHome)(), 'start-cache.json');
+}
+function readStart(url) {
+    try {
+        const got = JSON.parse(fs.readFileSync(file(), 'utf8'));
+        return got.url === url ? got : { url };
+    }
+    catch {
+        return { url };
+    }
+}
+function saveStart(url, change) {
+    try {
+        const now = readStart(url);
+        const next = {
+            ...now, ...change, url,
+            lines: { ...(now.lines ?? {}), ...(change.lines ?? {}) },
+        };
+        fs.writeFileSync(file(), JSON.stringify(next), { mode: 0o600 });
+    }
+    catch { /* a cache that cannot be written only means the next start waits */ }
+}

package/out/lib/ui.d.ts

@@ -35,6 +35,17 @@ export declare const c: {
  * and the brand is the one thing a customer notices before the engine.
  */
 export declare function spectrumAt(index: number, glyph: string): string;
+/**
+ * A small picture, one pixel to a character cell, each pixel a colored space.
+ *
+ * A cell's background is painted edge to edge by every terminal, so the
+ * picture has no seams. Half block glyphs pack two pixels into a cell but
+ * leave thin gaps and offsets in some fonts, which made the mark look broken
+ * in the macOS Terminal (owner, 28 September 2026). Each row of `pixels` is
+ * six hex digits per pixel, `......` for a clear one. Returns nothing without
+ * color, because the picture is only color.
+ */
+export declare function cellArt(pixels: string[]): string[];
 export declare function prismRule(w?: number): string;
 export declare function banner(subtitle?: string): string;
 export declare function money(v: number | null): string;

package/out/lib/ui.js

@@ -19,6 +19,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiveIndicator = exports.c = void 0;
 exports.width = width;
 exports.spectrumAt = spectrumAt;
+exports.cellArt = cellArt;
 exports.prismRule = prismRule;
 exports.banner = banner;
 exports.money = money;
@@ -86,6 +87,33 @@ function spectrumAt(index, glyph) {
     const [r, g, b] = SPECTRUM[Math.abs(index) % SPECTRUM.length];
     return `\x1b[38;2;${r};${g};${b}m${glyph}\x1b[0m`;
 }
+/**
+ * A small picture, one pixel to a character cell, each pixel a colored space.
+ *
+ * A cell's background is painted edge to edge by every terminal, so the
+ * picture has no seams. Half block glyphs pack two pixels into a cell but
+ * leave thin gaps and offsets in some fonts, which made the mark look broken
+ * in the macOS Terminal (owner, 28 September 2026). Each row of `pixels` is
+ * six hex digits per pixel, `......` for a clear one. Returns nothing without
+ * color, because the picture is only color.
+ */
+function cellArt(pixels) {
+    if (!useColorNow())
+        return [];
+    return pixels.map((row) => {
+        let line = '';
+        for (let x = 0; x < row.length / 6; x++) {
+            const hex = row.slice(x * 6, x * 6 + 6);
+            if (hex === '......') {
+                line += ' ';
+                continue;
+            }
+            const rgb = [0, 2, 4].map((k) => parseInt(hex.slice(k, k + 2), 16)).join(';');
+            line += `\x1b[48;2;${rgb}m \x1b[0m`;
+        }
+        return line;
+    });
+}
 function prismRule(w = width()) {
     if (!useColorNow())
         return '-'.repeat(w);

package/out/lib/voice.d.ts

@@ -34,6 +34,42 @@ export interface Recording {
  * headed off with `missing` so the person gets a sentence rather than an error.
  */
 export declare function start(): Recording;
+/** Live dictation in progress, on the Mac's own recogniser. */
+export interface LiveDictation {
+    /** The loudness now, 0 to 1. */
+    level: () => number;
+    /** The words so far. */
+    words: () => string;
+    /** Stop listening and get the final words, or null when it could not listen. */
+    stop: () => Promise<string | null>;
+    /** Why it could not listen, when it could not. */
+    problem: () => string;
+}
+/**
+ * Words as they are spoken, the way the web app shows them.
+ *
+ * Nothing is recorded to a file and nothing leaves the machine: the Mac's own
+ * recogniser listens and reports what it hears, several times a second.
+ * Returns null where there is no helper, and the caller records and has the
+ * server write it down instead, as before.
+ */
+export declare function listenLive(language?: string): LiveDictation | null;
+/**
+ * How loud the last tenth of a second was, from 0 to 1.
+ *
+ * Read off the file as it is written, so somebody speaking sees the meter move
+ * and knows they are being heard, before a single word has come back. Sixteen
+ * bit mono at 16 kHz is 3,200 bytes a tenth of a second.
+ */
+export declare function level(file: string): number;
+/**
+ * What has been said so far, as a WAV file a transcriber can read.
+ *
+ * The recorder writes the header's lengths only when it stops, so a copy taken
+ * mid recording claims no audio at all. The copy gets the lengths of what is
+ * actually there. Returns null until there is at least half a second to send.
+ */
+export declare function soFar(file: string): string | null;
 /** Delete the recording and the folder holding it. Always, and immediately. */
 export declare function discard(file: string): void;
 /**

package/out/lib/voice.js

@@ -36,6 +36,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.recorder = recorder;
 exports.missing = missing;
 exports.start = start;
+exports.listenLive = listenLive;
+exports.level = level;
+exports.soFar = soFar;
 exports.discard = discard;
 exports.transcribe = transcribe;
 /**
@@ -102,7 +105,9 @@ const RECORDERS = [
             ...(process.platform === 'darwin'
                 ? ['-f', 'avfoundation', '-i', ':default']
                 : ['-f', 'alsa', '-i', 'default']),
-            '-ac', '1', '-ar', RATE, '-y', out,
+            // Written as it is heard, not held until the end, so the meter and the
+            // words so far have something to read while the person is speaking.
+            '-ac', '1', '-ar', RATE, '-flush_packets', '1', '-y', out,
         ],
     },
     // Linux's own, present on most desktop installs.
@@ -206,6 +211,136 @@ function start() {
     };
     return { file, by: tool.name, stop };
 }
+/** The helper built beside this file on a Mac, when there is one. */
+function helper() {
+    if (process.platform !== 'darwin')
+        return null;
+    const p = path.join(__dirname, '..', 'native', 'dictate');
+    return fs.existsSync(p) ? p : null;
+}
+/**
+ * Words as they are spoken, the way the web app shows them.
+ *
+ * Nothing is recorded to a file and nothing leaves the machine: the Mac's own
+ * recogniser listens and reports what it hears, several times a second.
+ * Returns null where there is no helper, and the caller records and has the
+ * server write it down instead, as before.
+ */
+function listenLive(language = 'en-US') {
+    const bin = helper();
+    if (!bin)
+        return null;
+    const child = (0, node_child_process_1.spawn)(bin, [language], { stdio: ['pipe', 'pipe', 'ignore'] });
+    let loud = 0;
+    let heard = '';
+    let final = null;
+    let why = '';
+    let rest = '';
+    const ended = new Promise((resolve) => child.once('close', () => resolve()));
+    child.stdout?.on('data', (chunk) => {
+        rest += chunk.toString('utf8');
+        const lines = rest.split('\n');
+        rest = lines.pop() ?? '';
+        for (const line of lines) {
+            const kind = line.slice(0, 1);
+            const text = line.slice(2);
+            if (kind === 'L')
+                loud = Number(text) || 0;
+            else if (kind === 'P')
+                heard = text;
+            else if (kind === 'F')
+                final = text;
+            else if (kind === 'E')
+                why = text;
+        }
+    });
+    // The helper never outlives the session.
+    const abandon = () => { try {
+        child.kill('SIGKILL');
+    }
+    catch { /* gone */ } };
+    process.once('exit', abandon);
+    return {
+        level: () => loud,
+        words: () => heard,
+        problem: () => why,
+        stop: async () => {
+            // Closing its input is "Enter was pressed": it says its final words and ends.
+            try {
+                child.stdin?.end();
+            }
+            catch { /* gone */ }
+            const timeout = new Promise((resolve) => setTimeout(resolve, 4000).unref());
+            await Promise.race([ended, timeout]);
+            abandon();
+            process.off('exit', abandon);
+            if (why && !final && !heard)
+                return null;
+            return (final ?? heard).trim();
+        },
+    };
+}
+/** Where the samples start in a WAV file this recorder wrote, or -1. */
+function dataStart(buf) {
+    const at = buf.indexOf('data', 12, 'ascii');
+    return at < 0 ? -1 : at + 8;
+}
+/**
+ * How loud the last tenth of a second was, from 0 to 1.
+ *
+ * Read off the file as it is written, so somebody speaking sees the meter move
+ * and knows they are being heard, before a single word has come back. Sixteen
+ * bit mono at 16 kHz is 3,200 bytes a tenth of a second.
+ */
+function level(file) {
+    try {
+        const size = fs.statSync(file).size;
+        const n = 3200;
+        if (size < 44 + n)
+            return 0;
+        const fd = fs.openSync(file, 'r');
+        const buf = Buffer.alloc(n);
+        fs.readSync(fd, buf, 0, n, size - n - (size - 44) % 2);
+        fs.closeSync(fd);
+        let sum = 0;
+        for (let i = 0; i + 1 < n; i += 2) {
+            const s = buf.readInt16LE(i) / 32768;
+            sum += s * s;
+        }
+        const rms = Math.sqrt(sum / (n / 2));
+        // Speech sits roughly between -50 dB (quiet room) and -10 dB (close and loud).
+        const db = 20 * Math.log10(rms || 1e-9);
+        return Math.max(0, Math.min(1, (db + 50) / 40));
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * What has been said so far, as a WAV file a transcriber can read.
+ *
+ * The recorder writes the header's lengths only when it stops, so a copy taken
+ * mid recording claims no audio at all. The copy gets the lengths of what is
+ * actually there. Returns null until there is at least half a second to send.
+ */
+function soFar(file) {
+    try {
+        const buf = fs.readFileSync(file);
+        const start = dataStart(buf);
+        if (start < 0 || buf.length - start < 16000)
+            return null;
+        const usable = buf.length - ((buf.length - start) % 2);
+        const copy = Buffer.from(buf.subarray(0, usable));
+        copy.writeUInt32LE(usable - 8, 4);
+        copy.writeUInt32LE(usable - start, start - 4);
+        const out = path.join(path.dirname(file), 'so-far.wav');
+        fs.writeFileSync(out, copy);
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
 /** Delete the recording and the folder holding it. Always, and immediately. */
 function discard(file) {
     try {
@@ -229,7 +364,7 @@ async function transcribe(baseUrl, credential, file) {
     const granted = await (0, gateway_1.ask)({ intent: 'transcribe', prompt: '' });
     const pass = granted.ok && granted.served !== false ? granted.upload : null;
     if (granted.ok && granted.served !== false && !pass) {
-        throw new Error(granted.message || 'your workspace would not allow that recording');
+        throw new Error(granted.message || 'your organization would not allow that recording');
     }
     const where = pass?.upload_path || '/api/v1/agent/transcribe';
     const res = await fetch(`${baseUrl.replace(/\/+$/, '')}${where}${pass?.ticket ? `?ticket=${encodeURIComponent(pass.ticket)}` : ''}`, { method: 'POST', headers: { Authorization: `Bearer ${credential}` }, body: form });

package/out/lib/words.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The few words the published command line tool says on its own, in one place.
+ *
+ * Everything about the work arrives from the service already worded (rule 17).
+ * What is left here is what the tool must say when the service, a file or the
+ * operating system gives it nothing to say: a refused address, a file it cannot
+ * read, a call that failed without a reason. Same shape as the editor's
+ * `i18n.ts` and the desktop app's `labels.js`.
+ */
+declare const EN: {
+    readonly connectorNotStarted: "the connector could not be started";
+    readonly addressRefused: "the organization address was refused";
+    readonly fileNotFound: "not found: {{file}}";
+    readonly fileNoPermission: "cannot read {{file}}: permission denied";
+    readonly providerCallFailed: "provider call failed";
+    readonly somethingWrong: "something went wrong";
+};
+export type WordKey = keyof typeof EN;
+export declare function word(key: WordKey, vars?: Record<string, string | number>): string;
+export {};

package/out/lib/words.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.word = word;
+/**
+ * The few words the published command line tool says on its own, in one place.
+ *
+ * Everything about the work arrives from the service already worded (rule 17).
+ * What is left here is what the tool must say when the service, a file or the
+ * operating system gives it nothing to say: a refused address, a file it cannot
+ * read, a call that failed without a reason. Same shape as the editor's
+ * `i18n.ts` and the desktop app's `labels.js`.
+ */
+const EN = {
+    connectorNotStarted: 'the connector could not be started',
+    addressRefused: 'the organization address was refused',
+    fileNotFound: 'not found: {{file}}',
+    fileNoPermission: 'cannot read {{file}}: permission denied',
+    providerCallFailed: 'provider call failed',
+    somethingWrong: 'something went wrong',
+};
+function word(key, vars) {
+    let s = EN[key];
+    if (vars)
+        for (const [k, v] of Object.entries(vars))
+            s = s.split(`{{${k}}}`).join(String(v));
+    return s;
+}