owflow 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dawid Paluchowski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,162 @@
+![Owflow logo](logo.png)
+
+# Owflow
+
+**Structured, standards-aware development workflows for OpenCode**
+
+Describe what you want to build, and the plugin handles the rest - from specification through implementation to verification - while enforcing your project's coding standards at every step.
+
+Started as a simple OpenCode fork of [Maister Claude Code plugin](https://github.com/SkillPanel/maister), Owflow aims to deliver production ready workflows using the full [Opencode](https://opencode.ai/) plugin support.
+
+## What You Get
+
+- **Guided workflows** for features, bug fixes, enhancements, performance, migrations, research, and product design
+- **Auto-discovered standards** from your codebase - config files, source patterns, and documentation are analyzed and enforced throughout every workflow
+- **Test-driven implementation** with automated planning, incremental verification, and full test suite runs before completion
+- **Pause and resume** any workflow - state is preserved across sessions
+- **Production readiness checks** including code review, reality assessment, and pragmatic over-engineering detection
+
+## Getting Started
+
+### Prerequisites
+
+- [Opencode](https://opencode.ai/) CLI installed and configured
+
+### Installation
+
+Add owflow to the `plugin` array in your `opencode.json` ([global or project-level](https://opencode.ai/docs/plugins/#load-order)):
+
+```json
+{
+  "plugin": ["owflow"]
+}
+```
+
+### Initial project setup
+
+Initialize your project to auto-detect coding standards and generate project documentation:
+
+```bash
+/flow-init
+```
+
+This scans your codebase and creates `.owflow/` with standards, docs, and task folders. May take a few minutes on larger projects.
+
+If you have another project already using Owflow, you can reuse its standards as a starting point:
+
+```bash
+/flow-init --standards-from=/path/to/other-project
+```
+
+### First Workflow
+
+```bash
+/development Add user profile page with avatar upload
+```
+
+Or just discuss your task with LLM model and then run:
+
+```bash
+/development
+```
+
+The plugin picks up context from your conversation - no arguments needed.
+
+## How It Works
+
+1. You describe a task - either as an argument or just in conversation
+2. The plugin classifies it (feature, bug, enhancement, etc.) and proposes a workflow
+3. You confirm, and it guides you through phases: **requirements → spec → plan → implement → verify**
+4. At each phase, it asks for your input and decisions
+5. You get tested, verified code with a detailed work log
+
+All artifacts are saved in `.owflow/tasks/` organized by type and date.
+
+### Context-Aware Commands
+
+Every workflow command works without arguments. The plugin reads your current conversation to extract the task description and auto-detect the task type:
+
+```
+You: "The login page throws a 500 error when the session expires"
+You: /development
+→ Auto-detects: bug fix, extracts description from conversation
+```
+
+```
+You: /standards-update
+→ Scans conversation for patterns like "we always use..." or "prefer X over Y"
+```
+
+You can always be explicit when you prefer - arguments and flags simply override the auto-detection.
+
+## Supported Workflows
+
+| Command           | Use When                                    |
+| ----------------- | ------------------------------------------- |
+| `/development`    | Features, bug fixes, enhancements           |
+| `/research`       | Research with synthesis and solution design |
+| `/performance`    | Optimizing speed or resource usage          |
+| `/migration`      | Changing technologies or patterns           |
+| `/product-design` | Product and feature design                  |
+
+Task type (feature/bug/enhancement) is auto-detected from context. Override with `--type=feature|bug|enhancement` if needed. Or use `/work` as a single entry point that routes to the right workflow.
+
+### Quick Commands
+
+For smaller tasks that don't need a full workflow:
+
+| Command         | Use When                                                    |
+| --------------- | ----------------------------------------------------------- |
+| `/quick-plan`   | You want a plan with standards awareness before coding      |
+| `/quick-dev`    | You know what to do - just implement with standards applied |
+| `/quick-bugfix` | Quick TDD-driven bug fix — write failing test, fix, verify  |
+
+## Standards-Aware Development
+
+This is the key differentiator. Owflow doesn't just run workflows - it learns your project's conventions and enforces them:
+
+- **`flow-init`** scans config files, source code, and documentation to auto-detect your coding standards
+- **Continuous checking** - standards are consulted before specification, during planning, and while coding (not just at the start)
+- **`/standards-discover`** refreshes standards from your evolving codebase
+- **`/standards-update`** lets you add or refine standards manually, or sync from another project with `--from=PATH`
+
+Standards live in `.owflow/docs/standards/` and are indexed in `.owflow/docs/INDEX.md`.
+
+**Important**: Do not use plan mode with workflows (see [Best Practices](#best-practices) below).
+
+## Beta Channel
+
+Want to try experimental features before they hit stable? Install from the beta channel:
+
+TBD
+
+## Best Practices
+
+**Don't use plan mode when starting a workflow.** Planning is a built-in part of every workflow — the orchestrator creates specs, plans, and other files as it goes. Claude Code's plan mode restricts file creation, which conflicts with this. Let the workflow handle planning on its own.
+
+**Start workflows in a fresh session.** This is especially useful when chaining workflows (e.g., research → development). Research and product-design artifacts already contain all the context needed, so a clean session avoids noise from prior conversation.
+
+**Chain workflows by passing a task folder.** If you've completed a research or product-design workflow and want to build on those results, pass the task folder directly:
+
+```bash
+/development .owflow/tasks/research/2026-01-12-oauth-research
+```
+
+You can also append additional instructions to narrow scope or guide the workflow:
+
+```bash
+/development .owflow/tasks/product-design/2026-03-10-dashboard-redesign Implement only phase 1
+```
+
+## Known Issues
+
+**Orchestrator may stall after long phases.** After context compaction (which typically happens after lengthy phases like implementation), the main agent may stop progressing automatically. If you notice it's idle, just type something like "continue" or "proceed" — it will pick up where it left off. You can also re-invoke the workflow in resume mode to reload the orchestrator state:
+
+```bash
+/development .owflow/tasks/development/2026-03-24-my-feature
+```
+
+## Learn More
+
+- [Workflow Details](docs/workflows.md) - phases, examples, and task structure for each workflow type
+- [Full Command Reference](docs/commands.md) - all workflow, review, utility, and quick commands

package/dist/index.js

@@ -0,0 +1,197 @@
+/**
+ * Owflow OpenCode Plugin
+ * Registers skills/agents/commands via OpenCode's JS event system.
+ */
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "url";
+import matter from "gray-matter";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PLUGIN_ROOT = path.resolve(__dirname, "../..");
+/**
+ * Resolves model aliases to the configured small_model value.
+ * Maps common small/fast model aliases to OpenCode's small_model config.
+ *
+ * @param {string} modelValue - The model value from agent frontmatter
+ * @param {string} smallModel - The small_model from OpenCode config
+ * @returns {string|undefined} - Resolved model value or undefined
+ */
+const resolveModelAlias = (modelValue, smallModel) => {
+    // Aliases that should map to small_model
+    const SMALL_MODEL_ALIASES = [
+        "haiku", // Claude Code alias
+        "gpt-4o-mini", // OpenAI small model
+        "small", // Generic alias
+        "fast", // Generic alias
+    ];
+    // If no model specified or it's 'inherit', return undefined (let OpenCode decide)
+    if (!modelValue || modelValue === "inherit") {
+        return undefined;
+    }
+    // If it's a small model alias and we have a configured small_model, use it
+    if (SMALL_MODEL_ALIASES.includes(modelValue.toLowerCase())) {
+        if (smallModel) {
+            return smallModel;
+        }
+        // If no small_model configured, return undefined (inherit)
+        console.warn(`[owflow] Agent uses '${modelValue}' but no small_model configured in opencode.json - falling back to inherit`);
+        return undefined;
+    }
+    // Otherwise, pass through the original value
+    return modelValue;
+};
+const loadMarkdownDir = (dirPath) => {
+    try {
+        return fs
+            .readdirSync(dirPath)
+            .filter((f) => f.endsWith(".md"))
+            .map((f) => {
+            const raw = fs.readFileSync(path.join(dirPath, f), "utf8");
+            return matter(raw);
+        });
+    }
+    catch {
+        return [];
+    }
+};
+const prepareAgent = ({ data, content }, smallModel) => {
+    return {
+        prompt: content,
+        ...(data.description && { description: data.description }),
+        // Resolve model aliases (haiku, gpt-4o-mini, etc.) to small_model
+        ...(() => {
+            const resolvedModel = resolveModelAlias(data.model, smallModel);
+            return resolvedModel ? { model: resolvedModel } : {};
+        })(),
+        ...(data.mode && { mode: data.mode }),
+        // Add skills array if present
+        ...(data.skills && Array.isArray(data.skills) && { skills: data.skills }),
+        ...(data.hidden === "true" && { hidden: true }),
+    };
+};
+export const OwflowPlugin = async ({ $, directory }) => {
+    const agentBySession = new Map();
+    return {
+        /**
+         * Register owflow's skills, commands, and agents so OpenCode discovers
+         * them without requiring manual config file edits.
+         */
+        config: async (config) => {
+            let typedConfig = config;
+            // Get small_model config for alias resolution
+            // Try from config parameter first, fallback to reading opencode.json
+            let smallModel = typedConfig.small_model ?? "";
+            if (!smallModel) {
+                try {
+                    // Check project-level opencode.json
+                    const projectConfigPath = path.join(directory, "opencode.json");
+                    if (fs.existsSync(projectConfigPath)) {
+                        const rawConfig = fs.readFileSync(projectConfigPath, "utf8");
+                        const opencodeConfig = JSON.parse(rawConfig);
+                        smallModel = opencodeConfig.small_model;
+                    }
+                }
+                catch (error) {
+                    console.warn(`Couldn't read or parse opencode.json config - small_model remains undefined`);
+                }
+            }
+            // --- Skills ---
+            typedConfig.skills = typedConfig.skills || {};
+            typedConfig.skills.paths = typedConfig.skills.paths || [];
+            const skillsDir = path.join(PLUGIN_ROOT, "skills");
+            if (!typedConfig.skills.paths.includes(skillsDir)) {
+                typedConfig.skills.paths.push(skillsDir);
+            }
+            // --- Commands ---
+            typedConfig.command = typedConfig.command || {};
+            const commandsDir = path.join(PLUGIN_ROOT, "commands");
+            for (const { data, content } of loadMarkdownDir(commandsDir)) {
+                const name = data.name;
+                if (!name)
+                    continue;
+                // Don't overwrite commands the user has explicitly configured
+                if (typedConfig.command[name])
+                    continue;
+                typedConfig.command[name] = {
+                    template: content,
+                    ...(data.description && { description: data.description }),
+                    ...(data.agent && { agent: data.agent }),
+                    ...(data.model && { model: data.model }),
+                    ...(data.subtask !== undefined && {
+                        subtask: data.subtask === "true",
+                    }),
+                };
+            }
+            // --- Agents ---
+            typedConfig.agent = typedConfig.agent || {};
+            const agentsDir = path.join(PLUGIN_ROOT, "agents");
+            for (const markdown of loadMarkdownDir(agentsDir)) {
+                const name = markdown.data.name;
+                if (!name)
+                    continue;
+                // Don't overwrite agents the user has explicitly configured
+                if (typedConfig.agent[name])
+                    continue;
+                try {
+                    typedConfig.agent[name] = prepareAgent(markdown, smallModel);
+                }
+                catch (error) {
+                    console.warn(`[owflow] Failed to register agent '${name}': ${error.message}`);
+                }
+            }
+            config = typedConfig;
+        },
+        /**
+         * Post-compaction reminder.
+         * Injects orchestrator state reminder into the compaction context so the
+         * AI knows to re-read orchestrator-state.yml after the context is rebuilt.
+         */
+        "experimental.session.compacting": async (input, output) => {
+            const tasksDir = `${directory}/.owflow/tasks`;
+            try {
+                await $ `test -d ${tasksDir}`;
+                output.context.push(`## owflow Workflow State
+If an orchestrator workflow was active before compaction, you MUST re-read
+orchestrator-state.yml in that task's directory to verify completed_phases
+and determine the next phase. Use the question tool at Phase Gates.`);
+            }
+            catch {
+                // No .owflow/tasks directory — not a owflow project, skip injection
+            }
+        },
+        "chat.message": async (input, _output) => {
+            try {
+                agentBySession.set(input.sessionID, input.agent ?? "main");
+            }
+            catch {
+                // ignore
+            }
+        },
+        "tool.execute.before": async (input, output) => {
+            try {
+                if (input.tool !== "bash")
+                    return;
+                const agentName = agentBySession.get(input.sessionID) ?? "main";
+                const WHITELIST = [
+                    "task-group-implementer",
+                    "test-suite-runner",
+                    "e2e-test-verifier",
+                    "user-docs-generator",
+                    "docs-operator",
+                ];
+                if (WHITELIST.includes(agentName))
+                    return;
+                const cmd = output?.args?.command ?? "";
+                const DESTRUCTIVE = /git\s+stash|git\s+reset\s+--hard|git\s+checkout\s+--\s+\.|git\s+checkout\s+\.\s*(?:$|\s)|git\s+clean|git\s+push\s+(?:--force|-f)|rm\s+-[rf]{2}/i;
+                if (DESTRUCTIVE.test(cmd)) {
+                    throw new Error(`Blocked: destructive command not permitted for agent "${agentName}"`);
+                }
+            }
+            catch (e) {
+                // Re-throw only intentional blocks; swallow unexpected errors
+                if (e.message?.startsWith("Blocked:"))
+                    throw e;
+            }
+        },
+    };
+};

package/dist/skills/product-design/server/index.js

@@ -0,0 +1,302 @@
+import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Parse --task-path from CLI args
+const taskPathArg = process.argv.find((a) => a.startsWith("--task-path="));
+const taskPath = taskPathArg ? taskPathArg.split("=")[1] : null;
+if (!taskPath) {
+    console.warn("[visual-companion] No --task-path provided. Mockups will NOT be saved to disk.");
+}
+// In-memory state: array of all mockups (screens)
+const mockups = [];
+let latestId = null;
+let version = 0;
+const sseClients = [];
+function slugify(title) {
+    return (title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "") || "untitled");
+}
+// Save a rendered standalone HTML file to disk. Returns true if saved, false if skipped.
+function saveToDisk(mockup) {
+    if (!taskPath) {
+        console.warn(`[visual-companion] Skipping disk save for "${mockup.id}" — no task path configured.`);
+        return false;
+    }
+    const dir = path.join(taskPath, "analysis", "mockups");
+    fs.mkdirSync(dir, { recursive: true });
+    const html = renderScreen(mockup);
+    const filePath = path.join(dir, `${mockup.id}.html`);
+    fs.writeFileSync(filePath, html, "utf-8");
+    return true;
+}
+// Render a single screen page with navigation
+function renderScreen(mockup) {
+    const templatePath = path.join(__dirname, "template.html");
+    let html = fs.readFileSync(templatePath, "utf-8");
+    const title = mockup.title || "Untitled";
+    const content = `<style>${mockup.css || ""}</style>\n<div id="mockup-content">${mockup.html || ""}</div>`;
+    const annotations = JSON.stringify(mockup.annotations || []);
+    // Build screen nav
+    const navItems = mockups
+        .map((m) => `<a href="/screen/${m.id}" class="nav-screen${m.id === mockup.id ? " active" : ""}">${m.title}</a>`)
+        .join("");
+    const idx = mockups.indexOf(mockup);
+    const prev = idx > 0 ? mockups[idx - 1] : null;
+    const next = idx < mockups.length - 1 ? mockups[idx + 1] : null;
+    const prevLink = prev
+        ? `<a href="/screen/${prev.id}" class="nav-arrow">&larr; ${prev.title}</a>`
+        : "<span></span>";
+    const nextLink = next
+        ? `<a href="/screen/${next.id}" class="nav-arrow">${next.title} &rarr;</a>`
+        : "<span></span>";
+    const nav = mockups.length > 1
+        ? `<nav class="screen-nav"><div class="nav-screens">${navItems}</div><div class="nav-prevnext">${prevLink}${nextLink}</div></nav>`
+        : "";
+    html = html.replace("{{TITLE}}", title).replace("{{TITLE}}", title);
+    html = html.replace("{{NAV}}", nav);
+    html = html.replace("{{CONTENT}}", content);
+    html = html.replace("{{ANNOTATIONS}}", annotations);
+    return html;
+}
+// Render the gallery index page
+function renderGallery() {
+    const templatePath = path.join(__dirname, "template.html");
+    let html = fs.readFileSync(templatePath, "utf-8");
+    const title = `Design Gallery — ${mockups.length} screen${mockups.length !== 1 ? "s" : ""}`;
+    let content;
+    if (mockups.length === 0) {
+        content =
+            '<div class="placeholder">Waiting for design mockups...<br>The orchestrator will send screens here.</div>';
+    }
+    else {
+        const cards = mockups
+            .map((m) => `
+      <a href="/screen/${m.id}" class="gallery-card">
+        <div class="gallery-card-title">${m.title}</div>
+        <div class="gallery-card-preview"><style scoped>${m.css || ""}</style>${m.html || ""}</div>
+      </a>
+    `)
+            .join("");
+        content = `<div class="gallery-grid">${cards}</div>`;
+    }
+    html = html.replace("{{TITLE}}", title).replace("{{TITLE}}", title);
+    html = html.replace("{{NAV}}", "");
+    html = html.replace("{{CONTENT}}", content);
+    html = html.replace("{{ANNOTATIONS}}", "[]");
+    return html;
+}
+// Parse JSON body from request
+function parseBody(req) {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        req.on("data", (chunk) => {
+            data += chunk;
+        });
+        req.on("end", () => {
+            try {
+                resolve(data ? JSON.parse(data) : {});
+            }
+            catch (err) {
+                reject(new Error("Invalid JSON body"));
+            }
+        });
+        req.on("error", reject);
+    });
+}
+// Notify all SSE clients
+function notifyClients() {
+    for (let i = sseClients.length - 1; i >= 0; i--) {
+        try {
+            sseClients[i].write("data: refresh\n\n");
+        }
+        catch {
+            sseClients.splice(i, 1);
+        }
+    }
+}
+function jsonResponse(res, statusCode, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(statusCode, {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(payload),
+    });
+    res.end(payload);
+}
+function htmlResponse(res, html) {
+    res.writeHead(200, {
+        "Content-Type": "text/html",
+        "Content-Length": Buffer.byteLength(html),
+    });
+    res.end(html);
+}
+// Main request handler
+async function handler(req, res) {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    try {
+        // GET /status
+        if (req.method === "GET" && url.pathname === "/status") {
+            jsonResponse(res, 200, {
+                status: "ok",
+                version: "1.0.0",
+                port: activePort,
+                screens: mockups.length,
+                taskPath: taskPath || null,
+                persistence: !!taskPath,
+            });
+            return;
+        }
+        // POST /shutdown
+        if (req.method === "POST" && url.pathname === "/shutdown") {
+            jsonResponse(res, 200, { status: "shutting_down" });
+            cleanupPidFile();
+            setTimeout(() => process.exit(0), 100);
+            return;
+        }
+        // GET /events (SSE)
+        if (req.method === "GET" && url.pathname === "/events") {
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive",
+            });
+            res.write("data: connected\n\n");
+            sseClients.push(res);
+            req.on("close", () => {
+                const idx = sseClients.indexOf(res);
+                if (idx !== -1)
+                    sseClients.splice(idx, 1);
+            });
+            return;
+        }
+        // POST /update
+        if (req.method === "POST" && url.pathname === "/update") {
+            const body = await parseBody(req);
+            const id = slugify(body.title || "untitled");
+            const mockup = {
+                id,
+                type: body.type || "mockup",
+                title: body.title || "Untitled",
+                html: body.html || "",
+                css: body.css || "",
+                annotations: body.annotations || [],
+            };
+            // Update existing or add new
+            const existingIdx = mockups.findIndex((m) => m.id === id);
+            if (existingIdx !== -1) {
+                mockups[existingIdx] = mockup;
+            }
+            else {
+                mockups.push(mockup);
+            }
+            latestId = id;
+            version++;
+            const saved = saveToDisk(mockup);
+            notifyClients();
+            jsonResponse(res, 200, {
+                status: "updated",
+                version,
+                id,
+                screens: mockups.length,
+                saved,
+            });
+            return;
+        }
+        // GET /screen/:id
+        const screenMatch = url.pathname.match(/^\/screen\/([a-z0-9-]+)$/);
+        if (req.method === "GET" && screenMatch) {
+            const mockup = mockups.find((m) => m.id === screenMatch[1]);
+            if (!mockup) {
+                jsonResponse(res, 404, { error: "Screen not found" });
+                return;
+            }
+            htmlResponse(res, renderScreen(mockup));
+            return;
+        }
+        // GET /latest
+        if (req.method === "GET" && url.pathname === "/latest") {
+            const mockup = mockups.find((m) => m.id === latestId);
+            if (!mockup) {
+                htmlResponse(res, renderGallery());
+                return;
+            }
+            htmlResponse(res, renderScreen(mockup));
+            return;
+        }
+        // GET / (gallery)
+        if (req.method === "GET" && url.pathname === "/") {
+            htmlResponse(res, renderGallery());
+            return;
+        }
+        jsonResponse(res, 404, { error: "Not found" });
+    }
+    catch (err) {
+        console.error("Request error:", err.message);
+        jsonResponse(res, 500, { error: err.message });
+    }
+}
+// PID file management
+function pidFilePath() {
+    if (!taskPath)
+        return null;
+    return path.join(taskPath, "analysis", "mockups", ".visual-companion.pid");
+}
+function writePidFile() {
+    const p = pidFilePath();
+    if (!p)
+        return;
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, String(process.pid), "utf-8");
+}
+function cleanupPidFile() {
+    const p = pidFilePath();
+    if (p)
+        try {
+            fs.unlinkSync(p);
+        }
+        catch { }
+}
+process.on("SIGTERM", () => {
+    cleanupPidFile();
+    process.exit(0);
+});
+process.on("SIGINT", () => {
+    cleanupPidFile();
+    process.exit(0);
+});
+// Port fallback logic
+let activePort = null;
+function tryPort(port) {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer(handler);
+        server.listen(port, () => resolve(server));
+        server.on("error", reject);
+    });
+}
+async function start() {
+    const ports = [3847, 3848, 3849, 3850];
+    for (const port of ports) {
+        try {
+            await tryPort(port);
+            activePort = port;
+            console.log(`Visual companion server running at http://localhost:${port}`);
+            if (taskPath)
+                console.log(`Saving mockups to: ${path.join(taskPath, "analysis", "mockups")}`);
+            writePidFile();
+            return;
+        }
+        catch (err) {
+            if (err.code === "EADDRINUSE") {
+                console.error(`Port ${port} in use, trying next...`);
+                continue;
+            }
+            throw err;
+        }
+    }
+    console.error("All ports (3847-3850) in use. Cannot start server.");
+    process.exit(1);
+}
+start();

package/dist/types/opencode-types.js

@@ -0,0 +1 @@
+// workaround til something is not done with issue https://github.com/anomalyco/opencode/issues/24065

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "owflow",
+  "version": "0.1.0",
+  "description": "Spec-driven development AI workflow for OpenCode",
+  "type": "module",
+  "module": "index.ts",
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "workflow",
+    "spec-driven",
+    "development"
+  ],
+  "author": "palucdev",
+  "license": "MIT",
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.14.44",
+    "@types/bun": "^1.3.13",
+    "gray-matter": "^4.0.3"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "engines": {
+    "node": "^25"
+  }
+}