@cspeach/cli 1.1.14 → 1.1.16

package/dist/one-shot.js

@@ -170,6 +170,8 @@ export async function runOneShot(prompt, opts) {
             console.error(chalk.dim(`[offline classifier — proxy unreachable: ${c.transport_error ?? 'unknown'}]`));
         }
         const pct = Math.round(c.confidence * 100);
+        if (c.screenshot)
+            console.log(chalk.dim(`┄ Screenshot: ${c.screenshot}`));
         if (c.confidence < 0.6) {
             const alternates = [c.skill, ...c.alternates].slice(0, 3).map((s) => `/${s}`).join(', ');
             console.error(chalk.yellow(`[classifier] Low confidence (${pct}%). Using /${c.skill}. ` +

package/dist/projects/image-attachments.js

@@ -0,0 +1,155 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+/**
+ * Tier 1 screenshots (2026-09-23, spec 2026-09-16-image-attachments-1.1.5.md).
+ *
+ * An image path in the prompt — typed, `@`-referenced, or dragged in (a
+ * terminal pastes the path as text, double-quoted when it has spaces) — is
+ * read and sent as an image content block. The path in the text becomes
+ * `[attached <name>]`. In standalone mode a screenshot of an ST22 dump or an
+ * ATC list is how users show us what they see.
+ */
+const MEDIA_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+};
+/** Raw-file cap. The API limit is 5 MB per image as base64 (4/3 inflation). */
+export const MAX_IMAGE_BYTES = Math.floor((5 * 1024 * 1024 * 3) / 4);
+export const MAX_IMAGES_PER_TURN = 5;
+/** Appended to the text block whenever an image is attached. */
+export const IMAGE_PROMPT_NOTE = '(Anything taken from an attached image must be stated as "from the screenshot", ' +
+    'and object names read from it confirmed with the user before use.)';
+function mediaTypeOf(p) {
+    return MEDIA_TYPES[path.extname(p).toLowerCase()] ?? null;
+}
+function formatBytes(n) {
+    if (n < 1024 * 1024)
+        return `${Math.max(1, Math.round(n / 1024))} KB`;
+    return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+export async function expandImageAttachments(message, cwd, log) {
+    // One token per match: optional @, then a "double" or 'single' quoted run,
+    // or a bare word.
+    const tokenRe = /@?(?:"([^"\r\n]+)"|'([^'\r\n]+)'|(\S+))/g;
+    const found = [];
+    let m;
+    while ((m = tokenRe.exec(message)) !== null) {
+        const quoted = m[1] ?? m[2];
+        if (quoted !== undefined) {
+            if (mediaTypeOf(quoted)) {
+                found.push({ index: m.index, length: m[0].length, token: quoted });
+            }
+            else {
+                // A quoted run that is not an image path ("some text with x.png", or
+                // an apostrophe pair) — rescan its words instead of skipping them.
+                const openQuote = m.index + (m[0].startsWith('@') ? 1 : 0);
+                tokenRe.lastIndex = openQuote + 1;
+            }
+            continue;
+        }
+        let token = m[3];
+        let length = m[0].length;
+        const trail = /[,;:.!?)\]]+$/.exec(token);
+        if (trail && trail[0].length < token.length) {
+            token = token.slice(0, -trail[0].length);
+            length -= trail[0].length;
+        }
+        if (token.includes('://') || !mediaTypeOf(token))
+            continue;
+        found.push({ index: m.index, length, token });
+    }
+    if (found.length === 0)
+        return { text: message, images: [] };
+    // Resolve against cwd; keep only files that exist. One block per file even
+    // if it is named twice.
+    const byPath = new Map();
+    const substitutions = [];
+    for (const f of found) {
+        const abs = path.resolve(cwd, f.token);
+        let size;
+        try {
+            const st = await fs.stat(abs);
+            if (!st.isFile())
+                throw new Error('not a file');
+            size = st.size;
+        }
+        catch {
+            if (log)
+                log(`(image ${f.token} not found — looked in ${cwd})`);
+            continue;
+        }
+        const name = path.basename(abs);
+        if (!byPath.has(abs))
+            byPath.set(abs, { name, size });
+        substitutions.push({ index: f.index, length: f.length, replacement: `[attached ${name}]` });
+    }
+    if (byPath.size === 0)
+        return { text: message, images: [] };
+    if (byPath.size > MAX_IMAGES_PER_TURN) {
+        return {
+            text: message,
+            images: [],
+            error: `${byPath.size} images in one message — the limit is ${MAX_IMAGES_PER_TURN}. Nothing was sent.`,
+        };
+    }
+    for (const { name, size } of byPath.values()) {
+        if (size > MAX_IMAGE_BYTES) {
+            return {
+                text: message,
+                images: [],
+                error: `${name} is ${formatBytes(size)} — the limit is ${formatBytes(MAX_IMAGE_BYTES)} per image. ` +
+                    'Crop it or save it as JPEG and try again. Nothing was sent.',
+            };
+        }
+    }
+    const images = [];
+    for (const [abs, { name, size }] of byPath) {
+        const data = (await fs.readFile(abs)).toString('base64');
+        images.push({ type: 'image', source: { type: 'base64', media_type: mediaTypeOf(abs), data } });
+        if (log)
+            log(`(attached ${name} — ${formatBytes(size)})`);
+    }
+    substitutions.sort((a, b) => b.index - a.index);
+    let text = message;
+    for (const s of substitutions) {
+        text = text.slice(0, s.index) + s.replacement + text.slice(s.index + s.length);
+    }
+    return { text: `${text}\n\n${IMAGE_PROMPT_NOTE}`, images };
+}
+/**
+ * The user message content sent to the model: the plain string when no image
+ * is attached (unchanged from before this feature), else images first, then
+ * the text — enrichment blocks stay in the text part.
+ */
+export function buildUserContent(text, images) {
+    if (images.length === 0)
+        return text;
+    return [...images, { type: 'text', text }];
+}
+/**
+ * Images stay in the conversation and are re-sent every turn. Past this
+ * many, the oldest are swapped for a short text note so a long session never
+ * hits the 32 MB request cap (and stops paying for stale screenshots).
+ */
+export const MAX_HISTORY_IMAGES = 10;
+/** Mutates `messages`; returns how many image blocks were removed. */
+export function trimHistoryImages(messages, max = MAX_HISTORY_IMAGES) {
+    const slots = [];
+    for (const m of messages) {
+        if (m.role !== 'user' || !Array.isArray(m.content))
+            continue;
+        m.content.forEach((b, i) => {
+            if (b?.type === 'image')
+                slots.push({ blocks: m.content, i });
+        });
+    }
+    const excess = slots.length - max;
+    for (let k = 0; k < excess; k++) {
+        const { blocks, i } = slots[k];
+        blocks[i] = { type: 'text', text: '[image removed from history]' };
+    }
+    return Math.max(0, excess);
+}

