looply-cli 0.0.0-stage → 0.3.0

package/dist/mcp-server.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_MCP_LINE_CHARS = exports.MCP_SERVER_NAME = exports.MCP_PROTOCOL_VERSION = void 0;
+exports.qualifiedToolName = qualifiedToolName;
+exports.makeMcpServer = makeMcpServer;
+exports.lineSplitter = lineSplitter;
+const tool_protocol_1 = require("./tool-protocol");
+const core_1 = require("@looply/core");
+/**
+ * THE PROTOCOL THE PROVIDER ALREADY SPEAKS.
+ *
+ * The provider transport runs outside the container and holds the model; the
+ * tools it may call are served from here, over its own MCP client. That choice
+ * is what keeps ONE provider invocation one provider invocation: the model can
+ * call twenty tools inside a single session, and none of them costs another
+ * model call.
+ *
+ * The alternative — ask the model for one tool request, kill it, run the tool,
+ * ask again — would multiply provider calls, change what a round costs and
+ * break the Phase-6 assumption that a round's budget counts invocations.
+ *
+ * JSON-RPC 2.0, newline-delimited, over stdio. No port, no listener, no
+ * ambient IPC anyone else on this machine could reach: the server lives and
+ * dies with the pipe the provider handed it.
+ *
+ * IMPLEMENTED HERE RATHER THAN TAKEN AS A DEPENDENCY. The surface actually
+ * needed is `initialize`, `tools/list` and `tools/call`, and adding a package
+ * to the tree to get three methods would be a supply-chain decision taken for
+ * convenience.
+ */
+exports.MCP_PROTOCOL_VERSION = '2024-11-05';
+exports.MCP_SERVER_NAME = 'looply';
+/** How the provider will name these tools once it has them. */
+function qualifiedToolName(tool) {
+    return `mcp__${exports.MCP_SERVER_NAME}__${tool}`;
+}
+const SCHEMAS = {
+    read: {
+        description: 'Read a UTF-8 text file from the project. Paths are project-relative. Large files come back truncated.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Project-relative path.' },
+                fromLine: { type: 'integer', minimum: 1, description: 'First line, 1-based and inclusive.' },
+                toLine: { type: 'integer', minimum: 1, description: 'Last line, 1-based and inclusive.' },
+            },
+            required: ['path'],
+            additionalProperties: false,
+        },
+    },
+    glob: {
+        description: 'List project files matching a glob such as "src/**/*.ts". Paths are project-relative.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string' },
+                under: { type: 'string', description: 'Project-relative subdirectory to search under.' },
+            },
+            required: ['pattern'],
+            additionalProperties: false,
+        },
+    },
+    grep: {
+        description: 'Search project files for a regular expression. Returns "path:line:text", bounded in number.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'A JavaScript regular expression.' },
+                include: { type: 'string', description: 'Only search paths matching this glob.' },
+                under: { type: 'string' },
+                ignoreCase: { type: 'boolean' },
+            },
+            required: ['pattern'],
+            additionalProperties: false,
+        },
+    },
+    edit: {
+        description: 'Replace exact text in a project file. The edit states how many occurrences it expects and fails if the file does not match, so re-applying it is safe.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string' },
+                oldText: { type: 'string', description: 'The exact text as it is now.' },
+                newText: { type: 'string' },
+                expected: { type: 'integer', minimum: 1, description: 'Occurrences expected. Defaults to 1.' },
+            },
+            required: ['path', 'oldText', 'newText'],
+            additionalProperties: false,
+        },
+    },
+    write: {
+        description: 'Write a whole UTF-8 text file in the project. "create" refuses to overwrite; "overwrite" requires the file to exist.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string' },
+                contents: { type: 'string', maxLength: tool_protocol_1.LIMITS.writeBytes },
+                intent: { type: 'string', enum: ['create', 'overwrite'] },
+            },
+            required: ['path', 'contents', 'intent'],
+            additionalProperties: false,
+        },
+    },
+};
+/**
+ * One MCP session over a line-oriented transport.
+ *
+ * `handleLine` is deliberately the whole surface: it takes one JSON-RPC message
+ * and produces whatever should be sent back, which makes the protocol testable
+ * without a process, a pipe or a provider.
+ */
+function makeMcpServer(bridge, policy, deps) {
+    const reply = (id, result) => {
+        deps.send(JSON.stringify({ jsonrpc: '2.0', id, result }));
+    };
+    const replyError = (id, code, message) => {
+        deps.send(JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } }));
+    };
+    const handleLine = async (line) => {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        }
+        catch {
+            // No id to answer against, so there is nobody to tell. Dropping a
+            // malformed frame is the only thing JSON-RPC allows here.
+            return;
+        }
+        const id = msg.id ?? null;
+        const method = msg.method ?? '';
+        if (method === 'initialize') {
+            reply(id, {
+                protocolVersion: exports.MCP_PROTOCOL_VERSION,
+                capabilities: { tools: {} },
+                serverInfo: { name: exports.MCP_SERVER_NAME, version: '1.0.0' },
+            });
+            return;
+        }
+        // Notifications carry no id and get no answer, by the specification.
+        if (method.startsWith('notifications/'))
+            return;
+        if (method === 'tools/list') {
+            reply(id, {
+                tools: tool_protocol_1.TOOL_NAMES.filter((t) => policy.tools.includes(t)).map((t) => ({
+                    name: t,
+                    description: SCHEMAS[t].description,
+                    inputSchema: SCHEMAS[t].inputSchema,
+                })),
+            });
+            return;
+        }
+        if (method === 'tools/call') {
+            const params = msg.params ?? {};
+            const name = String(params['name'] ?? '');
+            const args = (params['arguments'] ?? {});
+            // The tool name is a MODEL-SUPPLIED STRING. It selects among the tools
+            // this role has, and nothing else: it cannot name an executable, a root,
+            // or a tool the policy withheld.
+            const out = await bridge.call({ ...args, tool: name });
+            if (out.ok) {
+                /**
+                 * THE LAST TRUSTED POINT BEFORE THE MODEL, which is why the note is added
+                 * here and not in the worker — the worker runs inside the container.
+                 *
+                 * Two things the transport does not say (the audit’s A-09): whose words
+                 * these are, and whether they were cut short. `truncated` was computed by
+                 * the worker for every result that can overrun a limit and then dropped on
+                 * this line, so a file that stopped at the limit read exactly like a file
+                 * that ended.
+                 *
+                 * ⚠️ The record M7-2 keeps is written from the RESPONSE, upstream of this,
+                 * so it still reports what the file served rather than what the note added.
+                 */
+                reply(id, {
+                    content: [{ type: 'text', text: (0, core_1.servedText)(out) }],
+                    isError: false,
+                });
+            }
+            else {
+                // A REFUSAL IS A RESULT, not a transport error. The model is meant to
+                // be told "no" and carry on; a JSON-RPC error would end the session
+                // instead, and an agent that cannot be refused is an agent that must
+                // never be wrong.
+                reply(id, {
+                    content: [{ type: 'text', text: `${out.code}: ${out.because}` }],
+                    isError: true,
+                });
+            }
+            return;
+        }
+        if (id !== null)
+            replyError(id, -32601, `no such method: ${method}`);
+    };
+    return { handleLine };
+}
+/**
+ * How long one protocol line may get before it is refused.
+ *
+ * 🔴 THE BUFFER WAS UNBOUNDED, AND THE PEER IS THE UNCONTAINED PROVIDER.
+ *
+ * `held` grew with every chunk and was only ever drained by a newline, so a
+ * peer that sends bytes and never a newline grows the TRUSTED bridge's heap
+ * until it dies. Everything else about this transport is careful — the model
+ * gets no host tools, every tool call executes inside a container — and none of
+ * that helps against a peer that simply never stops talking.
+ *
+ * A megabyte, from the shape of the traffic rather than from taste: a line here
+ * is one JSON-RPC message, and the largest real one is a tool RESULT carrying
+ * at most `LIMITS.readBytes` (256 KB) of file content plus its envelope. Four
+ * times the largest legitimate message.
+ */
+exports.MAX_MCP_LINE_CHARS = 1024 * 1024;
+/**
+ * Split a growing buffer into complete lines, keeping the remainder.
+ *
+ * 🔴 A LINE OVER THE BOUND IS DISCARDED, NOT TRUNCATED AND NOT FATAL.
+ *
+ * Truncating would hand the parser half a JSON message, which is a different
+ * message rather than a shorter one. Throwing would let a peer kill the bridge
+ * by sending one long line — trading a memory exhaustion for a denial of
+ * service. So the splitter drops the oversized line, RESYNCHRONISES at the next
+ * newline, and says it happened; the peer's other messages keep working.
+ */
+function lineSplitter(maxChars = exports.MAX_MCP_LINE_CHARS, onOverflow) {
+    let held = '';
+    // True while discarding the remainder of a line that already went over.
+    let skipping = false;
+    return (chunk) => {
+        held += chunk;
+        const out = [];
+        for (;;) {
+            const nl = held.indexOf(String.fromCharCode(10));
+            if (nl === -1)
+                break;
+            const line = held.slice(0, nl);
+            held = held.slice(nl + 1);
+            if (skipping) {
+                // The tail of an oversized line. Its start is already gone, so the rest
+                // is not a message and must not be handed on as one.
+                skipping = false;
+                continue;
+            }
+            out.push(line);
+        }
+        if (held.length > maxChars) {
+            // No newline in sight and already over: drop what is held and keep
+            // dropping until one arrives.
+            if (!skipping)
+                onOverflow?.(held.length);
+            skipping = true;
+            held = '';
+        }
+        return out;
+    };
+}
+//# sourceMappingURL=mcp-server.js.map

