@tiic-tech/openworkflow 0.1.0

package/skills/run-team/references/runtime-audit.md

@@ -0,0 +1,56 @@
+# Runtime Audit
+
+Use this reference before planning or executing.
+
+## Required Checks
+
+Run:
+
+```bash
+python3 .codex/skills/run-team/scripts/audit_team_runtime.py --root . --format markdown
+git status --short
+git branch --show-current
+git log --oneline -5
+```
+
+Inspect:
+
+- `AGENT.md`
+- `.codex/agents/README.md`
+- `.codex/agents/orchestrator.md`
+- `.codex/runtime/STATE_MACHINE.md`
+- `.codex/runtime/RUNTIME_INDEX.yaml`
+- `.codex/runtime/scopes/<scope_id>/SCOPE.yaml`
+- `.codex/runtime/scopes/<scope_id>/MILESTONES.yaml`
+- `.codex/runtime/scopes/<scope_id>/IMPLEMENT_INDEX.yaml`
+- `.codex/runtime/scopes/<scope_id>/IMPLEMENT_ISSUE_INDEX.yaml`
+- `.codex/runtime/scopes/<scope_id>/AGENT_ROSTER.yaml`
+- active milestone `IMPLEMENT_TASKS.yaml`
+- active milestone `IMPLEMENT_ISSUES.yaml`
+
+## What To Detect
+
+- dirty unrelated files
+- active scope and milestone
+- completed or frozen scope
+- missing roster
+- stale `agent_id: null` in active tasks
+- unresolved issues
+- blocked tasks
+- missing prompt/review/archive directories
+- mismatch between runtime state and source files
+- completed milestones without QA report or checkpoint
+
+## Archive Use
+
+Read `archive/` to understand previous decisions or frozen snapshots. Do not revive archived work without creating a new task or scope that explains why.
+
+## Reporting
+
+Summarize:
+
+- current scope/milestone
+- run mode recommendation
+- blockers
+- next likely action
+- files that must be read next

package/skills/run-team/references/scope-selection.md

@@ -0,0 +1,64 @@
+# Scope Selection
+
+Use this reference when `/ow:team CONTENT` may need a new scope.
+
+## Continue Current Scope When
+
+- active scope status is active or blocked but still matches `CONTENT`
+- active milestone has remaining planned, prompted, in-progress, fix-required, or QA-ready tasks
+- unresolved issues must be fixed before moving forward
+- user asks to continue the same phase
+
+## Create New Scope When
+
+- MVP or current phase is completed and user asks for the next phase
+- `CONTENT` introduces a distinct delivery target or product stage
+- current scope was frozen and should not be modified
+- work is large enough to need its own milestone plan
+- acceptance criteria differ materially from the current scope
+
+## Scope Id Guidance
+
+Use short uppercase ids:
+
+- `V1` for first post-MVP iteration
+- `POST_MVP` for broad next-stage work
+- `LAUNCH` for release and production readiness
+- `CONTENT` for content expansion
+- `PERF` for performance work
+- `SECURITY` for security hardening
+- `MIGRATION` for structural migration
+
+## Milestone Requirements
+
+Every milestone needs:
+
+- `milestone_id`
+- `title`
+- `status`
+- `scope`
+- `target`
+- `dependencies`
+- `required_specs`
+- `expected_artifacts`
+- `estimated_atom_tasks`
+- `task_file`
+- `issue_file`
+- `qa_gate`
+- `acceptance`
+
+Keep contracts before broad implementation. For product work, prefer:
+
+```txt
+requirements/contracts -> architecture/data model -> implementation -> QA/hardening
+```
+
+## One-Question Rule
+
+Ask one question only if needed:
+
+```txt
+I infer the next scope is <scope_id>: <goal>. What is the delivery target, first milestone done criteria, and any required or forbidden roles/tools for this run?
+```
+
+If the user answer is incomplete, proceed with explicit assumptions.

