@realqiyan/agent-task 0.0.1-rc.2 → 0.1.0-rc.1

package/dist/configuration/contract.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { executorTypeSchema } from "../executors/validation.js";
+import { baseEnvKeys } from "./policy.js";
+const envKey = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
+const modelId = z.string().min(1).max(200);
+const coordinatorSchema = z.discriminatedUnion("provider", [
+    z.object({ provider: z.enum(["openai", "anthropic", "deepseek"]), model: modelId }).strict(),
+    z.object({
+        provider: z.literal("openai-compatible"), model: modelId,
+        api: z.enum(["openai-completions", "openai-responses"]).default("openai-completions"),
+        baseUrl: z.string().url().refine(value => {
+            const url = new URL(value);
+            return ["https:", "http:"].includes(url.protocol) && !url.username && !url.password && !url.search && !url.hash;
+        }, "baseUrl must be HTTP(S) without credentials, query or fragment"),
+        apiKeyEnv: envKey.refine(key => !baseEnvKeys.includes(key), "Credential must not use a base environment key"),
+        contextWindow: z.number().int().positive(),
+        maxTokens: z.number().int().positive(),
+        reasoning: z.boolean().default(false),
+    }).strict(),
+]).refine(value => value.provider !== "openai-compatible" || value.maxTokens <= value.contextWindow, "maxTokens must not exceed contextWindow");
+export const configSchema = z.object({
+    dataDir: z.string().min(1),
+    port: z.number().int().min(0).max(65535).default(8765),
+    tokenEnv: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).default("AGENT_TASK_TOKEN"),
+    coordinator: coordinatorSchema.optional(),
+    disabledExecutors: z.array(executorTypeSchema).max(4).refine(types => new Set(types).size === types.length, "Disabled executor types must be unique").default([]),
+}).strict();
+//# sourceMappingURL=contract.js.map

package/dist/{environment.js → configuration/environment.js}