package/dist/mcp-server.js.map

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

package/dist/model-routing.d.ts

@@ -0,0 +1,75 @@
+/**
+ * WHICH MODEL EACH ROLE RUNS, AND HOW HARD.
+ *
+ * Four roles drive a model: the implementer writes the change, the verifier
+ * checks an item against the code, the scanner fills the queue, and the brain
+ * plans — compiling a goal, judging a goal gap. Until this existed every one of
+ * them ran whatever the provider's own default happened to be: `claudeMediatedArgv`
+ * passed no `--model` at all, so a configuration file had no way to say that a
+ * round's three agents and the planner should be different models, or that a
+ * round should think as hard as it can.
+ *
+ * ⚠️ THE BUILT-IN PROVIDER ONLY. These become `--model` and `--effort` on the
+ * mediated Claude Code invocation. A configured `agent.command` is somebody
+ * else's binary and looply cannot guess the flag it takes for a model — exactly
+ * the reason `agent.no_host_tools` has to be declared rather than inferred — so
+ * for that branch this is documented as ignored, the way `agent.executable` is.
+ *
+ * 🔴 FABLE IS THE BRAIN, NEVER AN AGENT. The operator's standing rule, and a
+ * cost rule with a shape: the brain runs rarely and is where the most capable
+ * model earns its price; an agent turn runs every round of a 400-round night,
+ * and Fable bills at twice Opus per token. A file that names a Fable model for
+ * `default`, `implementer`, `verifier` or `scanner` is refused at config-load
+ * time, before a run starts, with the reason — not at round one after the first
+ * call has been paid for.
+ */
+/** The roles that drive a model, in the order a round meets them. */
+export declare const MODEL_ROLES: readonly ["implementer", "verifier", "scanner", "brain"];
+export type ModelRole = (typeof MODEL_ROLES)[number];
+/** The keys `agent.models` may carry: every role, plus the one that covers the rest. */
+export declare const MODEL_KEYS: readonly ["default", "implementer", "verifier", "scanner", "brain"];
+export type ModelKey = (typeof MODEL_KEYS)[number];
+/** `--effort`, as Claude Code spells it. Checked against `claude --help` on 2026-09-13. */
+export declare const EFFORT_LEVELS: readonly ["low", "medium", "high", "xhigh", "max"];
+export type Effort = (typeof EFFORT_LEVELS)[number];
+/**
+ * Role → model id. `default` covers any role not named; a role named here wins.
+ * Every value is one model id, passed as one argument — never a flag string.
+ */
+export type RoleModels = Partial<Record<ModelKey, string>>;
+/**
+ * Which model ids may only be the brain's.
+ *
+ * Matched on the family name rather than pinned to one id, so a later Fable
+ * release is covered the day it ships rather than the day somebody remembers
+ * this list. Case-insensitive because a model id is not, and a person typing
+ * one should not be able to step around a cost rule with a capital letter.
+ */
+export declare function isBrainOnlyModel(model: string): boolean;
+/** The model a role runs under this configuration, or undefined to leave it to the provider. */
+export declare function modelFor(role: ModelRole, models: RoleModels | undefined): string | undefined;
+/**
+ * The arguments that put a role on its model, ready to splice into a Claude
+ * Code command line. Empty when nothing is configured, so a project that says
+ * nothing about models produces the byte-identical invocation it did before.
+ */
+export declare function modelArgs(role: ModelRole, spec: {
+    models?: RoleModels;
+    effort?: Effort;
+}): string[];
+export type RoleModelsCheck = {
+    ok: true;
+} | {
+    ok: false;
+    key: string;
+    because: string;
+};
+/**
+ * Is this `agent.models` block one looply will drive?
+ *
+ * Pure, so `parseConfig` can refuse the file and `looply doctor` can name the
+ * key, from one rule. Each refusal names the exact key, because "invalid
+ * agent.models" is a sentence nobody can act on.
+ */
+export declare function checkRoleModels(models: RoleModels): RoleModelsCheck;
+//# sourceMappingURL=model-routing.d.ts.map

