oh-my-opencode-lite 0.1.1 → 0.1.3

package/README.md

@@ -7,7 +7,7 @@
 ---
 
 Delegate-first OpenCode plugin with a seven-agent roster, root-session
-`thoth_mem` persistence, disk-backed delegation records, bundled brainstorming,
+`thoth_mem` persistence, disk-backed delegation records, bundled requirements-interview,
 and a full SDD workflow.
 
 oh-my-opencode-lite keeps the `orchestrator` lean, pushes discovery into
@@ -43,7 +43,7 @@ bunx oh-my-opencode-lite@latest install --reset
 ```
 
 When skills are enabled, the installer adds the recommended external skills and
-copies the bundled brainstorming, cartography, plan-reviewer,
+copies the bundled requirements-interview, cartography, plan-reviewer,
 executing-plans, and SDD skills into your OpenCode skills directory.
 
 ### For LLM agents
@@ -83,6 +83,11 @@ specialists execute. Read-only discovery work goes to async specialists for
 context isolation. Advisory and write-capable work stays sync so review, undo
 safety, and verification remain straightforward.
 
+For blocking user decisions, the `orchestrator` uses a `question` tool —
+agents do not ask those questions in plain text. Independent work can be
+launched together when parallel dispatch is safe, and failed delegations are
+retried once before being reported back to the user.
+
 ### 🔑 Primary Agent
 
 <table width="100%">
@@ -227,7 +232,7 @@ safety, and verification remain straightforward.
 - Disk-persisted delegation results that survive compaction and in-memory loss
 - Bundled SDD pipeline: `sdd-propose`, `sdd-spec`, `sdd-design`, `sdd-tasks`,
   `sdd-apply`, `sdd-verify`, `sdd-archive`
-- Brainstorming skill with clarification-gate hook for ambiguous work
+- Requirements-interview skill for clarifying ambiguous work before implementation
 - `plan-reviewer` for oracle review loops on task plans
 - `executing-plans` for task-state ownership and progress tracking
 - `cartography` for repository mapping and codemap generation
@@ -249,16 +254,17 @@ The bundled SDD workflow follows this path:
 propose -> [spec || design] -> tasks -> apply -> verify -> archive
 ```
 
-For medium work, brainstorming can route into an accelerated path that starts at
+For medium work, the requirements interview can route into an accelerated path that starts at
 `propose -> tasks`. For complex work, the full path is used.
 
-Artifacts can be persisted in three modes:
+Artifacts can be persisted in four modes:
 
-| Mode | Writes to | Use when |
-| --- | --- | --- |
-| `thoth-mem` | Memory only | Fast iteration without repo planning files |
-| `openspec` | `openspec/` files only | Reviewable planning artifacts in the repo |
-| `hybrid` | Both | Maximum durability; default |
+| Mode | Writes to | Cost | Use when |
+| --- | --- | --- | --- |
+| `thoth-mem` | Memory only | Low | Fast iteration without repo planning files |
+| `openspec` | `openspec/` files only | Medium | Reviewable planning artifacts in the repo |
+| `hybrid` | Both | High | Maximum durability; default |
+| `none` | Neither | Lowest | Ephemeral iterations, no persistence |
 
 After `sdd-tasks`, the orchestrator can run an oracle review loop with
 `plan-reviewer`:
@@ -269,17 +275,22 @@ After `sdd-tasks`, the orchestrator can run an oracle review loop with
 4. Repeat until `[OKAY]`
 5. Continue into execution
 
-During execution, `executing-plans` owns task-state tracking:
+During execution, `executing-plans` owns task-state tracking. Progress has two
+mandatory layers: `todowrite` for the visual task list, plus a persistent SDD
+artifact via `tasks.md` checkboxes and/or `thoth_mem`.
 
 - `- [ ]` pending
 - `- [~]` in progress
 - `- [x]` completed
 - `- [-]` skipped with reason
 
-## Brainstorming & Clarification Gate
+## Requirements Interview
 
