@gaunt-sloth/agent 2.0.0-alpha.4 → 2.0.0-alpha.40

package/dist/core/deepAgentPermissions.d.ts

@@ -1,73 +0,0 @@
-import type { FilesystemPermission } from 'deepagents';
-export type { FilesystemPermission };
-/**
- * Tool names deepagents' filesystem middleware registers. This mirrors deepagents'
- * internal `FILESYSTEM_TOOL_NAMES` (which is declared in its types but not exported
- * at runtime). `createDeepAgent` throws on a name collision with any of these, so a
- * gsloth-supplied tool sharing one of these names is superseded by the deep agent's
- * built-in filesystem tool. Kept here as the single place the deep path references it.
- */
-export declare const FILESYSTEM_TOOL_NAMES: readonly ["ls", "read_file", "write_file", "edit_file", "glob", "grep", "execute"];
-/** The slice of GthConfig the permission mapping consumes. */
-export interface PermissionConfigSlice {
-    filesystem: string[] | 'all' | 'read' | 'none';
-    aiignore?: {
-        enabled?: boolean;
-        patterns?: string[];
-    };
-    /**
-     * Extra real filesystem roots to allow (`gth exec --allow-dir`). When present, the backend runs
-     * WITHOUT virtualMode, so permission paths are real absolute paths: access is allow-listed to
-     * cwd + these dirs and everything else is denied. Undefined/empty keeps the cwd-only sandbox.
-     */
-    allowDirs?: string[];
-}
-/**
- * Build allow+deny rules for the widened (`--allow-dir`) sandbox. Because the backend runs
- * without virtualMode, paths are REAL absolute paths, so we anchor allow rules at the resolved
- * absolute cwd and each allowed dir, then deny everything else. First-match-wins, so the allow
- * rules must come before the catch-all deny.
- */
-export declare function allowDirsToPermissions(allowDirs: string[]): FilesystemPermission[];
-/**
- * Convert `.aiignore` patterns (relative, .gitignore-ish) into deepagents deny rules.
- *
- * deepagents matches the path argument the model passes to a fs tool against ABSOLUTE
- * globs. EXT-13: the backend now runs WITHOUT virtualMode in both the default and widened
- * cases, so paths are REAL absolute paths and the caller passes the absolute cwd as `base`
- * to anchor these deny rules there.
- *
- * A bare pattern (`*.env`, `secret.txt`) should match at any depth, so we emit both a
- * top-level (`<base>/secret.txt`) and a recursive (`<base>/&#42;&#42;/secret.txt`) rule. A pattern
- * already containing "/" (`config/secrets.json`) is anchored as-is (plus a `/**` subtree rule).
- *
- * `base` defaults to "" (anchoring at the virtual root "/") for legacy callers; gsloth's
- * {@link buildPermissions} always passes the absolute cwd now.
- */
-export declare function aiignoreToPermissions(patterns: string[], base?: string): FilesystemPermission[];
-/**
- * Map gsloth's filesystem mode onto deepagents permission rules for the DEFAULT
- * (non-widen) code-mode sandbox.
- *
- * EXT-13: the default backend now runs WITHOUT virtualMode (real absolute paths), so
- * containment can no longer lean on the virtual-root chroot — it is enforced entirely by
- * these globs anchored at the REAL absolute cwd. We therefore allow read+write within
- * `cwd/**` (and `cwd`) and deny everything else (`/**`), mirroring what virtualMode gave
- * for free. An explicit `string[]` allow-list resolves each entry against the real cwd.
- *
- * - `all`  → no extra restriction beyond the cwd sandbox (matches the old virtualMode
- *            behavior, where `/` already meant cwd).
- * - `read` → deny all writes (the cwd sandbox still applies for reads).
- * - `none` → deny all reads and writes.
- * - `string[]` → allow each (cwd-resolved) dir, deny everything else.
- *
- * The `cwd` argument is injected (defaults to {@link getCurrentWorkDir}) so callers/tests
- * can anchor deterministically.
- */
-export declare function filesystemModeToPermissions(fs: string[] | 'all' | 'read' | 'none', cwd?: string, virtual?: boolean): FilesystemPermission[];
-/**
- * Compose the full permission list. `.aiignore` deny rules go FIRST so they win over
- * any allow rule (first-match-wins). Then the filesystem-mode rules. `.aiignore` is
- * skipped when explicitly disabled (`aiignore.enabled === false`) or has no patterns.
- */
-export declare function buildPermissions(config: PermissionConfigSlice, virtual?: boolean): FilesystemPermission[];

