@miroshnik/elves 2026.1018.2 → 2026.1019.1

package/README.md

@@ -155,7 +155,7 @@ No exaggeration: the spec format isn't the main token cost; what costs more is h
 You need `git` and [Bun](https://bun.sh) ≥ 1.2 — the installer (`bunx`) and the skill scripts run under it; a project's CI on Node adds the `oven-sh/setup-bun` step; the `github`, `est` and `dashboard` skills need [`gh`](https://cli.github.com) with the `project` scope (`gh auth refresh -s project`); `task-env` needs Docker with Compose (Docker Desktop on macOS).
 
 ```bash
-# onto the machine — the canon, skills and the hook for every agent it has; or a global package:
+# onto the machine — the canon, skills and the hook for every agent it has, and the elves command on PATH; or a global package:
 # bun add -g @miroshnik/elves && elves install -g
 bunx @miroshnik/elves install -g
 
@@ -193,7 +193,7 @@ An agent's sandbox (Claude Code's Bash) doesn't let bunx write its cache `~/.bun
 - Updating — `update` bumps the package version: `package.json` and the lockfile, a few lines in the branch of the current task, committed with it. A project with a copy of the flow of an earlier release moves to a thin one in a task of its own, one per project — `check` prints its `task new`, the hook names the canon loaded twice until then: `update` removes the copy, its symlinks and `.gitignore` exceptions, leads imports and CI paths into the copy to the package and lists what else names `.agents`.
 - The manifest, the shim, `AGENTS.md` and `.claude/settings.json`, if the project's git ignores them (`.agents/` or `.claude/` in `.gitignore`), are un-ignored by `install` and `update` with exceptions — an Elves block at the end of `.gitignore`, committed with them; what an exception can't un-ignore (a directory excluded by a personal rule), and anything ignored until `update` runs — `❌` in the output of the install and of `check`.
 
-**Onto the machine** (`-g`) — the canon, the skills and the hook: a thin project keeps no copy of the canon, its agents get it from the machine. `~/.agents/elves/` — `AGENTS.md`, `claude/CLAUDE.md`, `docs/*.md`; Claude Code — symlinks `~/.claude/rules/elves.md` and `elves-claude.md` (loaded in every project without the external-imports dialog), `~/.claude/skills` and the `SessionStart` hook in `~/.claude/settings.json`; the other agents — their global rule file linking to the canon (`~/.codex/AGENTS.md`, `~/.gemini/GEMINI.md`, `~/.copilot/copilot-instructions.md`, `~/.config/opencode/AGENTS.md`, `~/.config/amp/AGENTS.md`; a file of your own stays) and `~/.agents/skills`. A project that still has a copy loads the canon twice until it moves — the hook names it. A Claude Code cloud session gets the same from the project's `SessionStart` hook — `npm i -g bun@latest @miroshnik/elves && elves install -g` (the image's Bun lags behind), then `check --hook`; the machine's hook isn't there (the cloud doesn't read `~/.claude/settings.json`), an environment's setup script with the same command is an optional faster start. In an Elves clone with `--link` the machine's canon is the clone; its `.claude/CLAUDE.md` keeps the root `AGENTS.md` from loading a second time.
+**Onto the machine** (`-g`) — the canon, the skills and the hook: a thin project keeps no copy of the canon, its agents get it from the machine. `~/.agents/elves/` — `AGENTS.md`, `claude/CLAUDE.md`, `docs/*.md`; Claude Code — symlinks `~/.claude/rules/elves.md` and `elves-claude.md` (loaded in every project without the external-imports dialog), `~/.claude/skills` and the `SessionStart` hook in `~/.claude/settings.json`; the other agents — their global rule file linking to the canon (`~/.codex/AGENTS.md`, `~/.gemini/GEMINI.md`, `~/.copilot/copilot-instructions.md`, `~/.config/opencode/AGENTS.md`, `~/.config/amp/AGENTS.md`; a file of your own stays) and `~/.agents/skills`. The `elves` command in the terminal — in `~/.local/bin`, or the first directory of `PATH` inside the home directory you can write to: with `--link` a symlink to the clone's `bin/elves.ts`, otherwise a shim to the machine's release (`bunx @miroshnik/elves@<version>`) that `update -g` rewrites; an `elves` of your own (a script, a global package) stays, and `check -g` names it, a command missing or of another release, an `elves` earlier on `PATH`, and — when `PATH` has no such directory — the command that adds `~/.local/bin`. A project that still has a copy loads the canon twice until it moves — the hook names it. A Claude Code cloud session gets the same from the project's `SessionStart` hook — `npm i -g bun@latest @miroshnik/elves && elves install -g` (the image's Bun lags behind), then `check --hook`; the machine's hook isn't there (the cloud doesn't read `~/.claude/settings.json`), an environment's setup script with the same command is an optional faster start. In an Elves clone with `--link` the machine's canon is the clone; its `.claude/CLAUDE.md` keeps the root `AGENTS.md` from loading a second time.
 
 **Personal configuration** — everything that depends on specific repositories (the registry for `est`, your own model prices, notes) — lives outside the flow, in `~/.config/elves`; another directory — the `ELVES_CONFIG_DIR` variable, read by all skill scripts. `ELVES_PRIVATE=<path>` with `install -g` makes `~/.config/elves` a symlink to a private checkout; with `ELVES_CONFIG_DIR` the symlink isn't needed — the variable points at the checkout itself.
 

package/bin/elves.ts

@@ -6,7 +6,8 @@
  *
  *   bunx @miroshnik/elves install                      — into the project: the git root (or the current directory)
  *   bunx @miroshnik/elves install -g                   — machine-wide: the canon, skills and hook
- *   elves install -g                                   — the same from the npm package (npm i -g @miroshnik/elves)
+ *   elves install -g                                   — the same from the npm package (npm i -g @miroshnik/elves);
+ *                                                        install -g puts the elves command on PATH (`installCommand`)
  *   bun <Elves clone>/bin/elves.ts install -g --link   — from a clone: symlinks to the clone, edits show at once
  *   bunx @miroshnik/elves check [-g]                   — is the install behind: 0 — no, 1 — yes, 2 — can't tell
  *   bunx @miroshnik/elves update [-g]                  — bring the install up to date
@@ -76,7 +77,7 @@
  * proxy name) instead of holding copies. No dependencies, only node: APIs.
  */
 import { execFileSync, spawnSync } from "node:child_process";
