opencode-resolve 0.1.20 → 0.3.0

package/dist/agents.js

@@ -4,11 +4,7 @@ export const VALID_AGENT_NAMES = [
     "coder",
     "reviewer",
     "resolver",
-    "codex",
-    "gpt",
-    "glm",
     "architect",
-    "gpt-coder",
     "debugger",
     "researcher",
     "explorer",
@@ -20,7 +16,7 @@ export const DEFAULT_AGENT_CONFIG = {
     coder: {
         mode: "subagent",
         color: "#7CFC00",
-        maxSteps: 20,
+        maxSteps: 15,
         description: "Use for focused implementation, file edits, test runs, and fixing issues until the task is resolved.",
         prompt: [
             "You are Coder, a focused implementation subagent for OpenCode Resolve.",
@@ -45,7 +41,7 @@ export const DEFAULT_AGENT_CONFIG = {
     reviewer: {
         mode: "subagent",
         color: "#8A7CFF",
-        maxSteps: 8,
+        maxSteps: 6,
         description: "Internal read-only verification-gap auditor. Enabled as subagent by default but not part of the core resolver→coder path. Resolver dispatches only when it judges a verification gap exists on non-trivial changes.",
         prompt: [
             "You are Reviewer, a strictly read-only internal review subagent for OpenCode Resolve.",
@@ -65,7 +61,7 @@ export const DEFAULT_AGENT_CONFIG = {
     resolver: {
         mode: "all",
         color: "#FF7AC6",
-        maxSteps: 30,
+        maxSteps: 25,
         description: "Primary orchestrator in the fixed-role verified loop (resolver→coder). Decomposes work into verified checkpoints, dispatches coder, verifies each, and carries forward progress. Internal subagents (explorer, reviewer, deep-reviewer) are available by default but dispatched only when justified.",
         prompt: buildResolverPrompt(undefined),
         permission: {
@@ -74,30 +70,6 @@ export const DEFAULT_AGENT_CONFIG = {
             webfetch: "allow",
         },
     },
-    codex: {
-        mode: "all",
-        color: "#FFB347",
-        maxSteps: 35,
-        description: "Codex-optimized primary resolver for agentic coding work. Use when a Codex-style OpenAI coding model is pinned and you want a dedicated user-facing route separate from the neutral resolver.",
-        prompt: buildCodexResolverPrompt(),
-        permission: {
-            edit: "allow",
-            bash: "ask",
-            webfetch: "allow",
-        },
-    },
-    gpt: {
-        mode: "all",
-        color: "#FFB347",
-        maxSteps: 35,
-        description: "GPT-optimized primary resolver for agentic coding work. Use when a GPT/OpenAI coding model is pinned and you want a dedicated user-facing route separate from the neutral resolver.",
-        prompt: buildGPTResolverPrompt(),
-        permission: {
-            edit: "allow",
-            bash: "ask",
-            webfetch: "allow",
-        },
-    },
     architect: {
         mode: "subagent",
         color: "#00BFFF",
@@ -114,22 +86,6 @@ export const DEFAULT_AGENT_CONFIG = {
             webfetch: "allow",
         },
     },
-    "gpt-coder": {
-        mode: "subagent",
-        color: "#FFB347",
-        maxSteps: 20,
-        description: "Use for difficult implementation work that needs stronger reasoning than the default coder.",
-        prompt: [
-            "You are GPT Coder, a high-reasoning implementation subagent for difficult tasks.",
-            "Use the same small-change discipline as Coder, but take extra care with design, edge cases, and verification.",
-            "Inspect before editing, implement directly, verify when practical, and report exactly what changed.",
-        ].join("\n"),
-        permission: {
-            edit: "allow",
-            bash: "ask",
-            webfetch: "allow",
-        },
-    },
     debugger: {
         mode: "subagent",
         color: "#FF5F57",
@@ -165,7 +121,7 @@ export const DEFAULT_AGENT_CONFIG = {
     explorer: {
         mode: "subagent",
         color: "#33CCFF",
-        maxSteps: 6,
+        maxSteps: 5,
         description: "Internal pre-change fast scout for codebase/file/pattern/doc discovery. Enabled as subagent by default but not part of the core path. Read-only; quick model.",
         prompt: [
             "You are Explorer, a fast codebase scout subagent for OpenCode Resolve.",
@@ -203,7 +159,7 @@ export const DEFAULT_AGENT_CONFIG = {
     planner: {
         mode: "subagent",
         color: "#F4A300",
-        maxSteps: 10,
+        maxSteps: 8,
         description: "Internal advanced planner dispatched by the resolver when the user explicitly asks for a plan, decomposition, or implementation strategy. Read-only. Returns a concrete plan; never edits code.",
         prompt: [
             "You are Planner, the advanced planning subagent for OpenCode Resolve.",
@@ -219,139 +175,51 @@ export const DEFAULT_AGENT_CONFIG = {
             webfetch: "allow",
         },
     },
-    glm: {
-        mode: "all",
-        color: "#00FF9F",
-        maxSteps: 30,
-        description: "GLM-optimized orchestrator for ZAI coding-plan. Select this agent when running GLM-only to get maximum performance within session and rate limits. Serial coder dispatch, token-efficient prompts, coding-plan constraints handled automatically.",
-        prompt: buildGLMResolverPrompt(undefined),
-        permission: {
-            edit: "allow",
-            bash: "ask",
-            webfetch: "allow",
-        },
-    },
 };
-export const GLM_CODER_PROMPT = [
-    "You are Coder (GLM profile), a concise implementation subagent for OpenCode Resolve.",
-    "",
-    "Read ONLY files you will edit. Make the SMALLEST correct change.",
-    "Verify immediately: type check or lint on changed files. Full-repo lint is optional; if it fails outside your changes, report that as unrelated. Check LSP diagnostics when available. Report exit code + errors.",
-    "Return: changed files + verification result. No prose.",
-    "",
-    "NO EVIDENCE = INCOMPLETE WORK.",
-    "",
-    "NEVER: as any / @ts-ignore / empty catch / delete failing tests / leave code broken / commit without request / git add . / git add -A / stage unrelated files.",
-].join("\n");
-export const GPT_CODER_PROMPT = [
-    "You are Coder (GPT profile), an implementation subagent for OpenCode Resolve.",
-    "",
-    "Read ONLY files you need. Make the SMALLEST correct change.",
-    "Verify: type check or lint on changed files. Full-repo lint is optional; if it fails outside your changes, report that as unrelated. Check LSP diagnostics when available. Report exit code + errors.",
-    "Return: changed files + verification result. Keep it concise.",
-    "",
-    "NO EVIDENCE = INCOMPLETE WORK.",
-    "",
-    "NEVER: as any / @ts-ignore / empty catch / delete failing tests / leave code broken / commit without request / git add . / git add -A / stage unrelated files.",
-].join("\n");
-export function buildGLMResolverPrompt(maxParallelSubagents) {
+export function buildResolverPrompt(maxParallelSubagents, singleAgentMode = false) {
     const limit = typeof maxParallelSubagents === "number" && Number.isFinite(maxParallelSubagents)
         ? Math.max(1, Math.trunc(maxParallelSubagents))
-        : undefined;
-    const parallelRule = limit === undefined
-        ? "No hard cap. Fan out only for genuinely independent work, and back off immediately on rate-limit errors."
-        : limit === 1
-            ? "Dispatch ONE coder at a time. Wait for it to finish."
-            : `Dispatch up to ${limit} coder(s) concurrently. Wait for in-flight coders before dispatching more.`;
-    return [
-        "You are Resolver (GLM profile), the token-efficient orchestrator for OpenCode Resolve.",
-        "ZAI Coding Plan — quota is finite. Minimize unnecessary reads and dispatches.",
-        "",
-        `Parallel: ${parallelRule}`,
-        "Dispatch coder with: TASK (atomic goal), OUTCOME (success criteria), MUST DO, MUST NOT DO, CONTEXT (files/patterns).",
-        "After EVERY coder return: verify it works + follows codebase patterns. If not → re-dispatch with fix.",
-        "INTELLIGENT RECOVERY: On verify failure, dispatch debugger FIRST to diagnose root cause, THEN re-dispatch coder with precise fix. Do NOT blindly retry.",
-        "Trivial fixes → apply yourself. No subagent needed.",
-        "3 consecutive failures → STOP, REVERT, REPORT, ASK user.",
-        "10+ failures on same task → call architect to rethink the approach before continuing.",
-        "",
-        "If piloci MCP available: piloci_recall before inspecting code, piloci_memory after learning something non-obvious.",
-        "",
-        "Verify: type check or lint MUST pass on changed files. Full-repo lint is optional; if it fails outside your changes, report the unrelated failure instead of fixing unrelated files. NO EVIDENCE = NOT COMPLETE.",
-        "After non-trivial work: ask user to capture lesson → HARNESS.md (infra) or AGENTS.md (agent behavior).",
-        "",
-        "NEVER: as any / @ts-ignore / leave code broken / delete failing tests / commit without request / git add . / git add -A / stage unrelated files.",
-        "",
-        "Specialists: explorer (scope unknown), reviewer (verification gap), debugger (verify failure diagnosis), planner (user asks for plan). No deep-reviewer.",
-        "",
-        "CONTINUATION: After context compression or any intermediate step, immediately continue the current task. Do NOT pause, summarize status, or ask the user unless you face a CRITICAL decision requiring their input (destructive action, ambiguous requirement, security concern). Keep moving.",
-    ].join("\n");
-}
-export function buildGPTResolverPrompt() {
-    return [
-        "You are Resolver (GPT profile), the orchestrator for OpenCode Resolve.",
-        "Leverage GPT's reasoning — parallel dispatch, detailed checkpoint plans for deep tasks.",
-        "",
-        "Parallel coder dispatch for independent work. Deep-reviewer available for risky changes.",
-        "Dispatch coder with: TASK (atomic goal), OUTCOME (success criteria), MUST DO, MUST NOT DO, CONTEXT (files/patterns).",
-        "After EVERY coder return: verify it works + follows codebase patterns. If not → re-dispatch with fix.",
-        "INTELLIGENT RECOVERY: On verify failure, dispatch debugger FIRST to diagnose root cause, THEN re-dispatch coder with precise fix. Do NOT blindly retry.",
-        "Trivial fixes → apply yourself. No subagent needed.",
-        "3 consecutive failures → STOP, REVERT, REPORT, ASK user.",
-        "10+ failures on same task → call architect to rethink the approach before continuing.",
-        "",
-        "If piloci MCP available: piloci_recall before inspecting code, piloci_memory after learning something non-obvious.",
-        "",
-        "Verify: type check or lint MUST pass on changed files. Full-repo lint is optional; if it fails outside your changes, report the unrelated failure instead of fixing unrelated files. NO EVIDENCE = NOT COMPLETE.",
-        "After non-trivial work: ask user to capture lesson → HARNESS.md (infra) or AGENTS.md (agent behavior).",
-        "",
-        "NEVER: as any / @ts-ignore / leave code broken / delete failing tests / commit without request / git add . / git add -A / stage unrelated files.",
-        "",
-        "Specialists: explorer (scope unknown), reviewer (verification gap), deep-reviewer (risky/security/architectural), debugger (verify failure diagnosis), planner (user asks for plan).",
-        "",
-        "CONTINUATION: After context compression or any intermediate step, immediately continue the current task. Do NOT pause, summarize status, or ask the user unless you face a CRITICAL decision requiring their input (destructive action, ambiguous requirement, security concern). Keep moving.",
-    ].join("\n");
-}
-export function buildCodexResolverPrompt() {
-    return [
-        "You are Codex Resolver, the OpenAI Codex-optimized primary agent for OpenCode Resolve.",
-        "Use Codex-style software engineering judgment: inspect narrowly, patch directly when trivial, dispatch focused coders when parallel work is useful, and verify before reporting.",
-        "",
-        "Prefer coder for implementation slices, explorer for quick scope discovery, reviewer for verification gaps, deep-reviewer for risky/security/architecture changes, debugger for verify failure diagnosis, planner only when the user asks for a plan.",
-        "Dispatch coder with: TASK (atomic goal), OUTCOME (success criteria), MUST DO, MUST NOT DO, CONTEXT (files/patterns).",
-        "After EVERY coder return: verify it works + follows codebase patterns. If not → re-dispatch with precise fix.",
-        "INTELLIGENT RECOVERY: On verify failure, dispatch debugger FIRST to diagnose root cause, THEN re-dispatch coder with precise fix. Do NOT blindly retry.",
-        "Trivial fixes → apply yourself. No subagent needed.",
-        "3 consecutive failures → STOP, REVERT, REPORT, ASK user.",
-        "",
-        "Verify: type check or lint MUST pass on changed files. Full-repo lint is optional; if it fails outside your changes, report the unrelated failure instead of fixing unrelated files. Check LSP diagnostics when available. NO EVIDENCE = NOT COMPLETE.",
-        "",
-        "NEVER: as any / @ts-ignore / leave code broken / delete failing tests / commit without request / git add . / git add -A / stage unrelated files.",
-        "",
-        "CONTINUATION: After context compression or any intermediate step, immediately continue the current task. Do NOT pause, summarize status, or ask the user unless you face a CRITICAL decision requiring their input (destructive action, ambiguous requirement, security concern). Keep moving.",
-    ].join("\n");
-}
-export function buildResolverPrompt(maxParallelSubagents) {
-    const explicitLimit = typeof maxParallelSubagents === "number" && Number.isFinite(maxParallelSubagents)
-        ? Math.max(1, Math.trunc(maxParallelSubagents))
-        : undefined;
-    const parallelRule = explicitLimit === undefined
-        ? "Fan out for independent work. Back off on rate-limit errors."
-        : explicitLimit === 1
-            ? "Dispatch ONE coder at a time. Wait for it to finish."
-            : `Dispatch up to ${explicitLimit} coders concurrently.`;
+        : 1;
+    const parallelRule = limit <= 1
+        ? "Serial dispatch: ONE coder at a time. Wait for verification before the next dispatch."
+        : `Dispatch up to ${limit} coders concurrently, then WAIT for all to verify before continuing.`;
+    const dispatchRule = `Parallel: ${parallelRule}`;
+    // singleAgentMode: resolver edits directly — no coder dispatch. Cheaper for small tasks,
+    // avoids subagent context duplication. The verify loop discipline still applies.
+    const modeRule = singleAgentMode
+        ? [
+            "DIRECT MODE (single-agent): Make ALL edits yourself with edit/write tools. Do NOT dispatch a coder subagent for implementation.",
+            "Use subagents (explorer/reviewer/debugger) only to GATHER information or diagnose — never to write code.",
+        ].join("\n")
+        : dispatchRule;
+    const loopSteps = singleAgentMode
+        ? [
+            "LOOP DISCIPLINE (mandatory):",
+            "  1. make the smallest correct edit yourself (read the file first, change the least that fixes it)",
+            "  2. run the verify command (type check / lint / test) — NO EXCEPTION",
+            "  3. on verify FAIL → read the exact error, fix the precise cause. Do NOT repeat the same change.",
+            "  4. loop steps 1-3 until the change is verified. Only THEN report done.",
+        ].join("\n")
+        : [
+            "LOOP DISCIPLINE (mandatory):",
+            "  1. dispatch coder with TASK / OUTCOME / MUST DO / MUST NOT DO / CONTEXT",
+            "  2. after EVERY coder return, run the verify command (type check / lint / test) — NO EXCEPTION",
+            "  3. on verify FAIL → re-dispatch coder with the exact error + a precise fix instruction. Do NOT repeat the same change.",
+            "  4. loop steps 1-3 until the change is verified. Only THEN report done.",
+            "  5. trivial fix → apply it yourself (no subagent), then verify.",
+        ].join("\n");
+    const recovery = singleAgentMode
+        ? "INTELLIGENT RECOVERY: On verify failure, run resolve-diagnostics and read the error closely before re-editing. Never blindly retry the identical change."
+        : "INTELLIGENT RECOVERY: On verify failure, dispatch debugger FIRST to diagnose root cause, THEN re-dispatch coder with the precise fix. Never blindly retry the identical change.";
     return [
         "You are Resolver, the context-efficient orchestrator for OpenCode Resolve.",
-        "Drive tasks to verified resolution with minimal context and fewest LLM calls.",
-        "You and Coder form the verified resolve loop.",
+        "Your single job: drive the task to a VERIFIED resolution and keep the resolve loop closed until it converges.",
+        "Token budget is finite. Minimize unnecessary reads; one focused change beats several exploratory ones.",
         "",
-        `Parallel: ${parallelRule}`,
-        "Dispatch coder with: TASK (atomic goal), OUTCOME (success criteria), MUST DO, MUST NOT DO, CONTEXT (files/patterns).",
-        "After EVERY coder return: verify it works + follows codebase patterns. If not → re-dispatch with fix.",
-        "INTELLIGENT RECOVERY: On verify failure, dispatch debugger FIRST to diagnose root cause, THEN re-dispatch coder with precise fix. Do NOT blindly retry.",
-        "Trivial fixes → apply yourself. No subagent needed.",
-        "3 consecutive failures → STOP, REVERT, REPORT, ASK user.",
-        "10+ failures on same task → call architect to rethink the approach before continuing.",
+        modeRule,
+        loopSteps,
+        recovery,
+        "ESCALATION (enforced by the harness, follow it): 3 consecutive failures → STOP, revert the last change, report to the user. 6 → pivot to architect for a different approach.",
         "",
         "If piloci MCP available: piloci_recall before inspecting code, piloci_memory after learning something non-obvious.",
         "",
@@ -367,47 +235,19 @@ export function buildResolverPrompt(maxParallelSubagents) {
 }
 export const VALID_MODEL_ALIASES = [
     ...VALID_AGENT_NAMES,
-    "glm",
-    "gpt",
     "quick",
     "deep",
     "fast",
     "strong",
     "mini",
-    "codex",
     "bronze",
     "silver",
     "gold",
-    "gpt-bronze",
-    "gpt-silver",
-    "gpt-gold",
-    "glm-bronze",
-    "glm-silver",
-    "glm-gold",
 ];
 export const VALID_MODEL_ALIAS_SET = new Set(VALID_MODEL_ALIASES);
-export const VALID_PROFILES = new Set(["mix", "glm", "gpt"]);
 export const VALID_TIERS = new Set(["bronze", "silver", "gold"]);
-export const GLM_ENABLED = ["coder", "resolver", "glm", "explorer", "reviewer", "planner"];
-export const GPT_ENABLED = ["coder", "resolver", "gpt", "explorer", "reviewer", "deep-reviewer", "planner"];
 export const TIER_ENABLED = {
     bronze: ["coder", "resolver"],
     silver: ["coder", "resolver", "explorer", "reviewer", "planner"],
-    gold: ["coder", "resolver", "codex", "gpt", "glm", "explorer", "reviewer", "deep-reviewer", "planner", "debugger", "researcher"],
-};
-export const GLM_AGENT_OVERRIDES = {
-    coder: { maxSteps: 15 },
-    resolver: { maxSteps: 25 },
-    explorer: { maxSteps: 5 },
-    reviewer: { maxSteps: 6 },
-    planner: { maxSteps: 8 },
-};
-export const GPT_AGENT_OVERRIDES = {
-    coder: { maxSteps: 25 },
-    resolver: { maxSteps: 40 },
-    gpt: { maxSteps: 40 },
-    explorer: { maxSteps: 8 },
-    reviewer: { maxSteps: 10 },
-    "deep-reviewer": { maxSteps: 15 },
-    planner: { maxSteps: 12 },
+    gold: ["coder", "resolver", "explorer", "reviewer", "deep-reviewer", "planner", "architect", "debugger", "researcher"],
 };

package/dist/checkpoint.d.ts

@@ -0,0 +1,22 @@
+import type { RollbackKind } from "./types.js";
+/** Namespace for checkpoint refs. Outside refs/heads, so it never shows up as a branch. */
+export declare const CHECKPOINT_REF_NAMESPACE = "refs/resolve-checkpoint";
+export type Checkpoint = {
+    /** Full ref name, e.g. `refs/resolve-checkpoint/1730000000000-reset`. */
+    ref: string;
+    /** Copy-pasteable command that puts the worktree back the way it was. */
+    restoreCommand: string;
+};
+export declare function isGitRepository(directory: string): Promise<boolean>;
+/**
+ * Snapshot the worktree into `refs/resolve-checkpoint/<timestamp>-<kind>`.
+ * Throws with the underlying git error if the snapshot cannot be written — the
+ * caller must abort the destructive command rather than run it unprotected.
+ */
+export declare function createRollbackCheckpoint(directory: string, kind: RollbackKind): Promise<Checkpoint>;
+/**
+ * Restores every path recorded in the checkpoint, including files a later
+ * `git clean` deleted. Files created after the checkpoint are left alone —
+ * recovery is additive, never destructive.
+ */
+export declare function restoreCommandFor(ref: string): string;

package/dist/checkpoint.js

@@ -0,0 +1,72 @@
+// Rollback checkpoints.
+//
+// `git reset --hard` and `git clean -f` are the two recovery commands an agent
+// needs to escape a tangled worktree, and they are also the two that can destroy
+// uncommitted work. Before either runs, we snapshot the entire worktree —
+// tracked modifications *and* untracked files — into a git ref that nothing else
+// points at.
+//
+// The snapshot uses a throwaway index (`GIT_INDEX_FILE`) so the real index and
+// the working tree are never touched: add -A → write-tree → commit-tree →
+// update-ref. Nothing is staged, nothing is committed to any branch, no HEAD
+// move. The ref keeps the objects alive against `git gc`.
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runCommand } from "./utils.js";
+/** Namespace for checkpoint refs. Outside refs/heads, so it never shows up as a branch. */
+export const CHECKPOINT_REF_NAMESPACE = "refs/resolve-checkpoint";
+const GIT_TIMEOUT_MS = 15_000;
+export async function isGitRepository(directory) {
+    const { exitCode } = await runCommand("git rev-parse --is-inside-work-tree", directory, GIT_TIMEOUT_MS);
+    return exitCode === 0;
+}
+/**
+ * Snapshot the worktree into `refs/resolve-checkpoint/<timestamp>-<kind>`.
+ * Throws with the underlying git error if the snapshot cannot be written — the
+ * caller must abort the destructive command rather than run it unprotected.
+ */
+export async function createRollbackCheckpoint(directory, kind) {
+    const ref = `${CHECKPOINT_REF_NAMESPACE}/${Date.now()}-${kind}`;
+    const indexDirectory = await mkdtemp(join(tmpdir(), "opencode-resolve-ckpt-"));
+    const indexFile = join(indexDirectory, "index");
+    // One shell invocation: a failure anywhere aborts (set -e) and we surface it.
+    // `git add -A` against an empty throwaway index stages the whole worktree,
+    // honouring .gitignore. `commit-tree` parents on HEAD when a HEAD exists (a
+    // freshly-initialised repo has none).
+    const script = [
+        "set -e",
+        `export GIT_INDEX_FILE=${JSON.stringify(indexFile)}`,
+        // commit-tree refuses to run without a committer identity; a repo with no
+        // user.email configured must still be able to checkpoint.
+        "export GIT_AUTHOR_NAME=opencode-resolve GIT_AUTHOR_EMAIL=checkpoint@opencode-resolve.local",
+        "export GIT_COMMITTER_NAME=opencode-resolve GIT_COMMITTER_EMAIL=checkpoint@opencode-resolve.local",
+        "git add -A",
+        "tree=$(git write-tree)",
+        `message=${JSON.stringify(`opencode-resolve checkpoint before git ${kind}`)}`,
+        'if git rev-parse -q --verify HEAD >/dev/null 2>&1; then',
+        '  commit=$(git commit-tree "$tree" -p HEAD -m "$message")',
+        "else",
+        '  commit=$(git commit-tree "$tree" -m "$message")',
+        "fi",
+        `git update-ref ${JSON.stringify(ref)} "$commit"`,
+    ].join("\n");
+    try {
+        const { stderr, exitCode } = await runCommand(script, directory, GIT_TIMEOUT_MS);
+        if (exitCode !== 0) {
+            throw new Error(`checkpoint failed (git exit ${exitCode}): ${stderr.trim() || "no stderr"}`);
+        }
+    }
+    finally {
+        await rm(indexDirectory, { recursive: true, force: true }).catch(() => { });
+    }
+    return { ref, restoreCommand: restoreCommandFor(ref) };
+}
+/**
+ * Restores every path recorded in the checkpoint, including files a later
+ * `git clean` deleted. Files created after the checkpoint are left alone —
+ * recovery is additive, never destructive.
+ */
+export function restoreCommandFor(ref) {
+    return `git restore --source=${ref} -- .`;
+}

package/dist/config.d.ts

@@ -1,5 +1,5 @@
 import { Config } from "@opencode-ai/plugin";
-import { ResolveConfig, ProjectContext, ResolveAgentName, UnknownRecord, ResolvePluginOptions, ResolveAgentConfig, PermissionValue } from "./types.js";
+import { ResolveConfig, ProjectContext, ResolveAgentName, UnknownRecord, ResolvePluginOptions, ResolveAgentConfig, PermissionValue, ResolvePermissions } from "./types.js";
 export declare function applyResolveConfig(config: Config, resolveConfig: ResolveConfig, projectContext: ProjectContext): void;
 export declare function buildContextInjection(ctx: ProjectContext): string;
 export declare function defaultResolveConfig(): ResolveConfig;
@@ -11,6 +11,7 @@ export declare function getPluginOptions(config: Config): unknown;
 export declare function isResolvePluginEntry(entry: string): boolean;
 export declare function resolvePath(path: string, directory: string): string;
 export declare function normalizeResolveConfig(value: unknown, source: string): ResolvePluginOptions;
+export declare function normalizePermissions(value: unknown, source: string): ResolvePermissions;
 export declare function normalizeAgentConfig(value: unknown, source: string): ResolveAgentConfig;
 export declare function normalizeTools(value: unknown, source: string): Record<string, boolean>;
 export declare function normalizePermission(value: unknown, source: string): ResolveAgentConfig["permission"];
@@ -24,6 +25,7 @@ export declare function expectNumber(value: unknown, source: string): number;
 export declare function isObject(value: unknown): value is UnknownRecord;
 export declare function loadResolveConfig(directory: string, opencodeConfig: Config, options: unknown): Promise<ResolveConfig>;
 export declare const VALID_TOP_LEVEL_KEYS: Set<string>;
+export declare const VALID_PERMISSIONS_KEYS: Set<string>;
 export declare const VALID_AGENT_KEYS: Set<string>;
 export declare const VALID_MODES: Set<string>;
 export declare const VALID_PERMISSION_VALUES: Set<string>;

package/dist/config.js

@@ -1,17 +1,14 @@
 import { join, basename, isAbsolute, resolve } from "node:path";
 import { homedir } from "node:os";
-import { DEFAULT_AGENT_CONFIG, buildGLMResolverPrompt, GLM_CODER_PROMPT, buildGPTResolverPrompt, GPT_CODER_PROMPT, buildResolverPrompt, VALID_AGENT_NAME_SET, DEFAULT_MODELS, DEFAULT_ENABLED, VALID_AGENT_NAMES, GLM_ENABLED, GPT_ENABLED, TIER_ENABLED, GLM_AGENT_OVERRIDES, GPT_AGENT_OVERRIDES, VALID_MODEL_ALIAS_SET, VALID_PROFILES, VALID_TIERS } from "./agents.js";
+import { DEFAULT_AGENT_CONFIG, buildResolverPrompt, VALID_AGENT_NAME_SET, DEFAULT_MODELS, DEFAULT_ENABLED, VALID_AGENT_NAMES, TIER_ENABLED, VALID_MODEL_ALIAS_SET, VALID_TIERS } from "./agents.js";
 import { readFirstJson } from "./utils.js";
 export function applyResolveConfig(config, resolveConfig, projectContext) {
-    const profile = resolveConfig.profile;
-    const isGLM = profile === "glm";
-    const isGPT = profile === "gpt";
-    const profileEnabled = isGLM ? GLM_ENABLED : isGPT ? GPT_ENABLED : undefined;
     const tierEnabled = resolveConfig.tier ? TIER_ENABLED[resolveConfig.tier] : undefined;
-    const enabled = new Set(resolveConfig.enabled ?? tierEnabled ?? (profileEnabled ?? DEFAULT_ENABLED));
+    const enabled = new Set(resolveConfig.enabled ?? tierEnabled ?? DEFAULT_ENABLED);
     const models = { ...DEFAULT_MODELS, ...resolveConfig.models };
     const defaultModel = typeof config.model === "string" ? config.model : undefined;
     const maxParallelSubagents = resolveConfig.maxParallelSubagents;
+    const singleAgentMode = resolveConfig.singleAgentMode === true;
     const contextInjection = buildContextInjection(projectContext);
     config.agent ??= {};
     for (const name of Object.keys(DEFAULT_AGENT_CONFIG)) {
@@ -20,34 +17,18 @@ export function applyResolveConfig(config, resolveConfig, projectContext) {
         if (!isEnabled)
             continue;
         const base = DEFAULT_AGENT_CONFIG[name];
-        const profileOverride = isGLM ? GLM_AGENT_OVERRIDES[name] : isGPT ? GPT_AGENT_OVERRIDES[name] : undefined;
         const { enabled: _enabled, model: requestedModel, permission: userPermission, ...agentOverride } = override ?? {};
         const model = resolveModel(requestedModel ?? models[name] ?? defaultModel, models);
         const permission = buildPermission(base.permission, userPermission);
         const agentConfig = {
             ...base,
-            ...profileOverride,
             ...agentOverride,
         };
         if (agentOverride.prompt === undefined) {
-            if (isGLM) {
-                if (name === "resolver")
-                    agentConfig.prompt = buildGLMResolverPrompt(maxParallelSubagents);
-                else if (name === "coder")
-                    agentConfig.prompt = GLM_CODER_PROMPT;
+            if (name === "resolver") {
+                agentConfig.prompt = buildResolverPrompt(maxParallelSubagents, singleAgentMode);
             }
-            else if (isGPT) {
-                if (name === "resolver")
-                    agentConfig.prompt = buildGPTResolverPrompt();
-                else if (name === "coder")
-                    agentConfig.prompt = GPT_CODER_PROMPT;
-            }
-            else {
-                if (name === "resolver")
-                    agentConfig.prompt = buildResolverPrompt(maxParallelSubagents);
-            }
-            // Inject project context into all resolver-type agents
-            if ((name === "resolver" || name === "codex" || name === "glm") && contextInjection) {
+            if (name === "resolver" && contextInjection) {
                 agentConfig.prompt = agentConfig.prompt + "\n\n" + contextInjection;
             }
             // Inject verify commands into coder prompts
@@ -61,13 +42,6 @@ export function applyResolveConfig(config, resolveConfig, projectContext) {
             agentConfig.model = model;
         config.agent[name] = agentConfig;
     }
-    if (resolveConfig.context7 !== false) {
-        config.mcp ??= {};
-        config.mcp.context7 ??= {
-            type: "remote",
-            url: "https://mcp.context7.com/mcp",
-        };
-    }
     if (resolveConfig.commands) {
         config.command ??= {};
         config.command["resolve"] ??= {
@@ -114,14 +88,13 @@ export function buildContextInjection(ctx) {
 }
 export function defaultResolveConfig() {
     return {
-        profile: "mix",
         models: {},
         agents: {},
         preserveNative: true,
-        context7: true,
         commands: false,
         autoApprove: true,
         autoUpdate: true,
+        permissions: {},
     };
 }
 export function mergeResolveConfig(...configs) {
@@ -129,16 +102,16 @@ export function mergeResolveConfig(...configs) {
     for (const config of configs) {
         if (!config)
             continue;
-        result.profile = config.profile ?? result.profile;
         result.tier = config.tier ?? result.tier;
         result.enabled = config.enabled ?? result.enabled;
         result.preserveNative = config.preserveNative ?? result.preserveNative;
-        result.context7 = config.context7 ?? result.context7;
         result.commands = config.commands ?? result.commands;
         result.autoApprove = config.autoApprove ?? result.autoApprove;
         result.maxParallelSubagents = config.maxParallelSubagents ?? result.maxParallelSubagents;
         result.autoUpdate = config.autoUpdate ?? result.autoUpdate;
         result.language = config.language ?? result.language;
+        result.singleAgentMode = config.singleAgentMode ?? result.singleAgentMode;
+        result.permissions = { ...result.permissions, ...config.permissions };
         result.models = { ...result.models, ...config.models };
         result.agents = mergeAgents(result.agents, config.agents);
     }
@@ -223,21 +196,14 @@ export function normalizeResolveConfig(value, source) {
     }
     if (config.preserveNative !== undefined)
         result.preserveNative = expectBoolean(config.preserveNative, `${source}.preserveNative`);
-    if (config.context7 !== undefined)
-        result.context7 = expectBoolean(config.context7, `${source}.context7`);
     if (config.commands !== undefined)
         result.commands = expectBoolean(config.commands, `${source}.commands`);
     if (config.autoApprove !== undefined)
         result.autoApprove = expectBoolean(config.autoApprove, `${source}.autoApprove`);
     if (config.autoUpdate !== undefined)
         result.autoUpdate = expectBoolean(config.autoUpdate, `${source}.autoUpdate`);
-    if (config.profile !== undefined) {
-        const profile = expectString(config.profile, `${source}.profile`);
-        if (!VALID_PROFILES.has(profile)) {
-            throw new Error(`Unknown profile "${profile}" in ${source}.profile. Valid profiles: ${[...VALID_PROFILES].join(", ")}`);
-        }
-        result.profile = profile;
-    }
+    if (config.singleAgentMode !== undefined)
+        result.singleAgentMode = expectBoolean(config.singleAgentMode, `${source}.singleAgentMode`);
     if (config.tier !== undefined) {
         const tier = expectString(config.tier, `${source}.tier`);
         if (!VALID_TIERS.has(tier)) {
@@ -259,10 +225,26 @@ export function normalizeResolveConfig(value, source) {
         }
         result.maxParallelSubagents = limit;
     }
+    if (config.permissions !== undefined)
+        result.permissions = normalizePermissions(config.permissions, `${source}.permissions`);
     if (config.config !== undefined)
         result.config = expectString(config.config, `${source}.config`);
     return result;
 }
+export function normalizePermissions(value, source) {
+    const permissions = expectObject(value, source);
+    const result = {};
+    for (const key of Object.keys(permissions)) {
+        if (!VALID_PERMISSIONS_KEYS.has(key)) {
+            throw new Error(`Unknown permissions key "${key}" in ${source}. Valid: ${[...VALID_PERMISSIONS_KEYS].join(", ")}`);
+        }
+    }
+    if (permissions.allowGitReset !== undefined)
+        result.allowGitReset = expectBoolean(permissions.allowGitReset, `${source}.allowGitReset`);
+    if (permissions.allowGitClean !== undefined)
+        result.allowGitClean = expectBoolean(permissions.allowGitClean, `${source}.allowGitClean`);
+    return result;
+}
 export function normalizeAgentConfig(value, source) {
     const config = expectObject(value, source);
     for (const key of Object.keys(config)) {
@@ -384,20 +366,21 @@ export async function loadResolveConfig(directory, opencodeConfig, options) {
     return mergeResolveConfig(defaultResolveConfig(), fileConfig, pluginOptions);
 }
 export const VALID_TOP_LEVEL_KEYS = new Set([
-    "profile",
     "tier",
     "enabled",
     "models",
     "agents",
     "preserveNative",
-    "context7",
     "commands",
     "autoApprove",
     "maxParallelSubagents",
     "autoUpdate",
     "language",
+    "singleAgentMode",
+    "permissions",
     "config",
 ]);
+export const VALID_PERMISSIONS_KEYS = new Set(["allowGitReset", "allowGitClean"]);
 export const VALID_AGENT_KEYS = new Set([
     "enabled",
     "model",