-The bundled `brainstorming` skill is the front door for ambiguous or substantial
-work. Its workflow is six phases:
+The bundled `requirements-interview` skill is the front door for ambiguous or substantial
+work. It is step-0 in the orchestrator prompt and runs before implementation when the
+request is open-ended, spans multiple parts of the system, or needs scope calibration.
+
+Its workflow is six phases:
 
 1. Context gathering
 2. Interview
@@ -288,13 +299,8 @@ work. Its workflow is six phases:
 5. User approval
 6. Handoff
 
-The clarification-gate hook can auto-detect requests that should go through this
-flow before implementation. It checks for explicit planning keywords plus scope
-signals such as multi-view work, API/data changes, restructuring, multi-layer
-impact, business-language requests, open-ended phrasing, and cross-directory
-scope. When triggered, it injects a reminder for the `orchestrator` to load the
-brainstorming skill, ask one clarifying question at a time, and wait for
-explicit approval before coding.
+After clarification, the skill routes the work into direct implementation, accelerated
+SDD, or full SDD based on complexity assessment.
 
 ## 🧩 Skills & MCP Servers
 
@@ -302,9 +308,10 @@ explicit approval before coding.
 
 | Skill | Category | Purpose |
 | --- | --- | --- |
-| `brainstorming` | Clarification | Clarify intent, assess scope, and choose direct work vs accelerated or full SDD |
+| `requirements-interview` | Clarification | Clarify intent, assess scope, and choose direct work vs accelerated or full SDD |
 | `cartography` | Discovery | Generate and update hierarchical repository codemaps |
 | `plan-reviewer` | Review | Validate `tasks.md` for real execution blockers and return `[OKAY]` or `[REJECT]` |
+| `sdd-init` | SDD | Bootstrap OpenSpec structure and SDD context for a project |
 | `sdd-propose` | SDD | Create or update `proposal.md` |
 | `sdd-spec` | SDD | Write OpenSpec delta specs with RFC 2119 requirements and scenarios |
 | `sdd-design` | SDD | Produce `design.md` with technical decisions and file changes |
@@ -332,6 +339,23 @@ explicit approval before coding.
 | `grep_app` | Public GitHub code search | No auth required |
 | `thoth_mem` | Local persistent memory and artifact storage | Local command, default `npx -y thoth-mem@latest` |
 
