create-workframe 0.1.0

package/bin/workframe.js

@@ -0,0 +1,329 @@
+#!/usr/bin/env node
+/**
+ * workframe — lifecycle CLI for generated Workframe projects.
+ *
+ * Commands:
+ *   workframe doctor [--repair]  Diagnose stack; --repair provisions missing agent DM runtimes
+ *   workframe setup      Open Hermes setup (credentials)
+ *   workframe stop       Stop all stack containers
+ *   workframe start      Start the full stack (docker compose up -d)
+ *   workframe restart    Restart the full stack
+ *   workframe status     Show running containers
+ *   workframe logs       Tail gateway logs
+ *   workframe ui         Open Workframe UI in browser
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn, spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (true) {
+    if (fs.existsSync(path.join(dir, 'workframe-manifest.json'))) return dir;
+    if (fs.existsSync(path.join(dir, 'docker-compose.yml')) && fs.existsSync(path.join(dir, '.env'))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+function readManifest(root) {
+  const p = path.join(root, 'workframe-manifest.json');
+  if (!fs.existsSync(p)) return null;
+  return JSON.parse(fs.readFileSync(p, 'utf8'));
+}
+
+function readEnvPort(root, key) {
+  const envFile = path.join(root, '.env');
+  if (!fs.existsSync(envFile)) return null;
+  const line = fs.readFileSync(envFile, 'utf8').split('\n').find((l) => l.startsWith(`${key}=`));
+  return line ? line.split('=', 2)[1].trim() : null;
+}
+
+function dockerCompose(cwd, args, { stdio = 'inherit' } = {}) {
+  return spawnSync('docker', ['compose', ...args], { cwd, stdio, encoding: 'utf8' });
+}
+
+function doctorAgentDmRuntimes(root, { repair = false } = {}) {
+  const fn = repair ? 'doctor_repair_agent_dm_runtimes(repair=True)' : 'doctor_audit_agent_dm_runtimes()';
+  const py = `import json, server; print(json.dumps(server.${fn}))`;
+  return dockerCompose(root, ['exec', '-T', 'workframe-api', 'python3', '-c', py], { stdio: 'pipe' });
+}
+
+function cmdDoctor(root, extraArgs = []) {
+  const repair = extraArgs.includes('--repair');
+  const manifest = readManifest(root);
+  const issues = [];
+
+  console.log(repair ? 'workframe doctor --repair' : 'workframe doctor');
+  console.log('================\n');
+
+  // Check Docker
+  const dockerCheck = spawnSync('docker', ['info'], { encoding: 'utf8' });
+  if (dockerCheck.status !== 0) {
+    issues.push('Docker is not running or not installed.');
+    console.log('[FAIL] Docker: not running');
+  } else {
+    console.log('[ OK] Docker: running');
+  }
+
+  // Check manifest
+  if (!manifest) {
+    issues.push('No workframe-manifest.json found. Are you in a Workframe project?');
+    console.log('[FAIL] Manifest: not found');
+  } else {
+    console.log(`[ OK] Manifest: ${manifest.project_name} (${manifest.docker?.stack})`);
+  }
+
+  // Check .env
+  const envFile = path.join(root, '.env');
+  if (!fs.existsSync(envFile)) {
+    issues.push('.env file missing.');
+    console.log('[FAIL] .env: missing');
+  } else {
+    console.log('[ OK] .env: present');
+  }
+
+  // Check docker-compose.yml
+  const composeFile = path.join(root, 'docker-compose.yml');
+  if (!fs.existsSync(composeFile)) {
+    issues.push('docker-compose.yml missing.');
+    console.log('[FAIL] docker-compose.yml: missing');
+  } else {
+    console.log('[ OK] docker-compose.yml: present');
+  }
+
+  // Check required directories
+  for (const dir of ['Agents', 'Files']) {
+    if (!fs.existsSync(path.join(root, dir))) {
+      issues.push(`${dir}/ directory missing.`);
+      console.log(`[FAIL] ${dir}/: missing`);
+    } else {
+      console.log(`[ OK] ${dir}/: present`);
+    }
+  }
+
+  // Check containers
+  if (manifest && dockerCheck.status === 0) {
+    const ps = dockerCompose(root, ['ps', '--format', 'json']);
+    if (ps.status === 0 && ps.stdout) {
+      try {
+        const containers = JSON.parse(ps.stdout);
+        const expected = ['gateway', 'dashboard', 'workframe-api', 'workframe'];
+        for (const name of expected) {
+          const container = containers.find((c) => c.Name?.includes(name) || c.Service === name);
+          if (!container) {
+            issues.push(`${name} container not found.`);
+            console.log(`[FAIL] ${name}: not found`);
+          } else if (container.State !== 'running') {
+            issues.push(`${name} container is ${container.State}, not running.`);
+            console.log(`[FAIL] ${name}: ${container.State}`);
+          } else {
+            console.log(`[ OK] ${name}: running`);
+          }
+        }
+      } catch {
+        // Fallback: plain text parse
+        const psPlain = dockerCompose(root, ['ps']);
+        console.log('\nContainer status:\n' + psPlain.stdout);
+      }
+    }
+  }
+
+  // Check bootstrap
+  if (manifest) {
+    const nativeSlug = manifest.native_agent?.profile_slug;
+    const soulFile = path.join(root, 'Agents', 'profiles', nativeSlug, 'SOUL.md');
+    if (!fs.existsSync(soulFile)) {
+      issues.push('Native agent not bootstrapped. Run: ./scripts/bootstrap-native.sh');
+      console.log('[FAIL] Bootstrap: native SOUL missing');
+    } else {
+      console.log('[ OK] Bootstrap: native SOUL present');
+    }
+  }
+
+  // Check ports
+  if (manifest) {
+    const ports = manifest.ports;
+    if (ports) {
+      console.log(`\nPorts:`);
+      console.log(`  Gateway: ${ports.gateway}, Dashboard: ${ports.dashboard}, UI: ${ports.ui}, API: ${ports.api}`);
+    }
+  }
+
+  // Agent DM runtime slots (explicit repair only with --repair)
+  if (manifest && dockerCheck.status === 0) {
+    const api = dockerCompose(root, ['ps', '--format', 'json'], { stdio: 'pipe' });
+    const apiUp = api.status === 0 && (api.stdout || '').includes('workframe-api');
+    if (apiUp) {
+      const audit = doctorAgentDmRuntimes(root, { repair: false });
+      if (audit.status === 0 && audit.stdout) {
+        try {
+          const data = JSON.parse(audit.stdout.trim().split('\n').pop());
+          const missing = data.missing?.length ?? 0;
+          if (missing > 0) {
+            const msg = `${missing} agent DM runtime profile(s) missing`;
+            if (repair) {
+              const fixed = doctorAgentDmRuntimes(root, { repair: true });
+              if (fixed.status === 0 && fixed.stdout) {
+                const result = JSON.parse(fixed.stdout.trim().split('\n').pop());
+                const repaired = result.repaired?.length ?? 0;
+                const failed = result.failed?.length ?? 0;
+                console.log(`[REPAIR] Agent DM runtimes: ${repaired} provisioned, ${failed} failed`);
+                if (failed || (result.still_missing?.length ?? 0) > 0) {
+                  issues.push(msg);
+                }
+              } else {
+                issues.push(`${msg} (repair failed)`);
+                console.log('[FAIL] Agent DM runtime repair failed');
+              }
+            } else {
+              issues.push(`${msg} — run: workframe doctor --repair`);
+              console.log(`[WARN] Agent DM runtimes: ${msg}`);
+            }
+          } else {
+            console.log('[ OK] Agent DM runtimes: all provisioned');
+          }
+        } catch {
+          console.log('[skip] Agent DM runtime audit: could not parse API response');
+        }
+      } else {
+        console.log('[skip] Agent DM runtime audit: workframe-api not reachable');
+      }
+    }
+  }
+
+  if (issues.length > 0) {
+    console.log(`\n${issues.length} issue(s) found:\n`);
+    issues.forEach((i) => console.log(`  - ${i}`));
+    process.exit(1);
+  } else {
+    console.log('\nAll checks passed. Workframe is healthy.');
+  }
+}
+
+function cmdSetup(root) {
+  const manifest = readManifest(root);
+  const image = manifest?.docker?.image || 'nousresearch/hermes-agent:latest';
+  const name = manifest?.docker?.stack || 'workframe';
+  console.log('Opening Hermes setup (interactive)...');
+  console.log('Credentials never belong in chat.\n');
+  dockerCompose(root, ['pull'], { stdio: 'inherit' });
+  const res = spawnSync('docker', [
+    'run', '--rm', '-it',
+    '--name', `${name}-setup`,
+    '--entrypoint', 'hermes',
+    '-v', `${path.join(root, 'Agents')}:/opt/data`,
+    '-v', `${path.join(root, 'Files')}:/workspace`,
+    image, 'setup',
+  ], { stdio: 'inherit' });
+  if (res.status !== 0) {
+    console.error('Setup failed or was cancelled.');
+    process.exit(res.status || 1);
+  }
+}
+
+function cmdStop(root) {
+  console.log('Stopping Workframe stack...');
+  const res = dockerCompose(root, ['down']);
+  if (res.status !== 0) {
+    console.error('Failed to stop stack.');
+    process.exit(1);
+  }
+  console.log('Stack stopped.');
+}
+
+function cmdStart(root) {
+  console.log('Starting Workframe stack...');
+  const res = dockerCompose(root, ['up', '-d']);
+  if (res.status !== 0) {
+    console.error('Failed to start stack.');
+    process.exit(1);
+  }
+  const manifest = readManifest(root);
+  if (manifest?.ports) {
+    console.log(`\nWorkframe UI: http://127.0.0.1:${manifest.ports.ui}/`);
+    console.log(`Hermes chat:  http://127.0.0.1:${manifest.ports.dashboard}/chat`);
+  }
+  console.log('Stack started.');
+}
+
+function cmdRestart(root) {
+  console.log('Restarting Workframe stack...');
+  const res = dockerCompose(root, ['restart']);
+  if (res.status !== 0) {
+    console.error('Failed to restart stack.');
+    process.exit(1);
+  }
+  console.log('Stack restarted.');
+}
+
+function cmdStatus(root) {
+  dockerCompose(root, ['ps'], { stdio: 'inherit' });
+}
+
+function cmdLogs(root, args) {
+  const follow = args.includes('--follow') || args.includes('-f');
+  const composeArgs = ['logs'];
+  if (follow) composeArgs.push('--follow');
+  composeArgs.push('gateway');
+  dockerCompose(root, composeArgs, { stdio: 'inherit' });
+}
+
+function cmdUi(root) {
+  const manifest = readManifest(root);
+  const port = readEnvPort(root, 'WORKFRAME_UI_PORT') || manifest?.ports?.ui || '18644';
+  const url = `http://127.0.0.1:${port}/`;
+  console.log(`Opening Workframe UI: ${url}`);
+  const openCmd = process.platform === 'win32' ? 'start' : process.platform === 'darwin' ? 'open' : 'xdg-open';
+  const child = spawn(openCmd, [url], { detached: true, stdio: 'ignore' });
+  child.unref();
+}
+
+function usage() {
+  console.log(`workframe — lifecycle CLI for Workframe projects
+
+Usage:
+  workframe doctor [--repair]     Diagnose stack; --repair provisions missing agent DM runtimes
+  workframe setup               Open Hermes setup (credentials)
+  workframe start               Start the full stack (docker compose up -d)
+  workframe stop                Stop all stack containers
+  workframe restart             Restart the full stack
+  workframe status              Show running containers
+  workframe logs [--follow]     Tail gateway logs
+  workframe ui                  Open Workframe UI in browser
+
+Run from a Workframe project directory (where workframe-manifest.json lives).
+`);
+}
+
+const args = process.argv.slice(2);
+const command = args[0];
+const extraArgs = args.slice(1);
+
+const root = findProjectRoot();
+if (!root) {
+  console.error('ERROR: Not in a Workframe project. No workframe-manifest.json found.');
+  process.exit(1);
+}
+
+switch (command) {
+  case 'doctor':   cmdDoctor(root, extraArgs); break;
+  case 'setup':    cmdSetup(root); break;
+  case 'stop':     cmdStop(root); break;
+  case 'start':    cmdStart(root); break;
+  case 'restart':  cmdRestart(root); break;
+  case 'status':   cmdStatus(root); break;
+  case 'logs':     cmdLogs(root, extraArgs); break;
+  case 'ui':       cmdUi(root); break;
+  case '--help':
+  case '-h':
+  case 'help':     usage(); break;
+  default:
+    if (command) console.error(`Unknown command: ${command}`);
+    usage();
+    process.exit(command ? 1 : 0);
+}

package/docs/workspace-instructions/WORKFRAME_DISCORD.md

@@ -0,0 +1,20 @@
+# Discord Guide (Workframe)
+
+Use Discord for team-visible agent collaboration.
+
+Minimal structure:
+- #workframe-control
+- #workframe-status
+- #workframe-review
+- one thread per initiative when needed
+
+Interaction model:
+- mention concierge for intake/routing
+- concierge delegates through Kanban
+- status returns to channels/threads
+- canonical outputs go to project files
+
+Permissions:
+- owner/admin highest trust
+- role/channel permissions enforced in Discord
+- high-risk actions require explicit approval

package/docs/workspace-instructions/WORKFRAME_DOCUMENTS_AND_ARTIFACTS.md

@@ -0,0 +1,20 @@
+# Workframe Document and Artifact Conventions
+
+Single source of truth:
+- Project files under `/workspace`.
+
+Priority of truth:
+1) Files (canonical)
+2) Kanban records (execution history)
+3) Chat messages (conversation context)
+
+Required anchors:
+- README.md
+- AGENTS.md
+- .hermes.md
+- docs/INDEX.md
+
+Artifact conventions:
+- Keep markdown concise and linked.
+- Update existing canonical docs before adding new scattered files.
+- Do not store secrets/personal data in docs.

package/docs/workspace-instructions/WORKFRAME_KANBAN.md

@@ -0,0 +1,20 @@
+# Workframe Kanban Guide
+
+Role
+- Kanban is durable execution and handoff state.
+
+Worker loop
+1) read task context
+2) execute scoped work
+3) heartbeat for long tasks
+4) complete with handoff schema
+5) block only for real external decisions
+
+Heartbeat cadence
+- every 20-30 minutes for long tasks, or at phase boundaries.
+- use heartbeat schema from `docs/WORKFRAME_HANDOFF_SCHEMA.md`.
+
+Truth priority
+1) files (canonical)
+2) Kanban (operational state)
+3) chat (coordination surface)

package/docs/workspace-instructions/WORKFRAME_ONBOARDING.md

@@ -0,0 +1,21 @@
+# Workframe Onboarding
+
+Goal
+- turn vague intent into a clean, usable project workspace.
+
+Concierge onboarding loop
+1) clarify mission, scope, constraints, success criteria
+2) default to native-only starter, then expand with specialist packs or individual profiles on demand
+3) establish file-based source of truth
+4) route first tasks through Kanban
+5) persist outcomes in project files
+
+Minimum initial artifacts
+- README.md
+- AGENTS.md
+- .hermes.md
+- docs index + first strategy/plan notes
+
+Rule
+- chat is intake/coordination
+- files are canonical

package/docs/workspace-instructions/WORKFRAME_ROUTING.md

@@ -0,0 +1,29 @@
+# Workframe Routing Guide
+
+Routing owner
+- concierge (`{projectName} Agent`) owns routing decisions.
+
+Default lanes
+- strategy -> visionary
+- architecture/planning -> architect
+- docs hygiene -> docs
+- implementation/test -> dev
+- evidence/context -> research
+- UX/visual -> designer
+
+Routing rules
+- parallelize independent lanes
+- use dependencies only when required
+- keep each lane role-pure
+- persist final outcomes in files
+
+Dynamic library rule
+- if a request repeatedly falls outside current roles,
+  concierge proposes a new specialist profile.
+
+Routing model notes:
+
+- the native project agent owns Discord / Telegram messaging surfaces
+- specialist profile runtimes are started as API-only gateways inside the same Hermes container
+- UI lanes bind sessions by `profile + source_id + client_id`
+- session titles are lane-local and may be auto-suffixed for uniqueness

package/docs/workspace-instructions/WORKFRAME_TELEGRAM.md

@@ -0,0 +1,19 @@
+# Telegram Guide (Workframe)
+
+Use Telegram as a control and collaboration surface.
+
+Recommended rollout:
+1) Owner DM mode (concierge only).
+2) Controlled group mode after validation.
+
+Interaction model:
+- humans ask/approve in Telegram
+- concierge routes to Kanban
+- specialists execute
+- results summarized back to Telegram
+- durable outcomes written to files
+
+Permissions:
+- Owner/admin retains highest privileges.
+- Team permissions follow Telegram group/admin controls.
+- High-risk actions remain explicit-approval only.

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "create-workframe",
+  "version": "0.1.0",
+  "description": "Scaffold a clean Workframe + Hermes workspace with guided onboarding (v0.1.0 pre-release)",
+  "type": "module",
+  "bin": {
+    "create-workframe": "bin/create-workframe.js"
+  },
+  "files": [
+    "bin",
+    "docs/workspace-instructions",
+    "profiles",
+    "prompts",
+    "rules",
+    "shared",
+    "workframe-api",
+    "workframe-supervisor",
+    "workframe-ui/public",
+    "workframe-ui/docker",
+    "scripts/bundle-workframe-ui.mjs",
+    "scripts/bootstrap-workspace-link.sh",
+    "scripts/setup-stack-secrets.sh",
+    "scripts/sync-canonical-to-package.mjs",
+    "scripts/ensure-compose-host-paths.mjs",
+    "scripts/set-compose-public-url.mjs",
+    "scripts/lib",
+    "scripts/apply-update-hermes.sh",
+    "scripts/apply-update-workframe.sh",
+    "scripts/restart-gateway-hermes.sh",
+    "scripts/compose-docker-host.sh",
+    "scripts/verify-public-deploy.sh",
+    "scripts/fix-zk-encryption-key.sh",
+    "scripts/create_workframe_scaffold.py",
+    "scripts/new-project.mjs",
+    "scripts/select_agent_pack.py",
+    "scripts/security_audit.py",
+    "scripts/test-scaffold.mjs",
+    ".dockerignore",
+    ".gitignore",
+    "LICENSE",
+    "NOTICE",
+    "README.md",
+    "SECURITY.md"
+  ],
+  "scripts": {
+    "bundle-ui": "node scripts/bundle-workframe-ui.mjs",
+    "new-project": "node scripts/new-project.mjs",
+    "test:scaffold": "node scripts/test-scaffold.mjs",
+    "sync": "node scripts/sync-canonical-to-package.mjs",
+    "prepack": "node scripts/sync-canonical-to-package.mjs && node scripts/bundle-workframe-ui.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/architectonic/workframe.git"
+  },
+  "keywords": [
+    "workframe",
+    "hermes",
+    "agents",
+    "scaffold",
+    "create-workframe"
+  ]
+}

package/profiles/README.md

@@ -0,0 +1,15 @@
+# Profile templates (package source)
+
+Install-time packs reference a **project-agent** slot. At scaffold time it becomes `{slugify(projectName)}-agent` (e.g. `BrandAuthority` → `brandauthority-agent`, display name **BrandAuthority Agent**).
+
+## Layout
+
+- Native concierge SOUL template: `workframe-agent/SOUL.md` (rendered into the project-specific slug)
+- Specialists: `visionary/`, `architect/`, `docs/`, `dev/`, `research/`, `designer/`
+
+## Packs
+
+- **core** — native project agent + docs + dev
+- **product** — native + docs + dev + visionary + research + designer
+- **engineering** — native + docs + dev + architect + research
+- **vanilla** / **full** — native + all specialists

package/profiles/architect/AGENTS.md

@@ -0,0 +1,29 @@
+# AGENTS — Architect
+
+Operating rules for **Architect** (`architect`). Identity lives in `SOUL.md` in this profile home.
+
+## Scope
+
+| File | Purpose |
+|------|---------|
+| `SOUL.md` | Who you are, chain of command, design workflow |
+| `AGENTS.md` (this file) | Tools, skills, kanban, memory |
+| `/workspace/AGENTS.md` | Project workspace rules |
+
+## Tools & skills
+
+- Load **kanban-worker** before any kanban-dispatched task; call `kanban_complete` or `kanban_block` before exit.
+- Read `WORKFRAME_COHORT.md` when present — use **runtime_slug** for kanban/delegate, never bare `architect`.
+- CLI: `/opt/hermes/.venv/bin/hermes -p <runtime_slug> …` via **terminal** tool.
+- You are **not** Botfather — never create/delete/spawn other agents.
+
+## Memory & handoff
+
+- Design artifacts → `/workspace/docs/` or agreed code paths.
+- Update kanban with status, files changed, blockers.
+- Persist decisions in workspace; chat is intake only.
+
+## Credentials
+
+- Use the owning user's API keys on runtime profiles (`u-*-architect`).
+- No secrets in chat.

package/profiles/architect/SOUL.md

@@ -0,0 +1,44 @@
+# Architect — System Designer
+
+## Identity
+
+You are the **Architect** sibling profile in the Workframe orchestration system. Your job is to design system architecture, write API contracts, define database schemas, and produce implementation plans that the dev profile can execute.
+
+Never identify as the underlying model, provider, OWL, or a generic Hermes assistant. If asked who you are, answer as **Architect** only — never say you are OWL, Hermes Agent, or the underlying model/provider.
+
+**Operating rules:** read `AGENTS.md` in this profile home for tools, skills, and kanban discipline.
+
+## Chain of Command
+
+1. ABKB (`D:\ab\projects\abkb\`) — Rules of engagement, hard rules, project ontology. READ BEFORE WRITING.
+2. Roadmap — The product spec for the active project.
+3. Kanban (Hermes kanban.db) — Task board. Check in when you start, check out when done.
+4. Source code (`/workspace/` in container) — The truth.
+
+## Orchestrator
+
+Workframe Agent is the concierge/orchestrator. It assigns tasks via kanban. When you finish a task, update the kanban task status and add notes about what you produced.
+
+## Workflow
+
+1. Read your assigned kanban task
+2. Read the relevant ABKB docs and project profile
+3. Read the existing code you will modify
+4. Produce design artifacts (schemas, API contracts, implementation plans)
+5. Write artifacts to `/workspace/docs/` or the relevant code location
+6. Update kanban task with status and notes
+7. Wait for review or unblock instructions
+
+## Rules
+
+- Read before writing. Always read the full flow end-to-end before designing.
+- ADD, don't REPLACE. New code goes alongside existing code.
+- Design docs go in `/workspace/docs/`
+- Never edit Hermes source code. Only config and workspace files.
+- When in doubt, ask. Update kanban with blocked status and explain why.
+
+## Runtime profile (kanban / cron)
+
+You may run as a **per-user runtime profile** (`u-…-architect`), not the shared template `architect`. Read `WORKFRAME_COHORT.md` if present.
+
+When dispatched via kanban: load **kanban-worker** skill, call `kanban_complete` or `kanban_block` before exit. If API key resolution fails, `kanban_block` with reason — do not exit silently.

package/profiles/architect/skills/devops/kanban-worker/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: kanban-worker
+description: Protocol for architect instances dispatched via Workframe kanban — show, work, complete/block.
+---
+
+# Kanban worker (you were dispatched)
+
+You are running as a **user-scoped runtime profile** (`u-…-architect`), not the shared template `architect`. Your credentials come from the owning user's overlay.
+
+## Required lifecycle
+
+1. `kanban_show` — read task id, body, output paths
+2. Execute the work (terminal, write_file, read_file)
+3. `kanban_comment` — files changed, decisions, test notes
+4. **`kanban_complete(summary=…, metadata=…)`** when done  
+   OR **`kanban_block(reason=…)`** if stuck
+
+Never exit without step 4 — the dispatcher treats it as a protocol violation.
+
+## Workspace
+
+- Task `workspace_kind` is usually `scratch` or `dir:/workspace`
+- Write deliverables to paths specified in the task body (under `/workspace` when shared)
+
+## If you lack API access
+
+If provider resolver returns empty API key, call `kanban_block` explaining misconfiguration — do not exit silently.

package/profiles/designer/AGENTS.md

@@ -0,0 +1,26 @@
+# AGENTS — Designer
+
+Operating rules for **Designer** (`designer`). Identity lives in `SOUL.md` in this profile home.
+
+## Scope
+
+| File | Purpose |
+|------|---------|
+| `SOUL.md` | Who you are, design mission |
+| `AGENTS.md` (this file) | Tools, deliverables, handoff |
+| `/workspace/AGENTS.md` | Project workspace rules |
+
+## Tools & skills
+
+- Load **kanban-worker** for dispatched tasks.
+- Image/UI/design skills on demand.
+- Runtime slug: `u-*-designer` for kanban/delegate.
+
+## Deliverables
+
+- Design notes, prompts, and assets under `/workspace` — link from handoff.
+- Confirm brand/constraints before large visual changes.
+
+## Restrictions
+
+- Not Botfather — no agent lifecycle.