# art-director

Adopt this skill: https://proskills.md/skills/other/serejaris-personal-corp-os-skills-art-director

Page: https://proskills.md/skills/other/serejaris-personal-corp-os-skills-art-director
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/art-director/SKILL.md
size: 11571
sha: 80c5cc1b97fcf6db970be810d3ed4529856f3774
upstream: https://github.com/serejaris/personal-corp-os/blob/main/skills/art-director/SKILL.md

````text
---
name: art-director
description: Orchestrate iterative visual style searches with branch prompts, decision graphs, feedback loops, and final direction selection.
---

# Art Director

Use this skill when the work is an art-direction search for a media production workspace.

The skill coordinates this loop:

```text
brief -> references -> generation branches -> HTML preview -> feedback -> next branches -> selected direction
```

For single-image production, use the host repo's image-generation or media-run instructions. For comic pages, albums, storyboards, or platform-specific assets, use the host repo's format-specific playbook when one exists.

## Default Output Shape

For a project under `art-direction/<project>/`, each serious search pass should leave:

```text
art-direction/<project>/
  prompts/vNN/YYYY-MM-DD-vNN-<slug>-prompts.md
  process/vNN/YYYY-MM-DD-vNN-<slug>-log.md
  styles/YYYY-MM-DD-<style-system>.md
  assets/vNN-<slug>/
    <variant-id>.png
  vNN-<slug>.html
```

For a first run in an empty workspace, create the minimal folders before writing prompts:

```bash
mkdir -p art-direction/<project>/{prompts/v01,process/v01,styles,assets/v01-style-search}
cp skills/art-director/assets/style-search-map-template.html art-direction/<project>/v01-style-search.html
```

If the skill was installed without `assets/style-search-map-template.html`, create the same folders and write a simple local HTML preview from the cluster schema in this file.

If the run continues an existing direction, increment `vNN` and make every new node point back to its parent decision.

The visual map must be an iteration-cluster direction graph:

```text
idea
  -> iteration cluster
      -> option leaf nodes
      -> selected option node
      -> carry forward / drop
  -> next iteration cluster
      -> option leaf nodes
      -> selected option node
      -> output
```

Keep the important path explicit: iteration checkpoint -> option nodes -> selected option node -> next iteration checkpoint. Unselected options stay as leaf nodes with their status.

## Workflow

1. Read the current project files: `index.html`, latest `vNN-*.html`, `process/v*/`, `prompts/v*/`, `styles/`, and relevant `research/`.
2. Identify the active question: what style, artifact, audience, format, or campaign is being decided.
3. Build an iteration cluster before generation: incoming brief, 3-8 option leaves, difference axes, expected selection criteria, and what may carry forward.
4. Write prompts in `prompts/vNN/`. Each prompt needs iteration id, option id, role, difference axis, prompt, negative prompt, and reject criteria.
5. Generate or collect assets through the host repo's approved image-generation path.
6. Create or update the HTML direction map as the first section of `vNN-<slug>.html`.
7. Put preview cards under the map with anchors matching tree node ids.
8. Capture feedback as first-class nodes in the tree and in `process/vNN/...log.md`.
9. Create the next iteration from feedback: `feedback -> interpretation -> new branch -> asset -> decision`.
10. Mark selected, rejected, paused, and next branches explicitly.

## Iteration Cluster Contract

Every style-search HTML page starts with a direction graph that answers:

- Where did this visual direction come from?
- What was the brief for each iteration?
- Which option leaf nodes were shown for that iteration?
- Which option was selected?
- What changed in the next brief because of that selection?
- What was carried forward, dropped, or turned into output?

Use `skills/art-director/assets/style-search-map-template.html` as the starter preview when the host repo has no renderer yet. If a reusable host-repo renderer exists, record its path in the run log and use it as the local reference. A typical reusable setup is:

- proof page: `art-direction/<project>/vNN-dagre-full.html`;
- shared renderer/data shape: `art-direction/<project>/vNN-style-search-pages.js`;
- shared visual style: `art-direction/<project>/vNN-style-search-page.css`;
- graph runtime: a pinned dagre runtime, for example `@dagrejs/dagre@1.1.8`, when external network use is allowed by the host repo.

