@zcy2nn/agent-forge 1.1.3 → 1.1.5

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

@@ -1,26 +0,0 @@
-export declare const PHASE_REMINDER = "<internal_reminder>!IMPORTANT! Recall the workflow rules:\nUnderstand \u2192 choose the best parallelized path based on your capabilities and agents delegation rules \u2192 recall session reuse rules \u2192 execute \u2192 verify.\nIf delegating, launch the specialist in the same turn you mention it !END!</internal_reminder>";
-interface MessageInfo {
-    role: string;
-    agent?: string;
-    sessionID?: string;
-}
-interface MessagePart {
-    type: string;
-    text?: string;
-    [key: string]: unknown;
-}
-interface MessageWithParts {
-    info: MessageInfo;
-    parts: MessagePart[];
-}
-/**
- * Creates the experimental.chat.messages.transform hook for phase reminder injection.
- * This hook runs right before sending to API, so it doesn't affect UI display.
- * Only injects for the orchestrator agent.
- */
-export declare function createPhaseReminderHook(): {
-    'experimental.chat.messages.transform': (_input: Record<string, never>, output: {
-        messages: MessageWithParts[];
-    }) => Promise<void>;
-};
-export {};

package/dist/hooks/post-file-tool-nudge/index.d.ts

@@ -1,19 +0,0 @@
-/**
- * Post-tool nudge - queues a delegation reminder after file reads/writes.
- * Catches the "inspect/edit files → implement myself" anti-pattern.
- */
-interface ToolExecuteAfterInput {
-    tool: string;
-    sessionID?: string;
-    callID?: string;
-}
-interface ToolExecuteAfterOutput {
-    output?: unknown;
-}
-interface PostFileToolNudgeOptions {
-    shouldInject?: (sessionID: string) => boolean;
-}
-export declare function createPostFileToolNudgeHook(options?: PostFileToolNudgeOptions): {
-    'tool.execute.after': (input: ToolExecuteAfterInput, output: ToolExecuteAfterOutput) => Promise<void>;
-};
-export {};

package/dist/skills/systematic-debugging/condition-based-waiting-example.d.ts

@@ -1,51 +0,0 @@
-import type { ThreadManager } from '~/threads/thread-manager';
-import type { LaceEvent, LaceEventType } from '~/threads/types';
-/**
- * Wait for a specific event type to appear in thread
- *
- * @param threadManager - The thread manager to query
- * @param threadId - Thread to check for events
- * @param eventType - Type of event to wait for
- * @param timeoutMs - Maximum time to wait (default 5000ms)
- * @returns Promise resolving to the first matching event
- *
- * Example:
- *   await waitForEvent(threadManager, agentThreadId, 'TOOL_RESULT');
- */
-export declare function waitForEvent(threadManager: ThreadManager, threadId: string, eventType: LaceEventType, timeoutMs?: number): Promise<LaceEvent>;
-/**
- * Wait for a specific number of events of a given type
- *
- * @param threadManager - The thread manager to query
- * @param threadId - Thread to check for events
- * @param eventType - Type of event to wait for
- * @param count - Number of events to wait for
- * @param timeoutMs - Maximum time to wait (default 5000ms)
- * @returns Promise resolving to all matching events once count is reached
- *
- * Example:
- *   // Wait for 2 AGENT_MESSAGE events (initial response + continuation)
- *   await waitForEventCount(threadManager, agentThreadId, 'AGENT_MESSAGE', 2);
- */
-export declare function waitForEventCount(threadManager: ThreadManager, threadId: string, eventType: LaceEventType, count: number, timeoutMs?: number): Promise<LaceEvent[]>;
-/**
- * Wait for an event matching a custom predicate
- * Useful when you need to check event data, not just type
- *
- * @param threadManager - The thread manager to query
- * @param threadId - Thread to check for events
- * @param predicate - Function that returns true when event matches
- * @param description - Human-readable description for error messages
- * @param timeoutMs - Maximum time to wait (default 5000ms)
- * @returns Promise resolving to the first matching event
- *
- * Example:
- *   // Wait for TOOL_RESULT with specific ID
- *   await waitForEventMatch(
- *     threadManager,
- *     agentThreadId,
- *     (e) => e.type === 'TOOL_RESULT' && e.data.id === 'call_123',
- *     'TOOL_RESULT with id=call_123'
- *   );
- */
-export declare function waitForEventMatch(threadManager: ThreadManager, threadId: string, predicate: (event: LaceEvent) => boolean, description: string, timeoutMs?: number): Promise<LaceEvent>;