-import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, readlinkSync, readSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import { accessSync, constants as fsConstants, cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, readlinkSync, readSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { isatty } from "node:tty";
@@ -223,7 +224,10 @@ terminal — the previous one. In an Elves clone writes only auto and language,
 from the clone itself.
 -g — onto the machine: the canon in ~/.agents/elves with Claude Code's rules ~/.claude/rules/elves*.md and the global
 rule files of Codex, Gemini CLI, Copilot, OpenCode and Amp linking to it (someone else's file stays), the skills
-(~/.agents/skills, ~/.claude/skills) and the SessionStart hook; without a terminal too — a cloud session's project hook
+(~/.agents/skills, ~/.claude/skills), the SessionStart hook and the elves command in the terminal — in ~/.local/bin or
+the first directory of PATH inside the home directory that can be written: with --link a symlink to the clone's
+bin/elves.ts, otherwise a shim to the machine's release (bunx ${PACKAGE}@<version>); someone else's elves there stays
+(!), no such directory — no command, check -g names how to add one; without a terminal too — a cloud session's project hook
 or setup script (CLAUDE_CODE_REMOTE=true) gets the canon and skills without the hook: the cloud doesn't read
 ~/.claude/settings.json. From the npm package (npm i -g / bun add -g ${PACKAGE}) — the release of its version, without
 the network. --link — from an Elves clone: symlinks to the clone instead of copies, edits show up immediately.
@@ -242,7 +246,9 @@ mode (auto) and the language, holds the compose file to the task isolation rules
 docker compose; the task-env skill), names a test that runs standards and architecture again next to test:spec (○, the
 ready test without them) and warns (!) if a script in slot calls turbo and turbo.json doesn't pass the queue variables
 to tasks or a line leads into a file of the flow copy that update doesn't rewrite — the file, the line number and its
-text (the exit code stays the same); a thin project behind — update in this session's task (the package version in
+text (the exit code stays the same); for the machine the elves command missing or of another release is falling
+behind, someone else's elves in its place or one earlier on PATH — !, no directory for it — ! with the command that
+adds ~/.local/bin to PATH; a thin project behind — update in this session's task (the package version in
 package.json and the lockfile), a project with a copy of the flow — the move to a thin project in a task of its own: the
 task new command of the github skill, one task per project. For the machine names the task-env proxy of *.localhost
 addresses — running, not running or running
