@ethlete/agent-rules 0.1.0-next.28 → 0.1.0-next.29

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @ethlete/agent-rules
 
+## 0.1.0-next.29
+
+### Patch Changes
+
+- `agent-sessions restart` now waits until the session ended its turn and its prompt is empty, so it no longer types into a running turn or into your draft.
+- A multi-target sketch merge gives each target only the `shared/` files it imports, directly or transitively; an unimported file returns to the target that held it. `sketch new` refuses targets whose `shared/` files clash.
+- `et design sketch new` takes several parts: one sketch, one variant folder holding them all, one `ready`, one merge; `ready` and `preview` name every part a `shared/` edit reaches; Studio shows every target part.
+
 ## 0.1.0-next.28
 
 ### Minor Changes

package/content/mods/plugins/e2e-progress/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "e2e-progress",
-  "version": "0.1.0-next.28",
+  "version": "0.1.0-next.29",
   "description": "Live Playwright e2e progress from a run log, as a status line entry and a pane",
   "types": "./types/index.d.ts"
 }

package/content/skills/agent-sessions/SKILL.md

@@ -49,7 +49,7 @@ Nothing runs until you start it, so a person who does not use this does nothing.
 
 `up codex=codex gemini=gemini` starts a detached `tmux` session per agent, named like its sender name, and runs the command in it. It also starts a session named `mailbox-dispatch` that runs `dispatch`. A running session is left alone. Attach to a session with `tmux attach -t <name>`. Detach with `Ctrl-b`, then `d`. The session and its agent keep running. Use `down` to stop the dispatcher and the named sessions.
 
-`restart <name> <prompt...>` types the clear command (`/clear`, or `/new` for a `codex` name) and then the prompt into the session `<name>@<repo>` after `--after` seconds (default 5). The command returns at once, so end your turn after it. An agent uses it to clear itself and resume from its saved work state. It refuses any session other than the caller's own (from `$TMUX_PANE`), and the error names the caller's own sender name. Background commands of the old session still report into the new one.
+`restart <name> <prompt...>` types the clear command (`/clear`, or `/new` for a `codex` name) and then the prompt into the session `<name>@<repo>`, no sooner than `--after` seconds (default 5). It waits until that session ended its turn and its prompt holds no typed text, and gives up after 30 minutes. The command returns at once, so end your turn after it. An agent uses it to clear itself and resume from its saved work state. It refuses any session other than the caller's own (from `$TMUX_PANE`), and the error names the caller's own sender name. Background commands of the old session still report into the new one.
 
 `shell-install` writes one shell function per agent into `~/.zshrc` or `~/.bashrc`, between two marker lines. A second run replaces the block, and `--remove` deletes it. Use `--file` for another startup file and `--dry-run` to preview. After a new terminal opens, typing `claude` or `codex` in a repo with this skill runs the agent through `run`. Elsewhere the function starts the plain command. Run `shell-install` only when the user asks: it changes a file the user owns. `shell-init` prints the same functions without writing a file.
 

package/content/skills/agent-sessions/agent-sessions.mjs

@@ -35,6 +35,8 @@ const WAKE_GRACE_MS = 1500;
 const DRAFT_RETRY_MS = 2000;
 const RESTART_AFTER_SECONDS = 5;
 const RESTART_CLEAR_MS = 2500;
+const RESTART_POLL_MS = 2000;
+const RESTART_WAIT_MS = 30 * 60 * 1000;
 const repoSlug = basename(root).replace(/[.:]/g, '-');
 const sessionFor = (agent) => `${agent}@${repoSlug}`;
 const DISPATCH_SESSION = process.env.AGENT_MAILBOX_DISPATCH_SESSION ?? `mailbox-dispatch@${repoSlug}`;
@@ -102,6 +104,20 @@ const runsInSession = (agentArgs) =>
  * wake-up line from answering a permission dialog.
  */
 const SGR = `${String.fromCharCode(27)}\\[([0-9;]*)m`;