package/dist/model-routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-routing.d.ts","sourceRoot":"","sources":["../src/model-routing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,qEAAqE;AACrE,eAAO,MAAM,WAAW,0DAA2D,CAAC;AACpF,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAErD,wFAAwF;AACxF,eAAO,MAAM,UAAU,qEAAuC,CAAC;AAC/D,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnD,2FAA2F;AAC3F,eAAO,MAAM,aAAa,oDAAqD,CAAC;AAChF,MAAM,MAAM,MAAM,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAEpD;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC;AAE3D;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,gGAAgG;AAChG,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAE5F;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,SAAS,EACf,IAAI,EAAE;IAAE,MAAM,CAAC,EAAE,UAAU,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7C,MAAM,EAAE,CAMV;AAED,MAAM,MAAM,eAAe,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzF;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,UAAU,GAAG,eAAe,CAiCnE"}

package/dist/model-routing.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * WHICH MODEL EACH ROLE RUNS, AND HOW HARD.
+ *
+ * Four roles drive a model: the implementer writes the change, the verifier
+ * checks an item against the code, the scanner fills the queue, and the brain
+ * plans — compiling a goal, judging a goal gap. Until this existed every one of
+ * them ran whatever the provider's own default happened to be: `claudeMediatedArgv`
+ * passed no `--model` at all, so a configuration file had no way to say that a
+ * round's three agents and the planner should be different models, or that a
+ * round should think as hard as it can.
+ *
+ * ⚠️ THE BUILT-IN PROVIDER ONLY. These become `--model` and `--effort` on the
+ * mediated Claude Code invocation. A configured `agent.command` is somebody
+ * else's binary and looply cannot guess the flag it takes for a model — exactly
+ * the reason `agent.no_host_tools` has to be declared rather than inferred — so
+ * for that branch this is documented as ignored, the way `agent.executable` is.
+ *
+ * 🔴 FABLE IS THE BRAIN, NEVER AN AGENT. The operator's standing rule, and a
+ * cost rule with a shape: the brain runs rarely and is where the most capable
+ * model earns its price; an agent turn runs every round of a 400-round night,
+ * and Fable bills at twice Opus per token. A file that names a Fable model for
+ * `default`, `implementer`, `verifier` or `scanner` is refused at config-load
+ * time, before a run starts, with the reason — not at round one after the first
+ * call has been paid for.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EFFORT_LEVELS = exports.MODEL_KEYS = exports.MODEL_ROLES = void 0;
+exports.isBrainOnlyModel = isBrainOnlyModel;
+exports.modelFor = modelFor;
+exports.modelArgs = modelArgs;
+exports.checkRoleModels = checkRoleModels;
+/** The roles that drive a model, in the order a round meets them. */
+exports.MODEL_ROLES = ['implementer', 'verifier', 'scanner', 'brain'];
+/** The keys `agent.models` may carry: every role, plus the one that covers the rest. */
+exports.MODEL_KEYS = ['default', ...exports.MODEL_ROLES];
+/** `--effort`, as Claude Code spells it. Checked against `claude --help` on 2026-09-13. */
+exports.EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
+/**
+ * Which model ids may only be the brain's.
+ *
+ * Matched on the family name rather than pinned to one id, so a later Fable
+ * release is covered the day it ships rather than the day somebody remembers
+ * this list. Case-insensitive because a model id is not, and a person typing
+ * one should not be able to step around a cost rule with a capital letter.
+ */
+function isBrainOnlyModel(model) {
+    return /fable/i.test(model);
+}
+/** The model a role runs under this configuration, or undefined to leave it to the provider. */
+function modelFor(role, models) {
+    return models?.[role] ?? models?.default;
+}
+/**
+ * The arguments that put a role on its model, ready to splice into a Claude
+ * Code command line. Empty when nothing is configured, so a project that says
+ * nothing about models produces the byte-identical invocation it did before.
+ */
+function modelArgs(role, spec) {
+    const out = [];
+    const model = modelFor(role, spec.models);
+    if (model !== undefined)
+        out.push('--model', model);
+    if (spec.effort !== undefined)
+        out.push('--effort', spec.effort);
+    return out;
+}
+/**
+ * Is this `agent.models` block one looply will drive?
+ *
+ * Pure, so `parseConfig` can refuse the file and `looply doctor` can name the
+ * key, from one rule. Each refusal names the exact key, because "invalid
+ * agent.models" is a sentence nobody can act on.
+ */
+function checkRoleModels(models) {
+    for (const [key, model] of Object.entries(models)) {
+        if (!exports.MODEL_KEYS.includes(key)) {
+            return {
+                ok: false,
+                key: `agent.models.${key}`,
+                because: `unknown role "${key}" — one of ${exports.MODEL_KEYS.join(', ')}`,
+            };
+        }
+        if (typeof model !== 'string' || model.trim() === '') {
+            return { ok: false, key: `agent.models.${key}`, because: 'must be a model id' };
+        }
+        // One argument. A value with a space in it is a flag string somebody hoped
+        // would be split, and `spawn` does not split.
+        if (/\s/.test(model)) {
+            return {
+                ok: false,
+                key: `agent.models.${key}`,
+                because: `must be a single model id, not "${model}" — it is passed as one argument`,
+            };
+        }
+        if (key !== 'brain' && isBrainOnlyModel(model)) {
+            return {
+                ok: false,
+                key: `agent.models.${key}`,
+                because: `names ${model}, which looply runs only as the brain. ` +
+                    'An agent turn runs every round; the brain plans, rarely, and is where that model ' +
+                    'earns its price. Name it under agent.models.brain and give the agents an Opus-tier model.',
+            };
+        }
+    }
+    return { ok: true };
+}
+//# sourceMappingURL=model-routing.js.map

