alp-code 0.9.0

package/dist/src/agents/modes.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODE_PROFILES = exports.DEFAULT_MODE = exports.MODE_IDS = void 0;
+exports.homeRuntimeForMode = homeRuntimeForMode;
+exports.modelForMode = modelForMode;
+exports.reasoningEffortForMode = reasoningEffortForMode;
+exports.runtimeForMode = runtimeForMode;
+exports.isModeId = isModeId;
+exports.parseMode = parseMode;
+const model_context_1 = require("./model-context");
+/**
+ * Dial công suất — `low` · `medium` · `high` · `ultra`, cộng `puck`.
+ *
+ * Ý tưởng mượn từ Amp: người dùng không nên phải nhớ model nào giỏi việc gì, câu hỏi duy
+ * nhất còn lại là **"việc này khó cỡ nào"**. Nấc trả lời câu đó bằng một **loadout hoàn
+ * chỉnh**: mỗi vai đúng **một** model và một mức suy nghĩ.
+ *
+ * Một model cho mỗi vai kéo theo một hệ quả lớn: **model quyết định runtime**. `claude-*`
+ * phóng Claude Code, `gpt-*` phóng Codex CLI (`MODEL_RUNTIMES`). Không còn bước "chọn
+ * runtime rồi tra model" — nấc là lựa chọn duy nhất, và một nấc có thể trộn hai CLI trong
+ * cùng một phiên, đúng như Amp trộn. `oracle` luôn đứng ở runtime **đối diện** `main` — người
+ * được hỏi khi bí phải là một cách nhìn khác, không phải cùng model tự hỏi lại chính nó
+ * (vd `medium`: main Sol/Codex, oracle Opus 5/Claude).
+ *
+ * Bốn nấc dial chỉ xoay hai ghế mà độ khó chạm tới — `main` (người làm) và `oracle` (người
+ * được hỏi khi bí). Sáu vai còn lại giữ nguyên qua cả bốn nấc, đúng chỗ Amp ghim cứng
+ * subagent: model của chúng là **một phần công việc** chứ không phải một mức cố gắng —
+ * `search` cần retrieval nhanh dù câu hỏi to hay nhỏ, `titling` viết một dòng.
+ *
+ * `puck` nằm ngoài trục độ khó: nó là câu trả lời cho "chạy toàn Codex", cho máy chỉ cài
+ * `codex`, cho lúc hạn mức Claude đã hết, hoặc cho người muốn đúng loadout Amp mặc định.
+ */
+exports.MODE_IDS = ["low", "medium", "high", "ultra", "puck"];
+/**
+ * Nấc mặc định khi không ai nói gì — cùng lựa chọn của Amp. `medium` đủ cho phần lớn việc
+ * thường ngày; hai nấc trên dành cho việc mà một câu trả lời sai tốn nhiều hơn phần chênh.
+ */
+exports.DEFAULT_MODE = "medium";
+/**
+ * Sáu vai không nằm trên trục độ khó, giống nhau ở cả bốn nấc dial.
+ *
+ * `search` và `librarian` lấy thẳng lựa chọn của Amp (Terra cho search, Sol cho librarian):
+ * đó là hai việc retrieval thuần, nơi nhanh và rẻ ăn đứt sâu sắc. Bốn vai còn lại ở phía
+ * Claude, giữ đúng loadout ALP đang chạy trước khi có dial.
+ */
+const FIXED_ROLES = Object.freeze({
+    search: { model: "gpt-5.6-terra", reasoningEffort: "low" },
+    librarian: { model: "gpt-5.6-sol", reasoningEffort: "high" },
+    "read-thread": { model: "claude-haiku-4-5", reasoningEffort: "low" },
+    review: { model: "claude-opus-5", reasoningEffort: "high" },
+    compaction: { model: "claude-opus-5", reasoningEffort: "medium" },
+    titling: { model: "claude-haiku-4-5", reasoningEffort: "low" },
+});
+exports.MODE_PROFILES = Object.freeze({
+    low: {
+        summary: "việc vặt, câu trả lời nhanh — rẻ và đủ",
+        roles: {
+            ...FIXED_ROLES,
+            main: { model: "claude-sonnet-5", reasoningEffort: "high" },
+            oracle: { model: "gpt-5.6-sol", reasoningEffort: "high" },
+        },
+    },
+    medium: {
+        summary: "mặc định — việc thường ngày, sửa và đọc code trong một repo quen",
+        roles: {
+            ...FIXED_ROLES,
+            main: { model: "gpt-5.6-sol", reasoningEffort: "high" },
+            oracle: { model: "claude-opus-5", reasoningEffort: "high" },
+        },
+    },
+    high: {
+        summary: "việc khó — refactor xuyên module, bug không tái hiện được ngay",
+        roles: {
+            ...FIXED_ROLES,
+            main: { model: "claude-opus-5", reasoningEffort: "high" },
+            oracle: { model: "gpt-5.6-sol", reasoningEffort: "xhigh" },
+        },
+    },
+    ultra: {
+        summary: "việc mà trả lời sai tốn hơn phần chênh — thiết kế, migration, sự cố",
+        roles: {
+            ...FIXED_ROLES,
+            main: { model: "claude-opus-5", reasoningEffort: "high" },
+            oracle: { model: "gpt-6-astra", reasoningEffort: "high" },
+        },
+    },
+    puck: {
+        summary: "toàn Codex — máy chỉ có `codex`, hết hạn mức Claude, hoặc muốn đúng loadout Amp",
+        roles: {
+            main: { model: "gpt-5.6-sol", reasoningEffort: "xhigh" },
+            oracle: { model: "gpt-5.6-sol", reasoningEffort: "xhigh" },
+            search: { model: "gpt-5.6-terra", reasoningEffort: "low" },
+            librarian: { model: "gpt-5.6-sol", reasoningEffort: "high" },
+            "read-thread": { model: "gpt-5.6-luna", reasoningEffort: "low" },
+            review: { model: "gpt-5.6-terra", reasoningEffort: "medium" },
+            compaction: { model: "gpt-5.6-sol", reasoningEffort: "medium" },
+            titling: { model: "gpt-5.6-luna", reasoningEffort: "low" },
+        },
+    },
+});
+/**
+ * Runtime "nhà" của một nấc — runtime của ghế `main`.
+ *
+ * Chỉ dùng làm chỗ dựa cho vai **không** có trong loadout (custom agent mai này): nó vẫn
+ * khai `model: {claude, codex}`, và phía được chọn là phía mà nấc đang đứng. Tám vai
+ * built-in đều có mặt trong mọi nấc nên không bao giờ đi qua nhánh này.
+ */
+function homeRuntimeForMode(mode) {
+    return (0, model_context_1.runtimeForModel)(exports.MODE_PROFILES[mode].roles.main.model);
+}
+function modelForMode(definition, mode) {
+    const profile = exports.MODE_PROFILES[mode].roles[definition.id];
+    return profile?.model ?? definition.model[homeRuntimeForMode(mode)];
+}
+function reasoningEffortForMode(definition, mode) {
+    const profile = exports.MODE_PROFILES[mode].roles[definition.id];
+    return profile?.reasoningEffort ?? definition.reasoningEffort[homeRuntimeForMode(mode)];
+}
+/** CLI nào phóng vai này ở nấc này — suy từ model, vì model mới là thứ được chạy. */
+function runtimeForMode(definition, mode) {
+    return (0, model_context_1.runtimeForModel)(modelForMode(definition, mode));
+}
+function isModeId(value) {
+    return typeof value === "string" && exports.MODE_IDS.includes(value);
+}
+/**
+ * Fail-closed: một nấc gõ sai (`--mode smart`, `ALP_MODE=deep`) không được lặng lẽ rơi về
+ * mặc định, vì lúc đó người dùng tin mình đang chạy nấc khác với nấc thật sự chạy.
+ */
+function parseMode(value) {
+    if (isModeId(value))
+        return value;
+    throw new Error(`mode must be one of ${exports.MODE_IDS.join(", ")}, received \`${String(value)}\``);
+}