package/dist/core/deepAgentPermissions.js

@@ -1,161 +0,0 @@
-import path from 'node:path';
-import { getCurrentWorkDir } from '@gaunt-sloth/core/utils/systemUtils.js';
-/**
- * Tool names deepagents' filesystem middleware registers. This mirrors deepagents'
- * internal `FILESYSTEM_TOOL_NAMES` (which is declared in its types but not exported
- * at runtime). `createDeepAgent` throws on a name collision with any of these, so a
- * gsloth-supplied tool sharing one of these names is superseded by the deep agent's
- * built-in filesystem tool. Kept here as the single place the deep path references it.
- */
-export const FILESYSTEM_TOOL_NAMES = [
-    'ls',
-    'read_file',
-    'write_file',
-    'edit_file',
-    'glob',
-    'grep',
-    'execute',
-];
-/**
- * Build allow+deny rules for the widened (`--allow-dir`) sandbox. Because the backend runs
- * without virtualMode, paths are REAL absolute paths, so we anchor allow rules at the resolved
- * absolute cwd and each allowed dir, then deny everything else. First-match-wins, so the allow
- * rules must come before the catch-all deny.
- */
-export function allowDirsToPermissions(allowDirs) {
-    const cwd = getCurrentWorkDir();
-    const roots = [cwd, ...allowDirs.map((d) => path.resolve(cwd, d))];
-    // De-dupe resolved roots (e.g. an --allow-dir pointing back at cwd).
-    const uniqueRoots = Array.from(new Set(roots));
-    const allow = uniqueRoots.map((root) => ({
-        operations: ['read', 'write'],
-        paths: [`${root}/**`, root],
-        mode: 'allow',
-    }));
-    return [...allow, { operations: ['read', 'write'], paths: ['/**'], mode: 'deny' }];
-}
-/**
- * Strip a single leading "./" or "/" and any trailing slashes, using linear string
- * ops rather than regex. The previous `/\/+$/` trailing-slash regex was flagged by
- * CodeQL as a polynomial ReDoS (the `$` anchor makes the greedy `\/+` retry from every
- * start position → quadratic on a long run of slashes); plain slicing is O(n) and safe.
- */
-function normalizePathFragment(p) {
-    let start = 0;
-    if (p.startsWith('./'))
-        start = 2;
-    else if (p.startsWith('/'))
-        start = 1;
-    let end = p.length;
-    while (end > start && p[end - 1] === '/')
-        end--;
-    return p.slice(start, end);
-}
-/**
- * Convert `.aiignore` patterns (relative, .gitignore-ish) into deepagents deny rules.
- *
- * deepagents matches the path argument the model passes to a fs tool against ABSOLUTE
- * globs. EXT-13: the backend now runs WITHOUT virtualMode in both the default and widened
- * cases, so paths are REAL absolute paths and the caller passes the absolute cwd as `base`
- * to anchor these deny rules there.
- *
- * A bare pattern (`*.env`, `secret.txt`) should match at any depth, so we emit both a
- * top-level (`<base>/secret.txt`) and a recursive (`<base>/&#42;&#42;/secret.txt`) rule. A pattern
- * already containing "/" (`config/secrets.json`) is anchored as-is (plus a `/**` subtree rule).
- *
- * `base` defaults to "" (anchoring at the virtual root "/") for legacy callers; gsloth's
- * {@link buildPermissions} always passes the absolute cwd now.
- */
-export function aiignoreToPermissions(patterns, base = '') {
-    const rules = [];
-    for (const raw of patterns) {
-        const clean = normalizePathFragment(raw);
-        if (clean.length === 0)
-            continue;
-        const paths = clean.includes('/')
-            ? [`${base}/${clean}`, `${base}/${clean}/**`]
-            : [`${base}/${clean}`, `${base}/**/${clean}`];
-        rules.push({ operations: ['read', 'write'], paths, mode: 'deny' });
-    }
-    return rules;
-}
-/**
- * Map gsloth's filesystem mode onto deepagents permission rules for the DEFAULT
- * (non-widen) code-mode sandbox.
- *
- * EXT-13: the default backend now runs WITHOUT virtualMode (real absolute paths), so
- * containment can no longer lean on the virtual-root chroot — it is enforced entirely by
- * these globs anchored at the REAL absolute cwd. We therefore allow read+write within
- * `cwd/**` (and `cwd`) and deny everything else (`/**`), mirroring what virtualMode gave
- * for free. An explicit `string[]` allow-list resolves each entry against the real cwd.
- *
- * - `all`  → no extra restriction beyond the cwd sandbox (matches the old virtualMode
- *            behavior, where `/` already meant cwd).
- * - `read` → deny all writes (the cwd sandbox still applies for reads).
- * - `none` → deny all reads and writes.
- * - `string[]` → allow each (cwd-resolved) dir, deny everything else.
- *
- * The `cwd` argument is injected (defaults to {@link getCurrentWorkDir}) so callers/tests
- * can anchor deterministically.
- */
-export function filesystemModeToPermissions(fs, cwd = getCurrentWorkDir(), virtual = false) {
-    // EXT-16: on Windows the real cwd (`D:\...`) cannot be expressed as a deepagents
-    // permission glob — its `validatePath` requires POSIX `/`-rooted paths — so the backend
-    // runs in virtualMode and these rules anchor at the virtual root `/` (= cwd) instead of
-    // the real absolute cwd. On POSIX, `virtual` is false and this is the EXT-13 real-path
-    // sandbox unchanged. `rootGlob`/`rootPath` = "everything under the sandbox root".
-    const rootGlob = virtual ? '/**' : `${cwd}/**`;
-    const rootPath = virtual ? '/' : cwd;
-    if (fs === 'none')
-        return [{ operations: ['read', 'write'], paths: ['/**'], mode: 'deny' }];
-    if (fs === 'read') {
-        // Deny all writes everywhere; reads are still confined to the cwd sandbox below.
-        return [
-            { operations: ['write'], paths: ['/**'], mode: 'deny' },
-            { operations: ['read'], paths: [rootGlob, rootPath], mode: 'allow' },
-            { operations: ['read'], paths: ['/**'], mode: 'deny' },
-        ];
-    }
-    if (fs === 'all') {
-        // No allow-list restriction, but the cwd sandbox must still apply by default
-        // (allow cwd/**, deny /**) — this is what virtualMode enforced implicitly.
-        return [
-            { operations: ['read', 'write'], paths: [rootGlob, rootPath], mode: 'allow' },
-            { operations: ['read', 'write'], paths: ['/**'], mode: 'deny' },
-        ];
-    }
-    // string[] — explicit allow-list of directories. Real mode resolves each against the REAL
-    // cwd; virtual mode anchors each under the virtual root `/`. Allow read+write within each,
-    // deny everything else. Allow rules first (first-match-wins), deny catch-all last.
-    const allow = fs
-        .filter((d) => d !== 'all' && d !== 'read')
-        .map((d) => {
-        const frag = normalizePathFragment(d);
-        const dir = virtual ? `/${frag}` : path.resolve(cwd, frag);
-        return { operations: ['read', 'write'], paths: [`${dir}/**`, dir], mode: 'allow' };
-    });
-    return [...allow, { operations: ['read', 'write'], paths: ['/**'], mode: 'deny' }];
-}
-/**
- * Compose the full permission list. `.aiignore` deny rules go FIRST so they win over
- * any allow rule (first-match-wins). Then the filesystem-mode rules. `.aiignore` is
- * skipped when explicitly disabled (`aiignore.enabled === false`) or has no patterns.
- */
-export function buildPermissions(config, virtual = false) {
-    const cwd = getCurrentWorkDir();
-    const widen = Array.isArray(config.allowDirs) && config.allowDirs.length > 0;
-    const aiignoreEnabled = config.aiignore?.enabled !== false && !!config.aiignore?.patterns?.length;
-    // EXT-13/EXT-16: real mode anchors aiignore deny rules at the absolute cwd; virtual mode
-    // (Windows) anchors them at the virtual root ("" → "/"). Either way they keep matching the
-    // project-relative ignore patterns.
-    const base = virtual ? '' : cwd;
-    const aiignore = aiignoreEnabled ? aiignoreToPermissions(config.aiignore.patterns, base) : [];
-    // `--allow-dir` widens to the cwd + allowed-dirs allow-list, which needs REAL absolute paths
-    // and so cannot apply in virtualMode (EXT-16): when virtual, fall back to the cwd-only mode
-    // sandbox (the caller warns that widening is limited on this platform).
-    const modeRules = widen && !virtual
-        ? allowDirsToPermissions(config.allowDirs)
-        : filesystemModeToPermissions(config.filesystem, cwd, virtual);
-    return [...aiignore, ...modeRules];
-}
-//# sourceMappingURL=deepAgentPermissions.js.map