package/dist/tools/council.d.ts

@@ -1,10 +0,0 @@
-import { type PluginInput, type ToolDefinition } from '@opencode-ai/plugin';
-import type { CouncilManager } from '../council/council-manager';
-/**
- * Creates the council_session tool for multi-LLM orchestration.
- *
- * This tool triggers a full council session: parallel councillors →
- * formatted results returned to the council agent for synthesis.
- * Available to the council agent.
- */
-export declare function createCouncilTool(_ctx: PluginInput, councilManager: CouncilManager): Record<string, ToolDefinition>;

package/src/skills/codemap/README.md

@@ -1,59 +0,0 @@
-# Codemap Skill
-
-Repository understanding and hierarchical codemap generation.
-
-## Overview
-
-Codemap helps orchestrators map and understand codebases by:
-
-1. Selecting relevant code/config files using LLM judgment
-2. Creating `.slim/codemap.json` for change tracking
-3. Generating empty `codemap.md` templates for fixers to fill in
-
-Legacy `.slim/cartography.json` state is migrated to `.slim/codemap.json` automatically.
-
-## Commands
-
-```bash
-# Initialize mapping
-node codemap.mjs init --root /repo --include "src/**/*.ts" --exclude "node_modules/**"
-
-# Check what changed
-node codemap.mjs changes --root /repo
-
-# Update hashes
-node codemap.mjs update --root /repo
-```
-
-## Outputs
-
-### .slim/codemap.json
-
-```json
-{
-  "metadata": {
-    "version": "1.0.0",
-    "last_run": "2026-01-25T19:00:00Z",
-    "include_patterns": ["src/**/*.ts"],
-    "exclude_patterns": ["node_modules/**"]
-  },
-  "file_hashes": {
-    "src/index.ts": "abc123..."
-  },
-  "folder_hashes": {
-    "src": "def456..."
-  }
-}
-```
-
-### codemap.md (per folder)
-
-Empty templates created in each folder for fixers to fill with:
-- Responsibility
-- Design patterns
-- Data/control flow
-- Integration points
-
-## Installation
-
-Installed automatically via agent-forge installer when custom skills are enabled.

package/src/skills/codemap/SKILL.md

