alp-code 0.9.0

package/dist/src/cli/commands/delegate.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDelegateCommand = runDelegateCommand;
+exports.runDelegationLifecycleCommand = runDelegationLifecycleCommand;
+exports.createDefaultDelegationComposition = createDefaultDelegationComposition;
+const modes_1 = require("../../agents/modes");
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+const registry_1 = require("../../agents/registry");
+const local_process_backend_1 = require("../../backend/local-process-backend");
+const delegation_service_1 = require("../../delegation/delegation-service");
+const execution_service_1 = require("../../execution/execution-service");
+const execution_store_1 = require("../../execution/execution-store");
+const markdown_file_store_1 = require("../../memory/adapters/markdown-file-store");
+const memory_service_1 = require("../../memory/memory-service");
+const policy_engine_1 = require("../../policy/policy-engine");
+const claude_adapter_1 = require("../../runtime/claude-adapter");
+const codex_adapter_1 = require("../../runtime/codex-adapter");
+const workflow_runner_1 = require("../../workflow/workflow-runner");
+function required(args, index, message) {
+    const value = args[index];
+    if (!value)
+        throw new Error(message);
+    return value;
+}
+async function runDelegateCommand(argv, dependencies) {
+    const targetRole = argv[0];
+    if (!targetRole)
+        throw new Error("delegate requires a target role");
+    let background = false;
+    let timeoutMs = null;
+    let workspace = dependencies.cwd;
+    const task = [];
+    for (let index = 1; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value === "--runtime") {
+            // Nấc quyết định model, model quyết định CLI. Một cờ `--runtime` còn sót trong script
+            // cũ sẽ chọn sai CLI cho model của nấc, nên nó dừng ở đây chứ không bị bỏ qua.
+            throw new Error("`--runtime` không còn tồn tại; nấc quyết định model và runtime — dùng `alp mode set` hoặc ALP_MODE");
+        }
+        else if (value === "--background")
+            background = true;
+        else if (value === "--timeout-ms") {
+            timeoutMs = Number(required(argv, ++index, "--timeout-ms requires a number"));
+            if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+                throw new Error("--timeout-ms must be positive");
+        }
+        else if (value === "--workspace" || value === "--project") {
+            workspace = required(argv, ++index, `${value} requires a path`);
+        }
+        else if (value === "--parent-role" || value === "--role" || value === "--kind") {
+            throw new Error(`unsupported identity-aware raw-runtime shortcut \`${value}\``);
+        }
+        else if (value === "--backend") {
+            // Rejected rather than ignored. Unknown words fall through to the task below, so a
+            // stale `--backend paseo` left in a script would otherwise be handed to the agent as
+            // part of what it was asked to do, and the run would look fine while doing the wrong
+            // thing. There is one backend now; saying so is the only honest answer.
+            throw new Error("`--backend` was removed: delegation always runs on the local backend");
+        }
+        else if (value !== "--")
+            task.push(value);
+    }
+    if (!task.join(" ").trim())
+        throw new Error("delegate requires a task");
+    const parentRole = dependencies.env.ALP_DELEGATED_ROLE || dependencies.env.ALP_ROLE || "main";
+    const spawned = await dependencies.service.delegate({
+        parentRole,
+        parentExecutionId: dependencies.env.ALP_DELEGATION_EXECUTION_ID || null,
+        targetRole,
+        task: task.join(" "),
+        workspace,
+        workspaceMode: parentRole === "principal" && targetRole === "main"
+            ? "workspace-write"
+            : "read-only",
+        metadata: {},
+        executionOptions: { background, interactive: false, timeoutMs },
+    });
+    return !background && spawned.status === "running"
+        ? dependencies.service.wait(spawned.executionId, { timeoutMs })
+        : spawned;
+}
+async function runDelegationLifecycleCommand(argv, service) {
+    const command = argv[0];
+    if (command === "status")
+        return service.status(required(argv, 1, "status requires execution ID"));
+    if (command === "wait")
+        return service.wait(required(argv, 1, "wait requires execution ID"));
+    if (command === "cancel")
+        return service.cancel(required(argv, 1, "cancel requires execution ID"));
+    if (command === "cleanup")
+        return service.cleanup(required(argv, 1, "cleanup requires execution ID"));
+    if (command === "list")
+        return service.listExecutions();
+    throw new Error(`unknown delegation lifecycle command \`${command ?? ""}\``);
+}
+async function createDefaultDelegationComposition(repoRoot, env = process.env) {
+    const localRequire = (0, node_module_1.createRequire)(__filename);
+    const configModule = localRequire((0, node_path_1.join)(repoRoot, "scripts", "lib", "delegation", "config.cjs"));
+    const config = configModule.loadDelegationConfig(repoRoot, env);
+    // The one backend. It spawns the runtime as a child process, so it needs no daemon and
+    // works on a machine where nothing else is installed — and it hands the runtime its own
+    // settings file, which is what makes a role's `permissions.deny` real rather than
+    // advisory. Its state lives in `local.json` under the delegation state directory, so a
+    // later CLI process can run lifecycle commands against an execution this one started.
+    const backend = new local_process_backend_1.LocalProcessBackend({ env, stateDir: config.stateDir });
+    const policy = new policy_engine_1.PolicyEngine({ registry: registry_1.agentRegistry });
+    const memory = new memory_service_1.MemoryService({
+        store: new markdown_file_store_1.MarkdownFileStore({ root: (0, node_path_1.join)(repoRoot, "memory") }),
+        policy,
+        audit: { record() { } },
+    });
+    const executionService = new execution_service_1.ExecutionService({
+        registry: registry_1.agentRegistry,
+        policy,
+        memory,
+        workflowRunner: new workflow_runner_1.WorkflowRunner(),
+        store: new execution_store_1.FileExecutionStore({ root: (0, node_path_1.join)(config.stateDir, "execution-snapshots") }),
+    });
+    const service = new delegation_service_1.DelegationService({
+        registry: registry_1.agentRegistry,
+        policy,
+        memory,
+        executionService,
+        runtimeAdapters: new Map([
+            ["claude", new claude_adapter_1.ClaudeRuntimeAdapter({ env })],
+            ["codex", new codex_adapter_1.CodexRuntimeAdapter({ env })],
+        ]),
+        backend,
+        executionStore: new delegation_service_1.FileDelegationExecutionStore({ file: (0, node_path_1.join)(config.stateDir, "code-native-executions.json") }),
+        // Con kế thừa nấc của cha: một phiên `ultra` mà subagent lặng lẽ tụt về `medium` thì
+        // nấc chỉ còn đúng ở ghế ngoài cùng.
+        config: env.ALP_MODE ? { mode: (0, modes_1.parseMode)(env.ALP_MODE) } : {},
+    });
+    return { service, config: { stateDir: config.stateDir } };
+}