@@ -260,7 +266,7 @@ Examples:
   update: `elves update [-g]
 
 Brings it up to date: a --link clone — git pull --ff-only, the machine's copy — install of the latest release: the
-canon, the skills and the hook; a project — install of the latest release: ${PACKAGE} in package.json and the
+canon, the skills, the hook and the elves shim of that release; a project — install of the latest release: ${PACKAGE} in package.json and the
 lockfile, a few lines in the branch of the current task; a project with a copy of the flow moves to a thin one (install
 --help), by hand after it — a check of the project that knows the queue wrapper by the copy's path (. .agents/slot.sh
 now), AI_DEV_SLOT* in the project's code → ELVES_SLOT*, formatting the shortened imports, git add -A before the first
@@ -1794,6 +1800,150 @@ function agentRules(home: string, has: (dir: string, cmd?: string) => boolean) {
   }
 }
 
+/**
+ * The `elves` command in the terminal (#632): `bunx @miroshnik/elves …` and `bun <clone>/bin/elves.ts …` aren't a
+ * command, and the global package's bin directory (`~/.bun/bin`) may not be on PATH at all — Bun from Homebrew.
+ * Where — `commandDir`; what — with `--link` a symlink to the clone's `bin/elves.ts` (its `sh` shebang works through a
+ * symlink), otherwise a shim to the machine's release through bunx (`commandShim`): the bunx directory is temporary,
+ * and the command matches the canon on the machine — `update -g` rewrites it with the release. Ours (`ownCommand`) is
+ * replaced; someone else's `elves` in that directory — a script of the user's, a global package — stays with a `!`
+ * line, and so does an `elves` earlier on PATH that the shell runs instead. No directory for it — no command: the `!`
+ * line of `check -g` has the command that adds `~/.local/bin` to PATH. Not in a cloud session: there the flow comes
+ * by `npm i -g` (`CLOUD_FLOW`), and its `elves` is the command.
+ */
+const COMMAND = "elves";
+/** The shim's line by which the install knows its own file. */
+const COMMAND_MARK = "# Elves: the machine's elves command";
+/** What a dry run names next to the command's path. */
+const COMMAND_NOTE = "the elves command in the terminal";
+
+/** PATH directories: absolute, in order, without repeats. */
+const pathDirs = () => [...new Set((process.env.PATH ?? "").split(path.delimiter).filter((d) => path.isAbsolute(d)).map((d) => path.resolve(d)))];
+
+/** A directory the install can write into. */
+function writableDir(dir: string) {
+  try {
+    accessSync(dir, fsConstants.W_OK);
+    return statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/** A file the shell runs: a regular file (through symlinks) with the execute bit. */
+function runnable(file: string) {
+  try {
+    accessSync(file, fsConstants.X_OK);
+    return statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/** Under dir, dir itself aside — by the path as given or by the real one (macOS /var → /private/var). */
+function inside(dir: string, p: string) {
+  const real = (x: string) => {
+    try {
+      return realpathSync(x);
+    } catch {
+      return x;
+    }
+  };
+  return [
+    [dir, p],
+    [real(dir), real(p)],
+  ].some(([d, x]) => {
+    const rel = path.relative(d!, x!);
+    return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+  });
+}
+
+/**
+ * The install's own command: a symlink to a clone's `bin/elves.ts` — not into node_modules, that is a global package;
+ * a clone gone or moved too — or a file with COMMAND_MARK.
+ */
+function ownCommand(file: string) {
+  const st = lstat(file);
+  if (st?.isSymbolicLink()) {
+    const to = readlinkSync(file);
+    return /(?:^|\/)bin\/elves\.ts$/.test(to) && !to.split("/").includes("node_modules");
+  }
+  if (!st?.isFile() || st.size > 4096) return false;
+  try {
+    return readFileSync(file, "utf8").includes(COMMAND_MARK);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * The command's directory: where PATH already has ours; otherwise `~/.local/bin` — if PATH has it (missing — the
+ * install creates it); otherwise the first directory of PATH inside the home directory that can be written — not
+ * outside it: system directories need root, and the install doesn't ask for it. null — no such directory on PATH.
+ */
+function commandDir(home: string): string | null {
+  const dirs = pathDirs();
+  const own = dirs.find((d) => ownCommand(path.join(d, COMMAND)));
+  if (own) return own;
+  const mine = dirs.filter((d) => inside(home, d));
+  const local = path.join(home, ".local/bin");
+  if (mine.includes(local) && (!lstat(local) || writableDir(local))) return local;
+  return mine.find(writableDir) ?? null;
+}
+
+/**
+ * The shim of a machine with a copy: the release it was installed from by its npm package — the bunx package of the
+ * same version as the canon; a release unknown — by the SHA (a clone without `--link`, a package pinned by SHA),
+ * without it — the latest release.
+ */
+function commandShim(src: string) {
+  const version = release ? npmVersion(release) : null;
+  const sha = version ? null : sourceSha(src);
+  const spec = version ? `${PACKAGE}@${version}` : sha ? `github:${SOURCE}#${sha}` : PACKAGE;
+  const what = version ? `release ${release}` : sha ? `Elves ${short(sha)}` : "the latest release";
+  return ["#!/bin/sh", `${COMMAND_MARK} — ${what}; set by \`${RUN} install -g\`, update -g rewrites it`, `exec bunx --silent ${spec} "$@"`, ""].join("\n");
+}
+
+/**
+ * No directory for the command: what the owner runs — `~/.local/bin` into PATH in the shell's profile and the same
+ * install with it on PATH.
+ */
+function pathCommand(src: string, linkMode: boolean) {
+  const shell = path.basename(process.env.SHELL ?? "");
+  const profile = shell === "zsh" ? "~/.zshrc" : shell === "bash" ? "~/.bashrc" : "~/.profile";
+  const again = linkMode ? `bun --no-env-file ${shWord(path.join(src, "bin/elves.ts"))} install -g --link` : `${RUN} update -g`;
+  return `mkdir -p ~/.local/bin && echo 'export PATH="$HOME/.local/bin:$PATH"' >> ${profile} && PATH="$HOME/.local/bin:$PATH" ${again}`;
+}
+
+/** The `elves` command (see COMMAND): a dry run names what it would change and the `!` lines. */
+function installCommand(src: string, home: string, linkMode: boolean) {
+  if (remote()) return;
+  const shown = (p: string) => (inside(home, p) ? `~/${path.relative(home, p)}` : p);
+  const say = (file: string, text: string) => (dry ? void change("!", file, { note: text }) : warn(`${shown(file)} — ${text}`));
+  const dir = commandDir(home);
+  if (!dir) {
+    const text = `${COMMAND_NOTE} isn't installed: PATH has no directory inside the home directory that can be written — add ~/.local/bin: ${pathCommand(src, linkMode)}`;
+    return dry ? void change("!", path.join(home, ".local/bin", COMMAND), { note: text }) : void note(text);
+  }
+  const dst = path.join(dir, COMMAND);
+  const st = lstat(dst);
+  if (st && !ownCommand(dst)) return say(dst, `someone else's elves (a script of the user's, a global package) — left as is; the machine's command goes here once it's removed: ${RUN} update -g`);
+  const target = path.join(src, "bin/elves.ts");
+  const text = linkMode ? linkText(target, dst, home) : commandShim(src);
+  const same = linkMode ? Boolean(st?.isSymbolicLink()) && readlinkSync(dst) === text : Boolean(st?.isFile()) && runnable(dst) && readFileSync(dst, "utf8") === text;
+  if (!same && dry) change(st ? "~" : "+", dst, { note: COMMAND_NOTE });
+  else if (!same) {
+    if (st) rmSync(dst);
+    mkdirSync(dir, { recursive: true });
+    if (linkMode) symlinkSync(text, dst);
+    else writeFileSync(dst, text, { mode: 0o755 });
+    note(`${shown(dst)} — ${COMMAND_NOTE}: ${linkMode ? `→ ${target}` : (/^exec (.*) "\$@"$/m.exec(text)?.[1] ?? "")}`);
+  }
+  const dirs = pathDirs();
+  const first = dirs.slice(0, dirs.indexOf(dir)).map((d) => path.join(d, COMMAND)).find(runnable);
+  if (first) say(first, `comes first on PATH: elves runs it, not ${shown(dst)} — remove it or put ${shown(dir)} before ${shown(path.dirname(first))} in PATH`);
+}
+
 /**
  * The URL of a GitHub origin on the repository's name before the rename (LEGACY_SOURCE, the name is case-insensitive) —
  * the same URL on SOURCE: the form, the credentials, the port and `.git` stay; another repository or host — null.
@@ -1835,8 +1985,8 @@ const remote = () => process.env.CLAUDE_CODE_REMOTE === "true";
 /**
  * The machine (#557): the canon `~/.agents/elves/` — a copy or, with `--link`, a symlink to the clone — with Claude
  * Code's rules `~/.claude/rules/elves*.md` (the same `installRules` and `claudeRules` as in a project: what a previous
- * install left under the flow's former name moves), the other agents' rule files (`agentRules`), skills and the hook.
- * Claude Code is on the machine — `~/.claude`, `claude` on PATH or a cloud session: its project hook (`cloudHook`) or
+ * install left under the flow's former name moves), the other agents' rule files (`agentRules`), skills, the `elves`
+ * command in the terminal (`installCommand`) and the hook. Claude Code is on the machine — `~/.claude`, `claude` on PATH or a cloud session: its project hook (`cloudHook`) or
  * its environment's setup script runs in a fresh home. The cloud doesn't read `~/.claude/settings.json` — no hook there.
  */
 function installGlobal(src: string, linkMode: boolean) {
@@ -1879,6 +2029,8 @@ function installGlobal(src: string, linkMode: boolean) {
       note(`${CONFIG} → ${priv}`);
     }
   }
