SuperAPI AI Directory
Partner with us中文AI newsFavorites
Skillsorca-workflow

orca-workflow

Office & productivity

View repository

Updated 10-15 16:40

About this skill

Skill: orca-workflow

🧭 Dispatch backend — choose cheap agent/model, run multiple workers in parallel, opencode/orchestration syntax → see orca-dispatch-reference (single source of truth, don't duplicate syntax here).

WHAT

Purpose and context

  • Purpose: Propose → gate → dispatch → verify via Orca. Agent pool 1:1 per engine (claude, agy, opencode, kiro, copilot). Claude: analyze. Others: execute. Kill opencode if it waits too long.
  • Trigger (when to use):
  • "propose ", "feature request", "implement "
  • "run lint", "verify wiki"
  • "sync template", "upstream"
  • Non-goals: does not handle INCIDENTS (bug, runtime error, regression → orca-issue); does not duplicate dispatch backend syntax (→ orca-dispatch-reference); does not re-describe the behavior of /propose, /plan, /query (single source of truth in the child skill).

Mental model

yêu cầu tính năng → R12 sweep → /query (wiki) → /propose (SPEC .md + .html render rẻ) → gate người duyệt → /plan (PLAN máy đọc) → task-create có dấu dự án → cổng HITL/AFK + kiểu việc → dispatch --inject nguyên văn → worker_done → [/qc-code] → verify-before-commit → output report. Claude analyzes; other agents execute; T-id (durable ledger) is separate from task_xxxx (Orca ephemeral, runtime-global).

Input and output contract

Field Required? Meaning
In feature description ("propose ", "implement ") yes incident → branch to orca-issue
In llmwiki/wiki/ no missing/empty → write "no precedent yet"
In user approval at gate yes before /plan + dispatch
In available agent CLI (opencode/agy/kiro/gh copilot/orca) no exhausted → Claude does it itself
Out SPEC draft .md + .html (via /propose) yes human reviewer artifact
Out llmwiki/wiki/sources/draft/DDMMYY-<tên>-PLAN.md (via /plan) yes after approval machine execution artifact
Out Orca task with project marker + T-id status yes approved/rejected/dispatched via code-logger (fail-open)
Out output report llmwiki/wiki/draft/orca/DDMMYY-<ten>.md + index + log yes (unless 0 artifacts) "done" = worker_done + verify-before-commit green + report Status updated

Rules and capabilities

  • RULE-01 (MUST): Caveman Mode: Choose the level of detail based on the file's reader. Markdown files that a MACHINE or AGENT reads and executes (SKILL.md, policy.yaml, AGENT.md, pure reference tables) can be written concisely — caveman here saves tokens with no downside. But documents that HUMANS read or review MUST have caveman turned off and be written in full — proposal, output-report, wiki content (concept/ADR/registry), README, CONTRIBUTING and runbook, along with every HTML page. These files must be prose with complete, readable sentences; do not drop conjunctions, do not write clipped abbreviations, do not stuff tables in place of explanatory sentences. Lesson 2026-06-27: the user responded "caveman compressed too much when writing documentation", then clarified — machine-read files can be terse, human-read files need to be complete.
  • RULE-02 (MUST): Claude: analyze. Others: execute. Kill opencode if it waits too long.
  • RULE-03 (MUST): Process problem ledger (problem-tree) — The project has llmwiki/ then the problem-tree ledger is located at llmwiki/html/problem-tree.html (framework repo: fdk-problem-tree.html). Any session that discovers or resolves a process/framework problem → update the node into the JSON block #tree-data (append-only; solved must record solvedBy; scope across the 3 pillars harness/skills/llmwiki — green only when 3/3). Forgetting doesn't lose it either: the SessionEnd hook (R17) automatically writes a pending card in code, to be distilled next time.
  • RULE-04 (MUST): task spec MUST be stamped with the project: orca orchestration task-create --spec "$(python3 harness/scripts/orca-reconcile.py --stamp '<spec>')" (the Orca task ledger is runtime-global).
  • RULE-05 (MUST): an agent assigned HITL work is left only to guess on the user's behalf and then stay silent — that is the 1/5 figure, not a dumb model — HITL is not dispatched to a headless CLI.
  • RULE-06 (MUST): --inject injects VERBATIM the task brief from PLAN along with ## Global constraints; do NOT summarize it again.
  • RULE-07 (MUST): Container / DB safety — run docker inspect <container_name> --format '{{json .Mounts}}' | python3 -m json.tool before any --force-recreate, down, recreate; if the volume differs → STOP, ask the user (details in Reference).
  • Capabilities: read the wiki; create gate/task/dispatch via the orchestration runtime; run a headless agent CLI or interactive terminal; write wiki draft + T-id ledger; (optional) cross-session memory via HTTP; push skill sync to the source repo.

Failure boundaries

  • The input is an incident → branch to orca-issue, do not propose.
  • R12 sweep: subrepo TARGET after remote → blocked until git pull --rebase; offline → fail-open.
  • User rejects at the gate → cancelled, T-id state=rejected.
  • HITL task → not dispatched, label ready-for-human (waiting for a human).
  • Headless CLI silent for more than ~60–90s / creates no file / missing diagram-box → kill, Claude takes over (fallback).
  • Container volume differs from compose → blocked, ask the user.
  • task-update --status done → ok:false silently (valid status: ready | in_progress | completed | failed).

HOW

Main workflow

Step Type Inputs Action Outputs/exit Failure/next
W01 deterministic workspace Step 0 — R12 (B) pre-work sweep pull-gate-sweep.sh once fresh base TARGET after remote → pull --rebase then loop
W02 judgment feature Step 1 — CALL /query synthesize wiki context known + gaps empty → "no precedent"
W03 judgment context Step 2 — CALL /propose (SPEC .md); .html render dispatch to cheap CLI with watchdog SPEC .md + .html CLI silent → B03
W04 effect SPEC Step 3 — orca orchestration gate-create, wait for user; record T-id approved/rejected approve reject → cancelled
W05 judgment SPEC approved Step 4 — CALL /plan → PLAN; task-create each ### Task with spec stamped task task_xxxx R7 PLAN blocked → fix PLAN
W06 judgment task Step 4b — Gate 1 HITL/AFK, Gate 2 work type → archetype, then cost table AFK task with type + CLI HITL → B02
W07 effect AFK task Step 5 — orca orchestration dispatch --task <id> --to <agent> --inject (verbatim brief, first line declares work type); T-id dispatched worker running —
W08 deterministic dispatch Step 6 — orca orchestration check --wait --types worker_done --timeout-ms 300000 worker_done timeout/silent → B03
W09 deterministic diff Step 7 — verify-before-commit (including qc-regression.py --run) clean commit red → fix
W10 effect result Output report + update agent Status + sync push skill (Delivery section) draft + index + log 0 artifact → skip

Details of each step (source of truth for W01–W09):

  1. R12 (B) — pre-work sweep of entire workspace (ONCE, before working / multi-agent fan-out): orchestrator runs harness/poc-vendor-neutral/bin/pull-gate-sweep.sh — scans EVERY subrepo (from .harness-workspace.yaml, missing → auto-discover harnessed), parallel fetch; subrepo TARGET after remote → STOP, git pull --rebase in that repo then dispatch (whole agent fleet shares fresh base); subrepo watch warning only. 1 repo → sweep auto-reduces to pull-gate.sh. Offline → fail-open. DOES NOT block per-edit (intentionally omitted per-edit PreToolUse). R12 (C) gate2 per-repo: install every subrepo with install-harness.sh --all-subrepos; manual check pull-gate.sh gate2.
  2. query: CALL skill query (Skill tool → query, or /query) to synthesize context from wiki/ about the feature — do NOT read manually in scattered fashion, use the correct wiki-loop query (synthesize [[wikilinks]], return what is known + gaps). Project does not yet have wiki/ (or query returns empty) → record "no precedent yet" then move to step 2.
  3. propose — do NOT re-describe; CALL skill propose (Skill tool → /propose, following the pattern of step 1 calling query). All R7 requirements (pair .md+.html, ## Plan, ## Agent Task Assignment, glass-style docs-site-macos, detailed prose) live in the child skill — to change propose behavior only edit llmwiki/skills/dev-loop/propose.md, do NOT edit here (single source of truth, see [[ADR-003-skill-as-single-source-of-truth]]).
    • Separate Claude-thinks / cheap-CLI-renders: Claude (via /propose) only produces SUBSTANCE = .md render-complete (Plan + prose + ## Render brief = diagram step as data + prose paragraph per task). The .html part is the RENDER mechanical of ## Render brief → dispatch to a cheap CLI per the cost table (OpenCode big-pickle → agy → kiro, $0). Render is free so use Full docs-site-macos richness, do NOT trim — Claude tokens are spent only on substance, not bloated by HTML richness.
    • Watchdog + R7 gate (lesson 250626 — headless delivers ~1/5): wait ~60–90s; silence / no file created / missing diagram-box → kill, Claude render fallback. Try cheap CLIs in order of availability (probe --version); exhausted → Claude. R7 still blocks at write+commit so quality is gated regardless of who renders.
  4. gate: orca orchestration gate-create --question "Duyệt proposal này?" → wait for user (send along the html preview URL)
    • Pillar 3 lifecycle (best-effort, fail-open): user APPROVES → python3 harness/scripts/code-logger.py --task set <T-id> state=approved note="gate" (<T-id> = field task: in the draft frontmatter minted by /propose ; if empty, skip). User REJECTS → --task set <T-id> state=rejected. Command is fail-open, does not block the flow.
  5. After approval — CALL skill plan (Skill tool → /plan) BEFORE decomposing. /propose produces SPEC (what a HUMAN reads to approve); /plan expands it into llmwiki/wiki/sources/draft/DDMMYY-<tên>-PLAN.md — what the MACHINE reads to execute: each ### Task has **Files:** (exact paths), **Interfaces:** (Consumes/Produces — signatures for neighboring tasks), and 2–5 minute TDD-style steps with real code + command + expected output. R7 PLAN branch blocks if missing. Only then orca orchestration task-create for each ### Task — spec must MARK the project: orca orchestration task-create --spec "$(python3 harness/scripts/orca-reconcile.py --stamp '<spec>')". Orca's task ledger is runtime-global (the Orca guide says so outright); measured 2026-07-20: 18 terminals from MANY projects all write to one ledger, so task-list in repo A returns tasks from repo B as well — and an orchestrator will mistakenly claim another project's task, defeating the very goal of physical-layer bias separation. Orca has no project field (task-create has no tag, task-list has no filter), so this mark is the only way to attribute accurately — and it still holds after the terminal that created the task has died (measured: 0/17 old terminals still alive). Cross-check: orca-reconcile.py [--scope current|all].
    • Why mandatory, not "should": a cheap headless CLI agent inherits no context from this session and cannot ask again — it has only exactly what we inject; when it hits ambiguity it guesses and stays silent. A thin brief is precisely the cause of the measured "~1/5 delivery" (lesson 250626), not a dumb model.
    • PLAN does not need .html — HTML is tied to the SPEC (what people view when approving), generated by /propose . Drawing diagrams for the agent to read is burning tokens for nothing. 4b. ASSIGN THE RIGHT KIND OF WORK — the gate runs BEFORE choosing a CLI. The cost table below only answers "which model is cheapest". It never asked "can this work be done without a human" — and that is the missing piece of the ~1/5 number. Two gates, in this order:
    • Gate 1 — HITL/AFK. A task that needs a live person to answer (design decision, trade-off, something only the user knows, external access, manual verification) is HITL → label ready-for-human in the ledger, DO NOT dispatch to a headless CLI. Only tasks AFK (ready-for-agent) proceed. Hard rule: an agent assigned HITL work can only guess on the user's behalf and stay silent — that is the 1/5 number, not a dumb model.
    • Gate 2 — work type → archetype. Tag the task type: research (pull out facts) · prototype (rough draft to react to) · grilling (ask one question at a time) · build (execute per brief) · sweep (mechanical cleanup). Map to archetype (ADR-015) → persona preamble. Only then come the cost table for choosing a CLI — it drops to the last step, not the first.
  6. dispatch: orca orchestration dispatch --task <id> --to <agent> --inject
    • --inject inject the FULL brief of that task from PLAN (Files + Interfaces + Steps) along with ## Global constraints of the PLAN. Do NOT summarize — summarizing is exactly where context drops, and what drops is always what the agent needs.
    • The FIRST line of the brief declares the type of work: one sentence stating plainly what kind of session this is — "you are resolving a DECISION, not going to build" / "you are doing mechanical cleanup, NOT adding a feature". The type of work determines the shape of the session, not just the choice of model; an agent that knows what it is doing behaves completely differently from an agent that receives a lump of description.
    • Lifecycle pillar 3 (best-effort): when assigning work → python3 harness/scripts/code-logger.py --task set <T-id> state=dispatched note="<agent>". This is T-id durable (immutable audit trail), independent of task_xxxx ephemeral of orca orchestration. Fail-open.
    • Persona by archetype (Boris Cherny — 5 lifecycle roles): to dispatch by a specific posture call with keyword — /proto /build /sweep /grow /maintain. Mechanism: python3 harness/scripts/archetype.py --get /<kw> → print (a) suggested CLI for that archetype (Prototyper→cheap opencode · Builder/Grower/Maintainer→Claude · Sweeper→opencode), and (b) persona PREAMBLE (llmwiki/personas/<archetype>.md) — inject that preamble into <task> before dispatch so that agy/opencode/kiro take on the right role (e.g. Sweeper is forbidden from adding features). Which CLI matches which archetype is the adapter verified:false (harness/archetypes.config.yaml). See ADR-015.
  7. Wait: orca orchestration check --wait --types worker_done --timeout-ms 300000 6b. (Optional) Senior QC before commit — if you want a senior pair of eyes to scrutinize the diff before finalizing, call /qc-code (Skill tool → qc-code): review 4 items (security/performance/naming/logic) with scoring + verdict, and generate a reproducing test qc-* for each logic bug. Verdict NEEDS FIX → fix before committing. Optional, not mandatory — the LLM verdict is advisory (the human decides), the hard gate is the test qc-* run in step 7.
  8. Check: verify-before-commit runs automatically before each commit (including step 3b: qc-regression.py --run run test qc-* deterministically — a reproduced bug does not silently come back).

Branches

ID Kind Guard Behavior Skip / failure Rejoin
B01 conditional_required input is an INCIDENT (bug, runtime error, regression, "it was working yesterday") CALL skill orca-issue instead of propose severe incident needing fan-out → orca-issue escalates to W07, keeping its 2 hard gates ends (or W07 when escalating)
B02 conditional_required task needs a live person to answer (HITL) label ready-for-human in the ledger, do NOT dispatch headless CLI — wait for the person, then W06
B03 recovery headless CLI silent ~60–90s / creates no file / missing diagram-box kill + Claude takes over per spec; try the next cheap CLI in the pre-existing order (probe --version) CLIs exhausted → Claude currently running step (W03/W08)
B04 user_optional want to inspect the diff before finalizing Step 6b — /qc-code (advisory verdict + test qc-*) NEEDS FIX verdict → fix before commit W09
B05 user_optional want to dispatch by posture (/proto /build /sweep /grow /maintain) python3 harness/scripts/archetype.py --get /<kw> → suggested CLI + inject PREAMBLE persona into <task> — W07
B06 conditional_required about to touch docker (--force-recreate, down, recreate) docker inspect mounts, compared with compose; different → STOP and ask user no backup + confirmation → do not change volume currently running step
B07 capability_optional has AGENTMEMORY_TOKEN search at session start / remember after decision + session end (Reference — AgentMemory) none → skip W02 / W10

Incident branch details (verbatim):

Branching: INCIDENT ≠ feature

Input is incident (bug, runtime error, regression, "it worked yesterday") → CALL skill orca-issue instead of propose: separate loop triage → repro-first gate (not reproduced means not fixed) → fix red→green → double distill. Severe incidents needing fan-out: orca-issue escalates back here to dispatch, but its 2 hard gates still hold.

Validation and stopping

Human gate: W04 gate (approve SPEC) and HITL Gate 1 at W06. Machine gate: R7 blocks SPEC/PLAN with missing sections at write+commit; verify-before-commit + qc-regression.py --run before each commit. CLI watchdog ~60–90s (B03); check --wait timeout 300000 ms. Reconcile tasks by project: orca-reconcile.py [--scope current|all].

Examples

  • Positive: "propose export CSV for the report" → sweep clean → /query returns 2 related pages → /propose generate SPEC, .html render with opencode run -m opencode/big-pickle → user approves gate → /plan generate DDMMYY-export-csv-PLAN.md 3 tasks → task-create has stamp → 2 AFK tasks build dispatch --inject, 1 HITL task ("choose date format") tagged ready-for-human → worker_done → verify-before-commit green → output report.
  • Boundary/failure: "yesterday login still worked, today 500" → B01: do not propose, call orca-issue (repro-first).
  • Boundary: opencode run render .html silent for 90s, no file created → B03: kill, Claude render fallback; R7 still guards quality at write time.

Reference — Gotchas orchestration CLI (lesson 230626)

  • 2 ids from task-create --json: response has envelope id (uuid) AND result.task.id (task_xxxx). All subsequent commands (gate-create --task, dispatch --task, task-update --id) MUST use result.task.id, NOT the envelope id. Using the wrong one: the gate can still create/resolve but points to a ghost task → the real task gets stuck at ready.
  • Valid status of task-update --status: ready | in_progress | completed | failed. There is NO done — passing done returns ok:false silently (no clear error).
  • To reliably get the real id: orca orchestration task-list --json then match by spec.

Reference — Container / DB safety (MANDATORY before touching docker)

Before touching a container (docker compose / docker run)

# BẮT BUỘC chạy trước bất kỳ --force-recreate, down, recreate nào:
docker inspect <container_name> --format '{{json .Mounts}}' | python3 -m json.tool

Compare Source path with the volume in the compose file about to be used. If different → STOP, ask the user.

Cozyroom production DB: /mnt/c/Users/olive/orca/workspaces/home-spotify/m/data/metadata.db Never change the volume mount without backup + user confirmation.

Lesson 2026-05-29: recreating a container with the wrong compose path → lost the entire user DB.

Reference — Quick dispatch

⚠️ Headless CLI agents are NOT reliable (lesson 250626 — orca-eval): opencode run / agy -p / kiro run running in the background from Claude Code usually does not deliver (process exits/hangs, no file created — measured 1/5 tasks succeeded). Rule: set a watchdog (~60–90s), if silent/no file → kill + Claude takes over per spec (don't wait pointlessly). Use OpenCode for INDEPENDENT boilerplate tasks that have been verified; tasks with dependencies/nuance → Claude does them. To REALLY dispatch to an agent → prefer orca terminal interactive instead of -p/run.

# OpenCode non-interactive (DEFAULT — dùng big-pickle miễn phí):
# ⚠ KHÔNG dùng --dangerously-skip-permissions khi dispatch từ Claude Code — auto-mode classifier sẽ DENY (bài học 120626)
opencode run -m opencode/big-pickle --dir "<project>" "<task>"

# Antigravity non-interactive:
agy -p "<task>"

# Kiro non-interactive:
kiro run --dir "<project>" "<task>"

# GitHub Copilot Coding Agent (async — via GitHub issue):
gh issue create --title "<task>" --body "<task details>" --assignee "@me"
# Then: gh copilot suggest "<task>" or trigger via VS Code Copilot Chat

# Nếu dùng Orca terminal (interactive):
orca terminal list
orca terminal create --worktree active --title "OpenCode" --command "opencode"
orca terminal send --title "OpenCode" --text "<task>"
orca terminal wait --for tui-idle && orca terminal read --title "OpenCode"

Reference — Task assignment by cost

Task Agent Model
Search, grep, list, read OpenCode opencode/big-pickle ($0)
Write boilerplate, CRUD OpenCode opencode/big-pickle ($0)
Wiki ingest/lint OpenCode opencode/big-pickle ($0)
Review diff, explain agy default
Architectural decisions Claude Code Opus 5 (claude-opus-5) — see the Claude chain at /orca-dispatch-reference
Debug hard errors Claude Code Sonnet 5 (claude-sonnet-5) by default, upgrade to Opus 5 if stuck
Frontend UI boilerplate Kiro default
Cross-file refactor Kiro default
PR review + suggest fixes Copilot gpt-4o (GitHub)

Reference — Agent binaries

Agent Binary CHECK
Antigravity agy agy --version
OpenCode opencode run -m opencode/big-pickle opencode --version
Kiro kiro run kiro --version
GitHub Copilot gh copilot suggest gh copilot --version
Orca GUI only — use via orca terminal * commands orca terminal list

Reference — Antigravity Dispatch Reality (tested 2026-05-21, updated 2026-05-23)

Binary: agy — %LOCALAPPDATA%\agy\bin\agy.exe. NOT antigravity, NOT ~/.local/bin/agy (Linux).

Create terminal:

orca terminal create --worktree active --title "Antigravity" --command "agy"

Hook: Orca v1.4.21 fixes Windows hook quoting — antigravity-hook.cmd no manual edit needed.

OpenCode: opencode — npm global at %APPDATA%\npm\opencode.cmd.

Dispatch status:

Step Status
dispatch --inject Try after v1.4.21 — if it fails, use terminal send
terminal send manually OK
Antigravity reads files/runs commands OK
worker_done to inbox Needs retest

Reference — Slash Skill Installation per Agent CLI

Agent receiving dispatch: self-install skill from llmwiki/skills/ before starting.

Claude Code CLI

mkdir -p .claude/commands/
cp llmwiki/skills/<loop>/<name>.md .claude/commands/<name>.md
# User-level:
mkdir -p ~/.claude/commands/
cp llmwiki/skills/<loop>/<name>.md ~/.claude/commands/<name>.md

OpenCode CLI

mkdir -p ~/.agents/skills/<name>/
cp llmwiki/skills/<loop>/<name>.md ~/.agents/skills/<name>/SKILL.md
# Restart OpenCode để discover skill mới.

Antigravity CLI

mkdir -p ~/.agents/skills/<name>/
cp llmwiki/skills/<loop>/<name>.md ~/.agents/skills/<name>/SKILL.md

Kiro CLI

mkdir -p ~/.kiro/skills/<name>/
cp llmwiki/skills/<loop>/<name>.md ~/.kiro/skills/<name>/SKILL.md

GitHub Copilot

# Workspace-level steering via .github/copilot-instructions.md
# Skills injected as context file:
mkdir -p .github/
cat llmwiki/skills/<loop>/<name>.md >> .github/copilot-instructions.md
# Or per-skill steering file (Copilot Workspace):
mkdir -p .github/skills/
cp llmwiki/skills/<loop>/<name>.md .github/skills/<name>.md

Rules for all agents

  • Copy skill files only — skip README.md, index.md, log.md.
  • File by file — no cp -R.
  • Scope: .claude/commands/ (Claude Code); ~/.agents/skills/ (OpenCode/agy); ~/.kiro/skills/ (Kiro); .github/ (Copilot).
  • After installing, report: 
    | Agent       | Skill   | Installed at                            |
|-------------|---------|------------------------------------------|
| claude-cli  | propose | .claude/commands/propose.md              |
| opencode    | propose | ~/.agents/skills/propose/SKILL.md        |
| antigravity | propose | ~/.agents/skills/propose/SKILL.md        |
| kiro        | propose | ~/.kiro/skills/propose/SKILL.md          |
| copilot     | propose | .github/skills/propose.md                |

Reference — AgentMemory — Persistent Cross-Session Memory

Service at https://agentmemory.giatbh.io.vn/ — stores context between sessions.

BASE="https://agentmemory.giatbh.io.vn"
TOKEN="${AGENTMEMORY_TOKEN}"

# Health check
curl -sk -H "Authorization: Bearer $TOKEN" "$BASE/agentmemory/health"

# Ghi memory (cuối session hoặc sau quyết định quan trọng)
curl -sk -X POST "$BASE/agentmemory/remember" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"content":"<nội dung>","category":"fact|preference|decision|context"}'

# Tìm kiếm (đầu session hoặc trước khi propose)
curl -sk -H "Authorization: Bearer $TOKEN" \
  "$BASE/agentmemory/search?query=<từ+khóa>"

When to use:

  • Start of session: search context before starting
  • After a decision: save approach + rationale
  • End of session: save completed tasks, commits, status

Reference — Main commands

orca orchestration run --spec "Propose: <tính năng>. Query wiki, tạo draft, gate chờ duyệt."

Detailed dispatch: llmwiki/skills/orchestrate/orca-dispatch-reference.md

Delivery — Output Report (after implementation is complete)

This is the result report after implementation, NOT a propose plan. The propose plan must be created in Step 2 BEFORE doing anything.

After all implementation tasks complete, write an output report to the wiki.

Steps

1. Build the filename:

  • Format: DDMMYY-<ten>.md
  • DDMMYY = today (e.g., 020626 for 2 June 2026)
  • <ten> = 2–4 kebab-case words summarising what was done (e.g., landing-page-coteccons, brand-kit-fintech, ingest-auth-spec)

2. Write llmwiki/wiki/draft/orca/DDMMYY-<ten>.md:

---
type: draft
title: "DDMMYY-<ten>"
status: proposed
tags: [<skill-name>, output-report]
timestamp: YYYY-MM-DD
---

# DDMMYY-<ten>
**Type:** draft
**Status:** proposed
**Tags:** <skill-name>, output-report
**Proposed:** YYYY-MM-DD

## Agent Task Assignment
| Task | Agent | Status |
|------|-------|--------|
| <mô tả task 1> | <tên agent> | pending / in-progress / done |
| <mô tả task 2> | <tên agent> | pending / in-progress / done |

## What
<One sentence — what this skill invocation produced or decided>

## Output
<Key artefacts, files created/modified, or decisions made>

## Files
| File | Action |
|------|--------|
| `path/to/file` | created / modified |

## Notes
- Invoked via: `/<skill-name>` skill

## Origin
- **Draft:** `wiki/draft/orca/DDMMYY-<ten>.md`
- **Commit:** _(filled by verify-before-commit)_
- **Date promoted:** _(filled by verify-before-commit)_

3. Update wiki index & log:

  • llmwiki/wiki/index.md — append one row: | [DDMMYY-<ten>](draft/orca/DDMMYY-<ten>.md) | draft | YYYY-MM-DD |
  • llmwiki/wiki/log.md — append: ## YYYY-MM-DD — <skill-name> — <ten>

4. Update agent statuses & sync push — MANDATORY, do not skip:

  • Reopen the file llmwiki/wiki/draft/orca/DDMMYY-<ten>.md
  • Update the Status column in the table ## Agent Task Assignment according to the actual status of each agent (pending → in-progress → done)
  • Clone rheinmir/setup branch orca, copy the modified skill files, then push back up: 
    git clone git@github.com:rheinmir/setup.git /tmp/rheinmir-setup-sync -b orca --depth 1
cp /path/to/skill.md /tmp/rheinmir-setup-sync/skills/<skill-name>/SKILL.md
cd /tmp/rheinmir-setup-sync
git add .
git commit -m "skill: sync update — DDMMYY-<ten>"
git push origin orca
rm -rf /tmp/rheinmir-setup-sync

Skip only when the skill does not produce any artifact or decision.