@@ -1,163 +0,0 @@
----
-name: codemap
-description: Generate comprehensive hierarchical codemaps for UNFAMILIAR repositories. Expensive operation - only use when explicitly asked for codebase documentation or initial repository mapping
----
-
-# Codemap Skill
-
-You help users understand and map repositories by creating hierarchical codemaps.
-
-## When to Use
-
-- User asks to understand/map a repository
-- User wants codebase documentation
-- Starting work on an unfamiliar codebase
-
-## Workflow
-
-### Step 1: Check for Existing State
-
-**First, check if `.slim/codemap.json` exists in the repo root.**
-
-If it does not exist, check for legacy state at `.slim/cartography.json`.
-
-If legacy state exists: move `.slim/cartography.json` to `.slim/codemap.json`, then continue with change detection.
-
-If `.slim/codemap.json` exists: Skip to Step 3 (Detect Changes) - no need to re-initialize.
-
-If neither file exists: Continue to Step 2 (Initialize).
-
-### Step 2: Initialize (Only if no state exists)
-
-1. **Analyze the repository structure** - List files, understand directories
-2. **Infer patterns** for **core code/config files ONLY** to include:
-   - **Include**: `src/**/*.ts`, `package.json`, etc.
-   - **Exclude (MANDATORY)**: Do NOT include tests, documentation, or translations.
-     - Tests: `**/*.test.ts`, `**/*.spec.ts`, `tests/**`, `__tests__/**`
-     - Docs: `docs/**`, `*.md` (except root `README.md` if needed), `LICENSE`
-     - Build/Deps: `node_modules/**`, `dist/**`, `build/**`, `*.min.js`
-   - Respect `.gitignore` automatically
-3. **Run codemap.mjs init**:
-
-```bash
-node ~/.config/opencode/skills/codemap/scripts/codemap.mjs init \
-  --root ./ \
-  --include "src/**/*.ts" \
-  --exclude "**/*.test.ts" --exclude "dist/**" --exclude "node_modules/**"
-```
-
-This creates:
-- `.slim/codemap.json` - File and folder hashes for change detection
-- Empty `codemap.md` files in all relevant subdirectories
-
-4. **Delegate codemap writing to Implementer agents** - Spawn one implementer per folder to read code and create or update its specific `codemap.md` file.
-
-### Step 3: Detect Changes (If state already exists)
-
-1. **Run codemap.mjs changes** to see what changed:
-
-```bash
-node ~/.config/opencode/skills/codemap/scripts/codemap.mjs changes \
-  --root ./
-```
-
-2. **Review the output** - It shows:
-   - Added files
-   - Removed files
-   - Modified files
-   - Affected folders
-
-3. **Only update affected codemaps** - Spawn one implementer per affected folder to update its `codemap.md`.
-4. **Run update** to save new state:
-
-```bash
-node ~/.config/opencode/skills/codemap/scripts/codemap.mjs update \
-  --root ./
-```
-
-### Step 4: Finalize Repository Atlas (Root Codemap)
-
-Once all specific directories are mapped, the Orchestrator must create or update the root `codemap.md`. This file serves as the **Master Entry Point** for any agent or human entering the repository.
-
-1.  **Map Root Assets**: Document the root-level files (e.g., `package.json`, `index.ts`, `plugin.json`) and the project's overall purpose.
-2.  **Aggregate Sub-Maps**: Create a "Repository Directory Map" section. For every folder that has a `codemap.md`, extract its **Responsibility** summary and include it in a table or list in the root map.
-3.  **Cross-Reference**: Ensure that the root map contains the absolute or relative paths to the sub-maps so agents can jump directly to the relevant details.
-
-### Step 5: Register Codemap in AGENTS.md
-
-**OpenCode auto-loads `AGENTS.md` into agent context on every session.** To ensure agents automatically discover and use the codemap, update (or create) `AGENTS.md` at the repo root:
-
-1. If `AGENTS.md` already exists and already contains a `## Repository Map` section, **skip this step** — the reference is already set up.
-2. If `AGENTS.md` exists but has no `## Repository Map` section, **append** the section below.
-3. If `AGENTS.md` doesn't exist, **create** it with the section below.
-
-```markdown
-## Repository Map
-
-A full codemap is available at `codemap.md` in the project root.
-
-Before working on any task, read `codemap.md` to understand:
-- Project architecture and entry points
-- Directory responsibilities and design patterns
-- Data flow and integration points between modules
-
-For deep work on a specific folder, also read that folder's `codemap.md`.
-```
-
-This is idempotent — repeated codemap runs will detect the existing section and skip. No duplication.
-
-## Codemap Content
-
-Implementers are responsible for writing `codemap.md` files during this workflow. Use precise technical terminology to document the implementation:
-
-- **Responsibility** - Define the specific role of this directory using standard software engineering terms (e.g., "Service Layer", "Data Access Object", "Middleware").
-- **Design Patterns** - Identify and name specific patterns used (e.g., "Observer", "Singleton", "Factory", "Strategy"). Detail the abstractions and interfaces.
-- **Data & Control Flow** - Explicitly trace how data enters and leaves the module. Mention specific function call sequences and state transitions.
-- **Integration Points** - List dependencies and consumer modules. Use technical names for hooks, events, or API endpoints.
-
-Example codemap:
-
-```markdown
-# src/agents/
-
-## Responsibility
-Defines agent personalities and manages their configuration lifecycle.
-
-## Design
-Each agent is a prompt + permission set. Config system uses:
-- Default prompts (orchestrator.ts, researcher.ts, etc.)
-- User overrides from ~/.config/opencode/agent-forge.json
-- Permission wildcards for skill/MCP access control
-
-## Flow
-1. Plugin loads → calls getAgentConfigs()
-2. Reads user config preset
-3. Merges defaults with overrides
-4. Applies permission rules (wildcard expansion)
-5. Returns agent configs to OpenCode
-
-## Integration
-- Consumed by: Main plugin (src/index.ts)
-- Depends on: Config loader, skills registry
-```
-
-Example **Root Codemap (Atlas)**:
-
-```markdown
-# Repository Atlas: agent-forge
-
-## Project Responsibility
-A high-performance, low-latency agent orchestration plugin for OpenCode, focusing on specialized sub-agent delegation and multiplexer-assisted child sessions.
-
-## System Entry Points
-- `src/index.ts`: Plugin initialization and OpenCode integration.
-- `package.json`: Dependency manifest and build scripts.
-- `agent-forge.json`: User configuration schema.
-
-## Directory Map (Aggregated)
-| Directory | Responsibility Summary | Detailed Map |
-|-----------|------------------------|--------------|
-| `src/agents/` | Defines agent personalities (Orchestrator, Researcher) and manages model routing. | [View Map](src/agents/codemap.md) |
-| `src/features/` | Core logic for tmux integration and session state. | [View Map](src/features/codemap.md) |
-| `src/config/` | Implements the configuration loading pipeline and environment variable injection. | [View Map](src/config/codemap.md) |
-```