package/dist/projects/save-command.js

@@ -371,6 +371,26 @@ export async function runSaveCommand(args) {
     if (spec.artefactType === 'plan')
         writePlanHandover(path, args.log);
     args.log(`Saved: ${path}`);
+    // Project Register (2026-09-18): when this laptop has joined a project, a
+    // decision / fix record is written to the LOCAL outbox as a by-product of the
+    // save. No project joined → `activeProject()` is one missing-file read and
+    // nothing else happens. A record failure never fails the save.
+    try {
+        const { activeProject } = await import('../register/store.js');
+        const joined = activeProject();
+        if (joined) {
+            const { recordFromEnvelope } = await import('../register/records.js');
+            const res = recordFromEnvelope(env, path, joined, { name: args.author.name }, args.cwd);
+            if (res?.file)
+                args.log(`Recorded for team project ${joined.projectId}: ${res.written} objects → ${res.file}`);
+            if (res?.refused.length) {
+                args.log(`Not recorded (${res.refused.length} not in the team project's object list): ${res.refused.slice(0, 5).join(', ')}${res.refused.length > 5 ? ', …' : ''}`);
+            }
+        }
+    }
+    catch (e) {
+        args.log(`(team project record not written: ${e instanceof Error ? e.message : String(e)})`);
+    }
     if (planExtract && prior) {
         args.log(`(revision v${env.version} of the existing plan — version chain preserved, no new id)`);
     }