package/skills/run-team/scripts/audit_team_runtime.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""Audit a repo-local Agent Team runtime before /ow:team execution."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+from pathlib import Path
+from typing import Any
+
+
+def run_git(root: Path, args: list[str]) -> str:
+    try:
+        result = subprocess.run(
+            ["git", *args],
+            cwd=root,
+            check=True,
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+        )
+    except (OSError, subprocess.CalledProcessError):
+        return ""
+    return result.stdout.strip()
+
+
+def read_text(path: Path) -> str:
+    try:
+        return path.read_text(encoding="utf-8")
+    except OSError:
+        return ""
+
+
+def first_match(text: str, pattern: str) -> str | None:
+    match = re.search(pattern, text, flags=re.MULTILINE)
+    return match.group(1).strip() if match else None
+
+
+def normalize_optional_scalar(value: str | None) -> str | None:
+    if value is None:
+        return None
+    cleaned = value.strip().strip("\"'")
+    if cleaned.lower() in {"", "null", "none", "~"}:
+        return None
+    return cleaned
+
+
+def count_values(text: str, key: str) -> dict[str, int]:
+    counts: dict[str, int] = {}
+    for value in re.findall(rf"^\s*{re.escape(key)}:\s*([A-Za-z0-9_-]+)\s*$", text, flags=re.MULTILINE):
+        counts[value] = counts.get(value, 0) + 1
+    return counts
+
+
+def list_files(path: Path, pattern: str) -> list[str]:
+    if not path.exists():
+        return []
+    return [str(p) for p in sorted(path.glob(pattern))]
+
+
+def audit(root: Path) -> dict[str, Any]:
+    runtime = root / ".codex" / "runtime"
+    runtime_index = runtime / "RUNTIME_INDEX.yaml"
+    runtime_text = read_text(runtime_index)
+    active_scope = normalize_optional_scalar(first_match(runtime_text, r"^active_scope:\s*(.+?)\s*$"))
+    scope_root = runtime / "scopes" / active_scope if active_scope else None
+    implement_index = scope_root / "IMPLEMENT_INDEX.yaml" if scope_root else None
+    implement_text = read_text(implement_index) if implement_index else ""
+    active_milestone = first_match(implement_text, r"^active_milestone:\s*([A-Za-z0-9_-]+)\s*$")
+
+    scope_dirs = [p.name for p in sorted((runtime / "scopes").iterdir()) if p.is_dir()] if (runtime / "scopes").exists() else []
+    milestone_root = scope_root / "milestones" if scope_root else None
+    milestone_dirs = [p.name for p in sorted(milestone_root.iterdir()) if p.is_dir()] if milestone_root and milestone_root.exists() else []
+
+    task_file = milestone_root / active_milestone / "IMPLEMENT_TASKS.yaml" if milestone_root and active_milestone else None
+    issue_file = milestone_root / active_milestone / "IMPLEMENT_ISSUES.yaml" if milestone_root and active_milestone else None
+    task_text = read_text(task_file) if task_file else ""
+    issue_text = read_text(issue_file) if issue_file else ""
+
+    archive_dirs_missing: list[str] = []
+    for path in [runtime, scope_root, *(milestone_root / m for m in milestone_dirs)] if scope_root and milestone_root else [runtime]:
+        if path and path.exists() and not (path / "archive").is_dir():
+            archive_dirs_missing.append(str(path / "archive"))
+
+    roster = scope_root / "AGENT_ROSTER.yaml" if scope_root else None
+    roster_text = read_text(roster) if roster else ""
+    active_agent_ids = re.findall(r"^\s*agent_id:\s*(?!null$)([A-Za-z0-9_.:-]+)\s*$", roster_text, flags=re.MULTILINE)
+
+    return {
+        "root": str(root),
+        "git": {
+            "branch": run_git(root, ["branch", "--show-current"]),
+            "head": run_git(root, ["log", "--oneline", "-1"]),
+            "status_short": run_git(root, ["status", "--short"]).splitlines(),
+        },
+        "runtime": {
+            "exists": runtime.exists(),
+            "active_scope": active_scope,
+            "scopes": scope_dirs,
+            "active_milestone": active_milestone,
+            "milestones": milestone_dirs,
+            "runtime_index": str(runtime_index),
+            "scope_root": str(scope_root) if scope_root else None,
+            "agent_roster": str(roster) if roster else None,
+            "active_agent_ids": active_agent_ids,
+            "task_file": str(task_file) if task_file else None,
+            "task_status_counts": count_values(task_text, "status"),
+            "task_agent_null_count": len(re.findall(r"^\s*agent_id:\s*null\s*$", task_text, flags=re.MULTILINE)),
+            "issue_file": str(issue_file) if issue_file else None,
+            "issue_status_counts": count_values(issue_text, "status"),
+            "archive_dirs_missing": archive_dirs_missing,
+        },
+        "source_files": {
+            "agent_guide": (root / "AGENT.md").exists(),
+            "agent_protocol": (root / ".codex" / "agents" / "README.md").exists(),
+            "orchestrator": (root / ".codex" / "agents" / "orchestrator.md").exists(),
+            "design_spec": (root / "DESIGN_SPEC").is_dir(),
+            "launch_checklist": (root / "LAUNCH_CHECKLIST.md").exists(),
+        },
+    }
+
+
+def to_markdown(data: dict[str, Any]) -> str:
+    git = data["git"]
+    runtime = data["runtime"]
+    lines = [
+        "# Agent Team Runtime Audit",
+        "",
+        f"- Root: `{data['root']}`",
+        f"- Branch: `{git['branch'] or 'unknown'}`",
+        f"- HEAD: `{git['head'] or 'unknown'}`",
+        f"- Dirty entries: {len(git['status_short'])}",
+        f"- Runtime exists: {runtime['exists']}",
+        f"- Active scope: `{runtime['active_scope'] or 'none'}`",
+        f"- Active milestone: `{runtime['active_milestone'] or 'none'}`",
+        f"- Scopes: {', '.join(runtime['scopes']) or 'none'}",
+        f"- Milestones: {', '.join(runtime['milestones']) or 'none'}",
+        f"- Task statuses: `{runtime['task_status_counts']}`",
+        f"- Active task `agent_id: null` count: {runtime['task_agent_null_count']}",
+        f"- Issue statuses: `{runtime['issue_status_counts']}`",
+        f"- Roster ids tracked: {len(runtime['active_agent_ids'])}",
+        f"- Missing archive dirs: {len(runtime['archive_dirs_missing'])}",
+        "",
+    ]
+    if git["status_short"]:
+        lines.append("## Dirty Worktree")
+        lines.extend(f"- `{entry}`" for entry in git["status_short"])
+        lines.append("")
+    if runtime["archive_dirs_missing"]:
+        lines.append("## Missing Archive Dirs")
+        lines.extend(f"- `{entry}`" for entry in runtime["archive_dirs_missing"])
+        lines.append("")
+    return "\n".join(lines)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Audit Agent Team runtime state.")
+    parser.add_argument("--root", default=".", help="Repository root.")
+    parser.add_argument("--format", choices=["json", "markdown"], default="json")
+    args = parser.parse_args()
+
+    data = audit(Path(args.root).expanduser().resolve())
+    if args.format == "markdown":
+        print(to_markdown(data))
+    else:
+        print(json.dumps(data, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/run-team/scripts/init_next_scope.py

@@ -0,0 +1,304 @@
+#!/usr/bin/env python3
+"""Initialize a next Agent Team scope for /ow:team execution."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class Milestone:
+    milestone_id: str
+    title: str
+
+
+def q(value: str | None) -> str:
+    return "null" if value is None else json.dumps(value)
+
+
+def slugify(value: str) -> str:
+    return re.sub(r"[^A-Za-z0-9]+", "-", value.strip().lower()).strip("-") or "milestone"
+
+
+def git_ref(root: Path) -> str | None:
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--short", "HEAD"],
+            cwd=root,
+            check=True,
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+        )
+    except (OSError, subprocess.CalledProcessError):
+        return None
+    return result.stdout.strip() or None
+
+
+def parse_milestone(raw: str) -> Milestone:
+    for sep in (":", "=", "|"):
+        if sep in raw:
+            left, right = raw.split(sep, 1)
+            return Milestone(left.strip().upper(), right.strip())
+    match = re.match(r"^(M\d+)\s+(.+)$", raw.strip(), flags=re.IGNORECASE)
+    if match:
+        return Milestone(match.group(1).upper(), match.group(2).strip())
+    raise ValueError(f"milestone must look like M01:Title, got {raw!r}")
+
+
+def write_file(path: Path, content: str, force: bool) -> None:
+    if path.exists() and not force:
+        print(f"SKIP {path}")
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")
+    print(f"WRITE {path}")
+
+
+def touch(path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if not path.exists():
+        path.write_text("", encoding="utf-8")
+        print(f"WRITE {path}")
+
+
+def yaml_list(items: list[str], indent: int) -> str:
+    prefix = " " * indent
+    if not items:
+        return f"{prefix}[]\n"
+    return "".join(f"{prefix}- {q(item)}\n" for item in items)
+
+
+def scope_yaml(scope_id: str, title: str, sources: list[str], app_roots: list[str], ref: str | None) -> str:
+    return (
+        f"scope_id: {scope_id}\n"
+        f"title: {q(title)}\n"
+        "status: active\n"
+        "source_artifacts:\n"
+        f"{yaml_list(sources, 2)}"
+        f"base_git_ref: {q(ref)}\n"
+        "runtime_protocol:\n"
+        "  agent_team_protocol: .codex/agents/README.md\n"
+        "  orchestrator_role: .codex/agents/orchestrator.md\n"
+        f"  agent_roster: .codex/runtime/scopes/{scope_id}/AGENT_ROSTER.yaml\n"
+        "boundary:\n"
+        "  application_roots:\n"
+        f"{yaml_list(app_roots, 4)}"
+        "  protected_roots:\n"
+        "    - .git/\n"
+        "    - .codex/runtime/\n"
+    )
+
+
+def milestones_yaml(scope_id: str, sources: list[str], milestones: list[Milestone]) -> str:
+    lines = [f"scope_id: {scope_id}", "source_artifacts:"]
+    lines.extend(f"  - {q(source)}" for source in sources)
+    lines.append("milestones:")
+    for index, milestone in enumerate(milestones):
+        status = "active" if index == 0 else "planned"
+        lines.extend(
+            [
+                f"  - milestone_id: {milestone.milestone_id}",
+                f"    title: {q(milestone.title)}",
+                f"    status: {status}",
+                f"    scope: {q('Deliver ' + milestone.title + '.')}",
+                "    target: Complete expected artifacts and pass QA gate.",
+                "    dependencies: []",
+                "    required_specs:",
+            ]
+        )
+        lines.extend(f"      - {q(source)}" for source in sources)
+        lines.extend(
+            [
+                "    expected_artifacts: []",
+                "    estimated_atom_tasks: 3-8",
+                f"    task_file: .codex/runtime/scopes/{scope_id}/milestones/{milestone.milestone_id}/IMPLEMENT_TASKS.yaml",
+                f"    issue_file: .codex/runtime/scopes/{scope_id}/milestones/{milestone.milestone_id}/IMPLEMENT_ISSUES.yaml",
+                "    qa_gate:",
+                "      - required checks pass or skipped checks are documented",
+                "    acceptance:",
+                "      - runtime state matches implementation reality",
+            ]
+        )
+    return "\n".join(lines) + "\n"
+
+
+def implement_index(scope_id: str, milestones: list[Milestone]) -> str:
+    active = milestones[0].milestone_id
+    lines = [f"scope_id: {scope_id}", f"active_milestone: {active}", "milestones:"]
+    for index, milestone in enumerate(milestones):
+        status = "active" if index == 0 else "planned"
+        lines.extend(
+            [
+                f"  - milestone_id: {milestone.milestone_id}",
+                f"    status: {status}",
+                f"    title: {q(milestone.title)}",
+                f"    task_file: .codex/runtime/scopes/{scope_id}/milestones/{milestone.milestone_id}/IMPLEMENT_TASKS.yaml",
+                f"    issue_file: .codex/runtime/scopes/{scope_id}/milestones/{milestone.milestone_id}/IMPLEMENT_ISSUES.yaml",
+                "    qa_report: null",
+                f"    branch: feat/{milestone.milestone_id.lower()}-{slugify(milestone.title)}",
+                "    last_checkpoint: null",
+            ]
+        )
+    return "\n".join(lines) + "\n"
+
+
+def agent_roster(scope_id: str, app_roots: list[str]) -> str:
+    impl_owns = ["frontend/src/app/", "frontend/src/components/", "frontend/src/systems/", "frontend/tests/"]
+    if not any(root.startswith("frontend") for root in app_roots):
+        impl_owns = app_roots or ["src/", "tests/"]
+    lines = [
+        f"scope_id: {scope_id}",
+        "roster_version: 1",
+        "updated_at: null",
+        "lifecycle_status_values:",
+        "  - available",
+        "  - active",
+        "  - idle",
+        "  - blocked",
+        "  - closed",
+        "  - archived",
+        "  - legacy_untracked",
+        "session_policies:",
+        "  persistent:",
+        "    purpose: Keep domain agents mounted across related atom tasks and issue-fix loops.",
+        "    reuse_rule: Resume the existing matching agent_id before spawning a replacement.",
+        "  event:",
+        "    purpose: Run async or one-off review, security, QA, and git drafting work.",
+        "    reuse_rule: Close after handoff unless the Orchestrator records a reason to keep it idle.",
+        "persistent_agents:",
+        "  - agent_name: tech-prompt-agent",
+        "    agent_id: null",
+        "    lifecycle_status: available",
+        "    session_policy: persistent",
+        "    owns:",
+        f"      - .codex/runtime/scopes/{scope_id}/milestones/*/prompts/",
+        "    current_task: null",
+        "    last_completed_task: null",
+        "    active_milestone: null",
+        "    notes: Spawn once for prompt planning, then resume for related prompts.",
+        "  - agent_name: implementation-agent",
+        "    agent_id: null",
+        "    lifecycle_status: available",
+        "    session_policy: persistent",
+        "    owns:",
+    ]
+    lines.extend(f"      - {path}" for path in impl_owns)
+    lines.extend(
+        [
+            "    current_task: null",
+            "    last_completed_task: null",
+            "    active_milestone: null",
+            "    notes: Rename to the repo domain agent before assignment, such as frontend-agent, backend-agent, or content-schema-agent.",
+            "event_agents:",
+            "  - agent_name: code-review-agent",
+            "    agent_id: null",
+            "    lifecycle_status: available",
+            "    session_policy: event",
+            "    trigger: artifact_ready",
+            "    closes_after_handoff: true",
+            "  - agent_name: tdd-qa-agent",
+            "    agent_id: null",
+            "    lifecycle_status: available",
+            "    session_policy: event",
+            "    trigger: qa_gate",
+            "    closes_after_handoff: true",
+            "  - agent_name: security-review-agent",
+            "    agent_id: null",
+            "    lifecycle_status: available",
+            "    session_policy: event",
+            "    trigger: security_sensitive_change",
+            "    closes_after_handoff: true",
+            "  - agent_name: git-release-agent",
+            "    agent_id: null",
+            "    lifecycle_status: available",
+            "    session_policy: event",
+            "    trigger: checkpoint_or_release",
+            "    closes_after_handoff: true",
+            "legacy_tracking:",
+            "  task_agent_ids_before_roster: legacy_untracked",
+            "  note: Do not invent ids for historical null task agent_id values.",
+        ]
+    )
+    return "\n".join(lines) + "\n"
+
+
+def update_runtime_index(runtime_index: Path, scope_id: str, title: str, source: str, ref: str | None, activate: bool) -> None:
+    block = (
+        f"  - scope_id: {scope_id}\n"
+        f"    title: {q(title)}\n"
+        "    status: active\n"
+        f"    source: {q(source)}\n"
+        f"    path: .codex/runtime/scopes/{scope_id}/\n"
+        f"    base_git_ref: {q(ref)}\n"
+    )
+    if not runtime_index.exists():
+        active = scope_id if activate else "null"
+        write_file(runtime_index, f"active_scope: {active}\nscopes:\n{block}", False)
+        return
+    text = runtime_index.read_text(encoding="utf-8")
+    if activate:
+        text = re.sub(r"^active_scope:\s*.*$", f"active_scope: {scope_id}", text, flags=re.MULTILINE)
+    if not re.search(rf"^\s*-\s*scope_id:\s*{re.escape(scope_id)}\s*$", text, flags=re.MULTILINE):
+        if re.search(r"^scopes:\s*\[\]\s*$", text, flags=re.MULTILINE):
+            text = re.sub(r"^scopes:\s*\[\]\s*$", f"scopes:\n{block.rstrip()}", text, flags=re.MULTILINE)
+        else:
+            if not text.endswith("\n"):
+                text += "\n"
+            text += block
+    runtime_index.write_text(text, encoding="utf-8")
+    print(f"WRITE {runtime_index}")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Initialize a next Agent Team scope.")
+    parser.add_argument("--root", default=".", help="Repository root.")
+    parser.add_argument("--scope-id", required=True, help="New scope id, for example V1 or POST_MVP.")
+    parser.add_argument("--scope-title", required=True, help="Human-readable scope title.")
+    parser.add_argument("--source-artifact", action="append", default=[], help="Source-of-truth artifact. Repeatable.")
+    parser.add_argument("--application-root", action="append", default=[], help="Application root. Repeatable.")
+    parser.add_argument("--milestone", action="append", required=True, help="Milestone as M01:Title. Repeatable.")
+    parser.add_argument("--activate", action="store_true", help="Set active_scope to this scope in RUNTIME_INDEX.yaml.")
+    parser.add_argument("--force", action="store_true", help="Overwrite scope-local files if they exist.")
+    args = parser.parse_args()
+
+    root = Path(args.root).expanduser().resolve()
+    scope_id = args.scope_id.upper()
+    sources = args.source_artifact or ["AGENT.md"]
+    app_roots = args.application_root or ["frontend/"]
+    milestones = [parse_milestone(raw) for raw in args.milestone]
+    ref = git_ref(root)
+
+    runtime = root / ".codex" / "runtime"
+    scope_root = runtime / "scopes" / scope_id
+    for directory in [runtime, runtime / "archive", runtime / "scopes", scope_root, scope_root / "archive", scope_root / "milestones"]:
+        directory.mkdir(parents=True, exist_ok=True)
+    touch(runtime / "archive" / ".gitkeep")
+    touch(scope_root / "archive" / ".gitkeep")
+
+    update_runtime_index(runtime / "RUNTIME_INDEX.yaml", scope_id, args.scope_title, sources[0], ref, args.activate)
+    write_file(scope_root / "SCOPE.yaml", scope_yaml(scope_id, args.scope_title, sources, app_roots, ref), args.force)
+    write_file(scope_root / "MILESTONES.yaml", milestones_yaml(scope_id, sources, milestones), args.force)
+    write_file(scope_root / "IMPLEMENT_INDEX.yaml", implement_index(scope_id, milestones), args.force)
+    write_file(scope_root / "IMPLEMENT_ISSUE_INDEX.yaml", f"scope_id: {scope_id}\nissues: []\n", args.force)
+    write_file(scope_root / "AGENT_ROSTER.yaml", agent_roster(scope_id, app_roots), args.force)
+
+    for milestone in milestones:
+        milestone_root = scope_root / "milestones" / milestone.milestone_id
+        for directory in [milestone_root, milestone_root / "prompts", milestone_root / "reviews", milestone_root / "archive"]:
+            directory.mkdir(parents=True, exist_ok=True)
+        touch(milestone_root / "prompts" / ".gitkeep")
+        touch(milestone_root / "reviews" / ".gitkeep")
+        touch(milestone_root / "archive" / ".gitkeep")
+        write_file(milestone_root / "IMPLEMENT_TASKS.yaml", "tasks: []\n", args.force)
+        write_file(milestone_root / "IMPLEMENT_ISSUES.yaml", "issues: []\n", args.force)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/templates/README.md

@@ -0,0 +1,5 @@
+# Templates
+
+OpenWorkflow keeps runtime template strings in TypeScript during M06 so package
+loading stays unchanged. This directory defines the future external template
+boundary for M07 and later.

package/templates/codex/README.md

@@ -0,0 +1,4 @@
+# Codex Templates
+
+Future home for externalized Codex adapter templates. M06 keeps the active
+template registry in `packages/adapters/codex/src/`.

package/templates/openworkflow/README.md

@@ -0,0 +1,4 @@
+# OpenWorkflow Templates
+
+Future home for platform-independent `.openworkflow/` contract templates.
+M06 only establishes the directory boundary.