@@ -1,5 +1,4 @@
-import { ADMIN_TOKEN_ENV, coordinatorCredentialEnv } from "./config.js";
-import { readPrivateText } from "./private-files.js";
+import { ADMIN_TOKEN_ENV, coordinatorCredentialEnv } from "./policy.js";
 export function parseEnvironment(text) {
     let value;
     try {
@@ -13,9 +12,6 @@ export function parseEnvironment(text) {
         throw new Error("Invalid environment file");
     return value;
 }
-export function readEnvironment(path) {
-    return parseEnvironment(readPrivateText(path));
-}
 /** Credential names and values must stay separate, including historical token aliases. */
 export function validateServiceEnvironment(config, environment) {
     const token = environment[config.tokenEnv], adminToken = environment[ADMIN_TOKEN_ENV];

package/dist/configuration/files.js

@@ -0,0 +1,42 @@
+import { join } from "node:path";
+import { z } from "zod";
+import { checkDataDirectory, readPrivateText, replacePrivateText } from "../infrastructure/private-files.js";
+import { configSchema } from "./contract.js";
+import { parseEnvironment } from "./environment.js";
+import { validateConfig } from "./policy.js";
+export const configurationPaths = { checkDataDirectory };
+export function loadConfig(path) {
+    let value;
+    try {
+        value = JSON.parse(readPrivateText(path));
+    }
+    catch {
+        throw new Error("Cannot read configuration JSON");
+    }
+    return validateConfig(configSchema.parse(value));
+}
+export function readEnvironment(path) { return parseEnvironment(readPrivateText(path)); }
+export class LocalSettingsFiles {
+    configPath;
+    environmentPath;
+    constructor(configPath, environmentPath) {
+        this.configPath = configPath;
+        this.environmentPath = environmentPath;
+        if (configPath === environmentPath)
+            throw new Error("Configuration and environment must be separate files");
+    }
+    read() {
+        const configText = readPrivateText(this.configPath), environmentText = readPrivateText(this.environmentPath);
+        return { configText, environmentText, config: configSchema.parse(JSON.parse(configText)), environment: parseEnvironment(environmentText) };
+    }
+    publish(target, value) {
+        replacePrivateText(target === "config" ? this.configPath : this.environmentPath, JSON.stringify(value, null, 2) + "\n");
+    }
+}
+/** A stable launch locator is the only runtime input outside the selected dataDir. */
+export function startupPaths(home) {
+    const { dataDir } = z.object({ dataDir: z.string() }).strict().parse(JSON.parse(readPrivateText(join(home, "launch.json"))));
+    checkDataDirectory(dataDir);
+    return { dataDir, configPath: join(dataDir, "config.json"), environmentPath: join(dataDir, "environment.json") };
+}
+//# sourceMappingURL=files.js.map

package/dist/configuration/management.js

@@ -0,0 +1,6 @@
+/** Configuration preview and task impact are one management operation for all clients. */
+export function previewSettings(settings, tasks, input) {
+    const preview = settings.preview(input);
+    return { ...preview, affectedTasks: tasks.executorImpact(preview.config.disabledExecutors) };
+}
+//# sourceMappingURL=management.js.map

package/dist/configuration/model.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=model.js.map

package/dist/configuration/policy.js

@@ -0,0 +1,24 @@
+export const ADMIN_TOKEN_ENV = "AGENT_TASK_ADMIN_TOKEN";
+export const baseEnvKeys = ["HOME", "PATH", "LANG", "LC_ALL", "TZ", "TMPDIR", "NODE_OPTIONS", "NODE_PATH", "__proto__", "constructor", "prototype"];
+export function coordinatorCredentialEnv(config) {
+    switch (config.provider) {
+        case "openai": return "OPENAI_API_KEY";
+        case "anthropic": return "ANTHROPIC_API_KEY";
+        case "deepseek": return "DEEPSEEK_API_KEY";
+        case "openai-compatible": return config.apiKeyEnv;
+    }
+}
+export function validateConfig(value) {
+    const config = structuredClone(value);
+    if (!config.dataDir.startsWith("/") || /[\x00-\x1f\x7f]/.test(config.dataDir))
+        throw new Error("dataDir must be absolute without control characters");
+    const coordinatorKey = config.coordinator ? coordinatorCredentialEnv(config.coordinator) : undefined;
+    if (/^(NODE_|LD_|DYLD_)/.test(config.tokenEnv) || [...baseEnvKeys, ADMIN_TOKEN_ENV, "OPENAI_API_KEY", "ANTHROPIC_API_KEY", "DEEPSEEK_API_KEY", coordinatorKey].includes(config.tokenEnv))
+        throw new Error("tokenEnv must be separate from base environment, administrator and model credentials");
+    if (coordinatorKey === ADMIN_TOKEN_ENV)
+        throw new Error("Administrator token must not be used as a model credential");
+    if (new Set(config.disabledExecutors).size !== config.disabledExecutors.length)
+        throw new Error("Duplicate disabled executor type");
+    return config;
+}
+//# sourceMappingURL=policy.js.map

package/dist/configuration/ports.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ports.js.map

package/dist/{settings.js → configuration/settings.js}

@@ -1,9 +1,8 @@
 import { randomUUID } from "node:crypto";
-import { z } from "zod";
-import { ADMIN_TOKEN_ENV, configSchema, coordinatorCredentialEnv, validateConfig } from "./config.js";
+import { isDeepStrictEqual } from "node:util";
+import { ADMIN_TOKEN_ENV, coordinatorCredentialEnv, validateConfig } from "./policy.js";
 import { parseEnvironment, validateServiceEnvironment } from "./environment.js";
-import { checkDataDirectory, FileCommitError, readPrivateText, replacePrivateText } from "./private-files.js";
-import { credentialUpdateSchema, settingsConfigSchema } from "./settings-contract.js";
+import { FileCommitError } from "../shared/errors.js";
 export class SettingsError extends Error {
     code;
     constructor(code, message) {
@@ -14,15 +13,6 @@ export class SettingsError extends Error {
 const protectedKeys = new Set(["HOME", "PATH", "LANG", "LC_ALL", "TZ", "TMPDIR", "NODE_OPTIONS", "NODE_PATH",
     "PI_ACP_PI_COMMAND", "AGENT_TASK_TOKEN", ADMIN_TOKEN_ENV, "__proto__", "constructor", "prototype"]);
 const modelKeys = ["OPENAI_API_KEY", "ANTHROPIC_API_KEY", "DEEPSEEK_API_KEY"];
-function parse(schema, value) {
-    const result = schema.safeParse(value);
-    if (!result.success) {
-        // Field paths only: parser diagnostics and rejected values may contain credentials.
-        const fields = result.error.issues.slice(0, 8).map(issue => issue.path.join(".") || "request");
-        throw new SettingsError("invalid", "Invalid fields: " + fields.join(", "));
-    }
-    return result.data;
-}
 function referenced(config) {
     return new Set(config.coordinator ? [coordinatorCredentialEnv(config.coordinator)] : []);
 }
@@ -30,10 +20,15 @@ function editableKey(key, config) {
     return !protectedKeys.has(key) && key !== config.tokenEnv && !/^(NODE_|LD_|DYLD_)/.test(key) &&
         (/(?:_KEY|_TOKEN|_SECRET|_PASSWORD)$/.test(key) || referenced(config).has(key));
 }
+export function configChanges(before, after) {
+    return Object.keys(after).concat(Object.keys(before))
+        .filter((key, index, keys) => keys.indexOf(key) === index && !isDeepStrictEqual(before[key], after[key]))
+        .map(field => ({ field, before: before[field] ?? null, after: after[field] ?? null }));
+}
 /** Disk settings are next-start inputs only. This service never mutates live objects or process.env. */
 export class Settings {
-    configPath;
-    environmentPath;
+    files;
+    paths;
     edits = new Map();
     initial;
     running;
@@ -42,11 +37,9 @@ export class Settings {
     closed = false;
     uncertain = false;
     startedAt = new Date().toISOString();
-    constructor(configPath, environmentPath, running, base, environment) {
-        this.configPath = configPath;
-        this.environmentPath = environmentPath;
-        if (configPath === environmentPath)
-            throw new SettingsError("invalid", "Configuration and environment must be separate files");
+    constructor(files, paths, running, base, environment) {
+        this.files = files;
+        this.paths = paths;
         this.running = structuredClone(running);
         this.base = { ...base };
         this.runningEnvironment = { ...environment };
@@ -56,8 +49,7 @@ export class Settings {
         if (this.closed)
             throw new SettingsError("unavailable", "Configuration management is closed");
         try {
-            const configText = readPrivateText(this.configPath), environmentText = readPrivateText(this.environmentPath);
-            return { configText, environmentText, config: configSchema.parse(JSON.parse(configText)), environment: parseEnvironment(environmentText) };
+            return this.files.read();
         }
         catch {
             throw new SettingsError("unavailable", "Cannot read private configuration files; inspect their format, ownership and permissions offline");
@@ -96,18 +88,16 @@ export class Settings {
         }
         return snapshot;
     }
-    candidate(value) {
-        const input = parse(settingsConfigSchema, value), snapshot = this.editing(input.editToken);
+    candidate(input) {
+        const snapshot = this.editing(input.editToken);
         const environment = { ...this.base, ...snapshot.environment };
         let config;
         try {
             config = validateConfig(input.config);
-            checkDataDirectory(config.dataDir);
+            this.paths.checkDataDirectory(config.dataDir);
         }
-        catch (error) {
-            if (error instanceof z.ZodError)
-                throw new SettingsError("invalid", "Invalid configuration fields");
-            throw new SettingsError("invalid", "Local validation failed: check data directory, workspaces and credential isolation");
+        catch {
+            throw new SettingsError("invalid", "Local validation failed: check data directory, executor selection and credential isolation");
         }
         const previous = snapshot.config.coordinator, next = config.coordinator;
         const endpoint = (model) => model.provider === "openai-compatible" ? model.baseUrl : model.provider;
@@ -131,19 +121,44 @@ export class Settings {
         return config;
     }
     validate(value) { return this.candidate(value); }
-    saveConfig(value) {
-        const config = this.candidate(value);
-        const snapshot = this.editing(parse(settingsConfigSchema, value).editToken);
+    preview(input) {
+        const config = this.candidate(input);
+        return { config, changes: configChanges(this.editing(input.editToken).config, config) };
+    }
+    diff() {
+        const saved = this.snapshot().config;
+        return { changes: configChanges(this.running, saved), ...this.status() };
+    }
+    /** Convenience commands create a draft; all publication still uses saveConfig. */
+    prepareChange(value) {
+        const { editToken, change } = value;
+        const config = structuredClone(this.editing(editToken).config);
+        if (change.action === "coordinator-set")
+            config.coordinator = change.coordinator;
+        else if (change.action === "coordinator-clear")
+            delete config.coordinator;
+        else if (change.action === "executor-enable") {
+            config.disabledExecutors = config.disabledExecutors.filter(type => type !== change.id);
+        }
+        else if (!config.disabledExecutors.includes(change.id)) {
+            config.disabledExecutors.push(change.id);
+        }
+        const input = { editToken, config };
+        return { ...input, config: this.candidate(input) };
+    }
+    saveConfig(input) {
+        const config = this.candidate(input);
+        const snapshot = this.editing(input.editToken);
         if (config.tokenEnv !== snapshot.config.tokenEnv) {
             snapshot.environment[config.tokenEnv] = snapshot.environment[snapshot.config.tokenEnv];
             // Publish an alias first. Either configuration still uses the same service token.
-            this.publish(this.environmentPath, snapshot.environment);
+            this.publish("environment", snapshot.environment);
         }
-        this.publish(this.configPath, config);
+        this.publish("config", config);
         return this.get();
     }
-    saveCredential(value) {
-        const input = parse(credentialUpdateSchema, value), snapshot = this.editing(input.editToken);
+    saveCredential(input) {
+        const snapshot = this.editing(input.editToken);
         if (!editableKey(input.key, snapshot.config) || !editableKey(input.key, this.running) ||
             [snapshot.environment[snapshot.config.tokenEnv], snapshot.environment[ADMIN_TOKEN_ENV]].includes(snapshot.environment[input.key]))
             throw new SettingsError("invalid", "This environment key is not console-managed; new credential names must end in _KEY, _TOKEN, _SECRET or _PASSWORD");
@@ -161,12 +176,12 @@ export class Settings {
         }
         // Recheck the complete environment format, not only the edited value.
         parseEnvironment(JSON.stringify(snapshot.environment));
-        this.publish(this.environmentPath, snapshot.environment);
+        this.publish("environment", snapshot.environment);
         return this.get();
     }
-    publish(path, value) {
+    publish(target, value) {
         try {
-            replacePrivateText(path, JSON.stringify(value, null, 2) + "\n");
+            this.files.publish(target, value);
         }
         catch (error) {
             if (error instanceof FileCommitError && error.uncertain)

package/dist/executors/environment.js

@@ -0,0 +1,10 @@
+import { ADMIN_TOKEN_ENV, coordinatorCredentialEnv } from "../configuration/policy.js";
+/** Private service inputs never enter workers, even through an alias with the same value. */
+export function executorEnvironment(native, privateValues, config) {
+    const blocked = new Set([...Object.keys(privateValues), config.tokenEnv, ADMIN_TOKEN_ENV,
+        ...(config.coordinator ? [coordinatorCredentialEnv(config.coordinator)] : [])]);
+    const secrets = new Set([...Object.values(privateValues), ...[...blocked].map(key => native[key])].filter(Boolean));
+    return Object.fromEntries(Object.entries(native).filter(([key, value]) => value !== undefined && !blocked.has(key) && !secrets.has(value) &&
+        !/^(AGENT_TASK_|NODE_|LD_|DYLD_)/.test(key) && key !== "PI_ACP_PI_COMMAND"));
+}
+//# sourceMappingURL=environment.js.map

package/dist/executors/model.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=model.js.map

package/dist/executors/ports.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ports.js.map

package/dist/executors/registry.js

@@ -0,0 +1,131 @@
+import { errorText } from "../shared/errors.js";
+export function sameExecutor(a, b) {
+    return a.id === b.id && a.type === b.type && a.nativePath === b.nativePath;
+}
+export function authorizedProfile(snapshot, current) {
+    return Boolean(snapshot && current && sameExecutor(snapshot, current));
+}
+function status(executor, state = "ready") {
+    return { id: executor.id, type: executor.type, nativePath: executor.nativePath,
+        state, adapterVersion: executor.adapterVersion, error: null };
+}
+/** Owns the ready executor set and adapter installation lifetime, not native tool permissions. */
+export class ExecutorRegistry {
+    discovery;
+    profiles;
+    states;
+    disabled;
+    installing = new Map();
+    closed = false;
+    closing;
+    constructor(profiles, discovery, disabled = []) {
+        this.discovery = discovery;
+        this.disabled = new Set(disabled);
+        const found = discovery?.discover();
+        this.profiles = structuredClone((found?.executors ?? profiles).filter(profile => !this.disabled.has(profile.type)));
+        this.states = found ? found.states.map(entry => this.disabled.has(entry.type)
+            ? { ...entry, state: "disabled", error: null } : { ...entry })
+            : profiles.map(profile => status(profile, this.disabled.has(profile.type) ? "disabled" : "ready"));
+    }
+    checkOpen() { if (this.closed)
+        throw new Error("Executor registry closed"); }
+    list() { this.checkOpen(); return { executors: structuredClone(this.states) }; }
+    refresh() {
+        this.checkOpen();
+        if (!this.discovery)
+            return this.list();
+        const found = this.discovery.discover();
+        this.profiles = structuredClone(found.executors.filter(profile => !this.disabled.has(profile.type) && !this.installing.has(profile.type)));
+        this.states = found.states.map(entry => {
+            if (this.disabled.has(entry.type))
+                return { ...entry, state: "disabled", error: null };
+            if (this.installing.has(entry.type))
+                return { ...entry, state: "installing", error: null };
+            return { ...entry };
+        });
+        for (const entry of this.states) {
+            if (entry.state === "missing" && entry.nativePath !== null)
+                this.install(entry, false);
+        }
+        return this.list();
+    }
+    upgrade(id) {
+        this.checkOpen();
+        const entry = this.states.find(item => item.id === id);
+        if (!this.discovery || !entry || !entry.nativePath)
+            throw new Error("Executor is not installed: " + id);
+        if (this.disabled.has(entry.type))
+            throw new Error("Executor is disabled: " + id);
+        if (entry.type === "opencode")
+            throw new Error("OpenCode uses its native ACP command; update the native CLI directly");
+        this.install(entry, true);
+        return this.list();
+    }
+    install(entry, upgrade) {
+        const discovery = this.discovery;
+        if (!discovery || this.installing.has(entry.type))
+            return;
+        const controller = new AbortController(), expectedPath = entry.nativePath;
+        this.profiles = this.profiles.filter(profile => profile.type !== entry.type);
+        Object.assign(entry, { state: "installing", error: null });
+        const done = Promise.resolve().then(async () => {
+            try {
+                if (this.closed || controller.signal.aborted)
+                    return;
+                const executor = await discovery.install(entry.type, upgrade, controller.signal);
+                if (this.closed)
+                    return;
+                if (executor.type !== entry.type || executor.id !== entry.id || executor.nativePath !== expectedPath) {
+                    throw new Error("Native executor changed during adapter installation; refresh discovery");
+                }
+                discovery.check(executor);
+                this.profiles = [...this.profiles.filter(profile => profile.type !== entry.type), structuredClone(executor)];
+                this.states = this.states.map(item => item.type === entry.type ? status(executor) : item);
+            }
+            catch (error) {
+                if (!this.closed)
+                    this.states = this.states.map(item => item.type === entry.type ?
+                        { ...item, state: "error", error: errorText(error) } : item);
+            }
+            finally {
+                this.installing.delete(entry.type);
+            }
+        });
+        this.installing.set(entry.type, { controller, done });
+    }
+    ready(id) {
+        const profile = this.profiles.find(item => item.id === id);
+        if (!profile) {
+            const entry = this.states.find(item => item.id === id);
+            throw new Error("Executor is not ready: " + id + (entry ? " (" + entry.state + ")" : ""));
+        }
+        this.discovery?.check(profile);
+        return profile;
+    }
+    snapshot(ids) {
+        this.checkOpen();
+        const result = Object.create(null);
+        for (const id of ids)
+            result[id] = structuredClone(this.ready(id));
+        return result;
+    }
+    authorize(snapshot) {
+        this.checkOpen();
+        if (!snapshot)
+            throw new Error("Executor snapshot is missing");
+        const current = this.ready(snapshot.id);
+        if (!authorizedProfile(snapshot, current))
+            throw new Error("Native executor changed; existing task assignment cannot be replaced");
+        return structuredClone(current);
+    }
+    close() {
+        if (this.closing)
+            return this.closing;
+        this.closed = true;
+        for (const entry of this.installing.values())
+            entry.controller.abort();
+        this.closing = Promise.all([...this.installing.values()].map(entry => entry.done)).then(() => undefined);
+        return this.closing;
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/executors/validation.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import { absolutePath, identifier } from "../shared/validation.js";
+export const executorTypeSchema = z.enum(["pi", "codex", "claude", "opencode"]);
+export const executorRecord = z.object({
+    id: identifier, type: executorTypeSchema, nativePath: absolutePath,
+    command: absolutePath, args: z.array(z.string().max(4000)).max(100),
+    adapterVersion: z.string().min(1).max(200).nullable(),
+}).strict();
+//# sourceMappingURL=validation.js.map

package/dist/infrastructure/lock.js

@@ -0,0 +1,55 @@
+import { DatabaseSync } from "./sqlite.js";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+/** The stable installation lock prevents two launchers during a directory switch. */
+export async function acquireLauncherLock(home) {
+    const deadline = Date.now() + 1500;
+    for (;;) {
+        const db = new DatabaseSync(join(home, "launcher-lock.sqlite"));
+        try {
+            db.exec("PRAGMA busy_timeout=0; BEGIN EXCLUSIVE");
+        }
+        catch (error) {
+            db.close();
+            const code = error.errcode;
+            if (code !== 5 && code !== 6)
+                throw new Error("Cannot acquire launcher ownership; inspect the installation filesystem", { cause: error });
+            if (Date.now() >= deadline)
+                throw new Error("Another launcher owns this installation", { cause: error });
+            // On a new SQLite file, concurrent readers can all lose the first exclusive-lock attempt.
+            // Release each failed connection and stagger retries before any service work starts.
+            await delay(25 + Math.floor(Math.random() * 25));
+            continue;
+        }
+        let released = false;
+        return () => { if (!released) {
+            db.close();
+            released = true;
+        } };
+    }
+}
+/** A dedicated SQLite transaction owns an OS lock until close or process death.
+ * Local filesystems only. Never unlink this file: that would create a second lock identity.
+ */
+export async function acquireLock(directory) {
+    if (!["linux", "darwin"].includes(process.platform))
+        throw new Error("Supported platforms: Linux and macOS");
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const db = new DatabaseSync(join(directory, "service-lock.sqlite"));
+    try {
+        db.exec("PRAGMA busy_timeout=0; PRAGMA journal_mode=DELETE; BEGIN EXCLUSIVE");
+    }
+    catch (error) {
+        db.close();
+        throw new Error("State directory is locked or its filesystem does not support SQLite locking", { cause: error });
+    }
+    let released = false;
+    return async () => {
+        if (released)
+            return;
+        db.close();
+        released = true;
+    };
+}
+//# sourceMappingURL=lock.js.map

package/dist/{private-files.js → infrastructure/private-files.js}

@@ -1,3 +1,4 @@
+import { FileCommitError } from "../shared/errors.js";
 import { existsSync, constants, openSync, closeSync, fstatSync, lstatSync, realpathSync, readFileSync, writeFileSync, fsyncSync, renameSync, unlinkSync } from "node:fs";
 import { dirname, basename, join, isAbsolute, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -44,13 +45,6 @@ export function readPrivateText(path) {
         closeSync(fd);
     }
 }
-export class FileCommitError extends Error {
-    uncertain;
-    constructor(uncertain) {
-        super(uncertain ? "Configuration publication could not be confirmed; stop and inspect the files" : "Configuration was not published");
-        this.uncertain = uncertain;
-    }
-}
 /** Caller owns the configuration. No await between comparison, validation and publication. */
 export function replacePrivateText(path, text) {
     const temporary = join(dirname(path), "." + basename(path) + "." + randomUUID() + ".tmp");

package/dist/infrastructure/sqlite.js

@@ -0,0 +1,19 @@
+import { createRequire } from "node:module";
+// Node 22 warns on loading SQLite. Suppress only that known notice during the
+// synchronous import, then restore normal warning handling for all other code.
+const emitWarning = process.emitWarning;
+let sqlite;
+try {
+    process.emitWarning = (warning, ...args) => {
+        if (warning === "SQLite is an experimental feature and might change at any time"
+            && args[0] === "ExperimentalWarning")
+            return;
+        Reflect.apply(emitWarning, process, [warning, ...args]);
+    };
+    sqlite = createRequire(import.meta.url)("node:sqlite");
+}
+finally {
+    process.emitWarning = emitWarning;
+}
+export const DatabaseSync = sqlite.DatabaseSync;
+//# sourceMappingURL=sqlite.js.map

package/dist/infrastructure/version.js

@@ -0,0 +1,3 @@
+import { readFileSync } from "node:fs";
+export const version = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version;
+//# sourceMappingURL=version.js.map

package/dist/{acp.js → integrations/acp/connection.js}

@@ -2,10 +2,11 @@ import { spawn } from "node:child_process";
 import { Readable, Writable } from "node:stream";
 import { setTimeout as delay } from "node:timers/promises";
 import * as acp from "@agentclientprotocol/sdk";
-import { executorCommand } from "./executor-runtime.js";
-import { readInputFile } from "./results.js";
-import { permissionDecision } from "./permissions.js";
-import { version } from "./version.js";
+import { executorLaunch } from "./runtime.js";
+import { Results } from "../../results/service.js";
+import { LocalResultFiles } from "../../results/files.js";
+import { permissionDecision } from "../../executors/permissions.js";
+import { version } from "../../infrastructure/version.js";
 /** Project only public progress. Queue every piece before yielding so concurrent notifications cannot reorder output. */
 export function progressEvents(update) {
     if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
@@ -38,7 +39,7 @@ function signalGroup(child, signal) {
         }
     }
 }
-/** Kill the whole group even if its leader already exited; Linux systemd additionally owns a cgroup; macOS does not. */
+/** Kill the whole group even if its leader already exited. */
 export async function terminateGroup(child) {
     signalGroup(child, "SIGTERM");
     await delay(300);
@@ -47,11 +48,12 @@ export async function terminateGroup(child) {
     child.stdout?.destroy();
     child.stderr?.destroy();
 }
-export async function openAcp(executor, signal, emit, resultsRoot, inputFiles = []) {
+export async function openAcp(executor, workspace, signal, emit, resultsRoot, inputFiles = []) {
     signal.throwIfAborted();
-    const launch = executorCommand(executor.type, process.env);
+    const results = new Results(new LocalResultFiles(resultsRoot));
+    const launch = executorLaunch(executor, process.env);
     const child = spawn(launch.command, launch.args, {
-        cwd: executor.cwd, env: process.env, detached: true, stdio: ["pipe", "pipe", "pipe"],
+        cwd: workspace, env: launch.env, detached: true, stdio: ["pipe", "pipe", "pipe"],
     });
     const controller = new AbortController();
     const cancel = AbortSignal.any([signal, controller.signal]);
@@ -103,7 +105,7 @@ export async function openAcp(executor, signal, emit, resultsRoot, inputFiles =
             cancel.throwIfAborted();
             if (ctx.params.sessionId !== sessionId)
                 throw new Error("Wrong input-file session");
-            return { content: readInputFile(resultsRoot, inputFiles, ctx.params.path, ctx.params.line ?? 1, ctx.params.limit ?? undefined) };
+            return { content: results.readInputFile(inputFiles, ctx.params.path, ctx.params.line ?? 1, ctx.params.limit ?? undefined) };
         }
         catch (error) {
             controller.abort(error);
@@ -134,7 +136,7 @@ export async function openAcp(executor, signal, emit, resultsRoot, inputFiles =
         if (init.protocolVersion !== acp.PROTOCOL_VERSION)
             throw new Error("Incompatible ACP protocol version");
         await report("agent", { name: init.agentInfo?.name ?? null, version: init.agentInfo?.version ?? null });
-        const session = await connection.agent.request(acp.methods.agent.session.new, { cwd: executor.cwd, mcpServers: [] });
+        const session = await connection.agent.request(acp.methods.agent.session.new, { cwd: workspace, mcpServers: [] });
         sessionId = session.sessionId;
         await report("session", sessionId);
         cancel.throwIfAborted();
@@ -166,4 +168,4 @@ export async function openAcp(executor, signal, emit, resultsRoot, inputFiles =
         throw error;
     }
 }
-//# sourceMappingURL=acp.js.map
+//# sourceMappingURL=connection.js.map