toolroll 0.9.95 → 0.9.96

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.9.96 — 2026-11-08
+
+- **Tables in Telegram are readable on a phone.** Each row is a short list item with its name in full, and anything shared by every row is said once at the top, instead of a squeezed grid of cut-off words.
+- **No more false git alerts while you use Claude Code beside Toolroll.** A Claude Code plugin briefly links a checkout's index while it looks at changes; Toolroll counted that as tampering in other checkouts of the same repository and stopped releases and builds. Real tampering is still caught.
+
 ## 0.9.95 — 2026-11-07
 
 - **Cards in chat, and approving from chat.** Slack, Discord and Telegram show tasks, plans and results as proper cards. Anything that needs approval can be approved there by a person with authority, the same as on the web; long terms link to the review page.

package/dist/card-render.d.ts

@@ -3,8 +3,11 @@
  * made inert for each app, so a value can't become a link, a mention or formatting. Whatever an app can't show comes out
  * as readable text, and every renderer has the same plain version to fall back on.
  */
-import type { ChatCard } from "./contracts/chat-card.js";
+import type { ChatCard, ChatCardBlock } from "./contracts/chat-card.js";
 import { type Html } from "./html.js";
+type Table = Extract<ChatCardBlock, {
+    kind: "table";
+}>;
 /** A Text part is the lead's (a model's) words: always labelled as such, on every app, never as a record. */
 export declare const LEAD_NOTE_WORDS = "The lead's note, not Toolroll's records";
 /** The whole card as plain text: the version every app can show. */
@@ -24,3 +27,17 @@ export declare function telegramCardMessage(card: ChatCard): {
 };
 /** The card as the web chat's own markup; every value is escaped by `html`. */
 export declare function webCardHtml(card: ChatCard): Html;
+/**
+ * A table's rows for a phone: each row's first value in full as its name, then its other values on one line ("queued ·
+ * standing-orders · 3h ago"; a number keeps its column's label: "Failed attempts 2"). A column with the same value in
+ * every shown row is said once above the rows instead ("All: queued · Failed attempts 0").
+ */
+export declare function telegramTableRows(block: Table, keep: number): {
+    same: string;
+    rows: {
+        name: string;
+        rest: string;
+    }[];
+    more: number;
+};
+export {};

package/dist/card-render.js

