@xenosystem/agent-interface-host 0.1.3

package/dist/intake/RepositoryTodoIntakeSource.js

@@ -0,0 +1,168 @@
+/**
+ * Work that is already written down in the code — ADE §5.1.
+ *
+ * §5.1 names the sources work arrives from: *"a typed instruction, a spec or
+ * plan document, **a repository TODO**, an issue tracker, a scheduled trigger,
+ * or another agent."* This is that one, and it is the right first source for
+ * three reasons: it needs no credentials, no network and no tracker account, so
+ * it works on a fresh install; the work is genuinely there; and it exercises the
+ * `IntakeSource` seam without teaching this package what a tracker is.
+ *
+ * ## 🔴 A scan that could not read is a FAILED source, never an empty one
+ *
+ * `list()` throws rather than returning `[]` when the root cannot be read.
+ * `IntakeService` captures that as a failed source and marks the inbox
+ * incomplete — an empty inbox reads as "nothing to pick up", so a person stops
+ * looking. An unreadable directory is not an absence of work.
+ *
+ * Per-FILE read errors are different and are skipped: one unreadable file in a
+ * tree of thousands should not blank the inbox, and it is not evidence about the
+ * others. The distinction is deliberate: the root failing means the scan did not
+ * happen; a file failing means the scan happened and missed one thing.
+ *
+ * ## What it deliberately does not do
+ *
+ * No git. No ranking. No parsing beyond the marker and its line. §5.1's boundary
+ * is that XENO Agent "does not become a ticket system", and a TODO scanner that
+ * starts inferring priority and assignees is one.
+ */
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { extname, join, relative, sep } from 'node:path';
+import { intakeItemId } from '@xenosystem/agent-interface-core';
+/**
+ * Markers, in the form the ecosystem already writes them.
+ *
+ * `TODO(name):` and `TODO:` both appear in this repo, and a marker inside a word
+ * (`MASTODON`) is not one — hence the boundary and the required punctuation.
+ */
+const MARKER = /\b(TODO|FIXME|HACK|XXX)\b(?:\([^)]*\))?\s*:\s*(.+)$/;
+/** Directories never worth scanning. Not a preference — these are generated. */
+const SKIP_DIRECTORIES = new Set([
+    'node_modules', '.git', 'dist', 'out', 'build', 'coverage', '.next', '.turbo',
+    '.worktrees', 'target', 'vendor', '__pycache__',
+]);
+/** Extensions worth reading. An allow-list, because a binary is not a TODO. */
+const SCAN_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.rs', '.go', '.py', '.rb',
+    '.java', '.kt', '.swift', '.c', '.h', '.cc', '.cpp', '.cs', '.sh', '.ps1',
+    '.md', '.yml', '.yaml', '.toml',
+]);
+const DEFAULT_MAX_FILES = 2_000;
+const DEFAULT_MAX_ITEMS = 200;
+const DEFAULT_MAX_FILE_BYTES = 512 * 1024;
+export class RepositoryTodoIntakeSource {
+    id;
+    label;
+    #root;
+    #maxFiles;
+    #maxItems;
+    #maxFileBytes;
+    #externalIdPrefix;
+    /** True when a cap stopped the scan early. Read by `truncated()`. */
+    #truncated = false;
+    constructor(options) {
+        this.id = options.id ?? 'repository-todo';
+        this.label = options.label ?? 'Repository TODOs';
+        this.#root = options.rootDirectory;
+        this.#maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+        this.#maxItems = options.maxItems ?? DEFAULT_MAX_ITEMS;
+        this.#maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+        this.#externalIdPrefix = options.externalIdPrefix ?? '';
+    }
+    /**
+     * True when a cap stopped the scan before the tree was exhausted.
+     *
+     * 🔴 Exposed rather than swallowed. A truncated scan that looked complete
+     * would tell a developer their inbox is empty of everything below the cap,
+     * which is a claim this source cannot make.
+     */
+    truncated() {
+        return this.#truncated;
+    }
+    async list() {
+        this.#truncated = false;
+        // Deliberately NOT caught: a root that cannot be read means the scan did
+        // not happen, and `IntakeService` must report a failed source rather than
+        // an empty one.
+        const rootStat = await stat(this.#root);
+        if (!rootStat.isDirectory()) {
+            throw new Error(`Repository TODO source root is not a directory: ${this.#root}`);
+        }
+        const items = [];
+        let filesScanned = 0;
+        const walk = async (directory) => {
+            if (items.length >= this.#maxItems || filesScanned >= this.#maxFiles)
+                return;
+            let entries;
+            try {
+                entries = await readdir(directory, { withFileTypes: true });
+            }
+            catch {
+                // One unreadable directory is not evidence about the rest of the tree.
+                return;
+            }
+            for (const entry of entries) {
+                if (items.length >= this.#maxItems || filesScanned >= this.#maxFiles) {
+                    this.#truncated = true;
+                    return;
+                }
+                // A dotfile directory is skipped, a dotfile is not: `.eslintrc` may
+                // carry a TODO and reading it costs nothing.
+                if (entry.isDirectory()) {
+                    if (SKIP_DIRECTORIES.has(entry.name) || entry.name.startsWith('.'))
+                        continue;
+                    await walk(join(directory, entry.name));
+                    continue;
+                }
+                if (!entry.isFile())
+                    continue;
+                if (!SCAN_EXTENSIONS.has(extname(entry.name).toLowerCase()))
+                    continue;
+                filesScanned += 1;
+                const absolute = join(directory, entry.name);
+                let contents;
+                try {
+                    const raw = await readFile(absolute);
+                    contents = raw.subarray(0, this.#maxFileBytes).toString('utf8');
+                }
+                catch {
+                    // Skipped, not fatal — see the header on the root/file distinction.
+                    continue;
+                }
+                const relativePath = relative(this.#root, absolute).split(sep).join('/');
+                const lines = contents.split(/\r?\n/);
+                for (let index = 0; index < lines.length; index += 1) {
+                    if (items.length >= this.#maxItems) {
+                        this.#truncated = true;
+                        return;
+                    }
+                    const match = MARKER.exec(lines[index]);
+                    if (!match)
+                        continue;
+                    const marker = match[1];
+                    const text = match[2].trim();
+                    if (!text)
+                        continue;
+                    const source = {
+                        sourceId: this.id,
+                        // Stable across scans for an unchanged line, and unique within the
+                        // source. Line-based, so moving a TODO makes a new item -- which is
+                        // honest: this source has no way to track identity across edits.
+                        externalId: `${this.#externalIdPrefix}${relativePath}#${index + 1}`,
+                    };
+                    items.push({
+                        id: intakeItemId(source),
+                        source,
+                        title: `${marker}: ${text.length > 120 ? `${text.slice(0, 117)}...` : text}`,
+                        detail: `${relativePath}:${index + 1}\n${lines[index].trim()}`,
+                    });
+                }
+            }
+        };
+        await walk(this.#root);
+        if (filesScanned >= this.#maxFiles)
+            this.#truncated = true;
+        return items;
+    }
+}
+//# sourceMappingURL=RepositoryTodoIntakeSource.js.map

package/dist/intake/RepositoryTodoIntakeSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RepositoryTodoIntakeSource.js","sourceRoot":"","sources":["../../src/intake/RepositoryTodoIntakeSource.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AAExD,OAAO,EAAE,YAAY,EAAmB,MAAM,kCAAkC,CAAA;AAIhF;;;;;GAKG;AACH,MAAM,MAAM,GAAG,qDAAqD,CAAA;AAEpE,gFAAgF;AAChF,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC;IAC/B,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,QAAQ;IAC7E,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa;CAChD,CAAC,CAAA;AAEF,+EAA+E;AAC/E,MAAM,eAAe,GAAG,IAAI,GAAG,CAAC;IAC9B,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK;IACxE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM;IACzE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;CAChC,CAAC,CAAA;AA6BF,MAAM,iBAAiB,GAAG,KAAK,CAAA;AAC/B,MAAM,iBAAiB,GAAG,GAAG,CAAA;AAC7B,MAAM,sBAAsB,GAAG,GAAG,GAAG,IAAI,CAAA;AAEzC,MAAM,OAAO,0BAA0B;IAC5B,EAAE,CAAQ;IACV,KAAK,CAAQ;IACb,KAAK,CAAQ;IACb,SAAS,CAAQ;IACjB,SAAS,CAAQ;IACjB,aAAa,CAAQ;IACrB,iBAAiB,CAAQ;IAClC,qEAAqE;IACrE,UAAU,GAAG,KAAK,CAAA;IAElB,YAAY,OAA0C;QACpD,IAAI,CAAC,EAAE,GAAG,OAAO,CAAC,EAAE,IAAI,iBAAiB,CAAA;QACzC,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,kBAAkB,CAAA;QAChD,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,aAAa,CAAA;QAClC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,QAAQ,IAAI,iBAAiB,CAAA;QACtD,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,QAAQ,IAAI,iBAAiB,CAAA;QACtD,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,YAAY,IAAI,sBAAsB,CAAA;QACnE,IAAI,CAAC,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,IAAI,EAAE,CAAA;IACzD,CAAC;IAED;;;;;;OAMG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,UAAU,CAAA;IACxB,CAAC;IAED,KAAK,CAAC,IAAI;QACR,IAAI,CAAC,UAAU,GAAG,KAAK,CAAA;QAEvB,yEAAyE;QACzE,0EAA0E;QAC1E,gBAAgB;QAChB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACvC,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,mDAAmD,IAAI,CAAC,KAAK,EAAE,CAAC,CAAA;QAClF,CAAC;QAED,MAAM,KAAK,GAAiB,EAAE,CAAA;QAC9B,IAAI,YAAY,GAAG,CAAC,CAAA;QAEpB,MAAM,IAAI,GAAG,KAAK,EAAE,SAAiB,EAAiB,EAAE;YACtD,IAAI,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,SAAS,IAAI,YAAY,IAAI,IAAI,CAAC,SAAS;gBAAE,OAAM;YAE5E,IAAI,OAAO,CAAA;YACX,IAAI,CAAC;gBACH,OAAO,GAAG,MAAM,OAAO,CAAC,SAAS,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAA;YAC7D,CAAC;YAAC,MAAM,CAAC;gBACP,uEAAuE;gBACvE,OAAM;YACR,CAAC;YAED,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;gBAC5B,IAAI,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,SAAS,IAAI,YAAY,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;oBACrE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;oBACtB,OAAM;gBACR,CAAC;gBACD,oEAAoE;gBACpE,6CAA6C;gBAC7C,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;oBACxB,IAAI,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;wBAAE,SAAQ;oBAC5E,MAAM,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAA;oBACvC,SAAQ;gBACV,CAAC;gBACD,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE;oBAAE,SAAQ;gBAC7B,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;oBAAE,SAAQ;gBAErE,YAAY,IAAI,CAAC,CAAA;gBACjB,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,CAAA;gBAC5C,IAAI,QAAgB,CAAA;gBACpB,IAAI,CAAC;oBACH,MAAM,GAAG,GAAG,MAAM,QAAQ,CAAC,QAAQ,CAAC,CAAA;oBACpC,QAAQ,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;gBACjE,CAAC;gBAAC,MAAM,CAAC;oBACP,oEAAoE;oBACpE,SAAQ;gBACV,CAAC;gBAED,MAAM,YAAY,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;gBACxE,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;gBACrC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;oBACrD,IAAI,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;wBACnC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;wBACtB,OAAM;oBACR,CAAC;oBACD,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAW,CAAC,CAAA;oBACjD,IAAI,CAAC,KAAK;wBAAE,SAAQ;oBACpB,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAW,CAAA;oBACjC,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,CAAY,CAAC,IAAI,EAAE,CAAA;oBACxC,IAAI,CAAC,IAAI;wBAAE,SAAQ;oBAEnB,MAAM,MAAM,GAAG;wBACb,QAAQ,EAAE,IAAI,CAAC,EAAE;wBACjB,mEAAmE;wBACnE,oEAAoE;wBACpE,iEAAiE;wBACjE,UAAU,EAAE,GAAG,IAAI,CAAC,iBAAiB,GAAG,YAAY,IAAI,KAAK,GAAG,CAAC,EAAE;qBACpE,CAAA;oBACD,KAAK,CAAC,IAAI,CAAC;wBACT,EAAE,EAAE,YAAY,CAAC,MAAM,CAAC;wBACxB,MAAM;wBACN,KAAK,EAAE,GAAG,MAAM,KAAK,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE;wBAC5E,MAAM,EAAE,GAAG,YAAY,IAAI,KAAK,GAAG,CAAC,KAAM,KAAK,CAAC,KAAK,CAAY,CAAC,IAAI,EAAE,EAAE;qBAC3E,CAAC,CAAA;gBACJ,CAAC;YACH,CAAC;QACH,CAAC,CAAA;QAED,MAAM,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACtB,IAAI,YAAY,IAAI,IAAI,CAAC,SAAS;YAAE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;QAC1D,OAAO,KAAK,CAAA;IACd,CAAC;CACF"}

package/dist/intake/WorkspaceTodoIntakeSource.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Repository TODOs across the directories the user granted — ADE §5.1.
+ *
+ * `RepositoryTodoIntakeSource` scans ONE tree. This is what the composition
+ * mounts, and its only job is answering the question that blocked the mount:
+ * *which* tree?
+ *
+ * 🔴 **The answer is forced, not chosen: the directories the user granted.**
+ * The workspace authority exists so the host reads only what a person
+ * authorised through a native dialog. Any other root — the home directory, the
+ * process cwd, a guess — would scan a tree nobody permitted. So this is not a
+ * product preference about scope; it is the only root the host is allowed to
+ * read, which is why it needed no decision to build.
+ *
+ * ## Roots are read at LIST time, not at construction
+ *
+ * Sources are polled. Reading the grant set on every `list()` means a directory
+ * granted after startup appears in the next poll with no registration
+ * lifecycle, no event type, and no cache to invalidate — the three things a
+ * notification-based design would have added.
+ *
+ * ## A failed root fails the SOURCE
+ *
+ * If any granted root cannot be read, this throws, exactly as the single-root
+ * scanner does. `IntakeService` then marks the inbox incomplete. Returning the
+ * items it did find would report a partial inbox as a whole one, and an inbox
+ * that looks complete is one a person stops checking.
+ */
+import type { IntakeItem } from '@xenosystem/agent-interface-core';
+import type { IntakeSource } from './IntakeService.js';
+export interface WorkspaceTodoIntakeSourceOptions {
+    id?: string;
+    label?: string;
+    /** Read on every `list()`. See the header. */
+    resolveRoots: () => string[];
+    /**
+     * Bounded because a person may have granted many directories over time and an
+     * intake poll must return. Exceeding it is reported through `truncated()`
+     * rather than silently ignoring the rest.
+     */
+    maxRoots?: number;
+    maxItemsPerRoot?: number;
+}
+export declare class WorkspaceTodoIntakeSource implements IntakeSource {
+    #private;
+    readonly id: string;
+    readonly label: string;
+    constructor(options: WorkspaceTodoIntakeSourceOptions);
+    /** True when a cap, or a per-root cap, stopped the scan early. */
+    truncated(): boolean;
+    list(): Promise<IntakeItem[]>;
+}
+//# sourceMappingURL=WorkspaceTodoIntakeSource.d.ts.map

package/dist/intake/WorkspaceTodoIntakeSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkspaceTodoIntakeSource.d.ts","sourceRoot":"","sources":["../../src/intake/WorkspaceTodoIntakeSource.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAA;AAElE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAGtD,MAAM,WAAW,gCAAgC;IAC/C,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,8CAA8C;IAC9C,YAAY,EAAE,MAAM,MAAM,EAAE,CAAA;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAID,qBAAa,yBAA0B,YAAW,YAAY;;IAC5D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;gBAMV,OAAO,EAAE,gCAAgC;IAQrD,kEAAkE;IAClE,SAAS,IAAI,OAAO;IAId,IAAI,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;CA6BpC"}

package/dist/intake/WorkspaceTodoIntakeSource.js

@@ -0,0 +1,81 @@
+/**
+ * Repository TODOs across the directories the user granted — ADE §5.1.
+ *
+ * `RepositoryTodoIntakeSource` scans ONE tree. This is what the composition
+ * mounts, and its only job is answering the question that blocked the mount:
+ * *which* tree?
+ *
+ * 🔴 **The answer is forced, not chosen: the directories the user granted.**
+ * The workspace authority exists so the host reads only what a person
+ * authorised through a native dialog. Any other root — the home directory, the
+ * process cwd, a guess — would scan a tree nobody permitted. So this is not a
+ * product preference about scope; it is the only root the host is allowed to
+ * read, which is why it needed no decision to build.
+ *
+ * ## Roots are read at LIST time, not at construction
+ *
+ * Sources are polled. Reading the grant set on every `list()` means a directory
+ * granted after startup appears in the next poll with no registration
+ * lifecycle, no event type, and no cache to invalidate — the three things a
+ * notification-based design would have added.
+ *
+ * ## A failed root fails the SOURCE
+ *
+ * If any granted root cannot be read, this throws, exactly as the single-root
+ * scanner does. `IntakeService` then marks the inbox incomplete. Returning the
+ * items it did find would report a partial inbox as a whole one, and an inbox
+ * that looks complete is one a person stops checking.
+ */
+import { createHash } from 'node:crypto';
+import { RepositoryTodoIntakeSource } from './RepositoryTodoIntakeSource.js';
+const DEFAULT_MAX_ROOTS = 8;
+export class WorkspaceTodoIntakeSource {
+    id;
+    label;
+    #resolveRoots;
+    #maxRoots;
+    #maxItemsPerRoot;
+    #truncated = false;
+    constructor(options) {
+        this.id = options.id ?? 'repository-todo';
+        this.label = options.label ?? 'Repository TODOs';
+        this.#resolveRoots = options.resolveRoots;
+        this.#maxRoots = options.maxRoots ?? DEFAULT_MAX_ROOTS;
+        this.#maxItemsPerRoot = options.maxItemsPerRoot;
+    }
+    /** True when a cap, or a per-root cap, stopped the scan early. */
+    truncated() {
+        return this.#truncated;
+    }
+    async list() {
+        this.#truncated = false;
+        const roots = this.#resolveRoots();
+        const scanned = roots.slice(0, this.#maxRoots);
+        if (scanned.length < roots.length)
+            this.#truncated = true;
+        const items = [];
+        for (const root of scanned) {
+            const scanner = new RepositoryTodoIntakeSource({
+                // The SAME source id, so every TODO belongs to one source in the UI.
+                id: this.id,
+                label: this.label,
+                rootDirectory: root,
+                // 🔴 ...but a per-root PREFIX, because the scanner's external id is
+                // the path RELATIVE to its root: `src/a.ts#2` in two granted directories
+                // would otherwise be ONE id for two different TODOs, and claiming is by
+                // id. Derived from the root, so it is stable across polls and across
+                // reorderings of the grant list — a positional prefix would change an
+                // item's identity when an unrelated directory was granted.
+                externalIdPrefix: `${createHash('sha256').update(root).digest('hex').slice(0, 8)}:`,
+                ...(this.#maxItemsPerRoot === undefined ? {} : { maxItems: this.#maxItemsPerRoot }),
+            });
+            // Deliberately not caught: see the header. A root that cannot be read
+            // means this scan did not happen.
+            items.push(...await scanner.list());
+            if (scanner.truncated())
+                this.#truncated = true;
+        }
+        return items;
+    }
+}
+//# sourceMappingURL=WorkspaceTodoIntakeSource.js.map

package/dist/intake/WorkspaceTodoIntakeSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkspaceTodoIntakeSource.js","sourceRoot":"","sources":["../../src/intake/WorkspaceTodoIntakeSource.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAKxC,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAA;AAgB5E,MAAM,iBAAiB,GAAG,CAAC,CAAA;AAE3B,MAAM,OAAO,yBAAyB;IAC3B,EAAE,CAAQ;IACV,KAAK,CAAQ;IACb,aAAa,CAAgB;IAC7B,SAAS,CAAQ;IACjB,gBAAgB,CAAoB;IAC7C,UAAU,GAAG,KAAK,CAAA;IAElB,YAAY,OAAyC;QACnD,IAAI,CAAC,EAAE,GAAG,OAAO,CAAC,EAAE,IAAI,iBAAiB,CAAA;QACzC,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,kBAAkB,CAAA;QAChD,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,YAAY,CAAA;QACzC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,QAAQ,IAAI,iBAAiB,CAAA;QACtD,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAA;IACjD,CAAC;IAED,kEAAkE;IAClE,SAAS;QACP,OAAO,IAAI,CAAC,UAAU,CAAA;IACxB,CAAC;IAED,KAAK,CAAC,IAAI;QACR,IAAI,CAAC,UAAU,GAAG,KAAK,CAAA;QACvB,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,EAAE,CAAA;QAClC,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;QAC9C,IAAI,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM;YAAE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;QAEzD,MAAM,KAAK,GAAiB,EAAE,CAAA;QAC9B,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE,CAAC;YAC3B,MAAM,OAAO,GAAG,IAAI,0BAA0B,CAAC;gBAC7C,qEAAqE;gBACrE,EAAE,EAAE,IAAI,CAAC,EAAE;gBACX,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,aAAa,EAAE,IAAI;gBACnB,oEAAoE;gBACpE,yEAAyE;gBACzE,wEAAwE;gBACxE,qEAAqE;gBACrE,sEAAsE;gBACtE,2DAA2D;gBAC3D,gBAAgB,EAAE,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG;gBACnF,GAAG,CAAC,IAAI,CAAC,gBAAgB,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC;aACpF,CAAC,CAAA;YACF,sEAAsE;YACtE,kCAAkC;YAClC,KAAK,CAAC,IAAI,CAAC,GAAG,MAAM,OAAO,CAAC,IAAI,EAAE,CAAC,CAAA;YACnC,IAAI,OAAO,CAAC,SAAS,EAAE;gBAAE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;QACjD,CAAC;QACD,OAAO,KAAK,CAAA;IACd,CAAC;CACF"}

package/dist/isolation/CommandExecution.d.ts

@@ -0,0 +1,132 @@
+/**
+ * The one shape every agent-reachable command execution shares — ADE §5.3.
+ *
+ * ADOPTED at one of three sites. `EngineeringWorkbenchService.runProcess` runs
+ * through it via `LocalCommandExecutor`; `WorkspaceHostService.runCommand` and
+ * `executeWindowsPowerShellTool` in `packages/electron-host/src/sdkAgent.ts`
+ * still spawn directly.
+ *
+ * They move one at a time on purpose. Each carries its own access control that
+ * has to be reconciled rather than dropped — a string blocklist plus path
+ * authorization in one, consent plus a runtime policy engine plus a path
+ * allowlist in the other — and three in a single commit would be three
+ * behaviour changes behind one review. Engineering went first because it had
+ * the least to preserve and because its result shape was the model for
+ * `CommandExecutionResult`, so the adoption proved the port without bending the
+ * caller to fit.
+ *
+ * ## Why a port at all
+ *
+ * §5.3's target is to consume `xeno-use` sandboxes. `xeno-use` is AGPL-3.0 and
+ * this package is proprietary, so it is reached OUT OF PROCESS over `/v1/use/*`
+ * and never imported — the same boundary `RunObservationSource` holds one
+ * directory over. The port is what makes the local implementation and the
+ * sandbox implementation interchangeable at each call site.
+ *
+ * §5.3 also puts implementing containers, VMs and worktrees explicitly out of
+ * scope here. Nothing in this file starts anything; it describes a call.
+ */
+/**
+ * 🔴 **argv is a LIST, never a shell line.** The decision, made once.
+ *
+ * `xeno-use`'s `sandboxExec` takes argv as a list and refuses a shell string,
+ * for the ordinary reason: a string has to be parsed by *something*, and which
+ * something is exactly the ambiguity a sandbox boundary cannot afford.
+ *
+ * The agent's terminal tool genuinely needs a shell — an agent writes
+ * `npm test && node x.js`, not an argv. That is not a conflict, because
+ * **running a shell IS expressible as argv**:
+ *
+ * ```ts
+ * argv: ['powershell.exe', '-NoLogo', '-NoProfile', '-NonInteractive',
+ *        '-ExecutionPolicy', 'Bypass', '-Command', command]
+ * ```
+ *
+ * which is precisely what that tool already spawns today. So the rule costs
+ * nothing and buys the property that matters: **whether a shell is involved is
+ * visible at the call site**, in argv[0], rather than hidden behind a
+ * `shell: true` flag that a reader has to know the semantics of. A reviewer
+ * asking "does this run a shell?" reads one array.
+ *
+ * The rejected alternative was changing the agent tool to accept argv and
+ * dropping shell support. That would break what an agent actually writes, and
+ * §5.3 is about confining execution, not narrowing it.
+ */
+export interface CommandExecutionRequest {
+    /**
+     * The program and its arguments. Non-empty by type: an execution with no
+     * program is not a request this port can carry, and making that
+     * unrepresentable is cheaper than validating it at three call sites.
+     */
+    argv: readonly [string, ...string[]];
+    cwd: string;
+    /**
+     * REQUIRED, and the caller must already have capped it.
+     *
+     * `sandboxExec` makes its timeout required and bounded because a command that
+     * cannot time out turns a wedged process inside the sandbox into a wedged
+     * caller outside it. Optional here would let a caller omit it and inherit
+     * some implementation's default — which is how one path ends up unbounded
+     * while the gate that checks the others stays green. All three sites already
+     * cap; `executionTimeouts.test.ts` pins that.
+     */
+    timeoutMs: number;
+    /** Output ceiling. Absent means the implementation's own bound applies. */
+    maxOutputBytes?: number;
+}
+/**
+ * What happened. Modelled on `EngineeringWorkbenchService`'s `ProcessResult`,
+ * which is the only one of the three that already carried every fact.
+ *
+ * 🔴 A timeout and a non-zero exit are both RESULTS, not errors. The command
+ * ran; it is the caller's business what that means. Throwing for either would
+ * make an ordinary failing test indistinguishable from the executor breaking.
+ */
+export interface CommandExecutionResult {
+    stdout: string;
+    stderr: string;
+    /**
+     * 🔴 `null` when the process was KILLED BY A SIGNAL rather than exiting.
+     *
+     * Not a number with a sentinel. `ed6ed69` fixed exactly this: the agent's
+     * tool coerced `code ?? 1` and told the agent *"Command failed with exit code
+     * 1."* about a value the process never produced. Exit 1 means the program ran
+     * and failed; a signal means something else stopped it, and the command may
+     * be fine. `sandboxExec` returns an Option for the same reason, so a port
+     * that flattened it would discard the distinction at the boundary.
+     */
+    exitCode: number | null;
+    /** Distinct from a non-zero exit: the deadline fired and the child was killed. */
+    timedOut: boolean;
+    /** Output hit the ceiling. A short result and a truncated one are different. */
+    truncated: boolean;
+    /**
+     * The execution could not be attempted or completed — spawn failure, a
+     * refusal by the substrate. NOT set for a command that ran and failed.
+     */
+    error?: string;
+}
+/**
+ * Runs a command somewhere. Implemented locally today, by a sandbox later.
+ *
+ * Deliberately one method. A port is the exact set of calls a caller may make,
+ * and everything else about running a command — where it runs, what confines
+ * it, who approved it — belongs to whoever supplies the implementation.
+ */
+export interface CommandExecutionPort {
+    execute(request: CommandExecutionRequest): Promise<CommandExecutionResult>;
+}
+/**
+ * Whether a result should read as success.
+ *
+ * Exported so the rule has ONE spelling. Today each site derives it slightly
+ * differently — `!timedOut && exitCode === 0` in one, `exitCode === 0` in
+ * another — and a difference in a success predicate is the kind of thing that
+ * survives a refactor because both spellings look obviously right.
+ *
+ * A signal-killed process is NOT a success even though it has no failing exit
+ * code, which is the case a naive `exitCode === 0` gets wrong by way of `null`
+ * comparing unequal to 0 only by accident of the operator used.
+ */
+export declare function commandSucceeded(result: CommandExecutionResult): boolean;
+//# sourceMappingURL=CommandExecution.d.ts.map

package/dist/isolation/CommandExecution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommandExecution.d.ts","sourceRoot":"","sources":["../../src/isolation/CommandExecution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;OAIG;IACH,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAAA;IACpC,GAAG,EAAE,MAAM,CAAA;IACX;;;;;;;;;OASG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB,2EAA2E;IAC3E,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd;;;;;;;;;OASG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,kFAAkF;IAClF,QAAQ,EAAE,OAAO,CAAA;IACjB,gFAAgF;IAChF,SAAS,EAAE,OAAO,CAAA;IAClB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAA;CAC3E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAIxE"}

package/dist/isolation/CommandExecution.js

@@ -0,0 +1,48 @@
+/**
+ * The one shape every agent-reachable command execution shares — ADE §5.3.
+ *
+ * ADOPTED at one of three sites. `EngineeringWorkbenchService.runProcess` runs
+ * through it via `LocalCommandExecutor`; `WorkspaceHostService.runCommand` and
+ * `executeWindowsPowerShellTool` in `packages/electron-host/src/sdkAgent.ts`
+ * still spawn directly.
+ *
+ * They move one at a time on purpose. Each carries its own access control that
+ * has to be reconciled rather than dropped — a string blocklist plus path
+ * authorization in one, consent plus a runtime policy engine plus a path
+ * allowlist in the other — and three in a single commit would be three
+ * behaviour changes behind one review. Engineering went first because it had
+ * the least to preserve and because its result shape was the model for
+ * `CommandExecutionResult`, so the adoption proved the port without bending the
+ * caller to fit.
+ *
+ * ## Why a port at all
+ *
+ * §5.3's target is to consume `xeno-use` sandboxes. `xeno-use` is AGPL-3.0 and
+ * this package is proprietary, so it is reached OUT OF PROCESS over `/v1/use/*`
+ * and never imported — the same boundary `RunObservationSource` holds one
+ * directory over. The port is what makes the local implementation and the
+ * sandbox implementation interchangeable at each call site.
+ *
+ * §5.3 also puts implementing containers, VMs and worktrees explicitly out of
+ * scope here. Nothing in this file starts anything; it describes a call.
+ */
+/**
+ * Whether a result should read as success.
+ *
+ * Exported so the rule has ONE spelling. Today each site derives it slightly
+ * differently — `!timedOut && exitCode === 0` in one, `exitCode === 0` in
+ * another — and a difference in a success predicate is the kind of thing that
+ * survives a refactor because both spellings look obviously right.
+ *
+ * A signal-killed process is NOT a success even though it has no failing exit
+ * code, which is the case a naive `exitCode === 0` gets wrong by way of `null`
+ * comparing unequal to 0 only by accident of the operator used.
+ */
+export function commandSucceeded(result) {
+    if (result.timedOut)
+        return false;
+    if (result.error !== undefined)
+        return false;
+    return result.exitCode === 0;
+}
+//# sourceMappingURL=CommandExecution.js.map

package/dist/isolation/CommandExecution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommandExecution.js","sourceRoot":"","sources":["../../src/isolation/CommandExecution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AA+FH;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAA8B;IAC7D,IAAI,MAAM,CAAC,QAAQ;QAAE,OAAO,KAAK,CAAA;IACjC,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS;QAAE,OAAO,KAAK,CAAA;IAC5C,OAAO,MAAM,CAAC,QAAQ,KAAK,CAAC,CAAA;AAC9B,CAAC"}

package/dist/isolation/LocalCommandExecutor.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `CommandExecutionPort` over `node:child_process` — the LOCAL implementation.
+ *
+ * 🔴 This confines nothing. It starts a real process on the user's machine, as
+ * the signed-in user, with `process.env`. It exists so the three agent-reachable
+ * call sites can express what they need through a port whose OTHER
+ * implementation will be a sandbox, and so that swapping them is a composition
+ * change rather than a rewrite at each site.
+ *
+ * Naming it `Local` rather than `Default` is deliberate: a reader choosing an
+ * implementation should see that this one is defined by WHERE it runs, and be
+ * prompted to ask whether that is what they want.
+ *
+ * ## Extracted, not rewritten
+ *
+ * The body is `EngineeringWorkbenchService`'s `runProcess` moved behind the
+ * port — same spawn options, same output-limit trimming, same settle-once
+ * guard. That site was chosen to go first precisely because its result shape
+ * was the model for `CommandExecutionResult`, so nothing about its behaviour
+ * had to change to fit. An adoption that has to bend the caller is evidence the
+ * port is wrong, not that the caller is.
+ */
+import type { CommandExecutionPort, CommandExecutionRequest, CommandExecutionResult } from './CommandExecution.js';
+export declare class LocalCommandExecutor implements CommandExecutionPort {
+    execute(request: CommandExecutionRequest): Promise<CommandExecutionResult>;
+}
+//# sourceMappingURL=LocalCommandExecutor.d.ts.map

package/dist/isolation/LocalCommandExecutor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalCommandExecutor.d.ts","sourceRoot":"","sources":["../../src/isolation/LocalCommandExecutor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EACV,oBAAoB,EACpB,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,uBAAuB,CAAA;AAI9B,qBAAa,oBAAqB,YAAW,oBAAoB;IACzD,OAAO,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,sBAAsB,CAAC;CAyEjF"}

package/dist/isolation/LocalCommandExecutor.js

@@ -0,0 +1,97 @@
+/**
+ * `CommandExecutionPort` over `node:child_process` — the LOCAL implementation.
+ *
+ * 🔴 This confines nothing. It starts a real process on the user's machine, as
+ * the signed-in user, with `process.env`. It exists so the three agent-reachable
+ * call sites can express what they need through a port whose OTHER
+ * implementation will be a sandbox, and so that swapping them is a composition
+ * change rather than a rewrite at each site.
+ *
+ * Naming it `Local` rather than `Default` is deliberate: a reader choosing an
+ * implementation should see that this one is defined by WHERE it runs, and be
+ * prompted to ask whether that is what they want.
+ *
+ * ## Extracted, not rewritten
+ *
+ * The body is `EngineeringWorkbenchService`'s `runProcess` moved behind the
+ * port — same spawn options, same output-limit trimming, same settle-once
+ * guard. That site was chosen to go first precisely because its result shape
+ * was the model for `CommandExecutionResult`, so nothing about its behaviour
+ * had to change to fit. An adoption that has to bend the caller is evidence the
+ * port is wrong, not that the caller is.
+ */
+import { spawn } from 'node:child_process';
+const DEFAULT_MAX_OUTPUT_BYTES = 200_000;
+export class LocalCommandExecutor {
+    async execute(request) {
+        const [command, ...args] = request.argv;
+        const outputLimit = request.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+        return await new Promise((settle) => {
+            let stdout = '';
+            let stderr = '';
+            let settled = false;
+            let timedOut = false;
+            let truncated = false;
+            const child = spawn(command, args, {
+                cwd: request.cwd,
+                windowsHide: true,
+                // 🔴 Never `shell: true`. The port's rule is that argv is a list, and a
+                // shell — when one is wanted — is named in argv[0] by the caller. A
+                // `shell` flag here would reintroduce the ambiguity at the one place
+                // that must not have it: the boundary a sandbox implementation sits on.
+                shell: false,
+                env: process.env,
+            });
+            const timer = setTimeout(() => {
+                timedOut = true;
+                child.kill();
+            }, request.timeoutMs);
+            const append = (target, chunk) => {
+                const text = chunk.toString();
+                if (target === 'stdout')
+                    stdout += text;
+                else
+                    stderr += text;
+                if (stdout.length + stderr.length > outputLimit) {
+                    truncated = true;
+                    const keep = Math.max(4_000, Math.floor(outputLimit / 2));
+                    stdout = stdout.slice(-keep);
+                    stderr = stderr.slice(-keep);
+                }
+            };
+            child.stdout.on('data', (chunk) => append('stdout', chunk));
+            child.stderr.on('data', (chunk) => append('stderr', chunk));
+            child.on('error', (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                // The execution could not be ATTEMPTED. `exitCode: null` here means the
+                // same thing it means everywhere on this type — there is no exit code —
+                // and `error` is what distinguishes "never started" from "killed".
+                settle({ stdout, stderr, exitCode: null, timedOut, truncated, error: err.message });
+            });
+            child.on('close', (code) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                settle({
+                    stdout,
+                    stderr,
+                    // 🔴 Passed through, INCLUDING null. Node gives null when the child
+                    // was killed by a signal, and the port keeps that distinction rather
+                    // than coercing — the defect `ed6ed69` removed from the agent's tool.
+                    exitCode: code,
+                    timedOut,
+                    truncated,
+                    // Spread-omitted rather than set to undefined: `error` is optional
+                    // under `exactOptionalPropertyTypes`, and an explicit undefined is a
+                    // different type from an absent key.
+                    ...(timedOut ? { error: `Command timed out after ${request.timeoutMs}ms.` } : {}),
+                });
+            });
+        });
+    }
+}
+//# sourceMappingURL=LocalCommandExecutor.js.map

package/dist/isolation/LocalCommandExecutor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalCommandExecutor.js","sourceRoot":"","sources":["../../src/isolation/LocalCommandExecutor.ts"],"names":[],"mappings":"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"}