+  // the last step: an agent's sandbox may refuse a directory of PATH — the canon, the skills and the hook are in place
+  installCommand(src, home, linkMode);
 }
 
 /**

package/dist/github/scripts/github.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import {
   locale_default
-} from "../../spec/scripts/harness-qzb932c8.js";
+} from "../../spec/scripts/harness-wqrt5gpa.js";
 
 // skills/github/scripts/github.ts
 import { spawnSync } from "node:child_process";
@@ -11,12 +11,14 @@ import path from "node:path";
 import { parseArgs } from "node:util";
 var N = locale_default.names(locale_default.projectLanguage());
 var canonViews = () => [
-  { name: N.views.board, layout: "BOARD_LAYOUT" },
-  { name: N.views.table, layout: "TABLE_LAYOUT" },
+  { name: N.views.board, layout: "BOARD_LAYOUT", columns: ["TITLE", STATUS, "LABELS", "SUB_ISSUES_PROGRESS"] },
+  { name: N.views.table, layout: "TABLE_LAYOUT", columns: ["TITLE", STATUS, "LABELS", "ASSIGNEES", "SUB_ISSUES_PROGRESS", N.fields.estimate], groupBy: STATUS },
   { name: N.views.roadmap, layout: "ROADMAP_LAYOUT" }
 ];
+var BUILTIN_COLUMNS = { TITLE: "Title", ASSIGNEES: "Assignees", LABELS: "Labels", SUB_ISSUES_PROGRESS: "Sub-issues progress" };
 var STATUS = "Status";
 var statusOptions = () => [N.status.backlog, N.status.inProgress, N.status.done];
+var STATUS_COLORS = ["GREEN", "YELLOW", "PURPLE"];
 var numberFields = () => [N.fields.estimate, N.fields.actual, N.fields.tokens, N.fields.cost];
 var issueTypes = () => [N.issueTypes.task, N.issueTypes.bug, N.issueTypes.epic];
 var PRIORITY = "Priority";
@@ -36,6 +38,12 @@ var ISSUE_LABEL_LIMIT = 100;
 var WORKFLOW_ADDED = "Item added to project";
 var WORKFLOW_CLOSED = "Item closed";
 var WORKFLOW_AUTO_ADD = "Auto-add to project";
+var WORKFLOW_MERGED = "Pull request merged";
+var WORKFLOW_AUTO_CLOSE = "Auto-close issue";
+var WORKFLOW_SUB_ISSUES = "Auto-add sub-issues to project";
+var WORKFLOW_ARCHIVE = "Auto-archive items";
+var WORKFLOWS = [WORKFLOW_ADDED, WORKFLOW_CLOSED, WORKFLOW_MERGED, WORKFLOW_AUTO_CLOSE, WORKFLOW_AUTO_ADD, WORKFLOW_SUB_ISSUES, WORKFLOW_ARCHIVE];
+var ARCHIVE_FILTER = "is:issue is:closed updated:<@today-2w";
 var DEFAULT_TEMPLATE = "miroshnik/6";
 var RULESET = "elves";
 var FORMER_RULESET = "ai-dev";
@@ -122,6 +130,8 @@ var Q = {
           id number name layout filter
           sortByFields(first: 5) { nodes { direction field { ... on ProjectV2FieldCommon { name } } } }
           verticalGroupByFields(first: 5) { nodes { ... on ProjectV2FieldCommon { name } } }
+          groupByFields(first: 5) { nodes { ... on ProjectV2FieldCommon { name } } }
+          fields(first: 50) { nodes { ... on ProjectV2FieldCommon { id name dataType } } }
         }
       }
       fields(first: 100) {
@@ -650,7 +660,9 @@ function loadProject(io, id, withItems = true) {
       layout: v.layout,
       filter: v.filter ?? null,
       sortBy: (v.sortByFields?.nodes ?? []).map((s) => s.field?.name).filter(Boolean),
-      columnsBy: (v.verticalGroupByFields?.nodes ?? []).map((f) => f?.name).filter(Boolean)
+      columnsBy: (v.verticalGroupByFields?.nodes ?? []).map((f) => f?.name).filter(Boolean),
+      groupBy: (v.groupByFields?.nodes ?? []).map((f) => f?.name).filter(Boolean),
+      columns: (v.fields?.nodes ?? []).filter((f) => f?.id).map((f) => ({ id: f.id, name: f.name, dataType: f.dataType }))
     })),
     fields: p.fields.nodes.filter((f) => f && f.id).map((f) => ({ id: f.id, name: f.name, dataType: f.dataType, isIssueField: !!f.isIssueField, options: f.options ?? null })),
     workflows: p.workflows.nodes.filter(Boolean),
@@ -692,7 +704,12 @@ function analyze(s) {
   for (const other of s.repo.linked.filter((x) => x.id !== p.id)) {
     link(`another project is linked: ${q(other.title)} (${other.url})`, { kind: "confirm", text: `unlink project ${q(other.title)} from the repository`, mutations: [{ op: "UnlinkProject", input: { projectId: other.id, repositoryId: s.repo.id } }] });
   }
-  const views = add("views", `Views ${canonViews().map((v) => q(v.name)).join(", ")} — the right layout, no filter, no others`);
+  const fieldAlias = fieldAliases();
+  const columnKey = (f) => BUILTIN_FIELDS.has(f.dataType) ? f.dataType : fieldAlias[f.name] ?? f.name;
+  const columnName = (key) => p.fields.find((f) => columnKey(f) === key)?.name ?? BUILTIN_COLUMNS[key] ?? key;
+  const columnFields = (keys) => keys.map((k) => p.fields.find((f) => columnKey(f) === k)).filter((f) => !!f);
+  const configuration = (keys) => ({ visibleFieldIds: columnFields(keys).map((f) => f.id) });
+  const views = add("views", `Views ${canonViews().map((v) => q(v.name)).join(", ")} — the right layout, columns and grouping, no filter, no others`);
   const canonNames = new Set(canonViews().map((v) => v.name));
   const spare = p.views.filter((v) => !canonNames.has(v.name));
   for (const c of canonViews()) {
@@ -703,7 +720,8 @@ function analyze(s) {
         spare.splice(spare.indexOf(cand), 1);
         views(`missing ${q(c.name)}`, guarded(`rename view ${q(cand.name)} → ${q(c.name)}`, { op: "UpdateView", input: { viewId: cand.id, name: c.name } }));
       } else {
-        views(`missing ${q(c.name)}`, api(`create view ${q(c.name)} (${c.layout})`, { op: "CreateView", input: { projectId: p.id, name: c.name, layout: c.layout } }));
+        const input = { projectId: p.id, name: c.name, layout: c.layout, ...c.columns ? { configuration: configuration(c.columns) } : {} };
+        views(`missing ${q(c.name)}`, api(`create view ${q(c.name)} (${c.layout})`, { op: "CreateView", input }));
       }
       continue;
     }
@@ -714,13 +732,26 @@ function analyze(s) {
     if (c.layout === "BOARD_LAYOUT" && v.layout === c.layout && v.columnsBy[0] !== STATUS) {
       views(`${q(c.name)} columns not by Status`, ui(`${q(c.name)}: View options → Column by → Status → Save`, `${p.url}/views/${v.number}`));
     }
+    if (c.columns) {
+      const have = v.columns.map(columnKey);
+      const missing = c.columns.filter((k) => !have.includes(k)).map((k) => q(columnName(k)));
+      const extra = v.columns.filter((f) => !c.columns.includes(columnKey(f))).map((f) => q(f.name));
+      if (missing.length || extra.length) {
+        const why = [missing.length ? `missing ${missing.join(", ")}` : "", extra.length ? `extra ${extra.join(", ")}` : ""].filter(Boolean).join("; ");
+        const set = columnFields(c.columns).map((f) => f.name).join(", ");
+        views(`${q(c.name)} columns: ${why}`, api(`${q(c.name)}: columns ${set}`, { op: "UpdateView", input: { viewId: v.id, configuration: configuration(c.columns) } }));
+      }
+    }
+    if (c.groupBy && v.layout === c.layout && v.groupBy[0] !== c.groupBy) {
+      views(`${q(c.name)} not grouped by ${c.groupBy}`, ui(`${q(c.name)}: View options → Group by → ${c.groupBy} → Save`, `${p.url}/views/${v.number}`));
+    }
   }
   for (const v of spare)
     views(`extra ${q(v.name)}`, guarded(`delete view ${q(v.name)}`, { op: "DeleteView", input: { viewId: v.id } }));
-  const status = add("status", `${STATUS}: ${statusOptions().join(" → ")}`);
+  const status = add("status", `${STATUS}: ${statusOptions().join(" → ")} (${STATUS_COLORS.join(", ")})`);
   const sf = p.fields.find((f) => f.name === STATUS && f.options);
   if (!sf) {
-    status(`no ${STATUS} field`, api(`create field ${STATUS}`, { op: "CreateField", input: { projectId: p.id, dataType: "SINGLE_SELECT", name: STATUS, singleSelectOptions: statusOptions().map((name) => ({ name, color: "GRAY", description: "" })) } }));
+    status(`no ${STATUS} field`, api(`create field ${STATUS}`, { op: "CreateField", input: { projectId: p.id, dataType: "SINGLE_SELECT", name: STATUS, singleSelectOptions: statusOptions().map((name, i) => ({ name, color: STATUS_COLORS[i], description: "" })) } }));
   } else if (sf.options.map((o) => o.name).join(`
 `) !== statusOptions().join(`
 `)) {
@@ -730,15 +761,17 @@ function analyze(s) {
       return i < 0 ? null : left.splice(i, 1)[0];
     };
     const aliases = statusAliases();
-    const next = statusOptions().map((name) => {
+    const next = statusOptions().map((name, i) => {
       const o = take((x) => x.name === name) ?? take((x) => aliases[x.name.toLowerCase()] === name);
-      return o ? { id: o.id, name, color: o.color, description: o.description ?? "" } : { name, color: "GRAY", description: "" };
+      return o ? { id: o.id, name, color: STATUS_COLORS[i], description: o.description ?? "" } : { name, color: STATUS_COLORS[i], description: "" };
     });
     const drop = left.length ? `; delete ${left.map((o) => q(o.name)).join(", ")}` : "";
     status(`options: ${sf.options.map((o) => o.name).join(", ") || "none"}`, guarded(`${STATUS}: ${statusOptions().join(", ")} (rename the existing ones keeping the id${drop})`, { op: "UpdateField", input: { fieldId: sf.id, singleSelectOptions: next } }));
+  } else if (sf.options.some((o, i) => o.color !== STATUS_COLORS[i])) {
+    const next = sf.options.map((o, i) => ({ id: o.id, name: o.name, color: STATUS_COLORS[i], description: o.description ?? "" }));
+    status(`colors: ${sf.options.map((o) => `${o.name} ${o.color}`).join(", ")}`, api(`${STATUS}: colors ${STATUS_COLORS.join(", ")} (keeping the id)`, { op: "UpdateField", input: { fieldId: sf.id, singleSelectOptions: next } }));
   }
   const fields = add("fields", `Fields ${numberFields().map(q).join(", ")} (Number), no other custom ones`);
-  const fieldAlias = fieldAliases();
   const renamed = new Set;
   for (const name of numberFields()) {
     const f = p.fields.find((x) => x.name === name);
@@ -804,13 +837,17 @@ function analyze(s) {
       types(`extra ${q(x.name)}`, { kind: "confirm", text: `disable type ${q(x.name)}`, url, mutations: [{ op: "UpdateIssueType", input: { issueTypeId: x.id, isEnabled: false } }] });
     }
   }
-  const wf = add("workflows", `Workflows ${[WORKFLOW_ADDED, WORKFLOW_CLOSED, WORKFLOW_AUTO_ADD].map(q).join(", ")} are on`);
+  const wf = add("workflows", `Workflows ${WORKFLOWS.map(q).join(", ")} are on`);
   const how = {
     [WORKFLOW_ADDED]: `Edit → Set value → ${STATUS}: ${N.status.backlog}`,
     [WORKFLOW_CLOSED]: `Edit → Set value → ${STATUS}: ${N.status.done}`,
-    [WORKFLOW_AUTO_ADD]: `Edit → repository ${s.repo.name}, filter is:issue is:open (Enter)`
+    [WORKFLOW_MERGED]: `Edit → Set value → ${STATUS}: ${N.status.done}`,
+    [WORKFLOW_AUTO_CLOSE]: `Edit → ${STATUS}: ${N.status.done}`,
+    [WORKFLOW_AUTO_ADD]: `Edit → repository ${s.repo.name}, filter is:issue is:open (Enter)`,
+    [WORKFLOW_SUB_ISSUES]: "Edit",
+    [WORKFLOW_ARCHIVE]: `Edit → filter ${ARCHIVE_FILTER} (Enter)`
   };
-  for (const name of [WORKFLOW_ADDED, WORKFLOW_CLOSED, WORKFLOW_AUTO_ADD]) {
+  for (const name of WORKFLOWS) {
     const w = p.workflows.find((x) => x.name === name);
     if (w?.enabled)
       continue;
@@ -1280,6 +1317,7 @@ var handedOutFile = (io) => {
   return file && `${file}.tasks`;
 };
 var CLOUD_HANDOUT = "@cloud";
+var SESSION_HANDOUT = "@session";
 function handedOut(io, slug) {
   const file = handedOutFile(io);
   return file ? handOutsIn(file, slug) : [];
@@ -1292,7 +1330,8 @@ function handOutsIn(file, slug) {
   return lines.filter((l) => l.startsWith(`${slug}#`)).map((l) => {
     const [number, ...rest] = l.slice(slug.length + 1).split(" ");
     const worktree = rest.join(" ").trim();
-    return { number: Number(number), worktree: worktree === CLOUD_HANDOUT ? null : worktree || null, cloud: worktree === CLOUD_HANDOUT };
+    const executor = worktree === CLOUD_HANDOUT ? "cloud" : worktree === SESSION_HANDOUT ? "session" : "subagent";
+    return { number: Number(number), worktree: executor === "subagent" ? worktree || null : null, executor };
   }).filter((h) => Number.isInteger(h.number) && h.number > 0);
 }
 function realPath(p) {
@@ -1809,8 +1848,10 @@ function cmdTaskQueue(io, slug, o) {
     const pr = openPr(i);
     const work = [status === N.status.inProgress ? q(N.status.inProgress) : "", pr === undefined ? "" : `open PR #${pr} https://github.com/${slug}/pull/${pr}`].filter(Boolean);
     const hand = handed.find((h) => h.number === i.number);
-    if (!work.length && hand?.cloud)
+    if (!work.length && hand?.executor === "cloud")
       work.push(`handed out to a cloud executor of this session, its wait — a background command: bash ${waitCi()} issue ${i.number}`);
+    else if (!work.length && hand?.executor === "session")
+      work.push("handed out to an app executor session of this session (start_session) — the end of each of its turns comes as the app's note");
     else if (!work.length && hand)
       work.push("handed out to an executor of this session");
     if (work.length) {
@@ -2079,7 +2120,7 @@ function taskBranchesHere(io, slug, number) {
   const refs = [...git("for-each-ref", "--format=%(refname)", "refs/heads/"), ...git("ls-remote", "--heads", "origin").map((l) => l.split("\t")[1] ?? "")];
   return [...new Set(refs.map((r) => r.trim().replace(/^refs\/heads\//, "")).filter((b) => isTaskBranch(b, number)))].sort();
 }
-function cmdTaskAssignment(io, slug, number, o = { cloud: false }) {
+function cmdTaskAssignment(io, slug, number, o = {}) {
   const issue = loadIssue(io, slug, number);
   const file = handedOutFile(io);
   const own = pinnedTask(io)?.task;
@@ -2096,7 +2137,7 @@ function cmdTaskAssignment(io, slug, number, o = { cloud: false }) {
     mkdirSync(path.dirname(file), { recursive: true });
     writeFileSync(path.join(path.dirname(file), ".gitignore"), `*
 `);
-    const where = o.cloud ? CLOUD_HANDOUT : worktree;
+    const where = o.cloud ? CLOUD_HANDOUT : o.session ? SESSION_HANDOUT : worktree;
     appendFileSync(file, `${slug}#${number}${where ? ` ${where}` : ""}
 `);
   }
@@ -2114,11 +2155,17 @@ function cmdTaskAssignment(io, slug, number, o = { cloud: false }) {
     inProgress: N.status.inProgress,
     done: N.lastLine.done,
     questions: N.sections.questions,
-    branches: restart.map((b) => `\`${b}\``).join(", ")
+    branches: restart.map((b) => `\`${b}\``).join(", "),
+    doneQuestions: N.lastLine.questions,
+    remaining: N.lastLine.remaining
   };
-  const lines = [N.queue.lead, ...restart.length ? [N.queue.resume] : [], N.queue.subagent, N.queue.session, N.queue.wait, N.queue.git, N.queue.subagents, N.queue.live, N.queue.found, N.queue.question, N.queue.answer];
+  const resume = restart.length ? [N.queue.resume] : [];
+  const lines = o.session ? [N.queue.sessionLead, ...resume, N.queue.sessionIs, N.queue.sessionName, N.queue.sessionWait, N.queue.sessionFound, N.queue.sessionQuestion, N.queue.sessionEnd] : [N.queue.lead, ...resume, N.queue.subagent, N.queue.session, N.queue.wait, N.queue.git, N.queue.subagents, N.queue.live, N.queue.refresh, N.queue.found, N.queue.question, N.queue.answer];
   for (const line of lines)
     io.out(locale_default.fill(line, vars));
+  if (o.session) {
+    io.out(`Next: the lines above — the executor session's prompt as is: start_session, initiation "user_asked", cwd — the folder of the ${slug} checkout on this machine (not a worktree), ` + `use_worktree true, background — the first line above; keep the session's id it returns. ` + `The end of each of its turns comes as the app's note, like an executor's answer — task queue again: in a queue of ${slug} the task is =; ${SESSION_ARCHIVE}.`);
+  }
   return 0;
 }
 function actualizeChecks() {
@@ -2308,7 +2355,8 @@ function cmdTaskClose(io, slug, number, o) {
     const prs = [...issue.prs, ...fresh].map((p) => `#${p.number} ${p.state === "OPEN" ? "open" : "closed without a merge"}`).join(", ");
     const what = prs ? `PR ${prs}` : `the task is ${issue.state === "OPEN" ? "open" : "closed without being done"}, no merged PR`;
     const checked = found ? `; checked: the PR–task link, the branch <type>/${number}-<slug> and «Closes #${number}» in the body of the last ${RECENT_PRS} PRs into ${found.base}` : "";
-    throw new GhError(`#${number} is too early to close: ${what}${checked} — close after the PR is merged or the task is closed`);
+    const noPr = !prs && issue.state === "OPEN" ? `; a task without a PR (a data edit, a reconciliation, research) — close the issue as completed with a result comment: gh issue close ${number} --repo ${slug} --reason completed --comment "<result>", then task close ${number} again` : "";
+    throw new GhError(`#${number} is too early to close: ${what}${checked} — close after the PR is merged or the task is closed${noPr}`);
   }
   if (issue.parent) {
     const epic = loadTaskText(io, slug, issue.parent.number);
@@ -3121,7 +3169,7 @@ that can't be continued, in the worktree of its task's branch.
 Examples:
   github task resume`,
   "task queue": `github task queue [--epic N] [--type Task|Bug] [--priority Urgent,High] [--repo owner/repo]
-github task queue --assignment <N> [--cloud] [--repo owner/repo]
+github task queue --assignment <N> [--cloud | --session] [--repo owner/repo]
 
 The dispatcher session's queue: ready tasks (open, not an epic, not in work, no open blockers — other repositories'
 too —, no external blocker label) by Priority, then number, each with its executor's prompt; the rest — in work (=: In
@@ -3140,13 +3188,17 @@ such a subagent at work or HEAD moved in the last ${QUIET_MINUTES} min — code
 dispatcher wait, no hand-out. --cloud — printed by the dispatcher: the brief of a cloud executor (claude.ai/code) —
 whole, # only at its task — and the dispatcher's steps: a cloud session can't message a local one, so the dispatcher
 waits for the task's closing (ci-wait issue N, background) and closes it locally; the hand-out has no worktree, and the
-queue's = line names that wait.
+queue's = line names that wait. --session — printed by the dispatcher: the prompt of an app executor session
+(start_session in the folder of another project, its own worktree) — a session by its project's canon and mode, named
+by the task, waiting in the background, ending with the canon's last line — and how to start it; the hand-out has no
+worktree, the task is = in the queue.
 
 Examples:
   github task queue --epic 40
   github task queue --type Bug --priority Urgent,High
   github task queue --assignment 42
-  github task queue --assignment 42 --cloud`,
+  github task queue --assignment 42 --cloud
+  github task queue --assignment 42 --session`,
   "task close": `github task close <N> [--no-git] [--repo owner/repo]
 
 After the PR merge and the deploy (or a close without a PR) in one call: the actual (est fact --write), Status Done, the
@@ -3299,6 +3351,7 @@ function main(argv, io) {
           "no-git": { type: "boolean", default: false },
           assignment: { type: "boolean", default: false },
           cloud: { type: "boolean", default: false },
+          session: { type: "boolean", default: false },
           auto: { type: "boolean", default: false }
         }
       });
@@ -3324,10 +3377,14 @@ function main(argv, io) {
       if (cmd === "queue") {
         if (values.cloud && !values.assignment)
           throw new GhError("--cloud — only with --assignment <N>: the brief of one task's cloud executor");
+        if (values.session && !values.assignment)
+          throw new GhError("--session — only with --assignment <N>: the prompt of one task's app executor session");
+        if (values.cloud && values.session)
+          throw new GhError("--cloud or --session, not both: a cloud executor or an app session");
         if (values.assignment) {
           if (positionals.length !== 1)
             throw new GhError("task queue --assignment <N>: one task number");
-          return cmdTaskAssignment(io, slug, issueNumber(positionals[0], "task queue --assignment"), { cloud: values.cloud });
+          return cmdTaskAssignment(io, slug, issueNumber(positionals[0], "task queue --assignment"), { cloud: values.cloud, session: values.session });
         }
         if (positionals.length)
           throw new GhError(`extra arguments: ${positionals.join(" ")} — the queue is chosen by --epic, --type and --priority`);

package/dist/spec/scripts/architecture.js

@@ -1,11 +1,11 @@
 import {
   locale_default
-} from "./harness-qzb932c8.js";
+} from "./harness-wqrt5gpa.js";
 import {
   invariant2,
   codeOnly2,
   envNamesInCode2
-} from "./harness-v9s1v9w3.js";
+} from "./harness-ay62ws50.js";
 
 // skills/spec/scripts/architecture.ts
 import { readdirSync, readFileSync } from "node:fs";

package/dist/spec/scripts/{harness-v9s1v9w3.js → harness-ay62ws50.js}

@@ -1,6 +1,6 @@
 import {
   locale_default
-} from "./harness-qzb932c8.js";
+} from "./harness-wqrt5gpa.js";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;

package/dist/spec/scripts/{harness-qzb932c8.js → harness-wqrt5gpa.js}

@@ -91,6 +91,7 @@ var en_default = {
     git: "- git — in separate calls, without `cd`, `&&` and `|`: worktree isolation refuses a compound command with git;",
     subagents: "- writing subagents — launch as needed, no limit: each gets its own worktree and «{task} #{number}» at the start of its prompt (`est` links its work by it); bring their commits into your branch, remove their worktrees and branches yourself after the merge — what didn't go, name in the answer;",
     live: "- while any of your subagents works, don't answer: wait for their answers — a background subagent wakes you with its answer; an answer with live subagents looks like a failure, and the dispatcher would give the task to a second executor next to you. Can't wait — answer `waits for subagents: <which and what they do>`: it isn't `failed`, there will be no second executor;",
+    refresh: '- the epic refresh — the subagent `task actualize` prints, without a worktree of its own (in yours) and not in the background (`run_in_background: false`): its answer — in the same turn, then `{script} task close {number}`, and only then the answer to the dispatcher: once you answer, a worktree without changes is removed, and a background subagent is left without a directory; a task without a PR (a data edit, a reconciliation, research) — first close the issue as completed with a result comment: `gh issue close {number} --repo {repo} --reason completed --comment "<result>"`;',
     found: "- work found outside the task — `{script} task new …` (work of the task's epic — with `--epic`: the dispatcher picks it up) — name it in the answer: whether to queue it is the owner's call;",
     question: "- a question without a clear recommendation — into «{questions}» of the task; don't start the code that depends on it and answer the dispatcher: the owner's answer comes back here.",
     answer: "The answer to the dispatcher — one line: `merged #<PR>` · `question: <the question, options, recommendation>` · `waits for subagents: <which and what they do>` · `failed: <what stopped and where>`.",
@@ -100,7 +101,14 @@ var en_default = {
     cloudDoc: "- the cloud — by `docs/cloud-sessions.md` of the canon, read it first: of the github skill's scripts `task show`, `task answer` and `task new` work there (over REST), the rest refuse, the scenarios section — by editing the description over REST, project fields aren't set from the cloud; the branch is the one the cloud assigned, don't rename it;",
     cloudClose: "- after the merge — its section «Closing a task from the cloud»: the «{actual}» comment of `est fact {number}` and a «{state}» comment with what the cloud can't do — both into the task;",
     cloudDispatcher: "- the dispatcher waits for the task to close and closes it locally — the actual, the status, the merged branch, archiving this session: don't message it, don't archive the session;",
-    cloudQuestion: "- a question without a clear recommendation — into «{questions}» of the task and to the owner in this session, don't start the code that depends on it; stopped (a question, a failure, a limit) — a «{state}» comment into the task."
+    cloudQuestion: "- a question without a clear recommendation — into «{questions}» of the task and to the owner in this session, don't start the code that depends on it; stopped (a question, a failure, a limit) — a «{state}» comment into the task.",
+    sessionLead: "{task} #{number} «{title}» in {repo}{epic}: you are an executor session of the dispatcher session — do the task whole by the canon of this project, in its mode (`check` prints it; outside auto — commit, push and merge on the owner's «yes»): the task's questions, `{script} task status {number} \"{inProgress}\" --branch <type>/{number}-<slug>`, the branch from a fresh origin/main, code and tests, PR, green CI, `pr premerge`, merge, deploy, the epic refresh, `{script} task close {number}`.",
+    sessionIs: "You are a session, not a subagent:",
+    sessionName: "- name the session `#{number} {title}` (`set_session_title`) once the task is taken — `est` links the session to the task by it;",
+    sessionWait: "- wait for CI and the deploy with a background command — `{waitCi} pr <PR>` (after the merge — `merged <PR>`): its completion wakes the session; no `Monitor`, watcher loop or `ScheduleWakeup` on top;",
+    sessionFound: "- work found outside the task — `{script} task new …` and the question «queue it?» by the canon; work of the task's epic — with `--epic` and without an executor of yours: the dispatcher's queue picks it up;",
+    sessionQuestion: "- a question without a clear recommendation — into «{questions}» of the task and to the owner in this session; don't start the code that depends on it: the answer comes here, from the owner or the dispatcher;",
+    sessionEnd: "- the end — the canon's last line («{done}» · «{doneQuestions} …» · «{remaining} …»), in auto mode after «{done}» — archiving the session by the canon: the dispatcher reads the end of each of your turns as your answer."
   },
   est: {
     answer: "Answer",
@@ -541,6 +549,7 @@ var ru_default = {
     git: "- git — отдельными вызовами, без `cd`, `&&` и `|`: составную команду с git изоляция worktree не пропускает;",
     subagents: "- пишущих субагентов запускай по необходимости, без лимита: каждому — свой worktree и «{task} #{number}» в начале промпта (по нему `est` привяжет его работу); их коммиты перенеси в свою ветку, их worktree и ветки после мержа убери сам — что не убралось, назови в ответе;",
     live: "- пока работает хоть один твой субагент, ответ не отдавай: жди их ответов — фоновый субагент будит тебя своим ответом; ответ при живых субагентах выглядит провалом, и диспетчер отдал бы задачу второму исполнителю рядом с тобой. Ждать нельзя — ответь `ждёт субагентов: <какие и что делают>`: это не «сломалось», второго исполнителя не будет;",
+    refresh: '- актуализация эпика — субагент, которого печатает `task actualize`, без своего worktree (в твоём) и не в фоне (`run_in_background: false`): его ответ — в том же ходе, затем `{script} task close {number}`, и только потом ответ диспетчеру: стоит тебе ответить, worktree без изменений убирают, и фоновый субагент остаётся без каталога; у задачи без PR (правка данных, сверка, исследование) — сначала закрой issue как выполненную с итоговым комментарием: `gh issue close {number} --repo {repo} --reason completed --comment "<итог>"`;',
     found: "- найденная работа вне задачи — `{script} task new …` (работа эпика задачи — с `--epic`: диспетчер её подхватит) — назови её в ответе: ставить ли её в очередь, решает владелец;",
     question: "- вопрос без ясной рекомендации — в «{questions}» задачи; код, который от него зависит, не начинай и ответь диспетчеру: ответ владельца придёт сюда же.",
     answer: "Ответ диспетчеру — одной строкой: `влито #<PR>` · `вопрос: <вопрос, варианты, рекомендация>` · `ждёт субагентов: <какие и что делают>` · `сломалось: <что и где остановилось>`.",
@@ -550,7 +559,14 @@ var ru_default = {
     cloudDoc: "- облако — по `docs/cloud-sessions.md` канона, прочитай его первым: из скриптов скилла github там работают `task show`, `task answer` и `task new` (через REST), остальные отказывают, раздел сценариев — правкой описания через REST, поля проекта из облака не ставятся; ветка — та, что назначило облако, не переименовывай;",
     cloudClose: "- после мержа — его раздел «Closing a task from the cloud»: комментарий «{actual}» от `est fact {number}` и комментарий «{state}» с тем, что из облака не сделать, — оба в задачу;",
     cloudDispatcher: "- диспетчер ждёт закрытия задачи и закрывает её локально — факт, статус, влитая ветка, архив этой сессии: сообщать ему не нужно, сессию не архивируй;",
-    cloudQuestion: "- вопрос без ясной рекомендации — в «{questions}» задачи и владельцу в этой сессии, код, который от него зависит, не начинай; остановился (вопрос, сбой, лимит) — комментарий «{state}» в задачу."
+    cloudQuestion: "- вопрос без ясной рекомендации — в «{questions}» задачи и владельцу в этой сессии, код, который от него зависит, не начинай; остановился (вопрос, сбой, лимит) — комментарий «{state}» в задачу.",
+    sessionLead: '{task} #{number} «{title}» в {repo}{epic}: ты сессия-исполнитель сессии-диспетчера — сделай задачу целиком по канону этого проекта, в его режиме (его печатает `check`; не в auto — коммит, пуш и мерж по «да» владельца): вопросы задачи, `{script} task status {number} "{inProgress}" --branch <тип>/{number}-<slug>`, ветка от свежего origin/main, код и тесты, PR, зелёный CI, `pr premerge`, мерж, деплой, актуализация эпика, `{script} task close {number}`.',
+    sessionIs: "Ты сессия, а не субагент:",
+    sessionName: "- назови сессию `#{number} {title}` (`set_session_title`), как только взял задачу, — по имени `est` привяжет сессию к задаче;",
+    sessionWait: "- CI и деплой жди фоновой командой — `{waitCi} pr <PR>` (после мержа — `merged <PR>`): её завершение будит сессию; без `Monitor`, цикла-наблюдателя и `ScheduleWakeup` поверх;",
+    sessionFound: "- найденная работа вне задачи — `{script} task new …` и вопрос «ставить в очередь?» по канону; работа эпика задачи — с `--epic` и без твоего исполнителя: её подхватит очередь диспетчера;",
+    sessionQuestion: "- вопрос без ясной рекомендации — в «{questions}» задачи и владельцу в этой сессии; код, который от него зависит, не начинай: ответ придёт сюда же — от владельца или диспетчера;",
+    sessionEnd: "- конец — последняя строка канона («{done}» · «{doneQuestions} …» · «{remaining} …»), в режиме auto после «{done}» — архивация сессии по канону: конец каждого твоего хода диспетчер читает как твой ответ."
   },
   est: {
     answer: "Ответ",

package/dist/spec/scripts/harness.js

@@ -23,8 +23,8 @@ import {
   envNamesInCode2,
   dotenvNames2,
   envVars2
-} from "./harness-v9s1v9w3.js";
-import"./harness-qzb932c8.js";
+} from "./harness-ay62ws50.js";
+import"./harness-wqrt5gpa.js";
 export {
   ENV_SERVICE2 as ENV_SERVICE,
   codeFiles2 as codeFiles,