package/dist/model-routing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-routing.js","sourceRoot":"","sources":["../src/model-routing.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;;;AA4BH,4CAEC;AAGD,4BAEC;AAOD,8BASC;AAWD,0CAiCC;AA7FD,qEAAqE;AACxD,QAAA,WAAW,GAAG,CAAC,aAAa,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,CAAU,CAAC;AAGpF,wFAAwF;AAC3E,QAAA,UAAU,GAAG,CAAC,SAAS,EAAE,GAAG,mBAAW,CAAU,CAAC;AAG/D,2FAA2F;AAC9E,QAAA,aAAa,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAU,CAAC;AAShF;;;;;;;GAOG;AACH,SAAgB,gBAAgB,CAAC,KAAa;IAC5C,OAAO,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC9B,CAAC;AAED,gGAAgG;AAChG,SAAgB,QAAQ,CAAC,IAAe,EAAE,MAA8B;IACtE,OAAO,MAAM,EAAE,CAAC,IAAI,CAAC,IAAI,MAAM,EAAE,OAAO,CAAC;AAC3C,CAAC;AAED;;;;GAIG;AACH,SAAgB,SAAS,CACvB,IAAe,EACf,IAA8C;IAE9C,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1C,IAAI,KAAK,KAAK,SAAS;QAAE,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IACpD,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS;QAAE,GAAG,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACjE,OAAO,GAAG,CAAC;AACb,CAAC;AAID;;;;;;GAMG;AACH,SAAgB,eAAe,CAAC,MAAkB;IAChD,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAClD,IAAI,CAAE,kBAAgC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACrD,OAAO;gBACL,EAAE,EAAE,KAAK;gBACT,GAAG,EAAE,gBAAgB,GAAG,EAAE;gBAC1B,OAAO,EAAE,iBAAiB,GAAG,cAAc,kBAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;aACnE,CAAC;QACJ,CAAC;QACD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YACrD,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,gBAAgB,GAAG,EAAE,EAAE,OAAO,EAAE,oBAAoB,EAAE,CAAC;QAClF,CAAC;QACD,2EAA2E;QAC3E,8CAA8C;QAC9C,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACrB,OAAO;gBACL,EAAE,EAAE,KAAK;gBACT,GAAG,EAAE,gBAAgB,GAAG,EAAE;gBAC1B,OAAO,EAAE,mCAAmC,KAAK,kCAAkC;aACpF,CAAC;QACJ,CAAC;QACD,IAAI,GAAG,KAAK,OAAO,IAAI,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;YAC/C,OAAO;gBACL,EAAE,EAAE,KAAK;gBACT,GAAG,EAAE,gBAAgB,GAAG,EAAE;gBAC1B,OAAO,EACL,SAAS,KAAK,yCAAyC;oBACvD,mFAAmF;oBACnF,2FAA2F;aAC9F,CAAC;QACJ,CAAC;IACH,CAAC;IACD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC;AACtB,CAAC"}

