owflow 0.3.0 → 0.4.3

package/dist/skills/research-synthesize/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: owflow:research-synthesize
+description: Research skill — delegates synthesis and evidence-based reporting to the research-synthesizer agent, producing the synthesis document and the comprehensive research report with per-finding confidence. Closes the research foundation (synthesis-complete) at the boundary with the optional chain (user choice).
+argument-hint: "[task-path-or-identifier]"
+user-invocable: true
+---
+
+# Research Synthesize — Synthesis & Research Report (synthesis-complete)
+
+Work phase of the research workflow. Delegates pattern synthesis and evidence-based reporting to the research-synthesizer agent (`analysis/synthesis.md` + `outputs/research-report.md`). This is the research-foundation boundary: the Exit Gate is the pause between the foundation and the optional-phase decision. State lives in `orchestrator-state.yml` — this skill reads it on entry and writes results on exit.
+
+Related phases: `/owflow:research-gather` (produces the merged findings); the optional chain (`research-brainstorm` / `research-design`) and `/owflow:research-finalize` follow, per the user's choice.
+
+## Entry Gate
+
+Resolve the `task-path-or-identifier` argument BEFORE anything else (see [Gate Contract](../orchestrator-framework/references/gate-contract.md)):
+
+- **Path** (absolute or project-relative) to the task directory — use as-is.
+- **Identifier** — exact directory name inside `.owflow/tasks/research/` (e.g., `2026-09-26-my-research`); resolve to its path.
+- If the argument is **missing**, the path does **not exist**, or matches **no identifier** → print the blocked block, then STOP (never guess or auto-pick a task):
+  1. Steps that must be completed first (in order), each with its command:
+     - Research brief & plan (`brief-written`, `plan-created`) → `/owflow:research-plan <task-path>`
+     - Parallel findings fan (`findings-gathered`) → `/owflow:research-gather <task-path>`
+  2. List available research-task identifiers (directories under `.owflow/tasks/research/`) to resume from, if any.
+  3. Hint: `Run /owflow:research <question> to start a task from scratch, or pass a task path/identifier to resume.`
+
+### Prerequisites
+
+| Required for this skill              | Where verified                                                                 | Produced by                          |
+| ------------------------------------ | ------------------------------------------------------------------------------ | ------------------------------------ |
+| State file exists                    | `<task-path>/orchestrator-state.yml`                                           | `/owflow:research <question>` or `/owflow:research-quick` |
+| Findings exist                       | `findings-gathered` in `completed_phases` + `analysis/findings/` has per-category files | `/owflow:research-gather <task-path>` (or the quick lane's condensed gather) |
+| Research question recorded           | `research_context.research_question` non-null in state                          | `/owflow:research-plan <task-path>`   |
+
+1. **Read `orchestrator-state.yml`** from the task path. If missing → mid-pipeline bootstrap ([Missing-state Bootstrap](../orchestrator-framework/references/gate-contract.md), starting slug `synthesis-complete`): `question` — create a fresh standard research task starting at this step, or decline → print `No research task found at <path>. Run /owflow:research <question> to start a task from scratch.` and STOP.
+2. **Content check — findings present**: the per-category files under `analysis/findings/` must exist (artifacts before state — drop the `findings-gathered` entry and route back to `/owflow:research-gather <task-path>` when they do not).
+3. **Skip/resume**: if `analysis/synthesis.md` AND `outputs/research-report.md` both exist, adopt them — append `synthesis-complete` if it is missing, backfill `research_outputs.synthesis` and `research_outputs.research_report` when those fields are still null, report the existing summaries, and route to the Exit Gate. Either file missing → re-run below (drop a stale `synthesis-complete` entry first).
+
+## Input / Output Artifacts
+
+| Artifact                                       | Normal mode (full lane)                                                                        | Quick mode (`research-quick`)                                             |
+| ---------------------------------------------- | ----------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- |
+| Consumed: `analysis/findings/*.md`             | all per-category files (the gather contract)                                                     | same — quick-lane findings feed the inline synthesis                                        |
+| Consumed: `research-synthesizer` agent (Task tool) | 1 delegated call                                                                             | n/a — synthesis is ALWAYS inline in the quick lane (the ONLY exception to this delegation)  |
+| Produced: `analysis/synthesis.md`              | delegated (patterns, cross-references, gaps)                                                     | written directly inline                                                                     |
+| Produced: `outputs/research-report.md`         | delegated (report + per-finding confidence)                                                      | written directly inline                                                                     |
+| State write                                    | `synthesis-complete`; `confidence_level`, `phase_summaries.synthesize`, `research_outputs.synthesis` + `.research_report` | same slug and fields, condensation-noted                     |
+
+## Execute (delegated synthesis)
+
+**Read first**: the [Delegation Rules](../orchestrator-framework/references/delegation-rules.md).
+
+> **ANTI-PATTERN — never write synthesis.md or research-report.md yourself. "The findings are few" is NOT a reason to skip delegation. (The quick lane is the ONLY exception — research-quick synthesizes inline and skips this section.)**
+
+1. **INVOKE NOW**: Task tool - `research-synthesizer` subagent (never the Skill tool — this is an agent). Pass (Pattern 7 — accumulated context): task_path, findings_directory_path, research_question, research_type, methodology (from state).
+
+**Synthesizer produces**:
+
+- Pattern analysis and cross-references → `analysis/synthesis.md`
+- Comprehensive research report answering research question → `outputs/research-report.md`
+- Confidence levels for each finding
+- Documented gaps and uncertainties
+
+> **SELF-CHECK on both artifacts**: after the Task tool returns, verify `analysis/synthesis.md` AND `outputs/research-report.md` exist (synthesis documents gaps; report carries confidence per finding). If missing: **STOP. Re-invoke the research-synthesizer with corrected context.** If the second attempt also fails, use `question` to report the failure and ask whether to retry (after targeted re-gathering if the gaps require it) or stop. There is no continue-without-synthesis path — every later step reads these artifacts. On stop, record the failure per the State Update Convention and print the resume command.
+
+### Post-synthesis decision re-cap (direct, condensable)
+
+The synthesizer's key outcomes are surfaced to the user here before the Exit Gate (decisions from subagents must go to the user — never silently skipped): overall `confidence_level`, top patterns, documented gaps. Extract a 1-2 sentence summary into `phase_summaries.synthesize`.
+
+### Close (`synthesis-complete`)
+
+1. **State write**: append `synthesis-complete` to `completed_phases`; update `research_context.confidence_level`, `phase_summaries.synthesize`; set `research_outputs.synthesis` and `research_outputs.research_report`; bump `orchestrator.updated`. On failure: append `synthesis-complete` to `failed_phases`, increment `auto_fix_attempts["synthesis-complete"]`. Then re-read state + run `verify_template` (see State Update Convention).
+
+## State Update Convention (per step)
+
+Apply after EVERY step above:
+
+1. **Write immediately** — update `orchestrator-state.yml` as soon as the step completes, appending ONLY the step slug actually performed (`synthesis-complete`) plus that step's fields. Never batch multiple steps into one end-of-skill write.
+2. **Timestamp** — set `orchestrator.updated` to the current UTC timestamp on every write.
+3. **Failures** — if the step fails or its retries are abandoned, do NOT append to `completed_phases`; instead append the step's slug to `orchestrator.failed_phases` and increment `auto_fix_attempts["synthesis-complete"]`.
+4. **Validate** — after every write, re-read the file to confirm values, then run the `verify_template` tool with `filePath: <task-path>/orchestrator-state.yml`, `templateName: orchestrator-state-research.yml`. Fix any reported issue immediately before proceeding.
+5. **Final check** — before the Exit Gate, one consolidated re-read + `verify_template` run to confirm the full state matches everything performed in this session.
+
+## Recovery
+
+| Step                              | Max Attempts | Strategy                              |
+| --------------------------------- | ------------ | ------------------------------------- |
+| Synthesize (`synthesis-complete`) | 2            | Request targeted re-gathering for gaps |
+
+## Exit Gate
+
+Present results, get user confirmation, then hand off (see [Gate Contract](../orchestrator-framework/references/gate-contract.md)). Never auto-invoke the next skill.
+
+### Results box
+
+```markdown
+## ✅ RESEARCH SYNTHESIZE COMPLETE — <research question>
+
+**Type** — [research type]
+**Confidence** — [confidence level from state]
+**Key patterns** — [2-3 one-line pattern highlights from synthesis]
+**Gaps** — [documented gaps and uncertainties, 1 line]
+
+**Artifacts**
+
+- `analysis/synthesis.md`
+- `outputs/research-report.md`
+```
+
+### Results-acceptance question
+
+Use `question` — "Are these results correct?" with options:
+
+- **Accept** — synthesis and report are good; continue.
+- **Adjust** — re-run the affected part with the user's corrections (targeted re-gathering for gaps, then re-synthesize), update state and artifacts, re-present the results box.
+- **Discuss** — walk through specific findings or confidence levels in more depth; then re-ask.
+- **Stop here** — print the resume command (`/owflow:research-synthesize <task-path>`) and end.
+
+### Next steps (after Accept)
+
+Research foundation complete (initialized, planned, gathered, synthesized). Continue to optional-phase evaluation?
+
+- `→ /owflow:research-brainstorm <task-path>` — when the user wants solution alternatives brainstormed. Remaining after: converge → design (when wanted) → finalize.
+- `→ /owflow:research-design <task-path>` — design-only branch (no brainstorming), seeded from the research report. Remaining after: finalize.
+- `→ /owflow:research-finalize <task-path>` — when neither is wanted: inventories the outputs and completes the task. If the foundation alone was the goal, this is the route — the task stays resumable.
+
+Then STOP.

package/dist/skills/rule-reviewer/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: owflow:rule-reviewer
-description: Score an AI rules file on 5 axes and return concrete actionable fixes
+description: "Score a rule-for-AI markdown file (CLAUDE.md, AGENTS.md, or any rules file) on 5 axes and return concrete actionable fixes"
 argument-hint: "[path/to/rules.md]"
 user-invocable: true
 ---

package/dist/skills/standards-discover/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: owflow:standards-discover
 description: Discover coding standards from project configuration files, code patterns, documentation, and external sources (PRs, CI/CD)
+argument-hint: "[task description]"
 user-invocable: true
 ---
 

package/dist/templates/orchestrator-state-research.yml

@@ -1,17 +1,17 @@
 orchestrator:
   started_phase: null
+  entry_point: null
   completed_phases: []
   failed_phases: []
   auto_fix_attempts:
-    phase-1: 0
-    phase-2: 0
-    phase-3: 0
-    phase-4: 0
-    phase-5: 0
-    phase-6: 0
-  options:
-    brainstorming_enabled: null
-    design_enabled: null
+    brief-written: 0
+    plan-created: 0
+    findings-gathered: 0
+    synthesis-complete: 0
+    alternatives-generated: 0
+    approaches-chosen: 0
+    design-generated: 0
+    research-completed: 0
   created: "YYYY-MM-DDTHH:MM:SSZ"
   updated: "YYYY-MM-DDTHH:MM:SSZ"
   task_path: null
@@ -38,17 +38,22 @@ research_context:
     categories: []
     count: 0
     source: "planner | default"
+  project_doc_paths: []
   phase_summaries:
-    phase-1:
+    plan:
       summary: null
       steps_completed: []
-    phase-3:
+    gather:
       summary: null
-    phase-4:
+    synthesize:
+      summary: null
+    brainstorm:
+      summary: null
+    converge:
       summary: null
       decision_areas: []
       deferred_ideas: []
-    phase-5:
+    design:
       summary: null
       architecture_style: null
       decisions_count: 0
@@ -59,3 +64,4 @@ research_outputs:
   solution_exploration: null
   high_level_design: null
   decision_log: null
+  synthesis: null

package/dist/tools/fork_task.js

@@ -0,0 +1,36 @@
+import { tool } from "@opencode-ai/plugin";
+import path from "node:path";
+import { forkTask } from "../utils/fork-task.js";
+export const fork_task = tool({
+    description: "Fork a research task: copy the whole source task directory into a new date-prefixed directory named from the slug, then trim the copied state so the fork continues from the chosen completed step (fork point) onwards. The source task is never modified.",
+    args: {
+        taskRoot: tool.schema.string().describe("Project-relative root of all tasks (typically '.owflow/tasks')"),
+        source: tool.schema.string().describe("Source task path or identifier under .owflow/tasks/research/"),
+        slug: tool.schema.string().describe("Lowercase-kebab-case slug for the fork name, 3-5 words, WITHOUT the date prefix (derived by the agent from a short descriptive name)"),
+        from: tool.schema.string().describe("Fork point: a completed step slug from the source task's completed_phases (e.g. 'synthesis-complete'); the fork continues from the step after it"),
+        intent: tool.schema.string().optional().describe("Optional one-line description of what the fork should explore; stamped into the fork's orchestrator.options.fork_information.intent"),
+    },
+    async execute(args, context) {
+        try {
+            const result = forkTask({
+                taskRoot: args.taskRoot,
+                source: args.source,
+                slug: args.slug,
+                from: args.from,
+                intent: args.intent,
+                cwd: context.directory,
+            });
+            return {
+                output: [
+                    `FORK CREATED`,
+                    `Fork path: ${path.relative(context.directory, result.forkPath).split(path.sep).join("/")}`,
+                    `Fork point: ${result.forkPoint}`,
+                    ...(args.intent ? [`Intent: ${args.intent}`] : []),
+                ].join("\n"),
+            };
+        }
+        catch (error) {
+            return { output: error.message };
+        }
+    },
+});

package/dist/tools/verify_template.js

@@ -1,8 +1,8 @@
 import { tool } from "@opencode-ai/plugin";
 import fs from "node:fs";
 import path from "node:path";
-import yaml from "yaml";
 import { fileURLToPath } from "node:url";
+import { findStructuralErrors, parseYamlFile, } from "../utils/yaml-structure.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export const verify_template = tool({
     description: "Check if file in the given path exists and follows correct YAML structure by checking against the template file from /templates.",
@@ -20,39 +20,18 @@ export const verify_template = tool({
             return { output: `Template '${templateName}' not found. Hint: Verify the template name is correct and exists in the /templates folder (e.g., 'orchestrator-state-development.yml').` };
         }
         let targetYaml;
-        try {
-            const fileContent = fs.readFileSync(absolutePath, "utf8");
-            targetYaml = yaml.parse(fileContent);
-        }
-        catch (error) {
-            return { output: `YAML Syntax Error in ${filePath}: ${error.message}. Hint: Check the file content for invalid YAML formatting, such as incorrect indentation or unescaped strings, and fix them.` };
+        const parsedTarget = parseYamlFile(absolutePath);
+        if (!parsedTarget.ok) {
+            return { output: `YAML Syntax Error in ${filePath}: ${parsedTarget.error}. Hint: Check the file content for invalid YAML formatting, such as incorrect indentation or unescaped strings, and fix them.` };
         }
+        targetYaml = parsedTarget.data;
         let templateYaml;
-        try {
-            const templateContent = fs.readFileSync(templatePath, "utf8");
-            templateYaml = yaml.parse(templateContent);
-        }
-        catch (error) {
-            return { output: `Internal Error: Failed to parse reference template YAML '${templateName}': ${error.message}. Hint: The template file itself contains invalid YAML syntax.` };
-        }
-        function checkStructure(templateObj, targetObj, currentPath = "") {
-            let errors = [];
-            if (typeof templateObj !== 'object' || templateObj === null) {
-                return errors;
-            }
-            for (const key of Object.keys(templateObj)) {
-                const newPath = currentPath ? `${currentPath}.${key}` : key;
-                if (typeof targetObj !== 'object' || targetObj === null || !(key in targetObj)) {
-                    errors.push(`Missing key: ${newPath}`);
-                    continue;
-                }
-                if (typeof templateObj[key] === 'object' && templateObj[key] !== null && !Array.isArray(templateObj[key])) {
-                    errors.push(...checkStructure(templateObj[key], targetObj[key], newPath));
-                }
-            }
-            return errors;
+        const parsedTemplate = parseYamlFile(templatePath);
+        if (!parsedTemplate.ok) {
+            return { output: `Internal Error: Failed to parse reference template YAML '${templateName}': ${parsedTemplate.error}. Hint: The template file itself contains invalid YAML syntax.` };
         }
-        const errors = checkStructure(templateYaml, targetYaml);
+        templateYaml = parsedTemplate.data;
+        const errors = findStructuralErrors(templateYaml, targetYaml);
         if (errors.length > 0) {
             return { output: `YAML Structure Validation Failed. Your file is missing the following required keys:\n- ${errors.join("\n- ")}\n\nHint: Update the file at ${filePath} to include these missing keys so it matches the structure of '${templateName}'.` };
         }

package/dist/utils/file-util.js

@@ -1,7 +1,7 @@
 import matter from "gray-matter";
 import fs from "node:fs";
 import path from "node:path";
-import { PLUGIN_ROOT } from "../constants.js";
+import { PLUGIN_ROOT } from "./plugin-info.js";
 export const loadMarkdownDir = (dirPath) => {
     const fullPath = path.join(PLUGIN_ROOT, dirPath);
     let files;

package/dist/utils/fork-task.js

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import path from "node:path";
+import yaml from "yaml";
+import { parseYamlFile } from "./yaml-structure.js";
+/** Lowercase kebab-case, exactly 3-5 words of [a-z0-9] (Task Name Generation convention). */
+export const RESEARCH_SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+){2,4}$/;
+const FORK_TERMINAL_STEP = "research-completed";
+/**
+ * Copies the whole source task directory into a new date-prefixed directory
+ * named from the slug, then trims the copied state so the fork continues
+ * from the fork point onwards. The source task is never modified.
+ */
+export const forkTask = (input) => {
+    const cwd = input.cwd ?? process.cwd();
+    if (!input.slug || !RESEARCH_SLUG_PATTERN.test(input.slug)) {
+        throw new Error("INVALID_NAME: slug must be lowercase kebab-case, 3-5 words of [a-z0-9] (e.g. 'compare-caching-strategies')");
+    }
+    const taskRoot = path.resolve(cwd, input.taskRoot);
+    const researchRoot = path.join(taskRoot, "research");
+    const sourceDir = [
+        path.resolve(cwd, input.source),
+        path.resolve(researchRoot, input.source),
+    ].find((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isDirectory());
+    if (sourceDir === undefined) {
+        throw new Error(`INVALID_SOURCE: no task directory at ${input.source}. Hint: pass the task path or a directory name under .owflow/tasks/research/.`);
+    }
+    if (!sourceDir.startsWith(researchRoot + path.sep)) {
+        throw new Error(`INVALID_SOURCE: ${input.source} is not a research task directory under .owflow/tasks/research/.`);
+    }
+    const parsedSourceState = parseYamlFile(path.join(sourceDir, "orchestrator-state.yml"));
+    if (!parsedSourceState.ok || !parsedSourceState.data) {
+        throw new Error(`INVALID_SOURCE: ${parsedSourceState.error ?? `no orchestrator-state.yml in ${input.source}`}`);
+    }
+    const sourceState = parsedSourceState.data;
+    const completed = Array.isArray(sourceState?.orchestrator?.completed_phases)
+        ? sourceState.orchestrator.completed_phases.filter((s) => typeof s === "string")
+        : [];
+    if (input.from === FORK_TERMINAL_STEP) {
+        throw new Error(`UNKNOWN_STEP: ${FORK_TERMINAL_STEP} is not a valid fork point — nothing diverges after completion.`);
+    }
+    if (!completed.includes(input.from)) {
+        throw new Error(`UNKNOWN_STEP: ${input.from} is not completed in the source task. Completed steps: ${completed.join(", ") || "none"}`);
+    }
+    const forkName = `${new Date().toISOString().slice(0, 10)}-${input.slug}`;
+    const forkPath = path.join(researchRoot, forkName);
+    if (fs.existsSync(forkPath)) {
+        throw new Error(`NAME_TAKEN: a research task directory "${forkName}" already exists. Hint: ask the user for another short descriptive name (3-5 words).`);
+    }
+    fs.cpSync(sourceDir, forkPath, { recursive: true });
+    const forkState = structuredClone(sourceState);
+    forkState.orchestrator.started_phase = null;
+    forkState.orchestrator.completed_phases = completed.slice(0, completed.indexOf(input.from) + 1);
+    forkState.orchestrator.entry_point = "research-fork";
+    forkState.orchestrator.task_path = path
+        .relative(cwd, forkPath)
+        .split(path.sep)
+        .join("/");
+    forkState.orchestrator.options = {
+        ...(forkState.orchestrator.options ?? {}),
+        fork_information: {
+            forked_from: path.basename(sourceDir),
+            fork_point: input.from,
+            forked_at: new Date().toISOString(),
+            ...(input.intent ? { intent: input.intent } : {}),
+        },
+    };
+    forkState.task = {
+        ...forkState.task,
+        status: "in_progress",
+        title: `${forkState.task?.title ?? "Research task"} (fork of ${path.basename(sourceDir)})`,
+    };
+    fs.writeFileSync(path.join(forkPath, "orchestrator-state.yml"), yaml.stringify(forkState), "utf8");
+    return { forkPath, forkName, forkPoint: input.from };
+};

package/dist/utils/plugin-info.js

@@ -0,0 +1,20 @@
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export const PLUGIN_ROOT = path.join(__dirname, ".."); // Points to dist/ where skills/commands/agents are copied
+const UNKNOWN_VERSION = "unknown";
+export const readPluginVersion = (pluginRoot = PLUGIN_ROOT) => {
+    try {
+        const packageJsonPath = path.join(pluginRoot, "..", "package.json");
+        const raw = fs.readFileSync(packageJsonPath, "utf8");
+        const version = JSON.parse(raw).version;
+        return typeof version === "string" && version.length > 0
+            ? version
+            : UNKNOWN_VERSION;
+    }
+    catch {
+        return UNKNOWN_VERSION;
+    }
+};
+export const PLUGIN_VERSION = readPluginVersion();

package/dist/utils/yaml-structure.js

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+import yaml from "yaml";
+export const parseYamlFile = (absolutePath) => {
+    try {
+        const fileContent = fs.readFileSync(absolutePath, "utf8");
+        return { ok: true, data: yaml.parse(fileContent) };
+    }
+    catch (error) {
+        return { ok: false, error: error.message };
+    }
+};
+export const findStructuralErrors = (templateObj, targetObj, currentPath = "") => {
+    const errors = [];
+    if (typeof templateObj !== "object" || templateObj === null) {
+        return errors;
+    }
+    for (const key of Object.keys(templateObj)) {
+        const newPath = currentPath ? `${currentPath}.${key}` : key;
+        if (typeof targetObj !== "object" ||
+            targetObj === null ||
+            !(key in targetObj)) {
+            errors.push(`Missing key: ${newPath}`);
+            continue;
+        }
+        if (typeof templateObj[key] === "object" &&
+            templateObj[key] !== null &&
+            !Array.isArray(templateObj[key])) {
+            errors.push(...findStructuralErrors(templateObj[key], targetObj[key], newPath));
+        }
+    }
+    return errors;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "owflow",
-  "version": "0.3.0",
+  "version": "0.4.3",
   "description": "Spec-driven development AI workflow for OpenCode",
   "type": "module",
   "main": "dist/index.js",

package/dist/commands/agents-md-generator.md

@@ -1,36 +0,0 @@
----
-name: owflow:agents-md-generator
-description: Generate AGENTS.md onboarding document for AI coding agents
-argument-hint: "[directory or file path]"
----
-
-CRITICAL INSTRUCTION: You MUST invoke the owflow:agents-md-generator skill immediately as your FIRST action.
-
-Use the Skill tool with these exact parameters:
-name: "agents-md-generator"
-prompt: "$ARGUMENTS"
-
-DO NOT:
-
-- Analyze the task before invoking the skill
-- Decide the task is "straightforward" and skip the skill
-- Substitute your own approach or workflow
-- Execute any part of the workflow yourself
-
-WHY: The user explicitly chose this workflow by using /owflow:agents-md-generator.
-Invoke the skill now and let it orchestrate the complete workflow.
-
----
-
-## About This Workflow
-
-Generates an `AGENTS.md` onboarding document for AI coding agents working in a repository. Inspects the repo (package manifest, README, scripts, lint/test config, layout, commit history) and writes a concise, reference-heavy contributor guide.
-
-The skill handles:
-
-- Repo-level vs directory-level scope detection
-- Create path (fresh generation) and Update path (surgical edits)
-- Quality guards enforcing length, specificity, and structure
-- Parallel discovery via subagents for large repos
-
-See `skills/agents-md-generator/SKILL.md` for complete workflow documentation.

package/dist/commands/dev-analyze.md

@@ -1,33 +0,0 @@
----
-name: owflow:dev-analyze
-description: Development — codebase analysis, clarifications, gap analysis & scope decisions
-argument-hint: "[task-path-or-identifier]"
----
-
-CRITICAL INSTRUCTION: You MUST invoke the owflow:dev-analyze skill immediately as your FIRST action.
-
-Use the Skill tool with these exact parameters:
-name: "dev-analyze"
-prompt: "$ARGUMENTS"
-
-DO NOT:
-
-- Analyze the task before invoking the skill
-- Decide the task is "straightforward" and skip the skill
-- Substitute your own approach or workflow
-- Execute any part of the workflow yourself
-
-WHY: The user explicitly chose this workflow phase by using /owflow:dev-analyze.
-Invoke the skill now and let it execute the phase, update orchestrator state,
-and present results with next-step suggestions.
-
----
-
-## About This Workflow
-
-Part of the development workflow. See `skills/dev-analyze/SKILL.md` for complete phase documentation.
-
-Entry points:
-
-- `/owflow:development <description>` — start a new development task (assisted mode)
-- `/owflow:goal-development <description>` — run all phases in one loop (orchestrated mode)

package/dist/commands/dev-bugfix.md

@@ -1,37 +0,0 @@
----
-name: owflow:dev-bugfix
-description: Quick bug fix with TDD red/green gates and complexity escalation — standard dev-task state, continuable by any dev-* subskill
-argument-hint: "[bug description | task-path-or-identifier]"
----
-
-CRITICAL INSTRUCTION: You MUST invoke the owflow:dev-bugfix skill immediately as your FIRST action.
-
-Use the Skill tool with these exact parameters:
-name: "dev-bugfix"
-prompt: "$ARGUMENTS"
-
-DO NOT:
-
-- Analyze the task before invoking the skill
-- Decide the task is "straightforward" and skip the skill
-- Substitute your own approach or workflow
-- Execute any part of the workflow yourself
-
-WHY: The user explicitly chose this workflow by using /owflow:dev-bugfix.
-Invoke the skill now and let it orchestrate the complete workflow.
-
----
-
-## About This Workflow
-
-Quick bug fix with TDD red/green gates and complexity escalation. An alternative entry point into the dev-* workflow: bootstraps (or resumes) a standard development task with `orchestrator-state.yml`.
-
-Pass a bug description for a fresh fix, or a task path/identifier (under `.owflow/tasks/development/`) to fix a newly emerging problem on an existing development task.
-The skill handles:
-
-- Task directory creation and state management
-- Phase execution with interactive gates
-- Subagent delegation for specialized work
-- Pause/resume capability
-
-See `skills/dev-bugfix/SKILL.md` for complete workflow documentation.

package/dist/commands/dev-finalize.md

@@ -1,33 +0,0 @@
----
-name: owflow:dev-finalize
-description: Development — E2E testing, user documentation & finalization
-argument-hint: "[task-path-or-identifier]"
----
-
-CRITICAL INSTRUCTION: You MUST invoke the owflow:dev-finalize skill immediately as your FIRST action.
-
-Use the Skill tool with these exact parameters:
-name: "dev-finalize"
-prompt: "$ARGUMENTS"
-
-DO NOT:
-
-- Analyze the task before invoking the skill
-- Decide the task is "straightforward" and skip the skill
-- Substitute your own approach or workflow
-- Execute any part of the workflow yourself
-
-WHY: The user explicitly chose this workflow phase by using /owflow:dev-finalize.
-Invoke the skill now and let it execute the phase, update orchestrator state,
-and present results with next-step suggestions.
-
----
-
-## About This Workflow
-
-Part of the development workflow. See `skills/dev-finalize/SKILL.md` for complete phase documentation.
-
-Entry points:
-
-- `/owflow:development <description>` — start a new development task (assisted mode)
-- `/owflow:goal-development <description>` — run all phases in one loop (orchestrated mode)

package/dist/commands/dev-implement.md

@@ -1,34 +0,0 @@
----
-name: owflow:dev-implement
-description: Development — execute implementation plan & TDD Green Gate. --quick bootstraps a condensed task when no state file exists.
-argument-hint: "[task-path-or-identifier | \"description\"] [--quick]"
----
-
-CRITICAL INSTRUCTION: You MUST invoke the owflow:dev-implement skill immediately as your FIRST action.
-
-Use the Skill tool with these exact parameters:
-name: "dev-implement"
-prompt: "$ARGUMENTS"
-
-DO NOT:
-
-- Analyze the task before invoking the skill
-- Decide the task is "straightforward" and skip the skill
-- Substitute your own approach or workflow
-- Execute any part of the workflow yourself
-
-WHY: The user explicitly chose this workflow phase by using /owflow:dev-implement.
-Invoke the skill now and let it execute the phase, update orchestrator state,
-and present results with next-step suggestions.
-
----
-
-## About This Workflow
-
-Part of the development workflow. See `skills/dev-implement/SKILL.md` for complete phase documentation.
-
-Entry points:
-
-- `/owflow:development <description>` — start a new development task (assisted mode)
-- `/owflow:goal-development <description>` — run all phases in one loop (orchestrated mode)
-- `/owflow:dev-implement --quick "<description>"` — condensed quick task: bootstraps a standard development task (state + condensed spec/plan) here, implements it directly with standards, then stops — continuable with `/owflow:dev-verify` or any dev-* subskill