package/dist/src/cli/commands/identity-sync.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentDocumentPath = agentDocumentPath;
+exports.syncIdentityDocuments = syncIdentityDocuments;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const render_identity_1 = require("../../agents/render-identity");
+function agentDocumentPath(directory, role) {
+    return (0, node_path_1.join)(directory, `${role}.md`);
+}
+/**
+ * Regenerates `<directory>/<role>.md` for every role in the registry.
+ *
+ * The registry stays the single source of truth; these files are a derived, machine-local
+ * cache that exists purely so the SessionStart hook can stay fast and dependency-free.
+ * Safe to run repeatedly — it always overwrites.
+ */
+async function syncIdentityDocuments(input, dependencies) {
+    const directory = input.directory;
+    await (0, promises_1.mkdir)(directory, { recursive: true, mode: 0o700 });
+    const written = [];
+    for (const definition of dependencies.registry.list()) {
+        const file = agentDocumentPath(directory, definition.id);
+        await (0, promises_1.writeFile)(file, (0, render_identity_1.renderIdentityDocument)(definition), {
+            encoding: "utf8",
+            mode: 0o600,
+        });
+        written.push(file);
+    }
+    return Object.freeze(written);
+}

package/dist/src/cli/commands/init.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectRegistryStore = void 0;
+exports.initializeProject = initializeProject;
+exports.deinitializeProject = deinitializeProject;
+const promises_1 = require("node:fs/promises");
+const promises_2 = require("node:fs/promises");
+const node_crypto_1 = require("node:crypto");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const state_paths_1 = require("../../state-paths");
+function within(root, target) {
+    const relation = (0, node_path_1.relative)((0, node_path_1.resolve)(root), (0, node_path_1.resolve)(target));
+    return relation === "" || (!relation.startsWith("..") && !(0, node_path_1.isAbsolute)(relation));
+}
+async function exists(path) {
+    try {
+        await (0, promises_2.lstat)(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+class ProjectRegistryStore {
+    file;
+    constructor(options = {}) {
+        this.file = options.file ?? (0, node_path_1.join)((0, node_os_1.homedir)(), ".alp", "projects.json");
+    }
+    async read() {
+        try {
+            const value = JSON.parse(await (0, promises_2.readFile)(this.file, "utf8"));
+            if (value.version !== 1 || !Array.isArray(value.projects))
+                throw new Error("unsupported project registry");
+            return { version: 1, projects: Object.freeze(value.projects.map((entry) => Object.freeze({ ...entry }))) };
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return { version: 1, projects: [] };
+            throw error;
+        }
+    }
+    async register(project) {
+        const current = await this.read();
+        const projects = current.projects.filter((entry) => entry.path !== project.path);
+        projects.push(Object.freeze({ ...project }));
+        projects.sort((left, right) => left.path.localeCompare(right.path));
+        await this.write({ version: 1, projects });
+    }
+    async unregister(projectPath) {
+        const current = await this.read();
+        await this.write({ version: 1, projects: current.projects.filter((entry) => entry.path !== projectPath) });
+    }
+    async isRegistered(projectPath) {
+        const canonical = await (0, promises_1.realpath)(projectPath);
+        const current = await this.read();
+        return current.projects.some((entry) => entry.path === canonical);
+    }
+    async write(value) {
+        const directory = (0, node_path_1.dirname)(this.file);
+        await (0, promises_2.mkdir)(directory, { recursive: true, mode: 0o700 });
+        await (0, promises_2.chmod)(directory, 0o700);
+        const temporary = (0, node_path_1.join)(directory, `.${(0, node_crypto_1.randomUUID)()}.projects.tmp`);
+        try {
+            await (0, promises_2.writeFile)(temporary, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" });
+            await (0, promises_2.rename)(temporary, this.file);
+            await (0, promises_2.chmod)(this.file, 0o600);
+        }
+        finally {
+            await (0, promises_2.rm)(temporary, { force: true });
+        }
+    }
+}
+exports.ProjectRegistryStore = ProjectRegistryStore;
+/**
+ * Marker string `deinitializeProject` looks for before deleting the file — it is how we
+ * tell a config we generated from one the user wrote themselves.
+ */
+const EXCLUDE_ENTRY = ".claude/settings.local.json";
+/**
+ * Keeps the generated settings file out of `git status` without touching a tracked file.
+ * `.git/info/exclude` is per-clone and never committed, so this stays invisible to the
+ * project's collaborators — unlike appending to `.gitignore`.
+ */
+async function excludeLocally(project) {
+    const file = (0, node_path_1.join)(project, ".git", "info", "exclude");
+    try {
+        const current = (await exists(file)) ? await (0, promises_2.readFile)(file, "utf8") : "";
+        if (current.split(/\r?\n/).some((line) => line.trim() === EXCLUDE_ENTRY))
+            return;
+        await (0, promises_2.mkdir)((0, node_path_1.dirname)(file), { recursive: true });
+        const separator = current === "" || current.endsWith("\n") ? "" : "\n";
+        await (0, promises_2.writeFile)(file, `${current}${separator}${EXCLUDE_ENTRY}\n`, "utf8");
+    }
+    catch { /* not a git checkout, or exclude unwritable — the settings file still works */ }
+}
+async function writeProjectSettings(project, repoRoot) {
+    const file = (0, node_path_1.join)(project, ".claude", "settings.local.json");
+    if (await exists(file)) {
+        const content = await (0, promises_2.readFile)(file, "utf8");
+        if (!content.toLowerCase().includes("alp init"))
+            await (0, promises_2.rename)(file, `${file}.alp-backup`);
+    }
+    await (0, promises_2.mkdir)((0, node_path_1.dirname)(file), { recursive: true });
+    // Forwarder ở `~/.alp/hooks`, KHÔNG phải hook trong thư mục cài: file này nằm trong repo của
+    // người dùng và sống lâu hơn bản cài ALP đã ghi ra nó. Một đường dẫn tuyệt đối tới thư mục
+    // cài sẽ chết khi lên version, đổi channel hoặc cài lại chỗ khác — và phiên `claude` mở tay
+    // chỉ im lặng mất identity, đúng kiểu hỏng câm khó lần ra nhất.
+    const hook = `${JSON.stringify(process.execPath)} ${JSON.stringify((0, state_paths_1.hookForwarder)("session-boot"))}`;
+    await (0, promises_2.writeFile)(file, `${JSON.stringify({
+        $generatedBy: "alp init",
+        hooks: { SessionStart: [{ hooks: [{ type: "command", command: hook }] }] },
+    }, null, 2)}\n`, "utf8");
+    await excludeLocally(project);
+}
+async function initializeProject(input, dependencies = {}) {
+    const project = await (0, promises_1.realpath)(input.project);
+    const metadata = await (0, promises_2.lstat)(project);
+    if (!metadata.isDirectory())
+        throw new Error(`project is not a directory: ${project}`);
+    const store = dependencies.store ?? new ProjectRegistryStore();
+    const registered = Object.freeze({ path: project });
+    await store.register(registered);
+    if (input.repoRoot)
+        await writeProjectSettings(project, input.repoRoot);
+    return registered;
+}
+async function removeEmpty(directory) {
+    try {
+        if ((await (0, promises_2.readdir)(directory)).length === 0)
+            await (0, promises_2.rm)(directory, { recursive: false });
+    }
+    catch { /* absent or non-empty */ }
+}
+async function removeOwnedSkillLinks(project, repoRoot) {
+    const skillsRoot = (0, node_path_1.join)(repoRoot, "skills");
+    for (const directory of [(0, node_path_1.join)(project, ".claude", "skills"), (0, node_path_1.join)(project, ".agents", "skills")]) {
+        let entries;
+        try {
+            entries = await (0, promises_2.readdir)(directory);
+        }
+        catch {
+            continue;
+        }
+        for (const name of entries) {
+            const link = (0, node_path_1.join)(directory, name);
+            let metadata;
+            try {
+                metadata = await (0, promises_2.lstat)(link);
+            }
+            catch {
+                continue;
+            }
+            if (!metadata.isSymbolicLink())
+                continue;
+            const target = await (0, promises_2.readlink)(link);
+            const resolved = (0, node_path_1.resolve)((0, node_path_1.dirname)(link), target);
+            if (within(skillsRoot, resolved))
+                await (0, promises_2.rm)(link, { force: true });
+        }
+        await removeEmpty(directory);
+        await removeEmpty((0, node_path_1.dirname)(directory));
+    }
+}
+async function cleanupGeneratedConfig(file) {
+    const backup = `${file}.alp-backup`;
+    if (await exists(file)) {
+        const content = await (0, promises_2.readFile)(file, "utf8");
+        if (content.toLowerCase().includes("alp init"))
+            await (0, promises_2.rm)(file);
+    }
+    if ((await exists(backup)) && !(await exists(file)))
+        await (0, promises_2.rename)(backup, file);
+    await removeEmpty((0, node_path_1.dirname)(file));
+}
+async function deinitializeProject(input, dependencies = {}) {
+    const project = await (0, promises_1.realpath)(input.project);
+    await removeOwnedSkillLinks(project, input.repoRoot);
+    await cleanupGeneratedConfig((0, node_path_1.join)(project, ".claude", "settings.local.json"));
+    await cleanupGeneratedConfig((0, node_path_1.join)(project, ".codex", "config.toml"));
+    await (dependencies.store ?? new ProjectRegistryStore()).unregister(project);
+}

package/dist/src/cli/commands/mode.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runModeCommand = runModeCommand;
+const modes_1 = require("../../agents/modes");
+const mode_preference_store_1 = require("../mode-preference-store");
+async function runModeCommand(input, options = {}) {
+    const store = options.store ?? new mode_preference_store_1.FileModePreferenceStore();
+    const write = options.write ?? ((text) => process.stdout.write(text));
+    if (input.action === "set") {
+        if (!input.mode)
+            throw new Error("mode set requires low, medium, high, ultra, or puck");
+        await store.write(input.mode);
+        write(`${input.mode}\n`);
+        return input.mode;
+    }
+    const preference = await store.read();
+    if (preference.warning)
+        write(`WARNING  ${preference.warning}\n`);
+    const mode = preference.mode ?? modes_1.DEFAULT_MODE;
+    write(`${mode}\n`);
+    return mode;
+}

package/dist/src/cli/commands/principal.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptPrincipalProfile = promptPrincipalProfile;
+exports.ensurePrincipalProfile = ensurePrincipalProfile;
+exports.runPrincipalCommand = runPrincipalCommand;
+const promises_1 = require("node:readline/promises");
+const principal_profile_store_1 = require("../../principal/principal-profile-store");
+const STDIN_ENDED = "stdin ended before the principal profile was complete";
+/**
+ * Reads answers off a line queue instead of `rl.question`.
+ *
+ * Two reasons. A piped stdin (`printf 'name\nanh\nem\n' | alp principal set`) flushes every
+ * line while only the first question is pending, and `rl.question` drops the rest; and when
+ * the input ends with a question outstanding, `rl.question` never settles, so the CLI would
+ * hang rather than fail. Queueing lines fixes the first, and the close handler turns the
+ * second into an error.
+ */
+function openTerminalPrompt() {
+    const reader = (0, promises_1.createInterface)({ input: process.stdin, output: process.stdout });
+    const lines = [];
+    const waiting = [];
+    let ended = false;
+    reader.on("line", (line) => {
+        const waiter = waiting.shift();
+        if (waiter)
+            waiter.resolve(line);
+        else
+            lines.push(line);
+    });
+    reader.on("close", () => {
+        ended = true;
+        for (const waiter of waiting.splice(0))
+            waiter.reject(new Error(STDIN_ENDED));
+    });
+    return {
+        ask(question) {
+            process.stdout.write(question);
+            const buffered = lines.shift();
+            if (buffered !== undefined)
+                return Promise.resolve(buffered);
+            if (ended)
+                return Promise.reject(new Error(STDIN_ENDED));
+            return new Promise((resolve, reject) => { waiting.push({ resolve, reject }); });
+        },
+        close: () => reader.close(),
+    };
+}
+async function promptPrincipalProfile(prompt) {
+    return (0, principal_profile_store_1.normalizePrincipalProfile)({
+        name: await prompt.ask("  Your name: "),
+        addressAs: await prompt.ask("  An agent addresses you as (anh, chị, bạn…): "),
+        selfAs: await prompt.ask("  An agent refers to itself as (em, tôi, mình…): "),
+    });
+}
+function describe(profile) {
+    return `PROFILE  ${profile.name} — agents say "${profile.selfAs}" and call you "${profile.addressAs}"\n`;
+}
+async function capturePrincipalProfile(dependencies) {
+    dependencies.write("\nWho is ALP serving? This is stored once, on this machine only.\n");
+    const prompt = (dependencies.openPrompt ?? openTerminalPrompt)();
+    let answered;
+    try {
+        answered = await promptPrincipalProfile(prompt);
+    }
+    finally {
+        prompt.close();
+    }
+    const profile = await (0, principal_profile_store_1.writePrincipalProfile)(answered, dependencies.file);
+    dependencies.write(describe(profile));
+    await dependencies.syncIdentity?.();
+    return profile;
+}
+/**
+ * Called by `alp init`. Asks only when the profile is missing and a terminal is attached;
+ * a non-interactive install (CI, scripts) keeps going with a neutral prompt rather than
+ * failing or guessing a name from git config.
+ *
+ * Never throws: the project registration has already happened by this point, so a refused
+ * or empty answer downgrades to the same note a non-interactive run gets.
+ */
+async function ensurePrincipalProfile(input, dependencies) {
+    const current = (0, principal_profile_store_1.readPrincipalProfile)(dependencies.file ?? (0, principal_profile_store_1.principalProfileFile)());
+    if (current.warning)
+        dependencies.write(`WARNING  ${current.warning}\n`);
+    if (current.profile)
+        return current.profile;
+    if (input.interactive) {
+        try {
+            return await capturePrincipalProfile(dependencies);
+        }
+        catch (error) {
+            dependencies.write(`WARNING  ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+    }
+    dependencies.write("NOTE     principal profile is unset; run `alp principal set` to add your name and forms of address\n");
+    return null;
+}
+async function runPrincipalCommand(input, dependencies) {
+    const file = dependencies.file ?? (0, principal_profile_store_1.principalProfileFile)();
+    if (input.action === "show") {
+        const current = (0, principal_profile_store_1.readPrincipalProfile)(file);
+        if (current.warning)
+            dependencies.write(`WARNING  ${current.warning}\n`);
+        if (!current.profile) {
+            dependencies.write("UNSET    no principal profile; run `alp principal set`\n");
+            return 1;
+        }
+        dependencies.write(describe(current.profile));
+        dependencies.write(`FILE     ${file}\n`);
+        return 0;
+    }
+    await capturePrincipalProfile(dependencies);
+    return 0;
+}

package/dist/src/cli/commands/run-main.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMainSession = runMainSession;
+const modes_1 = require("../../agents/modes");
+const promises_1 = require("node:fs/promises");
+const continuity_1 = require("../../context/continuity");
+async function runMainSession(input, dependencies) {
+    const definition = dependencies.registry.get("main");
+    if (definition.reportsTo !== "principal")
+        throw new Error("main must report to principal");
+    const selection = await dependencies.selector.select({
+        ...(input.mode === undefined ? {} : { requestedMode: input.mode }),
+        interactive: dependencies.interactive && input.mode === undefined,
+    });
+    if (!selection.ok)
+        return { executionId: "cancelled", status: "cancelled" };
+    const mode = selection.mode;
+    // Runtime là **hệ quả** của model, không phải một lựa chọn riêng: nấc ghim một model cho
+    // `main`, và model đó chỉ chạy được trên đúng một CLI.
+    const runtime = (0, modes_1.runtimeForMode)(definition, mode);
+    const executionId = dependencies.executionId();
+    const workspaceMode = dependencies.workspaceModeFor
+        ? await dependencies.workspaceModeFor(input.cwd)
+        : "read-only";
+    const execution = await dependencies.executionService.prepare({
+        executionId,
+        parent: "principal",
+        target: definition.id,
+        // Never rendered into a turn — an interactive launch writes no task file. It exists as
+        // audit metadata in `identity-capsule.json`, saying what this execution was opened for.
+        // The real task arrives as the principal's own first message.
+        task: continuity_1.INTERACTIVE_TASK_SENTINEL,
+        workspace: input.cwd,
+        workspaceMode,
+        mode,
+        memoryQueries: [],
+        characterBudget: 0,
+        invariantContext: "ALP execution policy is authoritative and fails closed.",
+        policyContext: "Direct raw runtime launch is unsupported; use ALP workflows.",
+    });
+    const adapter = dependencies.adapters.get(runtime);
+    if (!adapter)
+        throw new Error(`runtime \`${runtime}\` is not registered`);
+    const health = await adapter.probe();
+    if (!health.ok)
+        throw new Error(`${health.message}${health.remediation ? `; ${health.remediation}` : ""}`);
+    const launchSpec = await adapter.prepare({
+        execution,
+        // Nấc thắng khai báo của vai — cùng một `main` chạy bốn model khác nhau. Lấy từ cùng
+        // giá trị đã đi vào policy, để `policy.json` và tiến trình thật sự chạy không lệch nhau.
+        model: (0, modes_1.modelForMode)(definition, mode),
+        reasoningEffort: (0, modes_1.reasoningEffortForMode)(definition, mode),
+        interactive: true,
+    });
+    // The principal is sitting in front of this one, so it must own the terminal: a backend
+    // that tees stdout instead of inheriting it would leave the session with no tty and no
+    // way to type. `interactive` is the only thing that keeps `stdio: "inherit"` here.
+    const spawned = await dependencies.backend.spawn({
+        executionId,
+        launchSpec,
+        lifecycle: {
+            requestId: executionId,
+            parentExecutionId: null,
+            background: false,
+            interactive: true,
+            timeoutMs: null,
+        },
+    });
+    const backendResult = spawned.status === "running" ? await dependencies.backend.wait(executionId) : spawned;
+    const stateFile = execution.artifacts?.stateFile;
+    if (!stateFile || !["completed", "failed", "cancelled"].includes(backendResult.status))
+        return backendResult;
+    try {
+        const state = JSON.parse(await (0, promises_1.readFile)(stateFile, "utf8"));
+        const status = ["completed", "failed", "cancelled"].includes(String(state.status))
+            ? state.status
+            : backendResult.status;
+        return {
+            ...backendResult,
+            status,
+            ...(state.output === undefined
+                ? {}
+                // Prose answers pass through unchanged; only a non-string is serialized.
+                : { output: typeof state.output === "string" ? state.output : JSON.stringify(state.output) }),
+        };
+    }
+    catch {
+        return backendResult;
+    }
+}

package/dist/src/cli/commands/runtime.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRuntimeCommand = runRuntimeCommand;
+const runtime_preference_store_1 = require("../../runtime/runtime-preference-store");
+async function runRuntimeCommand(input, options = {}) {
+    const store = options.store ?? new runtime_preference_store_1.FileRuntimePreferenceStore();
+    const write = options.write ?? ((text) => process.stdout.write(text));
+    if (input.action === "set") {
+        if (!input.runtime)
+            throw new Error("runtime set requires claude or codex");
+        await store.write(input.runtime);
+        write(`${input.runtime}\n`);
+        return input.runtime;
+    }
+    const preference = await store.read();
+    if (preference.warning)
+        write(`WARNING  ${preference.warning}\n`);
+    const runtime = preference.runtime ?? "claude";
+    write(`${runtime}\n`);
+    return runtime;
+}

package/dist/src/cli/mode-preference-store.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileModePreferenceStore = void 0;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const modes_1 = require("../agents/modes");
+class FileModePreferenceStore {
+    file;
+    constructor(options = {}) {
+        this.file = options.file ?? (0, node_path_1.join)((0, node_os_1.homedir)(), ".alp", "mode.json");
+    }
+    async read() {
+        let content;
+        try {
+            content = await (0, promises_1.readFile)(this.file, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return { mode: null };
+            }
+            return {
+                mode: null,
+                warning: `invalid mode preference at ${this.file}; using \`${modes_1.DEFAULT_MODE}\``,
+            };
+        }
+        try {
+            const parsed = JSON.parse(content);
+            if (parsed === null || typeof parsed !== "object" || !(0, modes_1.isModeId)(parsed.mode)) {
+                throw new Error("invalid mode");
+            }
+            return { mode: parsed.mode };
+        }
+        catch {
+            return {
+                mode: null,
+                warning: `invalid mode preference at ${this.file}; using \`${modes_1.DEFAULT_MODE}\``,
+            };
+        }
+    }
+    async write(mode) {
+        if (!(0, modes_1.isModeId)(mode)) {
+            throw new Error(`invalid mode \`${String(mode)}\``);
+        }
+        const directory = (0, node_path_1.dirname)(this.file);
+        await (0, promises_1.mkdir)(directory, { recursive: true, mode: 0o700 });
+        await (0, promises_1.chmod)(directory, 0o700);
+        const temporary = (0, node_path_1.join)(directory, `.${(0, node_crypto_1.randomUUID)()}.mode.tmp`);
+        try {
+            await (0, promises_1.writeFile)(temporary, `${JSON.stringify({ mode })}\n`, { encoding: "utf8", flag: "wx", mode: 0o600 });
+            await (0, promises_1.chmod)(temporary, 0o600);
+            await (0, promises_1.rename)(temporary, this.file);
+            await (0, promises_1.chmod)(this.file, 0o600);
+        }
+        catch (error) {
+            await (0, promises_1.rm)(temporary, { force: true });
+            throw error;
+        }
+    }
+}
+exports.FileModePreferenceStore = FileModePreferenceStore;