@@ -139,6 +139,16 @@ export function discordCardEmbed(card, plain) {
 // ---- Telegram ------------------------------------------------------------------------------------------------------
 /** The card as one Telegram message: plain words, tables and charts as `pre` entities, so nothing in a value is parsed. */
 export function telegramCardMessage(card) {
+    // A phone can't fit a table's columns side by side, so each row is a short list item. Past Telegram's limit, rows are
+    // cut from the end (counted in "and N more") before falling back to the plain version.
+    for (let keep = TELEGRAM_ROWS; keep >= 1; keep = Math.floor(keep / 2)) {
+        const message = telegramCardWith(card, block => Math.min(block.rows.length, keep));
+        if (message.text.length <= 4000)
+            return message;
+    }
+    return { text: cardPlainText(card).slice(0, 4000), entities: [] };
+}
+function telegramCardWith(card, rowsFor) {
     const entities = [];
     let text = "";
     const add = (words, type) => {
@@ -168,7 +178,16 @@ export function telegramCardMessage(card) {
                 add(one, "bold");
             if (block.origin === "report")
                 add(reportWords);
-            add(tableLines(block, 40).join("\n"), "pre");
+            const listed = telegramTableRows(block, rowsFor(block));
+            if (listed.same !== "")
+                add(listed.same);
+            for (const row of listed.rows) {
+                add(row.name, "bold");
+                if (row.rest !== "")
+                    text += `\n${row.rest}`;
+            }
+            if (listed.more > 0)
+                add(moreWords(listed.more));
         }
         else if (block.kind === "chart") {
             for (const one of headOf(card, block.heading))
@@ -180,8 +199,7 @@ export function telegramCardMessage(card) {
         add(one);
     if (card.actions.length > 0)
         add(`Confirm below: ${card.actions.map(one => one.label).join(", ")}`);
-    // Telegram's own limit: past it, the whole plain version, cut, with no entities that could point past the end.
-    return text.length <= 4000 ? { text, entities } : { text: cardPlainText(card).slice(0, 4000), entities: [] };
+    return { text, entities };
 }
 // ---- web chat ------------------------------------------------------------------------------------------------------
 const CHART_COLORS = 6;
@@ -221,3 +239,22 @@ export function webCardHtml(card) {
     });
     return html `<div class="tc-card">${joinHtml(blocks)}${joinHtml(footWords(card).map(one => html `<p class="tc-note">${one}</p>`))}</div>`;
 }
+/** How many rows of a table a Telegram card shows before "and N more". */
+const TELEGRAM_ROWS = 20;
+/**
+ * A table's rows for a phone: each row's first value in full as its name, then its other values on one line ("queued ·
+ * standing-orders · 3h ago"; a number keeps its column's label: "Failed attempts 2"). A column with the same value in
+ * every shown row is said once above the rows instead ("All: queued · Failed attempts 0").
+ */
+export function telegramTableRows(block, keep) {
+    const shown = block.rows.slice(0, Math.max(0, keep));
+    const more = block.more + block.rows.length - shown.length;
+    const cell = (at, value) => block.columns[at].numeric ? `${block.columns[at].label} ${value}` : value;
+    const constant = block.columns.map((_, at) => at > 0 && shown.length > 1 && shown.every(row => row[at] === shown[0][at]));
+    const same = constant.flatMap((yes, at) => yes && shown[0][at] !== "" ? [cell(at, shown[0][at])] : []);
+    const rows = shown.map(row => ({
+        name: row[0] === "" ? "(untitled)" : row[0],
+        rest: row.flatMap((value, at) => at === 0 || constant[at] || value === "" ? [] : [cell(at, value)]).join(" · "),
+    }));
+    return { same: same.length === 0 ? "" : `All: ${same.join(" · ")}`, rows, more };
+}

package/dist/teardown-git.js

@@ -737,8 +737,8 @@ const WORKTREE_STATE_DIRS = ["sequencer", "rebase-merge", "rebase-apply"];
  * state, a split index's shared files); and the object store (the common `objects`, and a submodule git directory's
  * own under modules/): its fan-out folders' entries for links, `info` and `pack` all the way down, but not each loose
  * object (a big repository has very many, and hard-linked objects are legitimate). Any link is refused, so is a folder
- * that can't be listed, and so is any file walked deep with a second hard link (git appends to a log in place). The
- * exemption is by place only: an `objects` anywhere else (under refs/, logs/, worktrees/) is walked like the rest. For each one found, where it leads (for an incident's record).
+ * that can't be listed, and so is any file walked deep with a second hard link (git appends to a log in place), but for
+ * another checkout's index (siblingIndexes: still never a link). The exemptions are by place only: an `objects` anywhere else (under refs/, logs/, worktrees/) is walked like the rest. For each one found, where it leads (for an incident's record).
  *
  * Checked when the view is made and again after git ran; between the two, a process that outlived the agent's turn
  * can still swap one of these for a link and have git write through it mid-command. That window is an accepted
@@ -749,6 +749,7 @@ function pinned(dirs) {
     const seen = new Set();
     let budget = 400_000;
     const stores = objectStores(dirs.common);
+    const siblings = siblingIndexes(dirs);
     /** `deep`: every entry all the way down, each file held to one hard link. `shallow`: the folder's own entries
      * checked for links only. `store`: an object store (objects/: its fan-out folders shallow, `info` and `pack` deep
      * without the hard-link test). A link, or a folder that can't be listed, is swapped. */
@@ -776,7 +777,10 @@ function pinned(dirs) {
             swapped.push({ path, leadsTo: real });
             return;
         }
-        if (held.isFile() && mode === "deep" && held.nlink > 1) {
+        // Another checkout's own index, by exact place (siblingIndexes): held to being no link, but a second name is not
+        // counted. A tool in that checkout may hard-link it for a moment (Claude Code's security-guidance plugin does, to
+        // diff against a copy), and git never writes another checkout's index, nor any index in place.
+        if (held.isFile() && mode === "deep" && held.nlink > 1 && !siblings.has(path)) {
             swapped.push({ path, leadsTo: null });
             return;
         }
@@ -886,6 +890,32 @@ function objectStores(common) {
     visit(join(common, "modules"), 0);
     return stores;
 }
+/**
+ * The index files of the repository's other checkouts, by exact place, enumerated before the walk: `index` directly in
+ * each worktree folder of the common `worktrees` that isn't this checkout's own git directory, and, for a linked
+ * checkout, the main checkout's `index` in the common folder. The walk still refuses any of them that is a link; it
+ * only doesn't count a second hard link to one (pinned). The view links only this checkout's own index, and git writes
+ * an index only by renaming a new file over it, so a hard link at another checkout's can't take a write of the plane's
+ * anywhere. Measured (Nov 2026): Claude Code's security-guidance plugin hard-links the index of the checkout a session
+ * runs in to a temporary copy for up to seconds at a time, and a release gate that ran meanwhile in another checkout of
+ * the repository was stopped as an incident naming that checkout's index.
+ */
+function siblingIndexes(dirs) {
+    const indexes = new Set();
+    if (dirs.linked)
+        indexes.add(join(dirs.common, "index"));
+    let ids = [];
+    try {
+        ids = readdirSync(join(dirs.common, "worktrees"));
+    }
+    catch { /* none (an unlistable folder is the walk's to refuse) */ }
+    for (const id of ids) {
+        const folder = join(dirs.common, "worktrees", id);
+        if (folder !== dirs.gitdir)
+            indexes.add(join(folder, "index"));
+    }
+    return indexes;
+}
 function anchorOf(path) {
     const anchor = [];
     for (let at = path;; at = dirname(at)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.95",
+  "version": "0.9.96",
   "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
   "directories": {
     "doc": "docs"