kennel 0.1.9 → 0.2.1

package/node_modules/@raggle-ai/local/dist/acp/client.d.ts

@@ -0,0 +1,31 @@
+import type { AgentCapabilities, AuthenticateResponse, AuthMethodId, ClientCapabilities, ContentBlock, InitializeResponse, McpServer, PromptResponse, RequestPermissionRequest, RequestPermissionResponse, SessionId, SessionNotification } from "./sdk-types";
+export type AcpAgentProcessOptions = {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    clientCapabilities?: ClientCapabilities;
+    onPermissionRequest?: (request: RequestPermissionRequest) => Promise<RequestPermissionResponse>;
+    onSessionUpdate?: (notification: SessionNotification) => void | Promise<void>;
+    onStderr?: (text: string) => void;
+};
+export type AcpSessionOptions = {
+    cwd: string;
+    additionalDirectories?: string[];
+    mcpServers?: McpServer[];
+};
+export declare class AcpAgentClient {
+    private readonly sdk;
+    private readonly process;
+    private readonly connection;
+    readonly capabilities: AgentCapabilities;
+    readonly initialization: InitializeResponse;
+    private constructor();
+    static connect(options: AcpAgentProcessOptions): Promise<AcpAgentClient>;
+    authenticate(methodId: AuthMethodId): Promise<AuthenticateResponse>;
+    newSession(options: AcpSessionOptions): Promise<import("@agentclientprotocol/sdk").NewSessionResponse>;
+    loadSession(sessionId: SessionId, options: AcpSessionOptions): Promise<import("@agentclientprotocol/sdk").LoadSessionResponse>;
+    prompt(sessionId: SessionId, prompt: string | ContentBlock[]): Promise<PromptResponse>;
+    cancel(sessionId: SessionId): Promise<void>;
+    close(): Promise<void>;
+}