package/dist/model-transport.d.ts

@@ -0,0 +1,188 @@
+import { spawn } from 'node:child_process';
+import { type AgentInvoke, type AgentSpec } from './agent-exec';
+import { checkProviderAuth } from './provider-state';
+import { type ToolRole } from './tool-bridge';
+import type { OwnedChildren } from './owned-children';
+/**
+ * THE MODEL RUNS HERE; THE MODEL'S TOOLS DO NOT.
+ *
+ * Two phases of work established that the packaged provider cannot run inside
+ * an AppContainer — it spawns a child with piped stdio during startup, libuv
+ * implements that as a named pipe, and a container cannot create one — and that
+ * a restricted token cannot withhold the user's own files. So the provider
+ * process runs as the daemon user, and the boundary moves off the process and
+ * onto the CAPABILITY:
+ *
+ *   the model gets no host tools at all. Every capability it can call is a
+ *   Looply MCP tool, and each of those executes inside the container.
+ *
+ * WHAT THIS DOES AND DOES NOT CLAIM. It does not claim the provider binary is
+ * sandboxed — it is not, and a hostile provider executable could read what the
+ * user can read. That is supply-chain containment and belongs to a later phase.
+ * What is true here is narrower and is the Phase-7 property: model-callable
+ * authority is mediated, and Looply hands the transport no governed credential
+ * through its environment, arguments, configuration, working directory, or tool
+ * surface.
+ *
+ * THE FIVE CHANNELS. Those are the five ways authority could leak from Looply
+ * into the transport, and each is closed deliberately here: the environment is
+ * built up rather than inherited, the arguments carry no secret, the MCP config
+ * names only our own bridge, the working directory is sterile, and the provider
+ * state is a credential copy and nothing else.
+ */
+/**
+ * How much of the transport's own output the daemon will hold.
+ *
+ * 🔴 THE PROVIDER IS THE UNCONTAINED PROCESS, AND THIS WAS UNBOUNDED. Every
+ * chunk of its stdout and stderr was appended to one string with no ceiling, so
+ * the process this phase is ABOUT could exhaust the daemon's memory by talking.
+ * The container bounds what a contained child hands back; nothing bounded this,
+ * and this is the one that is not contained.
+ *
+ * ⚠️ THE TAIL IS WHAT MATTERS HERE, WHICH IS THE OPPOSITE OF THE CONTAINED CASE.
+ * A provider's answer is its LAST line — the JSON envelope readers parse with
+ * `.filter(startsWith('{')).pop()` — so dropping the front preserves the answer
+ * and dropping the back would destroy it. A gate step is the other way round,
+ * and `untrusted-exec.ts` keeps both ends for that reason.
+ */
+export declare const MAX_TRANSPORT_OUTPUT_CHARS: number;
+/** How the model's tool calls reach Looply. */
+export interface McpLaunch {
+    /** The server name the provider will qualify tool names with. */
+    name: string;
+    command: string;
+    args: readonly string[];
+}
+/**
+ * The provider's working directory: somewhere with nothing in it.
+ *
+ * NOT THE PROJECT, and this is load-bearing rather than tidy. Even with every
+ * built-in tool disabled, a coding CLI discovers things about the directory it
+ * starts in — configuration, ignore files, repository state. The transport is
+ * meant to learn about the project through the prompt and through tool results,
+ * and through nothing else, so it is started somewhere that has no project in
+ * it to discover.
+ *
+ * Per project and per role, so two sessions never share provider state.
+ */
+export declare function providerSessionDir(projectDir: string, role: ToolRole, home?: string): string;
+/** The MCP configuration the provider is given: exactly one server, ours. */
+export declare function mcpConfigJson(launch: McpLaunch): string;
+/**
+ * Where the bridge entry point lives.
+ *
+ * Beside this file once compiled. Under the test runner this module is loaded
+ * from `src`, where there is no compiled entry — and it must be the compiled
+ * one either way, since that is what the provider will actually spawn. Falling
+ * back to the sibling `dist` keeps the tests driving production's artefact.
+ */
+export declare function mcpMainPath(deps?: ModelTransportDeps): string;
+export interface ModelTransportDeps {
+    /**
+     * The run these invocations belong to, so its budget reservation can be
+     * settled at what it ACTUALLY cost rather than left to expire at an estimate.
+     *
+     * Absent for a `scan` or a `verify`, which are charged as themselves.
+     */
+    runId?: string;
+    /** Overridable so tests can drive a fake MCP-capable provider. */
+    packageDir?: string | null;
+    mcpMain?: string;
+    /** The node that runs the trusted bridge. Defaults to the daemon's own. */
+    bridgeNode?: string;
+    home?: string;
+    format?: 'text' | 'json';
+    now?: () => number;
+    spawnFn?: typeof spawn;
+    /** Overridable so a test can drive the built-in branch without a real provider login. */
+    checkAuth?: typeof checkProviderAuth;
+    /** Overridable for tests; production reads the platform's own shell. */
+    shell?: string;
+}
+/**
+ * The command line for one mediated turn.
+ *
+ * `--tools ""` is the mechanism that matters, and it was read off the installed
+ * CLI rather than assumed: it takes the list of available tools FROM THE
+ * BUILT-IN SET, and an empty value disables all of them. Without it the model
+ * would keep its own Read, Write, Edit, Glob, Grep and Bash, every one of which
+ * runs as the daemon, and the entire bridge would be decoration beside them.
+ *
+ * `--strict-mcp-config` then makes the supplied configuration the only one, so
+ * no server from the user's profile or a plugin becomes a capability by
+ * accident.
+ */
+/**
+ * Whether `spec` names the built-in provider — the one whose `--output-format
+ * json` envelope is written by the CLI around the model's text, rather than a
+ * configured command whose whole stdout is the model's to write. Only the
+ * former's envelope is read for cost, and only the former's is unwrapped by the
+ * round; a configured provider is driven exactly as it always was.
+ */
+export declare function isBuiltInProvider(spec: AgentSpec): boolean;
+export declare function claudeMediatedArgv(launch: McpLaunch, format: 'text' | 'json'): string[];
+/**
+ * Names the model is allowed to call, spelled the way the provider spells them.
+ *
+ * Belt and braces beside `--tools ""`: if a future version changed what an
+ * empty built-in set means, this still names the only acceptable surface.
+ */
+export declare function allowedToolArgs(role: ToolRole, launch: McpLaunch): string[];
+/**
+ * What the BUILT-IN provider is told about how it may load its tools.
+ *
+ * 🔴 WITHOUT THIS THE MODEL HAD NO TOOLS, AND SAID SO WITH FABRICATIONS.
+ * Claude Code can DEFER MCP tool schemas behind its own built-in `ToolSearch`
+ * tool, loading them only when the model asks. Looply passes `--tools ""`,
+ * which removes every built-in — `ToolSearch` with them — so a deferred
+ * `mcp__looply__read` was listed and could never be called. The switch is
+ * remote: the provider's cached flag `tengu_deferred_stub_tool` flipped on
+ * under an UNCHANGED 2.1.208 binary and an unchanged argv.
+ *
+ * MEASURED, LIVE, 2026-09-24: across 95 provider sessions on this profile,
+ * every tool-using session was from 2026-09-15; today three verifier turns in
+ * a row called nothing. Two narrated a tool call as text ("⚡ Tool use:
+ * Bash", then a fabricated `<system-reminder>`) and returned no verdict; the
+ * third, run straight into the binary with the seam out of the path, answered
+ * `stale` citing `src/split.ts:1` — a file that does not exist anywhere in
+ * the tree. A verifier that invents its evidence is worse than one that fails.
+ *
+ * `ENABLE_TOOL_SEARCH=false` is the binary's own switch back to "standard":
+ * MCP tools loaded up front, as they were. It adds NO host tool — the
+ * alternative, letting `ToolSearch` through `--tools`, would be the first
+ * built-in the mediated provider was ever allowed.
+ *
+ * ⚠️ BUILT-IN ONLY. A configured provider is somebody else's binary; it
+ * declares how its own tools are turned off (`no_host_tools`) and is told
+ * nothing it did not ask for.
+ */
+export declare const BUILT_IN_PROVIDER_ENV: Readonly<Record<string, string>>;
+/**
+ * An {@link AgentInvoke} that runs the model outside the container and its
+ * tools inside one.
+ *
+ * Fails closed in every direction it can: no provider runtime, no run; no
+ * bridge, no run; a configured provider that cannot speak the tool protocol,
+ * no run. None of them ever falls back to letting the model touch the host
+ * directly, which is the outcome this whole arc exists to prevent.
+ */
+export declare function makeMediatedAgentRunner(projectDir: string, role: ToolRole, spec?: AgentSpec, deps?: ModelTransportDeps, 
+/**
+ * The registry that stops this outliving the run that started it.
+ *
+ * 🔴 THE LIVE PROVIDER WAS NOT OWNED. The timeout below reaps it, and that
+ * covers a transport that hangs — but not a run that ENDS while one is in
+ * flight. `OwnedChildren` exists for exactly that, its docblock claims "a
+ * Ctrl-C, a `looply stop`" among what it covers, and the one process it most
+ * needed to hold was never adopted into it.
+ *
+ * The hazard is already recorded a few lines below, in `killTree`'s own
+ * docblock: stopping a round mid-turn "left a live stub and a live bridge
+ * behind, still holding a project, for as long as the machine stayed up".
+ * That was observed. This is the half that was missing.
+ *
+ * Optional, so every existing caller and fixture keeps working — but the
+ * production one passes it.
+ */
+owned?: OwnedChildren): AgentInvoke;
+//# sourceMappingURL=model-transport.d.ts.map