Serve preview pages through a local server:

```bash
python3 -m http.server 8080
```

Then open `http://127.0.0.1:8080/...`. If the preview depends on a CDN and the network is blocked, report the blocker and keep the run in `blocked` or `needs-local-runtime` status. Store third-party library source only when the host repo policy explicitly allows vendored dependencies.

## Dagre Rendering Contract

Recommended solution: dagre computes the graph layout; the page renders the graph as static HTML/SVG with a detail panel.

Responsibilities:

- dagre: node coordinates and edge routing for the directed decision graph;
- page JavaScript: graph schema normalization, DOM/SVG rendering, click handlers and validation;
- HTML/CSS: readable node cards, status colors, horizontal scroll and detail panel;
- detail panel: shows the selected node's body text and image asset when available.

Use manual SVG layout only as a fallback or baseline. Use Mermaid for docs and quick sketches only when dense style-search history is not required.

Required graph semantics:

- root idea node;
- iteration checkpoint nodes;
- option nodes for each iteration;
- selected option node connects to the next checkpoint;
- unselected options remain leaves;
- production output nodes attach to the producing checkpoint or selected option;
- visible labels use the iteration id, for example `V8-C`, so later readers can map preview cards back to the run log.

Cluster schema:

```json
{
  "id": "v8",
  "title": "V8 - Selected direction expansion",
  "brief": "Expand user-liked directions from V7.",
  "looked_at": "V8-A, V8-B, V8-C, V8-D",
  "selected": "v8-c",
  "parent": "v7",
  "carry_forward": "V8-C: sharp typography, high-contrast palette, warning label rhythm.",
  "drop": "Soft abstract metaphors as the main cover style.",
  "feedback": {
    "target": "v8-c",
    "safe_summary": "Reviewer wants the sharp typography direction pushed further.",
    "interpretation": "Intensify type scale and warning-label rhythm in V9."
  },
  "options": [
    {"id": "v8-a", "title": "V8-A - Soft sculpture system", "status": "shown"},
    {"id": "v8-c", "title": "V8-C - Brutal manifesto", "status": "selected"}
  ],
  "preview": "assets/v8-selected-directions/c-brutal-typography.png",
  "next": "v9",
  "terminal_status": "needs-feedback"
}
```

Required cluster fields:

- `id`
- `title`
- `brief`
- `looked_at`
- `options`
- `selected`
- `parent` when the cluster continues or forks a prior cluster
- `carry_forward`
- `drop`
- `feedback` when reviewer feedback exists
- `preview` when a representative image exists
- `next` unless the cluster is terminal

Required option statuses:

- `selected`
- `rejected`
- `shown`
- `output`

Terminal status values:

- `selected-final`
- `needs-feedback`
- `blocked`
- `needs-local-runtime`
- `reset`

## HTML Preview Rules

- The decision graph is the first visible section after the header.
- Every iteration cluster shows brief, looked-at variants, options, carry-forward, and dropped motifs.
- Option leaves render as visible nodes attached to their iteration checkpoint.
- Selected option nodes are highlighted and visually connect to the next iteration cluster.
- Production outputs attach to the cluster that produced them.
- The page includes a compact legend for status colors.
- The page includes a current selection block when a direction is selected.
- The page includes a next iteration block when feedback has created follow-up branches.
- The page is static HTML and is previewed through a local server.
- Every node with a representative image opens that image in a detail panel or links to a visible preview card.

Avoid duplicating the same graph nodes immediately below as cards or a second table. Add a legend, selected detail, or next-iteration block only when it answers a different question.

## Feedback Loop

When feedback arrives after a preview:

1. Record a redacted feedback summary in `process/vNN/...log.md`.
2. Quote raw feedback only when the source is safe for the repo visibility and the user has allowed it.
3. Add or update the iteration cluster's `feedback`, `carry_forward`, and `drop` fields.
4. Convert the feedback into 1-3 direct design operations: keep, drop, intensify, soften, merge, split, resize, reframe, change format, change reference.
5. Create the next iteration cluster with the changed brief and option leaves.
6. Generate the next branch set after the new cluster is visible in the HTML map.

Comment log format:

```md
## Feedback - YYYY-MM-DD HH:MM

Target node: `v12-03-operating-cards`

Safe summary:
> ...

Interpretation:
- Keep:
- Drop:
- Next branch:
```

## Branch Planning Rules

A good branch set varies real design architecture:

- layout system;
- palette role;
- typography behavior;
- image medium;
- narrative metaphor;
- artifact format;
- density;
- target platform;
- production layer: bitmap image, HTML/CSS overlay, carousel, comic, video storyboard, or another host-approved format.

Weak branch sets vary only color, mood words, or superficial adjectives.

Diversity gate:

- Use 3-8 option leaves.
- Cover at least three materially different axes across the set.
- Fail the branch plan if options differ only by palette, mood words, or adjectives.

## Selection Rules

Record selection as an operational decision:

- selected node id;
- why it won;
- what stays invariant;
- what must be removed;
- where the direction will be used next;
- required next asset or generation pass.

If the reviewer rejects the whole pass, make a new root child named `reset` and record the failure mode before generating again.

## Privacy And Source Rules

- Keep private chats, private screenshots, auth material, billing records, customer records, infrastructure details, and non-public repository links out of prompts, previews, READMEs, and public logs.
- Use repo-relative paths in run logs and examples.
- Replace internal project names with generic examples before publishing a reusable skill.
- Public references need source URL, author or owner, access date, and a usage boundary.
- Exact protected characters, brands, logos, or artist-style references need explicit rights, license, or editorial-risk notes in the host repo run log.

## Validation

Run the narrow checks that match the pass:

```bash
test -f art-direction/<project>/vNN-<slug>.html
rg -n "dagre|style-tree-data|cluster|graph|node-details" art-direction/<project>/vNN-<slug>.html
test -f art-direction/<project>/process/vNN/YYYY-MM-DD-vNN-<slug>-log.md
test -f art-direction/<project>/prompts/vNN/YYYY-MM-DD-vNN-<slug>-prompts.md
rg -n "feedback|carry_forward|drop|selected|terminal_status" art-direction/<project>/vNN-<slug>.html
git diff --check
```

If the preview uses an external CDN, also check the pinned runtime:

```bash
curl -I -L --max-time 10 https://cdn.jsdelivr.net/npm/@dagrejs/dagre@1.1.8/dist/dagre.min.js
```

For local visual review:

```bash
python3 -m http.server 8080
```

Then open `http://127.0.0.1:8080/...` and verify:

- the tree renders;
- every tree node with an asset links to a visible card;
- clicking a node opens its description and image in the detail panel;
- node count and edge count are greater than zero;
- the selected path exists;
- every referenced asset path resolves or is marked as pending;
- selected, rejected, and next states are visible;
- the current selection and next iteration are understandable from files.
````

## File: skills/art-director/assets/illustration.png
size: 506844
sha: 2355dde3cdaf477437011ed157e785b7535c2a0e
upstream: https://github.com/serejaris/personal-corp-os/blob/main/skills/art-director/assets/illustration.png

Content is not inlined in the catalog. Read the upstream file: https://github.com/serejaris/personal-corp-os/blob/main/skills/art-director/assets/illustration.png

## File: skills/art-director/assets/style-search-map-template.html
size: 11000
sha: ebb38086d94b066ea5eafd8cc0bf7f337e2964f2
upstream: https://github.com/serejaris/personal-corp-os/blob/main/skills/art-director/assets/style-search-map-template.html