package/node_modules/@raggle-ai/local/dist/acp/client.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcpAgentClient = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_stream_1 = require("node:stream");
+const importAcpSdk = Function("return import('@agentclientprotocol/sdk')");
+class AcpAgentClient {
+    constructor(sdk, process, connection, initialization) {
+        this.sdk = sdk;
+        this.process = process;
+        this.connection = connection;
+        this.initialization = initialization;
+        this.capabilities = initialization.agentCapabilities ?? {};
+    }
+    static async connect(options) {
+        const sdk = await importAcpSdk();
+        const agentProcess = (0, node_child_process_1.spawn)(options.command, options.args ?? [], {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        options.onStderr
+            ? agentProcess.stderr.on("data", (data) => options.onStderr?.(data.toString()))
+            : agentProcess.stderr.resume();
+        const permissionHandler = options.onPermissionRequest ??
+            (async () => ({ outcome: { outcome: "cancelled" } }));
+        const app = sdk
+            .client({ name: "raggle-scout" })
+            .onRequest(sdk.methods.client.session.requestPermission, (context) => permissionHandler(context.params));
+        if (options.onSessionUpdate) {
+            app.onNotification(sdk.methods.client.session.update, (context) => options.onSessionUpdate?.(context.params));
+        }
+        const stream = sdk.ndJsonStream(node_stream_1.Writable.toWeb(agentProcess.stdin), node_stream_1.Readable.toWeb(agentProcess.stdout));
+        const connection = app.connect(stream);
+        agentProcess.once("error", (error) => connection.close(error));
+        agentProcess.once("exit", (code, signal) => {
+            connection.close(new Error(`ACP agent exited (${signal ?? code ?? "unknown"})`));
+        });
+        try {
+            const initialization = await connection.agent.request(sdk.methods.agent.initialize, {
+                protocolVersion: sdk.PROTOCOL_VERSION,
+                clientCapabilities: options.clientCapabilities ?? {},
+                clientInfo: { name: "raggle-scout", version: "0.1.0" },
+            });
+            if (initialization.protocolVersion !== sdk.PROTOCOL_VERSION) {
+                throw new Error(`Unsupported ACP protocol version: ${initialization.protocolVersion}`);
+            }
+            return new AcpAgentClient(sdk, agentProcess, connection, initialization);
+        }
+        catch (error) {
+            connection.close(error);
+            agentProcess.kill();
+            throw error;
+        }
+    }
+    authenticate(methodId) {
+        return this.connection.agent.request(this.sdk.methods.agent.authenticate, { methodId });
+    }
+    async newSession(options) {
+        const request = {
+            cwd: options.cwd,
+            additionalDirectories: options.additionalDirectories,
+            mcpServers: options.mcpServers ?? [],
+        };
+        return this.connection.agent.request(this.sdk.methods.agent.session.new, request);
+    }
+    async loadSession(sessionId, options) {
+        if (!this.capabilities.loadSession)
+            throw new Error("The ACP agent does not support session loading");
+        const request = {
+            sessionId,
+            cwd: options.cwd,
+            additionalDirectories: options.additionalDirectories,
+            mcpServers: options.mcpServers ?? [],
+        };
+        return this.connection.agent.request(this.sdk.methods.agent.session.load, request);
+    }
+    prompt(sessionId, prompt) {
+        const content = typeof prompt === "string" ? [{ type: "text", text: prompt }] : prompt;
+        return this.connection.agent.request(this.sdk.methods.agent.session.prompt, { sessionId, prompt: content });
+    }
+    cancel(sessionId) {
+        return this.connection.agent.notify(this.sdk.methods.agent.session.cancel, { sessionId });
+    }
+    async close() {
+        this.connection.close();
+        if (!this.process.killed)
+            this.process.kill();
+        await this.connection.closed.catch(() => undefined);
+    }
+}
+exports.AcpAgentClient = AcpAgentClient;

package/node_modules/@raggle-ai/local/dist/acp/distributions.d.ts

@@ -0,0 +1,18 @@
+import type { AcpBinaryTarget, AcpBinaryTargetName, AcpRegistryAgent } from "./registry";
+export type AcpAgentDistribution = {
+    kind: "npx";
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+} | {
+    kind: "uvx";
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+} | {
+    kind: "binary";
+    target: AcpBinaryTargetName;
+    binary: AcpBinaryTarget;
+};
+export declare function acpBinaryTargetName(platform?: NodeJS.Platform, architecture?: string): AcpBinaryTargetName | undefined;
+export declare function selectAcpAgentDistribution(agent: AcpRegistryAgent, platform?: NodeJS.Platform, architecture?: string): AcpAgentDistribution | undefined;

package/node_modules/@raggle-ai/local/dist/acp/distributions.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acpBinaryTargetName = acpBinaryTargetName;
+exports.selectAcpAgentDistribution = selectAcpAgentDistribution;
+const node_os_1 = __importDefault(require("node:os"));
+function acpBinaryTargetName(platform = process.platform, architecture = node_os_1.default.arch()) {
+    const platformName = platform === "win32" ? "windows" : platform;
+    const architectureName = architecture === "arm64" ? "aarch64" : architecture === "x64" ? "x86_64" : architecture;
+    const target = `${platformName}-${architectureName}`;
+    const supported = [
+        "darwin-aarch64",
+        "darwin-x86_64",
+        "linux-aarch64",
+        "linux-x86_64",
+        "windows-aarch64",
+        "windows-x86_64",
+    ];
+    return supported.includes(target) ? target : undefined;
+}
+function packageLaunch(kind, distribution, platform) {
+    const command = platform === "win32" ? `${kind}.cmd` : kind;
+    const prefix = kind === "npx" ? ["--yes"] : [];
+    return {
+        kind,
+        command,
+        args: [...prefix, distribution.package, ...(distribution.args ?? [])],
+        env: distribution.env ?? {},
+    };
+}
+function selectAcpAgentDistribution(agent, platform = process.platform, architecture = node_os_1.default.arch()) {
+    if (agent.distribution.npx)
+        return packageLaunch("npx", agent.distribution.npx, platform);
+    if (agent.distribution.uvx)
+        return packageLaunch("uvx", agent.distribution.uvx, platform);
+    const target = acpBinaryTargetName(platform, architecture);
+    const binary = target ? agent.distribution.binary?.[target] : undefined;
+    return target && binary ? { kind: "binary", target, binary } : undefined;
+}

package/node_modules/@raggle-ai/local/dist/acp/index.d.ts

@@ -0,0 +1,4 @@
+export { AcpAgentClient, type AcpAgentProcessOptions, type AcpSessionOptions } from "./client";
+export { acpBinaryTargetName, selectAcpAgentDistribution, type AcpAgentDistribution } from "./distributions";
+export { ACP_REGISTRY_URL, acpRegistryAgent, defaultAcpRegistryCachePath, loadAcpRegistry, parseAcpRegistry, type AcpBinaryTarget, type AcpBinaryTargetName, type AcpPackageDistribution, type AcpRegistry, type AcpRegistryAgent, type AcpRegistryOptions, } from "./registry";
+export type { AgentCapabilities, AuthenticateResponse, AuthMethodId, ClientCapabilities, ContentBlock, InitializeResponse, McpServer, PromptResponse, RequestPermissionRequest, RequestPermissionResponse, SessionId, SessionNotification, } from "./sdk-types";

package/node_modules/@raggle-ai/local/dist/acp/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAcpRegistry = exports.loadAcpRegistry = exports.defaultAcpRegistryCachePath = exports.acpRegistryAgent = exports.ACP_REGISTRY_URL = exports.selectAcpAgentDistribution = exports.acpBinaryTargetName = exports.AcpAgentClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "AcpAgentClient", { enumerable: true, get: function () { return client_1.AcpAgentClient; } });
+var distributions_1 = require("./distributions");
+Object.defineProperty(exports, "acpBinaryTargetName", { enumerable: true, get: function () { return distributions_1.acpBinaryTargetName; } });
+Object.defineProperty(exports, "selectAcpAgentDistribution", { enumerable: true, get: function () { return distributions_1.selectAcpAgentDistribution; } });
+var registry_1 = require("./registry");
+Object.defineProperty(exports, "ACP_REGISTRY_URL", { enumerable: true, get: function () { return registry_1.ACP_REGISTRY_URL; } });
+Object.defineProperty(exports, "acpRegistryAgent", { enumerable: true, get: function () { return registry_1.acpRegistryAgent; } });
+Object.defineProperty(exports, "defaultAcpRegistryCachePath", { enumerable: true, get: function () { return registry_1.defaultAcpRegistryCachePath; } });
+Object.defineProperty(exports, "loadAcpRegistry", { enumerable: true, get: function () { return registry_1.loadAcpRegistry; } });
+Object.defineProperty(exports, "parseAcpRegistry", { enumerable: true, get: function () { return registry_1.parseAcpRegistry; } });

package/node_modules/@raggle-ai/local/dist/acp/registry.d.ts

@@ -0,0 +1,111 @@
+import { z } from "zod";
+export declare const ACP_REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
+declare const packageDistributionSchema: z.ZodObject<{
+    package: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strict>;
+declare const binaryTargetSchema: z.ZodObject<{
+    archive: z.ZodURL;
+    sha256: z.ZodOptional<z.ZodString>;
+    cmd: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strict>;
+declare const binaryTargetNameSchema: z.ZodEnum<{
+    "darwin-aarch64": "darwin-aarch64";
+    "darwin-x86_64": "darwin-x86_64";
+    "linux-aarch64": "linux-aarch64";
+    "linux-x86_64": "linux-x86_64";
+    "windows-aarch64": "windows-aarch64";
+    "windows-x86_64": "windows-x86_64";
+}>;
+declare const registrySchema: z.ZodObject<{
+    version: z.ZodString;
+    agents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        version: z.ZodString;
+        description: z.ZodString;
+        repository: z.ZodOptional<z.ZodURL>;
+        website: z.ZodOptional<z.ZodURL>;
+        authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        license: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        distribution: z.ZodObject<{
+            binary: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+                "darwin-aarch64": "darwin-aarch64";
+                "darwin-x86_64": "darwin-x86_64";
+                "linux-aarch64": "linux-aarch64";
+                "linux-x86_64": "linux-x86_64";
+                "windows-aarch64": "windows-aarch64";
+                "windows-x86_64": "windows-x86_64";
+            }> & z.core.$partial, z.ZodObject<{
+                archive: z.ZodURL;
+                sha256: z.ZodOptional<z.ZodString>;
+                cmd: z.ZodString;
+                args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strict>>>;
+            npx: z.ZodOptional<z.ZodObject<{
+                package: z.ZodString;
+                args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strict>>;
+            uvx: z.ZodOptional<z.ZodObject<{
+                package: z.ZodString;
+                args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$loose>>;
+    extensions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$strict>;
+export type AcpRegistry = z.infer<typeof registrySchema>;
+export type AcpRegistryAgent = AcpRegistry["agents"][number];
+export type AcpPackageDistribution = z.infer<typeof packageDistributionSchema>;
+export type AcpBinaryTarget = z.infer<typeof binaryTargetSchema>;
+export type AcpBinaryTargetName = z.infer<typeof binaryTargetNameSchema>;
+export type AcpRegistryOptions = {
+    cacheMaxAgeMs?: number;
+    cachePath?: string;
+    fetch?: typeof fetch;
+    forceRefresh?: boolean;
+    registryUrl?: string;
+    signal?: AbortSignal;
+};
+export declare function defaultAcpRegistryCachePath(): string;
+export declare function parseAcpRegistry(value: unknown): AcpRegistry;
+export declare function loadAcpRegistry(options?: AcpRegistryOptions): Promise<AcpRegistry>;
+export declare function acpRegistryAgent(registry: AcpRegistry, agentId: string): {
+    [x: string]: unknown;
+    id: string;
+    name: string;
+    version: string;
+    description: string;
+    distribution: {
+        binary?: Partial<Record<"darwin-aarch64" | "darwin-x86_64" | "linux-aarch64" | "linux-x86_64" | "windows-aarch64" | "windows-x86_64", {
+            archive: string;
+            cmd: string;
+            sha256?: string | undefined;
+            args?: string[] | undefined;
+            env?: Record<string, string> | undefined;
+        }>> | undefined;
+        npx?: {
+            package: string;
+            args?: string[] | undefined;
+            env?: Record<string, string> | undefined;
+        } | undefined;
+        uvx?: {
+            package: string;
+            args?: string[] | undefined;
+            env?: Record<string, string> | undefined;
+        } | undefined;
+    };
+    repository?: string | undefined;
+    website?: string | undefined;
+    authors?: string[] | undefined;
+    license?: string | undefined;
+    icon?: string | undefined;
+} | undefined;
+export {};

package/node_modules/@raggle-ai/local/dist/acp/registry.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACP_REGISTRY_URL = void 0;
+exports.defaultAcpRegistryCachePath = defaultAcpRegistryCachePath;
+exports.parseAcpRegistry = parseAcpRegistry;
+exports.loadAcpRegistry = loadAcpRegistry;
+exports.acpRegistryAgent = acpRegistryAgent;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+exports.ACP_REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
+const environmentSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.string());
+const argumentsSchema = zod_1.z.array(zod_1.z.string()).optional();
+const packageDistributionSchema = zod_1.z
+    .object({
+    package: zod_1.z.string().min(1),
+    args: argumentsSchema,
+    env: environmentSchema.optional(),
+})
+    .strict();
+const binaryTargetSchema = zod_1.z
+    .object({
+    archive: zod_1.z.url(),
+    sha256: zod_1.z
+        .string()
+        .regex(/^[a-fA-F0-9]{64}$/)
+        .optional(),
+    cmd: zod_1.z.string().min(1),
+    args: argumentsSchema,
+    env: environmentSchema.optional(),
+})
+    .strict();
+const binaryTargetNameSchema = zod_1.z.enum([
+    "darwin-aarch64",
+    "darwin-x86_64",
+    "linux-aarch64",
+    "linux-x86_64",
+    "windows-aarch64",
+    "windows-x86_64",
+]);
+const binaryDistributionSchema = zod_1.z
+    .partialRecord(binaryTargetNameSchema, binaryTargetSchema)
+    .refine((value) => Object.keys(value).length > 0, "A binary distribution must contain at least one platform target");
+const distributionSchema = zod_1.z
+    .object({
+    binary: binaryDistributionSchema.optional(),
+    npx: packageDistributionSchema.optional(),
+    uvx: packageDistributionSchema.optional(),
+})
+    .strict()
+    .refine((value) => value.binary || value.npx || value.uvx, "An agent must contain a distribution");
+const agentSchema = zod_1.z
+    .object({
+    id: zod_1.z.string().regex(/^[a-z][a-z0-9-]*$/),
+    name: zod_1.z.string().min(1),
+    version: zod_1.z.string().regex(/^[0-9]+\.[0-9]+\.[0-9]+/),
+    description: zod_1.z.string().min(1),
+    repository: zod_1.z.url().optional(),
+    website: zod_1.z.url().optional(),
+    authors: zod_1.z.array(zod_1.z.string()).optional(),
+    license: zod_1.z.string().optional(),
+    icon: zod_1.z.string().optional(),
+    distribution: distributionSchema,
+})
+    .passthrough();
+const registrySchema = zod_1.z
+    .object({
+    version: zod_1.z.string().regex(/^1\.[0-9]+\.[0-9]+$/),
+    agents: zod_1.z.array(agentSchema),
+    // The live v1 registry currently includes this reserved empty collection.
+    extensions: zod_1.z.array(zod_1.z.unknown()).max(0).optional(),
+})
+    .strict()
+    .superRefine((registry, context) => {
+    const ids = new Set();
+    for (const [index, agent] of registry.agents.entries()) {
+        if (ids.has(agent.id)) {
+            context.addIssue({ code: "custom", message: `Duplicate agent id: ${agent.id}`, path: ["agents", index, "id"] });
+        }
+        ids.add(agent.id);
+    }
+});
+function defaultAcpRegistryCachePath() {
+    const cacheDirectory = process.env.XDG_CACHE_HOME ?? node_path_1.default.join(node_os_1.default.homedir(), ".cache");
+    return node_path_1.default.join(cacheDirectory, "raggle", "acp-registry-v1.json");
+}
+function parseAcpRegistry(value) {
+    return registrySchema.parse(value);
+}
+async function readCachedRegistry(cachePath) {
+    const contents = await (0, promises_1.readFile)(cachePath, "utf8");
+    return parseAcpRegistry(JSON.parse(contents));
+}
+async function isFreshCache(cachePath, maxAgeMs) {
+    const cache = await (0, promises_1.stat)(cachePath);
+    return Date.now() - cache.mtimeMs <= maxAgeMs;
+}
+async function writeCachedRegistry(cachePath, registry) {
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(cachePath), { recursive: true });
+    const temporaryPath = `${cachePath}.${process.pid}.tmp`;
+    await (0, promises_1.writeFile)(temporaryPath, `${JSON.stringify(registry)}\n`, "utf8");
+    await (0, promises_1.rename)(temporaryPath, cachePath);
+}
+async function loadAcpRegistry(options = {}) {
+    const cachePath = options.cachePath ?? defaultAcpRegistryCachePath();
+    const cacheMaxAgeMs = options.cacheMaxAgeMs ?? 60 * 60 * 1_000;
+    if (!options.forceRefresh && (await isFreshCache(cachePath, cacheMaxAgeMs).catch(() => false))) {
+        const cached = await readCachedRegistry(cachePath).catch(() => undefined);
+        if (cached)
+            return cached;
+    }
+    try {
+        const response = await (options.fetch ?? fetch)(options.registryUrl ?? exports.ACP_REGISTRY_URL, {
+            headers: { accept: "application/json" },
+            signal: options.signal ?? AbortSignal.timeout(15_000),
+        });
+        if (!response.ok)
+            throw new Error(`ACP registry returned HTTP ${response.status}`);
+        const registry = parseAcpRegistry(await response.json());
+        await writeCachedRegistry(cachePath, registry);
+        return registry;
+    }
+    catch (error) {
+        const cached = await readCachedRegistry(cachePath).catch(() => undefined);
+        if (cached)
+            return cached;
+        const detail = error instanceof Error ? `: ${error.message}` : "";
+        throw new Error(`Cannot load the ACP registry and no valid cached registry is available${detail}`);
+    }
+}
+function acpRegistryAgent(registry, agentId) {
+    return registry.agents.find((agent) => agent.id === agentId);
+}

package/node_modules/@raggle-ai/local/dist/acp/sdk-types.d.ts

@@ -0,0 +1,17 @@
+import type * as Acp from "@agentclientprotocol/sdk" with { "resolution-mode": "import" };
+export type AgentCapabilities = Acp.AgentCapabilities;
+export type AuthenticateResponse = Acp.AuthenticateResponse;
+export type AuthMethodId = Acp.AuthMethodId;
+export type ClientCapabilities = Acp.ClientCapabilities;
+export type ClientConnection = Acp.ClientConnection;
+export type ContentBlock = Acp.ContentBlock;
+export type InitializeResponse = Acp.InitializeResponse;
+export type LoadSessionRequest = Acp.LoadSessionRequest;
+export type McpServer = Acp.McpServer;
+export type NewSessionRequest = Acp.NewSessionRequest;
+export type PromptResponse = Acp.PromptResponse;
+export type RequestPermissionRequest = Acp.RequestPermissionRequest;
+export type RequestPermissionResponse = Acp.RequestPermissionResponse;
+export type SessionId = Acp.SessionId;
+export type SessionNotification = Acp.SessionNotification;
+export type AcpSdk = typeof import("@agentclientprotocol/sdk", { with: { "resolution-mode": "import" } });

package/node_modules/@raggle-ai/local/dist/acp/sdk-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/@raggle-ai/local/dist/adapters/agent-instructions.d.ts

@@ -0,0 +1,100 @@
+import { type AgentInstructionOptions } from "../core/agent-instructions-settings";
+/** Read only this feature's settings, but don't silently discard malformed configuration. */
+export declare function readAgentInstructionSettings(): {
+    schemaVersion: 1;
+    defaultProfile: string;
+    includeGlobal: boolean;
+    maxBytes: number;
+    editor: {
+        mode: "system";
+    } | {
+        mode: "command";
+        executable: string;
+        args: string[];
+    };
+};
+/** A Git worktree boundary (including a .git file) must never inherit a parent's config. */
+export declare function agentInstructionProjectRoot(folder: string): {
+    root: string;
+    gitRoot: string;
+} | {
+    root: string;
+    gitRoot: undefined;
+};
+/** Read guidance from this exact folder only; never inherit a parent's file. */
+export declare function readRepositoryAgentInstructions(folder: string, maxBytes: number): {
+    content: string;
+    bytes: number;
+    path: string;
+} | undefined;
+export declare function inspectAgentInstructions(folder: string, options?: AgentInstructionOptions): {
+    schemaVersion: 1;
+    root: string;
+    configDirectory: string;
+    profile: string;
+    settings: {
+        schemaVersion: 1;
+        defaultProfile: string;
+        includeGlobal: boolean;
+        maxBytes: number;
+        editor: {
+            mode: "system";
+        } | {
+            mode: "command";
+            executable: string;
+            args: string[];
+        };
+    };
+    totalBytes: number;
+    sources: {
+        scope: "global" | "project";
+        profile: string;
+        path: string;
+        exists: boolean;
+        bytes: number;
+        content: string;
+    }[];
+};
+export declare function buildAgentInstructionsMessage(folder: string, options?: AgentInstructionOptions): string | undefined;
+export declare function agentInstructionFileTarget(folder: string, options?: {
+    profile?: string;
+    global?: boolean;
+}): {
+    path: string;
+    profile: string;
+    settings: {
+        schemaVersion: 1;
+        defaultProfile: string;
+        includeGlobal: boolean;
+        maxBytes: number;
+        editor: {
+            mode: "system";
+        } | {
+            mode: "command";
+            executable: string;
+            args: string[];
+        };
+    };
+};
+export declare function ensureAgentInstructionFile(folder: string, options?: {
+    profile?: string;
+    global?: boolean;
+}): {
+    path: string;
+    created: boolean;
+    profile: string;
+    settings: {
+        schemaVersion: 1;
+        defaultProfile: string;
+        includeGlobal: boolean;
+        maxBytes: number;
+        editor: {
+            mode: "system";
+        } | {
+            mode: "command";
+            executable: string;
+            args: string[];
+        };
+    };
+};
+export declare function listAgentInstructionFiles(folder: string, global?: boolean): any;