+> **🧠 [Thoth-Mem](https://github.com/EremesNG/thoth-mem)** is a persistent
+> memory MCP server purpose-built for cross-session context. The orchestrator
+> uses it to save architectural decisions, bug-fix learnings, SDD artifacts,
+> and session summaries so the next session picks up where the last one left
+> off — even after context-window compaction. It is included by default and
+> runs locally via `npx`.
+
+For targeted retrieval, Thoth-Mem uses a 3-layer recall protocol:
+
+1. `mem_search` — scan the compact index of IDs and titles
+2. `mem_timeline` — inspect chronological context around candidates
+3. `mem_get_observation` — read full content for selected records
+
+After task completion, an automatic save nudge reminds the orchestrator to
+persist important observations. Session start also degrades gracefully if
+`thoth_mem` is unavailable, so memory errors do not block the main plugin flow.
+
 Skill and MCP access in this project is prompt-driven. The generated plugin
 config focuses on model presets and runtime options rather than per-agent
 permission matrices.
@@ -349,6 +373,8 @@ permission matrices.
 
 ## Development
 
+The project targets `@opencode-ai/plugin` and `@opencode-ai/sdk` v1.3.3.
+
 | Command | Purpose |
 | --- | --- |
 | `bun run build` | Build TypeScript into `dist/` |

package/dist/agents/prompt-utils.d.ts

@@ -4,6 +4,9 @@ interface ComposeAgentPromptOptions {
     customAppendPrompt?: string;
     placeholders?: Record<string, string | number | undefined>;
 }
+export declare const QUESTION_PROTOCOL = "<questions>\nUse the `question` tool for blocking decisions. NEVER ask in plain text.\nPut the recommended option first with \"(Recommended)\". Short headers (<=30 chars).\nAfter calling question, STOP \u2014 do not continue execution.\n</questions>";
+export declare const SUBAGENT_RULES = "- Do not call thoth-mem session or prompt tools \u2014 memory is orchestrator-owned.\n- Use `question` tool for blocking decisions, never plain text.";
+export declare const RESPONSE_BUDGET = "Your response returns to an expensive orchestrator model. Be ruthlessly concise:\n- Return insights and conclusions, NEVER raw file contents or full code blocks.\n- Structured results (status, summary, files, issues) over prose.\n- If the orchestrator needs more detail, it will ask in a follow-up.";
 export declare function appendPromptSections(...sections: Array<string | undefined>): string;
 export declare function replacePromptPlaceholders(template: string, placeholders?: Record<string, string | number | undefined>): string;
 export declare function composeAgentPrompt({ basePrompt, customPrompt, customAppendPrompt, placeholders, }: ComposeAgentPromptOptions): string;

package/dist/background/background-manager.d.ts

@@ -56,6 +56,7 @@ export declare class BackgroundTaskManager {
     private agentBySessionId;
     private client;
     private directory;
+    private worktreeDirectory;
     private tmuxEnabled;
     private config?;
     private backgroundConfig;
@@ -64,7 +65,7 @@ export declare class BackgroundTaskManager {
     private activeStarts;
     private maxConcurrentStarts;
     private completionResolvers;
-    constructor(ctx: PluginInput, tmuxConfig?: TmuxConfig, config?: PluginConfig, delegationManager?: DelegationManager);
+    constructor(ctx: PluginInput, tmuxConfig?: TmuxConfig, config?: PluginConfig, delegationManager?: DelegationManager, worktreeDirectory?: string);
     private resolveRootSessionId;
     private createTaskId;
     private buildDelegationSummary;
@@ -114,15 +115,20 @@ export declare class BackgroundTaskManager {
     private processQueue;
     private resolveFallbackChain;
     private promptWithTimeout;
+    private createPatternPermission;
+    private createPatternRuleset;
     /**
-     * Calculate tool permissions for a spawned agent based on its own delegation rules.
-     * Agents that cannot delegate (leaf nodes) get delegation tools disabled entirely,
-     * preventing models from even seeing tools they can never use.
+     * Calculate delegation permissions for a spawned agent based on its own
+     * delegation rules.
+     *
+     * The permission payload is the primary control for child sessions. Legacy
+     * `tools` flags remain as a backward-compatible fallback because the plugin
+     * client still exposes pre-v2 prompt typings.
      *
      * @param agentName - The agent type being spawned
-     * @returns Tool permissions object with background_task and task enabled/disabled
+     * @returns Permission payload plus legacy tool toggles for compatibility
      */
-    private calculateToolPermissions;
+    private calculateDelegationPermissions;
     /**
      * Start a task in the background (Phase B).
      */

package/dist/cli/index.js

@@ -570,10 +570,10 @@ var SHARED_SKILL_DIRECTORY2 = "_shared";
 var SHARED_SKILL_SOURCE_PATH = `src/skills/${SHARED_SKILL_DIRECTORY2}`;
 var CUSTOM_SKILLS = [
   {
-    name: "brainstorming",
-    description: "Understand user intent and scope through structured clarification before implementation",
+    name: "requirements-interview",
+    description: "Mandatory step-0 discovery interview to understand user intent, clarify scope, and choose the right path before implementation",
     allowedAgents: ["orchestrator"],
-    sourcePath: "src/skills/brainstorming"
+    sourcePath: "src/skills/requirements-interview"
   },
   {
     name: "cartography",
@@ -587,6 +587,12 @@ var CUSTOM_SKILLS = [
     allowedAgents: ["orchestrator", "oracle"],
     sourcePath: "src/skills/plan-reviewer"
   },
+  {
+    name: "sdd-init",
+    description: "Initialize OpenSpec structure and SDD project context",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/sdd-init"
+  },
   {
     name: "sdd-propose",
     description: "Create change proposals for OpenSpec workflows",

package/dist/config/loader.d.ts

@@ -9,8 +9,8 @@ import { type PluginConfig } from './schema';
  *
  * JSONC format is preferred over JSON (allows comments and trailing commas).
  * Project config takes precedence over user config. Nested objects (agents,
- * tmux, background, fallback, thoth, delegation, clarificationGate,
- * artifactStore) are deep-merged, while top-level arrays are replaced entirely
+ * tmux, background, fallback, thoth, delegation, artifactStore) are
+ * deep-merged, while top-level arrays are replaced entirely
  * by project config.
  *
  * @param directory - Project directory to search for .opencode config

package/dist/config/schema.d.ts

@@ -127,25 +127,6 @@ export declare const DelegationConfigSchema: z.ZodObject<{
     timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 }, z.core.$strip>;
 export type DelegationConfig = z.infer<typeof DelegationConfigSchema>;
-export declare const ClarificationGateModeSchema: z.ZodEnum<{
-    off: "off";
-    "explicit-only": "explicit-only";
-    auto: "auto";
-    "auto-for-planning": "auto-for-planning";
-}>;
-export declare const ClarificationGateConfigSchema: z.ZodObject<{
-    mode: z.ZodDefault<z.ZodEnum<{
-        off: "off";
-        "explicit-only": "explicit-only";
-        auto: "auto";
-        "auto-for-planning": "auto-for-planning";
-    }>>;
-    min_scope_signals: z.ZodDefault<z.ZodNumber>;
-    hard_complex_signal_threshold: z.ZodDefault<z.ZodNumber>;
-    explicit_keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    planning_keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export type ClarificationGateConfig = z.infer<typeof ClarificationGateConfigSchema>;
 export declare const ArtifactStoreModeSchema: z.ZodEnum<{
     "thoth-mem": "thoth-mem";
     openspec: "openspec";
@@ -289,18 +270,6 @@ export declare const PluginConfigSchema: z.ZodObject<{
         storage_dir: z.ZodOptional<z.ZodString>;
         timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     }, z.core.$strip>>;
-    clarificationGate: z.ZodOptional<z.ZodObject<{
-        mode: z.ZodDefault<z.ZodEnum<{
-            off: "off";
-            "explicit-only": "explicit-only";
-            auto: "auto";
-            "auto-for-planning": "auto-for-planning";
-        }>>;
-        min_scope_signals: z.ZodDefault<z.ZodNumber>;
-        hard_complex_signal_threshold: z.ZodDefault<z.ZodNumber>;
-        explicit_keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        planning_keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
     artifactStore: z.ZodOptional<z.ZodObject<{
         mode: z.ZodDefault<z.ZodEnum<{
             "thoth-mem": "thoth-mem";

package/dist/delegation/delegation-manager.d.ts

@@ -1,7 +1,11 @@
+import type { PluginInput } from '@opencode-ai/plugin';
 import type { DelegationConfig } from '../config';
 import { type DelegationListEntry, type DelegationRecord, type PersistedDelegationRecord } from './types';
 export interface DelegationManagerOptions {
     directory: string;
+    worktreeDirectory?: string;
+    projectName?: string;
+    shell?: PluginInput['$'];
     config?: DelegationConfig;
     getActiveTaskIds?: (rootSessionId: string) => Iterable<string>;
 }
@@ -10,11 +14,13 @@ export interface PersistDelegationInput {
     record: DelegationRecord;
 }
 export declare class DelegationManager {
-    private readonly directory;
+    private readonly worktreeDirectory;
+    private readonly projectName;
+    private readonly shell?;
     private readonly config?;
     private readonly getActiveTaskIds?;
     constructor(options: DelegationManagerOptions);
-    resolveProjectId(directory?: string): Promise<string | null>;
+    resolveProjectId(worktreeDirectory?: string): Promise<string | null>;
     createTaskId(rootSessionId: string): Promise<string>;
     persist(input: PersistDelegationInput): Promise<PersistedDelegationRecord | null>;
     read(taskId: string, rootSessionId: string): Promise<PersistedDelegationRecord | null>;

package/dist/delegation/project-id.d.ts

@@ -1 +1,10 @@
-export declare function getProjectId(directory: string, timeoutMs?: number): Promise<string | null>;
+import type { PluginInput } from '@opencode-ai/plugin';
+interface ProjectIdOptions {
+    worktreeDirectory: string;
+    projectName?: string;
+    shell?: PluginInput['$'];
+    timeoutMs?: number;
+}
+export declare function getProjectId(directory: string, timeoutMs?: number, projectName?: string, shell?: PluginInput['$']): Promise<string | null>;
+export declare function getProjectId(options: ProjectIdOptions): Promise<string | null>;
+export {};

package/dist/hooks/auto-update-checker/index.d.ts

@@ -4,9 +4,10 @@ import type { AutoUpdateCheckerOptions } from './types';
  * Creates an OpenCode hook that checks for plugin updates when a new session is created.
  * @param ctx The plugin input context.
  * @param options Configuration options for the update checker.
+ * @param shell The BunShell instance for running commands.
  * @returns A hook object for the session.created event.
  */
-export declare function createAutoUpdateCheckerHook(ctx: PluginInput, options?: AutoUpdateCheckerOptions): {
+export declare function createAutoUpdateCheckerHook(ctx: PluginInput, options: AutoUpdateCheckerOptions | undefined, shell: PluginInput['$']): {
     event: ({ event }: {
         event: {
             type: string;

package/dist/hooks/index.d.ts

@@ -1,7 +1,6 @@
 export type { AutoUpdateCheckerOptions } from './auto-update-checker';
 export { createAutoUpdateCheckerHook } from './auto-update-checker';
 export { createChatHeadersHook } from './chat-headers';
-export { createClarificationGateHook } from './clarification-gate';
 export { createDelegateTaskRetryHook } from './delegate-task-retry';
 export { ForegroundFallbackManager, isRateLimitError, } from './foreground-fallback';
 export { createJsonErrorRecoveryHook } from './json-error-recovery';

package/dist/hooks/phase-reminder/index.d.ts

@@ -1,4 +1,4 @@
-export declare const PHASE_REMINDER = "<reminder>Recall Workflow Rules:\nUnderstand \u2192 find the best path (delegate based on rules and parallelize independent work) \u2192 execute \u2192 verify.\nIf delegating, launch the specialist in the same turn you mention it.</reminder>";
+export declare const PHASE_REMINDER = "<reminder>Recall Workflow Rules:\nUnderstand \u2192 find the best path (delegate based on rules and parallelize independent work) \u2192 execute \u2192 verify.\nIf delegating, launch the specialist in the same turn you mention it. If multiple delegations are independent, emit all tool calls in a single response \u2014 never serialize independent work across turns.</reminder>";
 interface MessageInfo {
     role: string;
     agent?: string;

package/dist/hooks/thoth-mem/protocol.d.ts

@@ -1,6 +1,7 @@
 export declare const SDD_TOPIC_KEY_FORMAT = "sdd/{change}/{artifact}";
-export declare const FIRST_ACTION_INSTRUCTION = "FIRST ACTION REQUIRED: Call mem_session_summary with the content of the compacted summary. This preserves what was accomplished before compaction. Do this BEFORE any other work. Then call mem_context to recover additional context from previous sessions.";
+export declare const FIRST_ACTION_INSTRUCTION = "FIRST ACTION REQUIRED: Call mem_session_summary with the content of the compacted summary. This preserves what was accomplished before compaction. Do this BEFORE any other work. Then call mem_context for a recent-session overview, and use the 3-layer recall protocol (mem_search with mode \"compact\" -> mem_timeline -> mem_get_observation) for precise retrieval.";
 export declare const SESSION_SUMMARY_TEMPLATE = "Use this exact structure for `mem_session_summary` content:\n\n## Goal\n[What we were working on this session]\n\n## Instructions\n[User preferences or constraints discovered during this session]\n\n## Discoveries\n- [Technical findings, gotchas, non-obvious learnings]\n\n## Accomplished\n- [Completed items with key details]\n\n## Next Steps\n- [What remains to be done]\n\n## Relevant Files\n- path/to/file.ts - [what it does or what changed]";
 export declare function buildCompactionReminder(sessionID: string): string;
 export declare function buildCompactorInstruction(project: string): string;
 export declare function buildMemoryInstructions(sessionID: string, project: string): string;
+export declare function buildSaveNudge(): string;