package/dist/core/deepAgentPermissions.js.map

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

package/dist/core/gthAcpServer.d.ts

@@ -1,27 +0,0 @@
-/**
- * @packageDocumentation
- * Thin wrapper over `deepagents-acp`'s `DeepAgentsServer` that fixes how its filesystem backend is
- * rooted, since 0.1.12 gets both the location and the path semantics wrong for an IDE-hosted agent.
- *
- * 1. **Per-session root.** deepagents-acp roots its backend once at `workspaceRoot ?? process.cwd()`
- *    and IGNORES the `cwd` carried by every ACP `session/new` request. An ACP host (Zed, JetBrains)
- *    spawns one long-lived agent subprocess and passes the real project root per session, so we
- *    re-root the backend to `session/new.cwd`.
- * 2. **Virtual-fs semantics.** deepagents-acp builds its backend WITHOUT `virtualMode`, so `/`
- *    resolves to the OS root and `ls /` lists the whole machine — but deepagents' filesystem prompt
- *    tells the model `/` is the workspace root (the convention the local runner uses via
- *    `FilesystemBackend({ virtualMode: true })`). We switch the backend into virtual-fs mode so
- *    `'/'`-rooted paths are workspace-relative.
- *
- * The server's connection handler dispatches `this.handleNewSession(params, conn)` dynamically, so
- * we patch that instance method before `start()`. Both fixes reach into deepagents-acp internals and
- * are guarded so a shape change degrades to a no-op rather than throwing; if a future deepagents-acp
- * honors session cwd / virtual mode itself, this becomes a harmless re-assert.
- */
-import { DeepAgentsServer, type DeepAgentsServerOptions } from 'deepagents-acp';
-/**
- * Construct and start a deepagents-acp server that roots its filesystem backend at each ACP
- * session's `cwd` and runs it in virtual-fs mode (so `/` is the workspace, not the OS root).
- * Resolves once the stdio transport is listening.
- */
-export declare function startGthAcpServer(options: DeepAgentsServerOptions): Promise<DeepAgentsServer>;