```text
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Style Search Decision Graph</title>
  <script src="https://cdn.jsdelivr.net/npm/@dagrejs/dagre@1.1.8/dist/dagre.min.js"></script>
  <style>
    :root {
      --bg: #f7f7f4;
      --paper: #ffffff;
      --ink: #171717;
      --muted: #656565;
      --line: #d8d8d2;
      --selected: #0f766e;
      --rejected: #9f1239;
      --shown: #525252;
      --output: #7c3aed;
    }

    * { box-sizing: border-box; }
    body {
      margin: 0;
      background: var(--bg);
      color: var(--ink);
      font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
      line-height: 1.45;
    }
    header, main { max-width: 1180px; margin: 0 auto; padding: 24px; }
    header { border-bottom: 1px solid var(--line); }
    h1 { margin: 0 0 8px; font-size: 28px; }
    .meta { margin: 0; color: var(--muted); }
    .layout { display: grid; grid-template-columns: 1fr 320px; gap: 20px; align-items: start; }
    .summary, .graph-shell, .panel, .card {
      background: var(--paper);
      border: 1px solid var(--line);
    }
    .summary { display: grid; grid-template-columns: repeat(3, 1fr); gap: 0; margin-bottom: 20px; }
    .summary > div { padding: 14px; border-right: 1px solid var(--line); }
    .summary > div:last-child { border-right: 0; }
    .summary h2 { margin: 0 0 8px; font-size: 14px; text-transform: uppercase; letter-spacing: .04em; color: var(--muted); }
    .summary p { margin: 0; }
    .graph-shell { overflow: auto; min-height: 520px; }
    svg { display: block; min-width: 900px; min-height: 520px; }
    .edge { fill: none; stroke: #9ca3af; stroke-width: 1.5; }
    .node rect {
      fill: #fff;
      stroke: #a3a3a3;
      stroke-width: 1.5;
    }
    .node.selected rect { stroke: var(--selected); stroke-width: 3; }
    .node.rejected rect { stroke: var(--rejected); }
    .node.output rect { stroke: var(--output); }
    .node text { font-size: 13px; fill: var(--ink); pointer-events: none; }
    .node .status { font-size: 11px; fill: var(--muted); }
    .panel { padding: 16px; position: sticky; top: 16px; }
    .panel h2 { margin: 0 0 8px; font-size: 18px; }
    .panel dl { margin: 0; display: grid; gap: 10px; }
    .panel dt { font-size: 12px; color: var(--muted); text-transform: uppercase; letter-spacing: .04em; }
    .panel dd { margin: 0; }
    .panel img { width: 100%; margin-top: 12px; border: 1px solid var(--line); }
    .cards { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 14px; margin-top: 20px; }
    .card { padding: 14px; }
    .card h3 { margin: 0 0 8px; font-size: 16px; }
    .badge { display: inline-block; padding: 2px 7px; border: 1px solid var(--line); color: var(--muted); font-size: 12px; }
    @media (max-width: 900px) {
      .layout, .cards { grid-template-columns: 1fr; }
      .panel { position: static; }
    }
  </style>
</head>
<body>
  <header>
    <h1>Style Search Decision Graph</h1>
    <p class="meta">Replace the sample data in this file with the current project clusters.</p>
  </header>
  <main>
    <section class="summary">
      <div>
        <h2>Legend</h2>
        <p><span class="badge">selected</span> chosen path</p>
        <p><span class="badge">rejected</span> dropped branch</p>
        <p><span class="badge">output</span> production asset</p>
      </div>
      <div>
        <h2>Current Selection</h2>
        <p id="current-selection">-</p>
      </div>
      <div>
        <h2>Next Iteration</h2>
        <p id="next-iteration">-</p>
      </div>
    </section>
    <section class="layout">
      <div class="graph-shell">
        <svg id="graph" role="img" aria-label="Style search decision graph"></svg>
      </div>
      <aside class="panel" id="node-details">
        <h2>Selected Node</h2>
        <dl>
          <dt>Title</dt><dd id="detail-title">Select a node</dd>
          <dt>Status</dt><dd id="detail-status">-</dd>
          <dt>Summary</dt><dd id="detail-summary">Click a node in the graph.</dd>
        </dl>
        <img id="detail-image" alt="" hidden>
      </aside>
    </section>
    <section class="cards" id="preview-cards"></section>
  </main>
  <script>
    const styleTreeData = {
      clusters: [
        {
          id: "v1",
          title: "V1 - First exploration",
          brief: "Explore three distinct visual systems for the media asset.",
          looked_at: "V1-A, V1-B, V1-C",
          selected: "v1-b",
          carry_forward: "High-contrast type, structured grid, visible production cues.",
          drop: "Soft generic abstractions.",
          feedback: {
            target: "v1-b",
            safe_summary: "Reviewer prefers the sharper editorial direction.",
            interpretation: "Push the editorial system in V2."
          },
          terminal_status: "needs-feedback",
          options: [
            { id: "v1-a", title: "V1-A - Soft editorial", status: "shown", summary: "A quiet layout with light texture." },
            { id: "v1-b", title: "V1-B - Sharp editorial", status: "selected", summary: "Strong type, grid, and production evidence.", preview: "assets/v01-style-search/v1-b.png" },
            { id: "v1-c", title: "V1-C - System diagram", status: "rejected", summary: "Too diagrammatic for the target asset." }
          ],
          next: "v2"
        },
        {
          id: "v2",
          parent: "v1",
          title: "V2 - Editorial expansion",
          brief: "Expand the selected sharp editorial direction.",
          looked_at: "V2-A, V2-B, V2-C",
          selected: "v2-a",
          carry_forward: "Sharp type, dense grid, restrained color.",
          drop: "Decorative texture that hides the message.",
          terminal_status: "selected-final",
          options: [
            { id: "v2-a", title: "V2-A - Final system", status: "selected", summary: "Best balance of readability and character." },
            { id: "v2-b", title: "V2-B - Dense poster", status: "shown", summary: "Useful reference, too loud for final." },
            { id: "v2-c", title: "V2-C - Minimal proof", status: "shown", summary: "Clean but less distinctive." }
          ]
        }
      ]
    };

    const graphEl = document.getElementById("graph");
    const cardsEl = document.getElementById("preview-cards");
    const detailTitle = document.getElementById("detail-title");
    const detailStatus = document.getElementById("detail-status");
    const detailSummary = document.getElementById("detail-summary");
    const detailImage = document.getElementById("detail-image");
    const currentSelection = document.getElementById("current-selection");
    const nextIteration = document.getElementById("next-iteration");

    const nodes = [];
    const edges = [];
    styleTreeData.clusters.forEach((cluster) => {
      nodes.push({
        id: cluster.id,
        title: cluster.title,
        status: cluster.terminal_status || "cluster",
        summary: cluster.brief
      });
      if (cluster.parent) edges.push([cluster.parent, cluster.id]);
      cluster.options.forEach((option) => {
        nodes.push({ ...option, cluster: cluster.id });
        edges.push([cluster.id, option.id]);
        if (option.id === cluster.selected && cluster.next) edges.push([option.id, cluster.next]);
      });
    });

    const g = new dagre.graphlib.Graph();
    g.setGraph({ rankdir: "LR", nodesep: 40, ranksep: 80, marginx: 30, marginy: 30 });
    g.setDefaultEdgeLabel(() => ({}));
    nodes.forEach((node) => g.setNode(node.id, { width: 190, height: 72, node }));
    edges.forEach(([from, to]) => g.setEdge(from, to));
    dagre.layout(g);

    const graph = g.graph();
    graphEl.setAttribute("viewBox", `0 0 ${graph.width + 80} ${graph.height + 80}`);

    g.edges().forEach((edge) => {
      const points = g.edge(edge).points;
      const path = document.createElementNS("http://www.w3.org/2000/svg", "path");
      path.setAttribute("class", "edge");
      path.setAttribute("d", points.map((point, index) => `${index === 0 ? "M" : "L"}${point.x},${point.y}`).join(" "));
      graphEl.appendChild(path);
    });

    nodes.forEach((node) => {
      const layout = g.node(node.id);
      const group = document.createElementNS("http://www.w3.org/2000/svg", "g");
      group.setAttribute("class", `node ${node.status || "shown"}`);
      group.setAttribute("transform", `translate(${layout.x - layout.width / 2},${layout.y - layout.height / 2})`);
      group.setAttribute("tabindex", "0");
      group.addEventListener("click", () => showDetails(node));
      const rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
      rect.setAttribute("width", layout.width);
      rect.setAttribute("height", layout.height);
      const title = document.createElementNS("http://www.w3.org/2000/svg", "text");
      title.setAttribute("x", 12);
      title.setAttribute("y", 28);
      title.textContent = node.title.length > 26 ? `${node.title.slice(0, 25)}...` : node.title;
      const status = document.createElementNS("http://www.w3.org/2000/svg", "text");
      status.setAttribute("class", "status");
      status.setAttribute("x", 12);
      status.setAttribute("y", 52);
      status.textContent = node.status || "shown";
      group.append(rect, title, status);
      graphEl.appendChild(group);
    });

    styleTreeData.clusters.flatMap((cluster) => cluster.options).forEach((option) => {
      const card = document.createElement("article");
      card.className = "card";
      const title = document.createElement("h3");
      title.textContent = option.title;
      const summary = document.createElement("p");
      summary.textContent = option.summary || "";
      const status = document.createElement("span");
      status.className = "badge";
      status.textContent = option.status;
      card.append(title, summary, status);
      if (option.preview) {
        const path = document.createElement("p");
        path.textContent = `Preview path: ${option.preview}`;
        card.appendChild(path);
      }
      cardsEl.appendChild(card);
    });

    function showDetails(node) {
      detailTitle.textContent = node.title;
      detailStatus.textContent = node.status || "shown";
      detailSummary.textContent = node.summary || "No summary yet.";
      if (node.preview) {
        detailImage.src = node.preview;
        detailImage.alt = node.title;
        detailImage.hidden = false;
      } else {
        detailImage.removeAttribute("src");
        detailImage.alt = "";
        detailImage.hidden = true;
      }
    }

    const terminalCluster = styleTreeData.clusters[styleTreeData.clusters.length - 1];
    currentSelection.textContent = terminalCluster.selected || "No selection yet.";
    nextIteration.textContent = terminalCluster.next || terminalCluster.terminal_status || "No next step recorded.";
    showDetails(nodes[0]);
  </script>
</body>
</html>
```