package/src/skills/codemap/codemap.md

@@ -1,36 +0,0 @@
-# src/skills/codemap/
-
-## Responsibility
-
-- Provide a command-style skill package that standardizes repository mapping workflows for unfamiliar codebases.
-- Define the task contract used by Orchestrator/implementer agents via `SKILL.md` and operational guidance via `README.md`.
-- Generate and evolve change-aware codemap state artifacts (`.slim/codemap.json`) and scaffold placeholders (`codemap.md`).
-
-## Design
-
-- Contract layer: `SKILL.md` (machine prompt contract) + `README.md` (human-facing operation notes).
-- Execution layer: `scripts/codemap.mjs` exports deterministic helper functions:
-  - `parseArgs(argv)`
-  - `cmdInit`, `cmdChanges`, `cmdUpdate`
-  - `selectFiles`, `computeFileHash`, `computeFolderHash`, `createEmptyCodemap`
-  - `loadState`, `saveState`, `migrateLegacyState`
-- Persistence model: JSON state at `.slim/codemap.json` with `metadata`, `file_hashes`, and `folder_hashes`.
-- Testing layer: `scripts/codemap.test.ts` validates pattern matching, hash determinism, and migration behavior.
-- The script intentionally avoids network and mutates only filesystem-local state and codemap templates.
-
-## Flow
-
-- Entry point `main(argv)` parses command and arguments (`init|changes|update`, `--root`, `--include`, `--exclude`, `--exception`) and dispatches via strict branches.
-- `cmdInit()` computes include/exclude candidate sets using `selectFiles()` and writes:
-  1) `.slim/codemap.json` via `saveState()`
-  2) one `codemap.md` per discovered folder via `createEmptyCodemap()`.
-- `cmdChanges()` reloads state (`loadState()` + `migrateLegacyState()`), recomputes current hashes, emits added/removed/modified diffs and affected folder list, and exits non-zero if state is absent.
-- `cmdUpdate()` recomputes full state from existing metadata and persists it, used after targeted fixers finish updates.
-- `codemap` skill invocation path in SKILL workflow is explicit: Step 1 checks `.slim/codemap.json` or `.slim/cartography.json`, then Step 2/3 selects init or incremental path.
-
-## Integration
-
-- Installed under OpenCode through `src/cli/custom-skills.ts` as `name: 'codemap'`, `sourcePath: 'src/skills/codemap'`.
-- `src/cli/install.ts` copies this directory into the user skill directory; OpenCode executes `scripts/codemap.mjs` from that context.
-- `src/hooks/filter-available-skills/index.ts` applies agent-level skill gating via names from `getSkillPermissionsForAgent()`.
-- `scripts/verify-release-artifact.ts` includes codemap skill metadata and runtime checks as required packaged files.