package/dist/core/gthAcpServer.js

@@ -1,71 +0,0 @@
-/**
- * @packageDocumentation
- * Thin wrapper over `deepagents-acp`'s `DeepAgentsServer` that fixes how its filesystem backend is
- * rooted, since 0.1.12 gets both the location and the path semantics wrong for an IDE-hosted agent.
- *
- * 1. **Per-session root.** deepagents-acp roots its backend once at `workspaceRoot ?? process.cwd()`
- *    and IGNORES the `cwd` carried by every ACP `session/new` request. An ACP host (Zed, JetBrains)
- *    spawns one long-lived agent subprocess and passes the real project root per session, so we
- *    re-root the backend to `session/new.cwd`.
- * 2. **Virtual-fs semantics.** deepagents-acp builds its backend WITHOUT `virtualMode`, so `/`
- *    resolves to the OS root and `ls /` lists the whole machine — but deepagents' filesystem prompt
- *    tells the model `/` is the workspace root (the convention the local runner uses via
- *    `FilesystemBackend({ virtualMode: true })`). We switch the backend into virtual-fs mode so
- *    `'/'`-rooted paths are workspace-relative.
- *
- * The server's connection handler dispatches `this.handleNewSession(params, conn)` dynamically, so
- * we patch that instance method before `start()`. Both fixes reach into deepagents-acp internals and
- * are guarded so a shape change degrades to a no-op rather than throwing; if a future deepagents-acp
- * honors session cwd / virtual mode itself, this becomes a harmless re-assert.
- */
-import { DeepAgentsServer } from 'deepagents-acp';
-import { resolve } from 'node:path';
-import { debugLog } from '@gaunt-sloth/core/utils/debugUtils.js';
-/**
- * Put an ACP filesystem backend into deepagents' virtual-fs mode so `'/'`-rooted paths are
- * workspace-relative (clamped under `cwd`), matching deepagents' prompt and the local runner.
- *
- * `virtualMode` covers the methods that route through `resolvePath` (ls) and the inline checks
- * (glob/grep). The ACP read/write proxy uses its own `resolveAbsPath`, which ignores `virtualMode`,
- * so override that too so proxied reads/writes hit the workspace, not the OS root.
- */
-function configureVirtualFs(backend) {
-    backend.virtualMode = true;
-    backend.resolveAbsPath = (filePath) => resolve(backend.cwd ?? process.cwd(), String(filePath).replace(/^\/+/, ''));
-}
-/**
- * Construct and start a deepagents-acp server that roots its filesystem backend at each ACP
- * session's `cwd` and runs it in virtual-fs mode (so `/` is the workspace, not the OS root).
- * Resolves once the stdio transport is listening.
- */
-export async function startGthAcpServer(options) {
-    const server = new DeepAgentsServer(options);
-    const internals = server;
-    const original = internals.handleNewSession;
-    if (typeof original === 'function') {
-        const bound = original.bind(server);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        internals.handleNewSession = async (params, conn) => {
-            const result = await bound(params, conn);
-            const backends = internals.acpBackends;
-            const cwd = typeof params?.cwd === 'string' && params.cwd.length > 0 ? resolve(params.cwd) : undefined;
-            if (backends && backends.size > 0) {
-                for (const backend of backends.values()) {
-                    if (!backend || typeof backend !== 'object')
-                        continue;
-                    if (cwd)
-                        backend.cwd = cwd;
-                    configureVirtualFs(backend);
-                }
-                debugLog(`ACP session: virtual fs, root ${cwd ?? '[startup workspace]'}`);
-            }
-            return result;
-        };
-    }
-    else {
-        debugLog('deepagents-acp handleNewSession not found to patch; session fs rooting disabled');
-    }
-    await server.start();
-    return server;
-}
-//# sourceMappingURL=gthAcpServer.js.map