## File: README.md
upstream: https://github.com/serejaris/personal-corp-os/blob/main/README.md

````text
# Personal Corp OS

Manager uses your local Manager Config for repositories and boards; the distributed skill contains no personal workspace logs.

[![en](https://img.shields.io/badge/lang-en-blue.svg)](README.md)
[![ru](https://img.shields.io/badge/lang-ru-green.svg)](README.ru.md)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
[![Validate](https://github.com/serejaris/personal-corp-os/actions/workflows/validate.yml/badge.svg)](https://github.com/serejaris/personal-corp-os/actions/workflows/validate.yml)

> Personal Corp is a way to run a one-person company through AI agents: tasks out of your head, departments instead of one person's memory, a weekly retro instead of "I'll sort it out someday".

This repo holds everything you need for that: the story of how the system works, templates for the HQ and a department, and the open skills for [Claude Code](https://docs.anthropic.com/en/docs/claude-code) and Codex.

By [Ris](https://t.me/ris_ai) — AI development & vibecoding.

Русская версия: [README.ru.md](README.ru.md).

## The problem: you are the bottleneck

Not because you work too little. Because strategy, memory, coordination, execution, and acceptance all sit in one pile — inside your head. While that is true, your department's throughput equals yours.

Hiring does not fix it: a new person takes the work but not the context, so you keep explaining. AI alone does not fix it either: an agent without context is the same new hire, except it does not remember yesterday.

The issue is not model strength. The issue is that context never leaves your head.

## What agent rules actually are

Agent rules are a plain text file sitting in a folder. No magic: text you read with your eyes and edit by hand.

Such a file lives in every folder, and its content differs.

![Every folder carries its own rules file: the HQ sees the whole system, a department sees only its domain](docs/images/rules-place-en.png)

Opening a folder, the agent learns three things from that file.

![What the agent learns: who works here, in which order to read, where the truth lives](docs/images/rules-inside-en.png)

Those three answers replace a long prompt. The agent gets them from the folder instead of your message, so you stop explaining the same thing every time.

## The core idea: the folder defines the view

Start the agent from the HQ and it reads the HQ rules and sees the map of the whole system. Start it from a department and it reads the department rules and sees that domain, its tasks, and its skills. Same model, different view, set by the folder rather than by a long prompt.

Everything else follows from that: for this to work, context has to leave your head into files, and those files have to sit in folders that carry rules.

## What a department is

A department is a folder that owns one domain and accumulates experience about it. Inside it has its own rules, its own tasks, and its own skills.

![A department: one domain next to the HQ with its own rules, tasks and skills](docs/images/department-en.png)

### Which departments people start with

I run about thirty. These are the usual first ones:

| Department | What it accumulates | Time to create it |
|---|---|---|
| Content | Voice, topics, finished texts, notes on what landed | You write regularly and re-explain your style every time |
| Research | Questions, found facts, sources, conclusions tied to decisions | You are looking up the same thing a second time |
| Sales | People, agreements, correspondence, deal status | You keep track of who was promised what in your head |
| Media | Briefs, prompts, finished assets, acceptance criteria | You generate images and video and the briefs get lost |
| Legal | Contracts, templates, wording you already agreed to | Every new contract is assembled from scratch |
| Finance | Expenses, subscriptions, recurring payments | You cannot recall what is charged every month |

A department exists for repetition. Work that happened once is fine living in the HQ.

## What a skill is

A skill is a written-down way of working that can be repeated. You walk the work by hand once, write the steps down, and from then on the agent runs them.

![A skill: your phrase, a line in the folder rules, the steps, the result](docs/images/skill-en.png)

## Four layers and who lives where

| Layer | Who acts | What lives here |
|---|---|---|
| Management | The human | Goal, priorities, limits, the right to say "good enough" |
| **Truth** | The human writes, the agent reads | Rules, memory, indexes, source of truth |
| **Operations** | The agent executes, the human accepts | Tasks, queue, statuses, runs, departments |
| Observation | The agent collects, the human looks | Dashboards, metrics, blockers |

A subagent lives only in the operations layer: it does not write truth about the system and does not accept results.

One test for any file: **is this truth about the system, or is it the result of work?** Truth sits in the folder from day one. Results are created by skills once there is something to record. That is why the templates ship no empty files for future reports, decisions, or glossaries.

## The route: how experience becomes capital

```mermaid
graph LR
    A["Task<br/>owner + criteria"] --> B["Execution<br/>human or agent"]
    B --> C["Acceptance<br/>good enough or not"]
    C --> D["Pattern<br/>what worked"]
    D --> E["Department memory<br/>rules and decisions"]
    E --> F["Priority<br/>next week"]
    F --> A
    style A fill:#8b5cf6,color:#fff
    style C fill:#f59e0b,color:#fff
    style E fill:#10b981,color:#fff
```

**1. Writing the task down.** A thought becomes a task once it has an owner, done criteria, and a place to live. Before that it lives in you. After that both a human and an agent can pick it up.

**2. Experience accumulating in departments.** Artifacts and decisions settle in a department — a separate folder for its own domain. Next time the agent reads the department instead of reading you.

**3. Retro with the agent.** Once a week you look at what worked and promote it into rules. Whatever you corrected twice becomes a written rule and stops needing you.

## The weekly rhythm

Three links on their own are a feature list. The rhythm turns them into a system.

```mermaid
graph LR
    R["retro<br/>what worked"] --> P["planning<br/>priorities of the week"]
    P --> D["daily<br/>living full-week view"]
    D --> T["tasks<br/>into departments"]
    T --> E["execution<br/>the trace goes back into the task"]
    E --> R
    style R fill:#f59e0b,color:#fff
    style P fill:#3b82f6,color:#fff
    style D fill:#64748b,color:#fff
    style T fill:#8b5cf6,color:#fff
    style E fill:#10b981,color:#fff
```

The rhythm answers the question that usually stays unanswered: when exactly does experience turn into a rule. Answer: at the retro, once a week, not "someday".

The same word gives a different result depending on the folder: "retro" inside a department means a slice of that department, "retro" in the HQ means a slice of the whole system. Folder rules win over general ones.

Each generated department also includes a local `daily` skill. It refreshes the living `WNN-plan.html`: the whole ISO week stays visible, past days keep their facts, today is highlighted, future days remain the plan, and browser-only Wealth habits persist locally.

## Three levels of task tracking

![Three levels of tasks: one list, day separate from long work, a shared tracker](docs/images/tasks-en.png)

## Templates

| Template | What it is |
|---|---|
| [`templates/hq`](./templates/hq/) | The HQ — the agent's entry point and the map of the system |
| [`templates/department`](./templates/department/) | A department — one domain with its own tasks and skills |

Departments sit **next to the HQ, not inside it**. Every template file opens with a line stating why it is there and which layer it belongs to.

## First step: 30 minutes today

1. Copy [`templates/hq`](./templates/hq/) to yo
````