package/dist/src/agents/oracle.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oracleAgent = void 0;
+const agent_definition_1 = require("./agent-definition");
+const house_rules_1 = require("./shared/house-rules");
+const voice_1 = require("./shared/voice");
+const types_1 = require("../workflow/types");
+exports.oracleAgent = (0, agent_definition_1.defineAgent)({
+    id: "oracle",
+    displayName: "Oracle 🔮",
+    model: { claude: "claude-opus-5", codex: "gpt-5.6-sol" },
+    reasoningEffort: { claude: "high", codex: "xhigh" },
+    reportsTo: "main",
+    delegatesTo: [],
+    // Suy luận trên cả tập bằng chứng một lượt; nén sớm là vứt đi chính bằng chứng đó. Nên
+    // vai này cũng lấy mặc định 90% như `main`, không tự siết mình xuống thấp hơn.
+    capabilities: {
+        tools: ["Read", "Glob", "Grep", "Bash", "WebSearch", "WebFetch", "Skill"],
+        skills: ["alp-debug", "alp-predict", "alp-scenario", "problem-solving"],
+        subagents: [],
+        mcpServers: [],
+        memory: {
+            read: ["shared", "project:*", "private:oracle"],
+            write: ["private:oracle"],
+        },
+        workspace: { readRoots: ["."], writeRoots: [] },
+    },
+    instructions: () => (0, voice_1.renderInstructions)("Oracle, the senior reasoning and architecture advisor", "Provide an independent second opinion, challenge assumptions, and expose trade-offs for high-risk decisions or debugging.", [...house_rules_1.CODE_NATIVE_HOUSE_RULES, ...house_rules_1.CODE_CRAFT_RULES, "Return recommendations only; do not implement changes or present assumptions as verified facts."]),
+    workflow: (0, types_1.defineLinearWorkflow)("advise", [
+        { id: "FRAME", allowedTools: ["Read", "Glob", "Grep"] },
+        { id: "CHALLENGE", allowedTools: ["Read", "Glob", "Grep", "Bash", "WebSearch", "WebFetch"] },
+        { id: "EVALUATE", allowedTools: ["Read", "Glob", "Grep", "Bash", "WebSearch", "WebFetch"] },
+        { id: "RECOMMEND", allowedTools: [] },
+    ]),
+    output: (0, voice_1.textOutput)("architecture-advice"),
+});