package/dist/core/gthAcpServer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gthAcpServer.js","sourceRoot":"","sources":["../../src/core/gthAcpServer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,gBAAgB,EAAgC,MAAM,gBAAgB,CAAC;AAChF,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,uCAAuC,CAAC;AAiBjE;;;;;;;GAOG;AACH,SAAS,kBAAkB,CAAC,OAA0B;IACpD,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAC3B,OAAO,CAAC,cAAc,GAAG,CAAC,QAAgB,EAAU,EAAE,CACpD,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAC;AAChF,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,OAAgC;IAEhC,MAAM,MAAM,GAAG,IAAI,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAC7C,MAAM,SAAS,GAAG,MAAuC,CAAC;IAE1D,MAAM,QAAQ,GAAG,SAAS,CAAC,gBAAgB,CAAC;IAC5C,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE,CAAC;QACnC,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACpC,8DAA8D;QAC9D,SAAS,CAAC,gBAAgB,GAAG,KAAK,EAAE,MAAW,EAAE,IAAS,EAAE,EAAE;YAC5D,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YACzC,MAAM,QAAQ,GAAG,SAAS,CAAC,WAAW,CAAC;YACvC,MAAM,GAAG,GACP,OAAO,MAAM,EAAE,GAAG,KAAK,QAAQ,IAAI,MAAM,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAC7F,IAAI,QAAQ,IAAI,QAAQ,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;gBAClC,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;oBACxC,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ;wBAAE,SAAS;oBACtD,IAAI,GAAG;wBAAE,OAAO,CAAC,GAAG,GAAG,GAAG,CAAC;oBAC3B,kBAAkB,CAAC,OAAO,CAAC,CAAC;gBAC9B,CAAC;gBACD,QAAQ,CAAC,iCAAiC,GAAG,IAAI,qBAAqB,EAAE,CAAC,CAAC;YAC5E,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC;IACJ,CAAC;SAAM,CAAC;QACN,QAAQ,CAAC,iFAAiF,CAAC,CAAC;IAC9F,CAAC;IAED,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;IACrB,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/core/gthDeepAgentFactory.d.ts

@@ -1,8 +0,0 @@
-import type { GthAgentFactory } from '@gaunt-sloth/core/core/types.js';
-/**
- * A {@link GthAgentFactory} that produces a {@link GthDeepAgent}. Pass this to
- * `GthAgentRunner` (its optional 3rd ctor arg) so the same runner drives a
- * `createDeepAgent` graph instead of the lean default — without `core` ever
- * importing `deepagents`.
- */
-export declare const gthDeepAgentFactory: GthAgentFactory;

package/dist/core/gthDeepAgentFactory.js

@@ -1,9 +0,0 @@
-import { GthDeepAgent } from '#src/core/GthDeepAgent.js';
-/**
- * A {@link GthAgentFactory} that produces a {@link GthDeepAgent}. Pass this to
- * `GthAgentRunner` (its optional 3rd ctor arg) so the same runner drives a
- * `createDeepAgent` graph instead of the lean default — without `core` ever
- * importing `deepagents`.
- */
-export const gthDeepAgentFactory = (statusUpdate, resolvers) => new GthDeepAgent(statusUpdate, resolvers);
-//# sourceMappingURL=gthDeepAgentFactory.js.map