+const isBusy = (session) => /esc to inte/i.test(tmux('capture-pane', '-p', '-t', `=${session}:`).stdout ?? '');
+
+/** Waits until the agent ended its turn and nobody types in its prompt, twice in a row; `false` after the time limit. */
+const waitForQuiet = (session) => {
+  const end = Date.now() + RESTART_WAIT_MS;
+  let quiet = 0;
+  while (Date.now() < end) {
+    quiet = isBusy(session) || hasDraft(session) ? 0 : quiet + 1;
+    if (quiet === 2) return true;
+    sleep(RESTART_POLL_MS);
+  }
+  return false;
+};
+
 const hasDraft = (session) => {
   const pane = tmux('capture-pane', '-p', '-e', '-t', `=${session}:`).stdout ?? '';
   const prompt = pane
@@ -311,20 +327,28 @@ if (command === 'send' && sender) {
   } else if (now) {
     const type = (...keys) => tmux('send-keys', '-t', `=${session}:`, ...keys);
     sleep(Number(afterSeconds ?? RESTART_AFTER_SECONDS) * 1000);
-    type('-l', sender.startsWith('codex') ? '/new' : '/clear');
-    sleep(ENTER_DELAY_MS);
-    type('Enter');
-    sleep(RESTART_CLEAR_MS);
-    type('-l', words.join(' '));
-    sleep(ENTER_DELAY_MS);
-    type('Enter');
+    if (!waitForQuiet(session)) {
+      process.exitCode = 1;
+    } else {
+      type('-l', sender.startsWith('codex') ? '/new' : '/clear');
+      sleep(ENTER_DELAY_MS);
+      type('Enter');
+      sleep(RESTART_CLEAR_MS);
+      if (waitForQuiet(session)) {
+        type('-l', words.join(' '));
+        sleep(ENTER_DELAY_MS);
+        type('Enter');
+      }
+    }
   } else {
     const delay = Number(afterSeconds ?? RESTART_AFTER_SECONDS);
     spawn(process.execPath, [script, 'restart', sender, '--now', '--after', String(delay), ...words], {
       detached: true,
       stdio: 'ignore',
     }).unref();
-    process.stdout.write(`Restarting ${session} in ${delay} seconds. End your turn now.\n`);
+    process.stdout.write(
+      `Restarting ${session} once its turn ended and its prompt is empty, ${delay} seconds at the earliest. End your turn now.\n`,
+    );
   }
 } else if (command === 'down') {
   [DISPATCH_SESSION, ...[sender, ...words].filter(Boolean).map(sessionFor)].forEach((name) => {

package/content/skills/design-exploration/SKILL.md

@@ -115,6 +115,7 @@ answers. Variants are drawn at the same geometry, and one variant wins only agai
 
 ```bash
 et design sketch new <layer>/<name> --variants a,b --by <model id> [--like <layer>/<name>] [--variant-note a=<text>]… [--product <p>]   # each variant starts as a copy of the part
+et design sketch new <layer>/<name> <layer>/<name>… --variants a --by <model id>   # one change across several parts: one sketch, one ready, one merge
 et design sketch report <layer>/<name> --variant b --by <model id> "phone"         # tell Studio what you build now
 et design sketch report <layer>/<name> --variant b --by <model id> --done         # you stopped drawing b; Studio shows its frames
 et design sketch check [<layer>/<name>] [--fix]                                    # each variant laid over the product
@@ -123,6 +124,10 @@ et design sketch reject <layer>/<name> --variant b [--reason <text>] --by <model
 et design sketch reopen <layer>/<name> --variant b [--reason <text>] --by <model id> # only when the user takes b back; the rejection stays in the history
 ```
 
+One change across several parts (an alias removal, a token rename) is one sketch with several targets: each
+variant holds every target, and `ready` compares them all. `ready` and `preview` also name every part a `shared/`
+edit reaches.
+
 Variants are alternatives. A variant never stands for a state of another variant: a hidden or
 collapsed mode of variant d is a further state of d, not a variant e. Before you draw a new control,
 look for a control that already does the job (an active rail button that toggles its panel), and
@@ -162,7 +167,9 @@ variant imports it as `@shared/<path>`, and a shared file may import `@system/..
 changed holds its own copy at `<variant>/shared/<path>`; `@shared/<path>` finds that copy first, and a merge
 of that variant takes it. On a merge, `shared/` moves into
 the target's folder as `shared/` with its imports made relative; when no part imports it, it is
-dropped. Only the target may import it: a merge refuses while another part of the picked variant
+dropped. With several targets, each takes only the files it imports, directly or through another
+shared file; a file nobody imports goes back to the target that held it, and the merge refuses one no
+target held. `sketch new` refuses targets whose `shared/` folders hold one path with different contents. Only the target may import it: a merge refuses while another part of the picked variant
 does, so move that code into the part. `sketch new` prints each file it puts in `shared/`, for example
 the `shared/` folder of a merged page: edit it there, as part of the sketch, not in a variant copy.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/agent-rules",
-  "version": "0.1.0-next.28",
+  "version": "0.1.0-next.29",
   "repository": {
     "type": "git",
     "url": "https://github.com/ethlete-io/ethdk",