package/dist/src/agents/read-thread.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readThreadAgent = void 0;
+const agent_definition_1 = require("./agent-definition");
+const house_rules_1 = require("./shared/house-rules");
+const voice_1 = require("./shared/voice");
+const types_1 = require("../workflow/types");
+exports.readThreadAgent = (0, agent_definition_1.defineAgent)({
+    id: "read-thread",
+    displayName: "Read Thread 🧵",
+    model: { claude: "claude-haiku-4-5", codex: "gpt-5.6-luna" },
+    reasoningEffort: { claude: "low", codex: "low" },
+    reportsTo: "main",
+    delegatesTo: [],
+    // Một thread là hữu hạn — đây là trần, không phải kỳ vọng. Chỉ khai được phía codex:
+    // cửa sổ của haiku-4-5 đúng bằng 200k, nên trên Claude trần này là chính bức tường, và
+    // mặc định 180k mới là con số còn chừa chỗ để nén.
+    autoCompactTokens: { codex: 200_000 },
+    capabilities: {
+        tools: ["Read", "Glob", "Grep", "Skill"],
+        skills: ["agent-memory"],
+        subagents: [],
+        mcpServers: [],
+        memory: {
+            read: ["shared", "project:*", "private:read-thread"],
+            write: ["private:read-thread"],
+        },
+        workspace: { readRoots: [], writeRoots: [] },
+    },
+    instructions: () => (0, voice_1.renderInstructions)("Read Thread, the memory retrieval specialist", "Retrieve prior facts, decisions, and logs from granted memory and preserve exact anchors and uncertainty.", [...house_rules_1.CODE_NATIVE_HOUSE_RULES, "Do not inspect source workspaces or change shared/project memory."]),
+    workflow: (0, types_1.defineLinearWorkflow)("retrieve-memory", [
+        { id: "PARSE_QUERY", allowedTools: [] },
+        { id: "RETRIEVE", allowedTools: ["Read", "Glob", "Grep"] },
+        { id: "VERIFY", allowedTools: ["Read", "Glob", "Grep"] },
+        { id: "REPORT", allowedTools: [] },
+    ]),
+    output: (0, voice_1.textOutput)("memory-retrieval-result"),
+});