package/dist/core/gthDeepAgentFactory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gthDeepAgentFactory.js","sourceRoot":"","sources":["../../src/core/gthDeepAgentFactory.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAoB,CAAC,YAAY,EAAE,SAAS,EAAE,EAAE,CAC9E,IAAI,YAAY,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC"}

package/dist/modules/acpModule.d.ts

@@ -1,40 +0,0 @@
-/**
- * @packageDocumentation
- * ACP (Agent Client Protocol) server entry for the Gaunt Sloth deep agent.
- *
- * This is a parallel front-door to the AG-UI server ({@link startAgUiServer}); both expose
- * the SAME {@link GthDeepAgent}. AG-UI stays the robot-controller path; ACP is an additional
- * way to drive Galvanized Pukeko from an ACP host (Zed, JetBrains, a future Pukeko client).
- *
- * It reuses {@link GthDeepAgent.buildDeepAgentParams} so tool resolution (with the filesystem
- * disabled so deepagents owns fs access), the `.aiignore`/filesystem→permission mapping and the
- * fs-denial-softening middleware are identical to the local runner path. `deepagents-acp`
- * supplies the rest of the coding-agent surface itself: a per-session `ACPFilesystemBackend`
- * (proxying reads/writes through the ACP client so unsaved editor buffers are visible), the
- * checkpointer, interactive `session/request_permission` gating, and tool-call/plan reporting.
- */
-import type { GthConfig } from '@gaunt-sloth/core/config.js';
-import type { GthCommand } from '@gaunt-sloth/core/core/types.js';
-export interface StartAcpServerOptions {
-    /** Agent name advertised to the ACP client (used for session routing). */
-    name?: string;
-    /** Human-readable description shown to ACP clients when listing agents. */
-    description?: string;
-    /** gsloth command whose config/prompt to apply (defaults to `'code'`, the full-fs agent). */
-    command?: GthCommand;
-}
-/**
- * Start the Gaunt Sloth deep agent as an ACP server over stdio.
- *
- * Resolves once the stdio transport is listening; the process then stays alive serving the
- * ACP host until it is terminated. The returned promise rejecting means startup failed.
- *
- * NOTE: deepagents-acp 0.1.12 does NOT forward `permissions` to `createDeepAgent` — on the ACP
- * path fs gating is delegated to the host's interactive permission prompts, not gsloth's
- * `.aiignore`→permissions mapping. `permissions` is still passed here for forward-compatibility.
- * EXT-13 caveat: the ACP backend keeps `virtualMode` ON (`/` = workspace, see gthAcpServer), while
- * EXT-13 re-anchored gsloth's default permissions at the REAL absolute cwd for the local runner. So
- * if a future deepagents-acp DOES forward these rules they would not match the virtual `/`-rooted
- * paths the ACP backend hands them — revisit the mapping (or the ACP backend's mode) at that point.
- */
-export declare function startAcpServer(config: GthConfig, options?: StartAcpServerOptions): Promise<void>;

package/dist/modules/acpModule.js