package/dist/model-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-transport.d.ts","sourceRoot":"","sources":["../src/model-transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAK3C,OAAO,EAAiB,KAAK,WAAW,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAS/E,OAAO,EAAyB,iBAAiB,EAAsB,MAAM,kBAAkB,CAAC;AAChG,OAAO,EAAiB,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKtD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,0BAA0B,QAAkB,CAAC;AAE1D,+CAA+C;AAC/C,MAAM,WAAW,SAAS;IACxB,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CACzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,GAAE,MAAkB,GAAG,MAAM,CAKvG;AAED,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAMvD;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,IAAI,GAAE,kBAAuB,GAAG,MAAM,CAIjE;AAED,MAAM,WAAW,kBAAkB;IACjC;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2EAA2E;IAC3E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;IACvB,yFAAyF;IACzF,SAAS,CAAC,EAAE,OAAO,iBAAiB,CAAC;IACrC,wEAAwE;IACxE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;GAYG;AACH;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAE1D;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAavF;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,GAAG,MAAM,EAAE,CAG3E;AAkBD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAEjE,CAAC;AAEH;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,QAAQ,EACd,IAAI,GAAE,SAAyB,EAC/B,IAAI,GAAE,kBAAuB;AAC7B;;;;;;;;;;;;;;;;GAgBG;AACH,KAAK,CAAC,EAAE,aAAa,GACpB,WAAW,CA4Wb"}