package/dist/src/agents/registry.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentRegistry = exports.AGENT_DEFINITIONS = void 0;
+exports.createAgentRegistry = createAgentRegistry;
+const node_path_1 = require("node:path");
+const agent_definition_1 = require("./agent-definition");
+const capability_catalog_1 = require("./capability-catalog");
+const errors_1 = require("./errors");
+const memory_grant_1 = require("./memory-grant");
+const model_context_1 = require("./model-context");
+const types_1 = require("./types");
+const KNOWN_TOOLS = new Set(types_1.TOOL_CATALOG);
+/** Claude's documented `autoCompactWindow` bounds; Codex publishes none, so it shares them. */
+const AUTO_COMPACT_MIN_TOKENS = 100_000;
+const AUTO_COMPACT_MAX_TOKENS = 1_000_000;
+const REASONING_EFFORTS = new Set(["low", "medium", "high", "xhigh", "max", "ultra"]);
+function assertNonEmpty(value, label, agentId) {
+    if (!value.trim()) {
+        throw new errors_1.AgentRegistryError("INVALID_AGENT", `agent \`${agentId}\` has an empty ${label}`);
+    }
+}
+function pathIsWithin(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));
+}
+function assertWorkspaceWriteSubset(agentId, writes, reads) {
+    for (const write of writes) {
+        if (!reads.some((read) => pathIsWithin(read, write))) {
+            throw new errors_1.AgentRegistryError("INVALID_WORKSPACE_GRANT", `agent \`${agentId}\` workspace write root \`${write}\` is not readable`);
+        }
+    }
+}
+function assertMemoryWriteSubset(agentId, writes, reads) {
+    for (const write of writes) {
+        if (!reads.some((read) => (0, memory_grant_1.memoryGrantCovers)(read, write))) {
+            throw new errors_1.AgentRegistryError("INVALID_MEMORY_GRANT", `agent \`${agentId}\` memory write grant \`${write}\` is not readable`);
+        }
+    }
+}
+function privateOwner(grant) {
+    return grant.startsWith("private:") ? grant.slice("private:".length) : null;
+}
+function assertNoDuplicates(agentId, label, names) {
+    const seen = new Set();
+    for (const name of names) {
+        if (seen.has(name)) {
+            throw new errors_1.AgentRegistryError("DUPLICATE_GRANT", `agent \`${agentId}\` names ${label} \`${name}\` twice`);
+        }
+        seen.add(name);
+    }
+}
+/**
+ * The three name-declared grants of §5.3, checked against the catalog the principal keeps.
+ *
+ * A name that resolves to nothing is refused rather than ignored: a definition asking for
+ * `mcpServers: ["github"]` on a machine that never trusted `github` is stating an intent
+ * the execution cannot honour, and the quiet reading of that — no server, run anyway — is
+ * how a role ends up reporting failure for a reason nobody can see.
+ */
+function assertCapabilityGrants(definition, catalog) {
+    const { skills, subagents, mcpServers, tools } = definition.capabilities;
+    assertNoDuplicates(definition.id, "skill", skills);
+    assertNoDuplicates(definition.id, "subagent", subagents);
+    assertNoDuplicates(definition.id, "mcp server", mcpServers);
+    const known = new Set(catalog.skills);
+    for (const skill of skills) {
+        if (!known.has(skill)) {
+            throw new errors_1.AgentRegistryError("UNKNOWN_SKILL", `agent \`${definition.id}\` has unknown skill \`${skill}\``);
+        }
+    }
+    for (const subagent of subagents) {
+        if (!Object.hasOwn(catalog.subagents, subagent)) {
+            throw new errors_1.AgentRegistryError("UNKNOWN_SUBAGENT", `agent \`${definition.id}\` has unknown subagent \`${subagent}\``);
+        }
+    }
+    for (const server of mcpServers) {
+        if (!Object.hasOwn(catalog.mcpServers, server)) {
+            throw new errors_1.AgentRegistryError("UNKNOWN_MCP_SERVER", `agent \`${definition.id}\` has unknown mcp server \`${server}\``);
+        }
+    }
+    // A subagent runs inside this role's own process. Handing it a tool the role does not
+    // hold would make the grant a way around the role's limits — the thing the house rule
+    // says it is not.
+    for (const subagent of subagents) {
+        for (const tool of catalog.subagents[subagent]?.tools ?? []) {
+            if (!definition.capabilities.tools.includes(tool)) {
+                throw new errors_1.AgentRegistryError("UNKNOWN_TOOL", `agent \`${definition.id}\` grants subagent \`${subagent}\` the ungranted tool \`${tool}\``);
+            }
+        }
+    }
+    const holdsSkillTool = tools.includes("Skill");
+    if (holdsSkillTool && skills.length === 0) {
+        throw new errors_1.AgentRegistryError("INVALID_SKILL_GRANT", `agent \`${definition.id}\` grants the \`Skill\` tool but names no skill`);
+    }
+    if (!holdsSkillTool && skills.length > 0) {
+        throw new errors_1.AgentRegistryError("INVALID_SKILL_GRANT", `agent \`${definition.id}\` names skills but has no \`Skill\` tool to invoke them`);
+    }
+}
+function assertDefinitionInvariants(definition, catalog) {
+    assertNonEmpty(definition.id, "id", definition.id);
+    assertNonEmpty(definition.displayName, "displayName", definition.id);
+    if (!definition.model.claude.trim()) {
+        throw new errors_1.AgentRegistryError("INVALID_AGENT", `agent \`${definition.id}\` is missing Claude runtime model`);
+    }
+    if (!definition.model.codex.trim()) {
+        throw new errors_1.AgentRegistryError("INVALID_AGENT", `agent \`${definition.id}\` is missing Codex runtime model`);
+    }
+    for (const runtime of types_1.RUNTIME_IDS) {
+        if (!REASONING_EFFORTS.has(definition.reasoningEffort[runtime])) {
+            throw new errors_1.AgentRegistryError("INVALID_AGENT", `agent \`${definition.id}\` has invalid ${runtime} reasoning effort`);
+        }
+    }
+    for (const runtime of types_1.RUNTIME_IDS) {
+        const autoCompact = definition.autoCompactTokens?.[runtime];
+        if (autoCompact === undefined)
+            continue;
+        const prefix = `agent \`${definition.id}\` has ${runtime} auto-compact threshold \`${autoCompact}\``;
+        if (!Number.isInteger(autoCompact)
+            || autoCompact < AUTO_COMPACT_MIN_TOKENS
+            || autoCompact > AUTO_COMPACT_MAX_TOKENS) {
+            throw new errors_1.AgentRegistryError("INVALID_AUTO_COMPACT_LIMIT", `${prefix}, outside ${AUTO_COMPACT_MIN_TOKENS}–${AUTO_COMPACT_MAX_TOKENS} whole tokens`);
+        }
+        // A threshold above the model's own window is a line the transcript can never cross:
+        // the runtime falls back to its hard limit and compacts later than the role asked,
+        // while argv still prints a number that says otherwise. Refused here rather than
+        // clamped at launch — the number is wrong where it is written, not where it is read.
+        const window = model_context_1.MODEL_CONTEXT_WINDOWS[definition.model[runtime]];
+        if (window !== undefined && autoCompact > window) {
+            throw new errors_1.AgentRegistryError("INVALID_AUTO_COMPACT_LIMIT", `${prefix} above the context window of \`${definition.model[runtime]}\` (${window} tokens)`);
+        }
+    }
+    assertNonEmpty(definition.workflow.id, "workflow id", definition.id);
+    assertNonEmpty(definition.output.name, "output contract name", definition.id);
+    assertWorkspaceWriteSubset(definition.id, definition.capabilities.workspace.writeRoots, definition.capabilities.workspace.readRoots);
+    assertMemoryWriteSubset(definition.id, definition.capabilities.memory.write, definition.capabilities.memory.read);
+    for (const tool of definition.capabilities.tools) {
+        if (!KNOWN_TOOLS.has(tool)) {
+            throw new errors_1.AgentRegistryError("UNKNOWN_TOOL", `agent \`${definition.id}\` has unknown tool \`${tool}\``);
+        }
+    }
+    assertCapabilityGrants(definition, catalog);
+    for (const grant of [
+        ...definition.capabilities.memory.read,
+        ...definition.capabilities.memory.write,
+    ]) {
+        const owner = privateOwner(grant);
+        if (owner !== null && owner !== definition.id) {
+            throw new errors_1.AgentRegistryError("INVALID_MEMORY_GRANT", `agent \`${definition.id}\` cannot access private memory for \`${owner}\``);
+        }
+    }
+}
+function assertRelations(definitions, known) {
+    for (const definition of definitions) {
+        if (definition.reportsTo !== "principal" && !known.has(definition.reportsTo)) {
+            throw new errors_1.AgentRegistryError("UNKNOWN_RELATION", `agent \`${definition.id}\` has unknown reportsTo \`${definition.reportsTo}\``);
+        }
+        for (const target of definition.delegatesTo) {
+            if (target === definition.id) {
+                throw new errors_1.AgentRegistryError("INVALID_DELEGATION", `agent \`${definition.id}\` cannot delegate to itself`);
+            }
+            if (!known.has(target)) {
+                throw new errors_1.AgentRegistryError("UNKNOWN_RELATION", `agent \`${definition.id}\` has unknown delegation target \`${target}\``);
+            }
+        }
+    }
+}
+function assertNoDelegationCycles(definitions, byId) {
+    const state = new Map();
+    const trail = [];
+    const visit = (id) => {
+        if (state.get(id) === "visited")
+            return;
+        if (state.get(id) === "visiting") {
+            const cycleStart = trail.indexOf(id);
+            const cycle = [...trail.slice(cycleStart), id];
+            throw new errors_1.AgentRegistryError("INVALID_DELEGATION", `delegation cycle: ${cycle.join(" -> ")}`);
+        }
+        state.set(id, "visiting");
+        trail.push(id);
+        for (const target of byId.get(id)?.delegatesTo ?? [])
+            visit(target);
+        trail.pop();
+        state.set(id, "visited");
+    };
+    for (const definition of definitions)
+        visit(definition.id);
+}
+function createAgentRegistry(input, options = {}) {
+    const catalog = options.catalog ?? capability_catalog_1.capabilityCatalog;
+    const definitions = [];
+    const byId = new Map();
+    for (const candidate of input) {
+        const definition = (0, agent_definition_1.defineAgent)(candidate);
+        if (byId.has(definition.id)) {
+            throw new errors_1.AgentRegistryError("DUPLICATE_AGENT", `duplicate agent \`${definition.id}\``);
+        }
+        assertDefinitionInvariants(definition, catalog);
+        definitions.push(definition);
+        byId.set(definition.id, definition);
+    }
+    assertRelations(definitions, new Set(byId.keys()));
+    assertNoDelegationCycles(definitions, byId);
+    const list = Object.freeze(definitions.slice());
+    return Object.freeze({
+        get(id) {
+            const definition = byId.get(id);
+            if (!definition) {
+                throw new errors_1.AgentRegistryError("UNKNOWN_AGENT", `unknown agent \`${id}\``);
+            }
+            return definition;
+        },
+        has(id) {
+            return byId.has(id);
+        },
+        list() {
+            return list;
+        },
+    });
+}
+const main_1 = require("./main");
+const search_1 = require("./search");
+const librarian_1 = require("./librarian");
+const read_thread_1 = require("./read-thread");
+const review_1 = require("./review");
+const oracle_1 = require("./oracle");
+const compaction_1 = require("./compaction");
+const titling_1 = require("./titling");
+exports.AGENT_DEFINITIONS = Object.freeze([
+    main_1.mainAgent,
+    search_1.searchAgent,
+    librarian_1.librarianAgent,
+    read_thread_1.readThreadAgent,
+    review_1.reviewAgent,
+    oracle_1.oracleAgent,
+    compaction_1.compactionAgent,
+    titling_1.titlingAgent,
+]);
+exports.agentRegistry = createAgentRegistry(exports.AGENT_DEFINITIONS);