@@ -1,70 +0,0 @@
-/**
- * @packageDocumentation
- * ACP (Agent Client Protocol) server entry for the Gaunt Sloth deep agent.
- *
- * This is a parallel front-door to the AG-UI server ({@link startAgUiServer}); both expose
- * the SAME {@link GthDeepAgent}. AG-UI stays the robot-controller path; ACP is an additional
- * way to drive Galvanized Pukeko from an ACP host (Zed, JetBrains, a future Pukeko client).
- *
- * It reuses {@link GthDeepAgent.buildDeepAgentParams} so tool resolution (with the filesystem
- * disabled so deepagents owns fs access), the `.aiignore`/filesystem→permission mapping and the
- * fs-denial-softening middleware are identical to the local runner path. `deepagents-acp`
- * supplies the rest of the coding-agent surface itself: a per-session `ACPFilesystemBackend`
- * (proxying reads/writes through the ACP client so unsaved editor buffers are visible), the
- * checkpointer, interactive `session/request_permission` gating, and tool-call/plan reporting.
- */
-import { getProcessCwd, stderr } from '@gaunt-sloth/core/utils/systemUtils.js';
-import { debugLog } from '@gaunt-sloth/core/utils/debugUtils.js';
-import { GthDeepAgent } from '#src/core/GthDeepAgent.js';
-import { startGthAcpServer } from '#src/core/gthAcpServer.js';
-import { createResolvers } from '#src/resolvers.js';
-/**
- * ACP-side status routing: the ACP protocol owns stdout (JSON-RPC framing), so agent
- * status/info must never touch it. Route everything to stderr.
- */
-const acpStatusUpdate = (_level, message) => {
-    stderr.write(`${message}\n`);
-};
-/**
- * Start the Gaunt Sloth deep agent as an ACP server over stdio.
- *
- * Resolves once the stdio transport is listening; the process then stays alive serving the
- * ACP host until it is terminated. The returned promise rejecting means startup failed.
- *
- * NOTE: deepagents-acp 0.1.12 does NOT forward `permissions` to `createDeepAgent` — on the ACP
- * path fs gating is delegated to the host's interactive permission prompts, not gsloth's
- * `.aiignore`→permissions mapping. `permissions` is still passed here for forward-compatibility.
- * EXT-13 caveat: the ACP backend keeps `virtualMode` ON (`/` = workspace, see gthAcpServer), while
- * EXT-13 re-anchored gsloth's default permissions at the REAL absolute cwd for the local runner. So
- * if a future deepagents-acp DOES forward these rules they would not match the virtual `/`-rooted
- * paths the ACP backend hands them — revisit the mapping (or the ACP backend's mode) at that point.
- */
-export async function startAcpServer(config, options = {}) {
-    const command = options.command ?? 'code';
-    const agent = new GthDeepAgent(acpStatusUpdate, createResolvers());
-    const params = await agent.buildDeepAgentParams(command, config);
-    // gsloth's composed system prompt (backstory + guidelines + per-command mode prompt + system
-    // prompt) comes back on `params.systemPrompt` — the SAME prompt the local runner passes to
-    // createDeepAgent. ACP has no per-turn hook, so it sets the agent's `systemPrompt` here.
-    const systemPrompt = params.systemPrompt;
-    // workspaceRoot is only the startup default: startGthAcpServer re-roots the filesystem backend
-    // to each ACP session's `cwd` (the IDE's project root). Use the raw process cwd, not
-    // getCurrentWorkDir() — its INIT_CWD preference leaks stale paths into this long-lived subprocess.
-    const workspaceRoot = getProcessCwd();
-    debugLog(`Starting ACP server (command: ${command}, startup workspace: ${workspaceRoot})`);
-    await startGthAcpServer({
-        agents: {
-            name: options.name ?? 'gaunt-sloth',
-            description: options.description ?? 'Gaunt Sloth deep coding agent',
-            model: params.model,
-            tools: params.tools,
-            systemPrompt,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            middleware: params.middleware,
-            // Forward-compat: ignored by deepagents-acp 0.1.12 (the host gates fs interactively).
-            permissions: params.permissions,
-        },
-        workspaceRoot,
-    });
-}
-//# sourceMappingURL=acpModule.js.map

package/dist/modules/acpModule.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"acpModule.js","sourceRoot":"","sources":["../../src/modules/acpModule.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,wCAAwC,CAAC;AAC/E,OAAO,EAAE,QAAQ,EAAE,MAAM,uCAAuC,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAWpD;;;GAGG;AACH,MAAM,eAAe,GAAyB,CAAC,MAAmB,EAAE,OAAe,EAAQ,EAAE;IAC3F,MAAM,CAAC,KAAK,CAAC,GAAG,OAAO,IAAI,CAAC,CAAC;AAC/B,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,MAAiB,EACjB,UAAiC,EAAE;IAEnC,MAAM,OAAO,GAAe,OAAO,CAAC,OAAO,IAAI,MAAM,CAAC;IAEtD,MAAM,KAAK,GAAG,IAAI,YAAY,CAAC,eAAe,EAAE,eAAe,EAAE,CAAC,CAAC;IACnE,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,oBAAoB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAEjE,6FAA6F;IAC7F,2FAA2F;IAC3F,yFAAyF;IACzF,MAAM,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;IAEzC,+FAA+F;IAC/F,qFAAqF;IACrF,mGAAmG;IACnG,MAAM,aAAa,GAAG,aAAa,EAAE,CAAC;IACtC,QAAQ,CAAC,iCAAiC,OAAO,wBAAwB,aAAa,GAAG,CAAC,CAAC;IAE3F,MAAM,iBAAiB,CAAC;QACtB,MAAM,EAAE;YACN,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,aAAa;YACnC,WAAW,EAAE,OAAO,CAAC,WAAW,IAAI,+BAA+B;YACnE,KAAK,EAAE,MAAM,CAAC,KAAK;YACnB,KAAK,EAAE,MAAM,CAAC,KAAK;YACnB,YAAY;YACZ,8DAA8D;YAC9D,UAAU,EAAE,MAAM,CAAC,UAAiB;YACpC,sFAAsF;YACtF,WAAW,EAAE,MAAM,CAAC,WAAW;SAChC;QACD,aAAa;KACd,CAAC,CAAC;AACL,CAAC"}

