@illuminis/comprism 0.1.5 → 0.1.7

package/out/lib/queue.js

@@ -51,7 +51,7 @@ const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const gateway_1 = require("./gateway");
 const config_1 = require("./config");
-const self_1 = require("./self");
+const self_1 = require("../machine/runtime/self");
 async function queue(op, payload = {}) {
     return (0, gateway_1.ask)({
         intent: "queue", prompt: "", op,

package/out/lib/readiness.d.ts

@@ -1,33 +1,6 @@
-export interface Requirement {
-    /** What it is for, said as the work it makes possible. */
-    purpose: string;
-    /** Any one of these being present is enough. */
-    anyOf: string[];
-    /** Work that cannot be done without it, for the message. */
-    without: string;
-    /** True when the tool cannot function at all without this. */
-    essential: boolean;
-}
-export declare const REQUIREMENTS: Requirement[];
-/** Is this program on the machine, by name, without running anything of theirs. */
-export declare function present(program: string): boolean;
-/**
- * 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.
- */
-export declare function howToInstall(missing: string[]): string;
-export interface Readiness {
-    ready: boolean;
-    /** One line per requirement, ready to print. */
-    lines: string[];
-    /** The command to run, empty when nothing is missing. */
-    fix: string;
-}
-/** What this machine can and cannot do, and how to close the gap. */
-export declare function check(): Readiness;
+import { REQUIREMENTS, check, howToInstall, present } from '../machine/runtime/needs';
+export type { Readiness, Requirement } from '../machine/runtime/needs';
+export { REQUIREMENTS, check, howToInstall, present };
 /** One checked item: its line, whether it is required, and the fix. */
 export interface Finding {
     ok: boolean;

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/ui.d.ts

@@ -36,13 +36,16 @@ export declare const c: {
  */
 export declare function spectrumAt(index: number, glyph: string): string;
 /**
- * A small picture, drawn two pixels to a character with the half block glyph:
- * the top pixel is the glyph's color and the bottom one its background, which
- * makes each pixel square in an ordinary terminal font. Each row of `pixels`
- * is six hex digits per pixel, `......` for a clear one, and two rows make one
- * line. Returns nothing without color, because the picture is only color.
+ * 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 pixelArt(pixels: string[]): string[];
+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,7 +19,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiveIndicator = exports.c = void 0;
 exports.width = width;
 exports.spectrumAt = spectrumAt;
-exports.pixelArt = pixelArt;
+exports.cellArt = cellArt;
 exports.prismRule = prismRule;
 exports.banner = banner;
 exports.money = money;
@@ -88,37 +88,31 @@ function spectrumAt(index, glyph) {
     return `\x1b[38;2;${r};${g};${b}m${glyph}\x1b[0m`;
 }
 /**
- * A small picture, drawn two pixels to a character with the half block glyph:
- * the top pixel is the glyph's color and the bottom one its background, which
- * makes each pixel square in an ordinary terminal font. Each row of `pixels`
- * is six hex digits per pixel, `......` for a clear one, and two rows make one
- * line. Returns nothing without color, because the picture is only color.
+ * 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 pixelArt(pixels) {
+function cellArt(pixels) {
     if (!useColorNow())
         return [];
-    const at = (row, x) => {
-        const hex = row?.slice(x * 6, x * 6 + 6);
-        return !hex || hex === '......' ? null
-            : [0, 2, 4].map((k) => parseInt(hex.slice(k, k + 2), 16)).join(';');
-    };
-    const lines = [];
-    for (let y = 0; y < pixels.length; y += 2) {
+    return pixels.map((row) => {
         let line = '';
-        for (let x = 0; x < (pixels[y]?.length ?? 0) / 6; x++) {
-            const top = at(pixels[y], x), bottom = at(pixels[y + 1], x);
-            if (top && bottom)
-                line += `\x1b[38;2;${top}m\x1b[48;2;${bottom}m▀\x1b[0m`;
-            else if (top)
-                line += `\x1b[38;2;${top}m▀\x1b[0m`;
-            else if (bottom)
-                line += `\x1b[38;2;${bottom}m▄\x1b[0m`;
-            else
+        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`;
         }
-        lines.push(line);
-    }
-    return lines;
+        return line;
+    });
 }
 function prismRule(w = width()) {
     if (!useColorNow())

package/out/lib/voice.d.ts

@@ -1,39 +1,5 @@
-/** One recording tool, as this file needs to drive it. */
-interface Recorder {
-    /** What to tell somebody who wants to know what is listening. */
-    name: string;
-    command: string;
-    args: (out: string) => string[];
-}
-/** The first recording tool this machine has, or null. */
-export declare function recorder(): Recorder | null;
-/**
- * What to tell somebody who has no recording tool, or null when they do.
- *
- * One sentence and one command. Not a list of three options with trade-offs:
- * somebody who just wanted to say a sentence out loud is not shopping for audio
- * software.
- */
-export declare function missing(): string | null;
-/** A recording in progress. */
-export interface Recording {
-    /** Where the audio is being written. */
-    file: string;
-    /** What is doing the listening, for the line on screen. */
-    by: string;
-    /** Stop, wait for the file to be finished properly, and hand it back. */
-    stop: () => Promise<{
-        file: string;
-        bytes: number;
-    }>;
-}
-/**
- * Start listening.
- *
- * Throws when there is nothing to listen with, which the caller should have
- * headed off with `missing` so the person gets a sentence rather than an error.
- */
-export declare function start(): Recording;
+export { discard, missing, recorder, start } from '../machine/voice/record';
+export type { Recorder, Recording } from '../machine/voice/record';
 /** Live dictation in progress, on the Mac's own recogniser. */
 export interface LiveDictation {
     /** The loudness now, 0 to 1. */
@@ -70,8 +36,6 @@ export declare function level(file: string): number;
  * 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;
 /**
  * The words in a recording, according to our server.
  *
@@ -83,4 +47,3 @@ export declare function transcribe(baseUrl: string, credential: string, file: st
     text: string;
     provider: string;
 }>;
-export {};

package/out/lib/voice.js

@@ -33,13 +33,10 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.recorder = recorder;
-exports.missing = missing;
-exports.start = start;
+exports.start = exports.recorder = exports.missing = exports.discard = void 0;
 exports.listenLive = listenLive;
 exports.level = level;
 exports.soFar = soFar;
-exports.discard = discard;
 exports.transcribe = transcribe;
 /**
  * Saying a request instead of typing it.
@@ -73,144 +70,13 @@ exports.transcribe = transcribe;
  */
 const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
-const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const gateway_1 = require("./gateway");
-/** Is this on the PATH at all. */
-function present(command) {
-    try {
-        return (0, node_child_process_1.spawnSync)('which', [command], { stdio: 'ignore' }).status === 0;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Sixteen kilohertz, one channel, everywhere.
- *
- * What every speech model wants and nothing more. Recording in studio quality
- * would make a file several times the size, take longer to upload, and be
- * downsampled by the vendor on arrival anyway.
- */
-const RATE = '16000';
-const RECORDERS = [
-    // sox first. It is the one built for this, it needs no device name, and it
-    // stops cleanly.
-    { name: 'sox', command: 'rec', args: (out) => ['-q', '-c', '1', '-r', RATE, out] },
-    {
-        name: 'ffmpeg',
-        command: 'ffmpeg',
-        args: (out) => [
-            '-loglevel', 'quiet', '-nostdin',
-            ...(process.platform === 'darwin'
-                ? ['-f', 'avfoundation', '-i', ':default']
-                : ['-f', 'alsa', '-i', 'default']),
-            // 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.
-    { name: 'arecord', command: 'arecord', args: (out) => ['-q', '-f', 'S16_LE', '-c', '1', '-r', RATE, out] },
-];
-/** The first recording tool this machine has, or null. */
-function recorder() {
-    return RECORDERS.find((r) => present(r.command)) ?? null;
-}
-/**
- * What to tell somebody who has no recording tool, or null when they do.
- *
- * One sentence and one command. Not a list of three options with trade-offs:
- * somebody who just wanted to say a sentence out loud is not shopping for audio
- * software.
- */
-function missing() {
-    if (recorder())
-        return null;
-    return process.platform === 'darwin'
-        ? 'Speaking needs a recording tool, and macOS does not come with one. '
-            + 'Install it once with:  brew install sox'
-        : 'Speaking needs a recording tool. Install it once with:  '
-            + 'sudo apt install sox   (or your system\'s package manager)';
-}
-/**
- * Start listening.
- *
- * Throws when there is nothing to listen with, which the caller should have
- * headed off with `missing` so the person gets a sentence rather than an error.
- */
-function start() {
-    const tool = recorder();
-    if (!tool)
-        throw new Error(missing() ?? 'No recording tool.');
-    const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'comprism-voice-')), 'said.wav');
-    const child = (0, node_child_process_1.spawn)(tool.command, tool.args(file), {
-        stdio: ['ignore', 'ignore', 'ignore'],
-    });
-    let stopped = null;
-    // The recorder never outlives the session. Closing the window or ending the
-    // process while it listens would otherwise leave a microphone recording to a
-    // file nobody knows about, the worst thing this tool could do.
-    const abandon = () => {
-        try {
-            child.kill('SIGKILL');
-        }
-        catch { /* already gone */ }
-        discard(file);
-    };
-    const onSignal = (signal) => {
-        abandon();
-        release();
-        process.kill(process.pid, signal);
-    };
-    const release = () => {
-        process.off('exit', abandon);
-        process.off('SIGHUP', onSignal);
-        process.off('SIGTERM', onSignal);
-    };
-    process.once('exit', abandon);
-    process.once('SIGHUP', onSignal);
-    process.once('SIGTERM', onSignal);
-    child.once('close', release);
-    const stop = () => {
-        if (stopped)
-            return stopped;
-        stopped = new Promise((resolve) => {
-            const done = () => {
-                let bytes = 0;
-                try {
-                    bytes = fs.statSync(file).size;
-                }
-                catch {
-                    bytes = 0;
-                }
-                resolve({ file, bytes });
-            };
-            // Interrupt, not kill. Every one of these tools finishes writing the WAV
-            // header on an interrupt and none of them does on a kill, and a header
-            // that was never finished reads as silence to whoever transcribes it.
-            child.once('close', done);
-            try {
-                child.kill('SIGINT');
-            }
-            catch {
-                done();
-            }
-            // A tool that has not closed in two seconds is not going to. Taking the
-            // file as it stands beats leaving somebody at a prompt that has stopped
-            // answering them.
-            setTimeout(() => {
-                try {
-                    child.kill('SIGKILL');
-                }
-                catch { /* already gone */ }
-                done();
-            }, 2000).unref();
-        });
-        return stopped;
-    };
-    return { file, by: tool.name, stop };
-}
+var record_1 = require("../machine/voice/record");
+Object.defineProperty(exports, "discard", { enumerable: true, get: function () { return record_1.discard; } });
+Object.defineProperty(exports, "missing", { enumerable: true, get: function () { return record_1.missing; } });
+Object.defineProperty(exports, "recorder", { enumerable: true, get: function () { return record_1.recorder; } });
+Object.defineProperty(exports, "start", { enumerable: true, get: function () { return record_1.start; } });
 /** The helper built beside this file on a Mac, when there is one. */
 function helper() {
     if (process.platform !== 'darwin')
@@ -341,13 +207,6 @@ function soFar(file) {
         return null;
     }
 }
-/** Delete the recording and the folder holding it. Always, and immediately. */
-function discard(file) {
-    try {
-        fs.rmSync(path.dirname(file), { recursive: true, force: true });
-    }
-    catch { /* a temp file we could not remove is not worth a word to anybody */ }
-}
 /**
  * The words in a recording, according to our server.
  *
@@ -364,7 +223,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 {};