package/dist/src/agents/render-identity.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderIdentityDocument = renderIdentityDocument;
+/**
+ * Renders a role's static identity as a standalone Markdown document.
+ *
+ * This is what `alp identity sync` writes to `.alp/agents/<role>.md`, and what the
+ * SessionStart hook injects on the native path — the principal ran `claude`/`codex`
+ * directly, so no adapter wrote a session context. Keeping it a flat file is the point:
+ * the hook reads it with one `readFileSync` and no `dist/` load.
+ *
+ * Only static facts belong here. A launch through `alp` gets `renderSessionContext`
+ * instead, which adds what only an execution knows: invariants, policy context, and the
+ * workspace grant. Per-task facts belong to `renderTaskInput`.
+ */
+function renderIdentityDocument(definition) {
+    const list = (values) => values.length === 0 ? "—" : values.join(", ");
+    return [
+        `# ${definition.displayName} — \`${definition.id}\``,
+        "",
+        definition.instructions(),
+        "",
+        "## Authority",
+        "",
+        "| | |",
+        "| --- | --- |",
+        `| Reports to | \`${definition.reportsTo}\` |`,
+        `| Delegates to | ${list(definition.delegatesTo)} |`,
+        `| Tools | ${list(definition.capabilities.tools)} |`,
+        `| Memory read | ${list(definition.capabilities.memory.read)} |`,
+        `| Memory write | ${list(definition.capabilities.memory.write)} |`,
+        `| Workspace read | ${list(definition.capabilities.workspace.readRoots)} |`,
+        `| Workspace write | ${list(definition.capabilities.workspace.writeRoots)} |`,
+        "",
+        "That table is the whole of your authority. If something you need is blocked, report it — do not route around it.",
+        "",
+    ].join("\n");
+}