package/dist/tools/shell/allowlist.d.ts

@@ -1,11 +0,0 @@
-/**
- * @module tools/shell/allowlist
- *
- * Re-export of the EXT-9 Tier-2 allow-list engine. The implementation lives in
- * `@gaunt-sloth/core` (`core/shell/allowlist`) because the core {@link GthAgentRunner}
- * owns the per-instance session store and the loaded persisted store and consults
- * `matchesApproval` before prompting (core cannot import from `@gaunt-sloth/agent`).
- *
- * See the core module for the exact safe-bin / anti-widening matching rule.
- */
-export { matchesApproval, hasWideningFlag, AllowlistStore, PersistedAllowlist, type ApprovalScope, type ApprovalStores, } from '@gaunt-sloth/core/core/shell/allowlist.js';

package/dist/tools/shell/allowlist.js

@@ -1,12 +0,0 @@
-/**
- * @module tools/shell/allowlist
- *
- * Re-export of the EXT-9 Tier-2 allow-list engine. The implementation lives in
- * `@gaunt-sloth/core` (`core/shell/allowlist`) because the core {@link GthAgentRunner}
- * owns the per-instance session store and the loaded persisted store and consults
- * `matchesApproval` before prompting (core cannot import from `@gaunt-sloth/agent`).
- *
- * See the core module for the exact safe-bin / anti-widening matching rule.
- */
-export { matchesApproval, hasWideningFlag, AllowlistStore, PersistedAllowlist, } from '@gaunt-sloth/core/core/shell/allowlist.js';
-//# sourceMappingURL=allowlist.js.map

package/dist/tools/shell/allowlist.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"allowlist.js","sourceRoot":"","sources":["../../../src/tools/shell/allowlist.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,eAAe,EACf,eAAe,EACf,cAAc,EACd,kBAAkB,GAGnB,MAAM,2CAA2C,CAAC"}

package/dist/tools/shell/arity.d.ts

@@ -1,11 +0,0 @@
-/**
- * @module tools/shell/arity
- *
- * Re-export of the EXT-9 Tier-2 command classifier. The implementation lives in
- * `@gaunt-sloth/core` (`core/shell/arity`) because the core {@link GthAgentRunner}
- * must consult it BEFORE prompting (and core cannot import from `@gaunt-sloth/agent`).
- * This stable agent-side path is kept for tests and any agent-layer consumers.
- *
- * See the core module for the arity table scope and the anti-injection fail-closed rule.
- */
-export { classifyCommand, tokenize, meaningfulPrefixTokens, type CommandClassification, } from '@gaunt-sloth/core/core/shell/arity.js';

package/dist/tools/shell/arity.js

@@ -1,12 +0,0 @@
-/**
- * @module tools/shell/arity
- *
- * Re-export of the EXT-9 Tier-2 command classifier. The implementation lives in
- * `@gaunt-sloth/core` (`core/shell/arity`) because the core {@link GthAgentRunner}
- * must consult it BEFORE prompting (and core cannot import from `@gaunt-sloth/agent`).
- * This stable agent-side path is kept for tests and any agent-layer consumers.
- *
- * See the core module for the arity table scope and the anti-injection fail-closed rule.
- */
-export { classifyCommand, tokenize, meaningfulPrefixTokens, } from '@gaunt-sloth/core/core/shell/arity.js';
-//# sourceMappingURL=arity.js.map

package/dist/tools/shell/arity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"arity.js","sourceRoot":"","sources":["../../../src/tools/shell/arity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,eAAe,EACf,QAAQ,EACR,sBAAsB,GAEvB,MAAM,uCAAuC,CAAC"}

package/dist/tools/shell/hardline.d.ts

@@ -1,15 +0,0 @@
-/**
- * Hardline patterns: [regex, human description]. Matched case-insensitively
- * against the normalized command.
- */
-export declare const HARDLINE_PATTERNS: ReadonlyArray<readonly [RegExp, string]>;
-export interface HardlineMatch {
-    /** Human-readable reason the command was refused. */
-    description: string;
-}
-/**
- * Check a raw command against the hardline blocklist. Normalizes first so
- * obfuscated variants are caught. Returns the match (with a description) when the
- * command is catastrophic, or `null` when it is allowed to proceed.
- */
-export declare function checkHardline(command: string): HardlineMatch | null;