package/dist/src/agents/review.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reviewAgent = void 0;
+const agent_definition_1 = require("./agent-definition");
+const house_rules_1 = require("./shared/house-rules");
+const voice_1 = require("./shared/voice");
+const types_1 = require("../workflow/types");
+exports.reviewAgent = (0, agent_definition_1.defineAgent)({
+    id: "review",
+    displayName: "Review 🔎",
+    model: { claude: "claude-opus-5", codex: "gpt-5.6-terra" },
+    reasoningEffort: { claude: "high", codex: "medium" },
+    reportsTo: "main",
+    delegatesTo: [],
+    // Một diff cộng code quanh nó, và mối nghi phải sống tới lúc ra phán quyết. Phía codex
+    // bỏ trống vì mặc định 90% của 272k đã thấp hơn trần này.
+    autoCompactTokens: { claude: 300_000 },
+    capabilities: {
+        tools: ["Read", "Glob", "Grep", "Bash", "Skill"],
+        skills: ["code-review", "alp-scenario", "security-scan"],
+        subagents: [],
+        mcpServers: [],
+        memory: {
+            read: ["shared", "project:*", "private:review"],
+            write: ["private:review"],
+        },
+        workspace: { readRoots: ["."], writeRoots: [] },
+    },
+    instructions: () => (0, voice_1.renderInstructions)("Review, the code review specialist", "Review one named concern per execution and report only actionable findings backed by concrete code evidence.", [...house_rules_1.CODE_NATIVE_HOUSE_RULES, ...house_rules_1.CODE_CRAFT_RULES, "Do not edit the implementation; rank findings by impact and explain the failure mode."]),
+    workflow: (0, types_1.defineLinearWorkflow)("review-concern", [
+        { id: "SCOPE_CONCERN", allowedTools: ["Read", "Glob", "Grep"] },
+        { id: "INSPECT", allowedTools: ["Read", "Glob", "Grep", "Bash"] },
+        { id: "VERIFY", allowedTools: ["Read", "Glob", "Grep", "Bash"] },
+        { id: "REPORT", allowedTools: [] },
+    ]),
+    output: (0, voice_1.textOutput)("code-review-report"),
+});

package/dist/src/agents/search.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchAgent = void 0;
+const agent_definition_1 = require("./agent-definition");
+const house_rules_1 = require("./shared/house-rules");
+const voice_1 = require("./shared/voice");
+const types_1 = require("../workflow/types");
+exports.searchAgent = (0, agent_definition_1.defineAgent)({
+    id: "search",
+    displayName: "Search 🔍",
+    model: { claude: "claude-sonnet-5", codex: "gpt-5.6-terra" },
+    reasoningEffort: { claude: "low", codex: "low" },
+    reportsTo: "main",
+    delegatesTo: [],
+    // Một cuộc tìm phình tới đây là đã hỏng; nén là cách hỏng rẻ hơn. Bằng nhau hai phía:
+    // trần này nói về việc tìm kiếm, không về model.
+    autoCompactTokens: { claude: 150_000, codex: 150_000 },
+    capabilities: {
+        tools: ["Read", "Glob", "Grep", "Bash", "Skill"],
+        skills: ["gkg", "repomix"],
+        subagents: [],
+        mcpServers: [],
+        memory: {
+            read: ["shared", "project:*", "private:search"],
+            write: ["private:search"],
+        },
+        workspace: { readRoots: ["."], writeRoots: [] },
+    },
+    instructions: () => (0, voice_1.renderInstructions)("Search, the local code retrieval specialist", "Locate symbols, call sites, and execution flows in the active workspace and return exact path/line evidence.", [...house_rules_1.CODE_NATIVE_HOUSE_RULES, "Do not modify source files or broaden beyond the requested retrieval question."]),
+    workflow: (0, types_1.defineLinearWorkflow)("retrieve-code", [
+        { id: "VALIDATE_WORKSPACE", allowedTools: ["Read", "Glob"] },
+        { id: "RETRIEVE", allowedTools: ["Read", "Glob", "Grep", "Bash"] },
+        { id: "VERIFY", allowedTools: ["Read", "Glob", "Grep", "Bash"] },
+        { id: "REPORT", allowedTools: [] },
+    ]),
+    output: (0, voice_1.textOutput)("code-search-result"),
+});

package/dist/src/agents/shared/house-rules.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODE_CRAFT_RULES = exports.CODE_NATIVE_HOUSE_RULES = void 0;
+/**
+ * Two bans, not one, because they rest on different reasons.
+ *
+ * Herdr and Paseo are foreign runtimes: whatever they launch is outside ALP policy entirely,
+ * and no grant can ever put it back inside. An in-process subagent is the opposite — it runs
+ * inside the session ALP itself started, under the workspace, sandbox and deny list this
+ * execution already carries, so it is bannable by *not being granted*, not by being what it is.
+ *
+ * These lived in one sentence ("never launch raw Herdr, Paseo, or in-process agents") until
+ * 2026-09-04. That sentence forbids the whole class, so the day a definition first declares
+ * `capabilities.subagents` the prompt would contradict the grant — vision §4.6. Splitting it
+ * before any grant exists means the rule needs no rewrite when one does: today no role is
+ * granted a subagent, and the rule already says exactly what that means.
+ */
+exports.CODE_NATIVE_HOUSE_RULES = Object.freeze([
+    "Use ALP policy and delegation boundaries; never launch raw Herdr or Paseo.",
+    "Launch no in-process subagent that this execution's policy does not grant — a subagent is not a way around your own limits.",
+    "Treat private memory as owner-only; hierarchy does not grant private access.",
+    "Do not commit, push, deploy, or perform destructive operations without explicit principal approval.",
+    "Return verifiable evidence and do not claim checks that were not run.",
+]);
+// Craft standard for roles that write or judge implementation code. Kept separate from the
+// house rules so read-only roles (search, librarian, read-thread, compaction, titling) do
+// not carry prompt they never act on.
+exports.CODE_CRAFT_RULES = Object.freeze([
+    "Surface assumptions instead of acting on them; when a request has multiple readings, present them rather than silently picking one.",
+    "Prefer the smallest solution that solves the stated problem: no abstraction, option, or error path nobody asked for.",
+    "Keep changes surgical: every changed line traces to the request, surrounding style is matched, and only orphans the change itself created are removed.",
+    "Turn the task into a check that can be run, then loop until that check passes.",
+]);

package/dist/src/agents/shared/principal.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.principalInstruction = principalInstruction;
+const principal_profile_store_1 = require("../../principal/principal-profile-store");
+/**
+ * The one line of every role's prompt that names who is being served.
+ *
+ * The profile is read from `~/.alp/principal.json` rather than compiled in: the name and
+ * the forms of address belong to the person running the install, not to the source tree.
+ * Until `alp init` (or `alp principal set`) captures one, roles get a neutral wording —
+ * a missing profile degrades the prompt, it never blocks a session or invents a name.
+ */
+function principalInstruction(profile = (0, principal_profile_store_1.readPrincipalProfile)().profile) {
+    const voice = "Communicate in Vietnamese, keep technical terms in English, and lead with the verified outcome.";
+    if (profile === null)
+        return `Serve the principal. ${voice}`;
+    return `Serve ${profile.name}. Address the principal as "${profile.addressAs}" and refer to yourself as "${profile.selfAs}". ${voice}`;
+}

package/dist/src/agents/shared/voice.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderInstructions = renderInstructions;
+exports.textOutput = textOutput;
+const principal_1 = require("./principal");
+function renderInstructions(role, purpose, rules, options = {}) {
+    const principalFacing = (options.audience ?? "principal") === "principal";
+    return [
+        `You are ${role}. ${purpose}`,
+        ...(principalFacing
+            ? [
+                (0, principal_1.principalInstruction)(),
+                "State status or conclusion first. Be concise, direct, and explicit about evidence and uncertainty.",
+            ]
+            : []),
+        ...rules.map((rule) => `- ${rule}`),
+    ].join("\n");
+}
+function textOutput(name) {
+    return {
+        name,
+        schema: { type: "string", minLength: 1 },
+        validate(value) {
+            return typeof value === "string" && value.trim().length > 0
+                ? { ok: true, value }
+                : { ok: false, issues: ["output must be non-empty text"] };
+        },
+    };
+}