@@ -10,6 +10,12 @@
 # Distributable disk images (produced by scripts/make-dmg.sh)
 /*.dmg
 
+# Agent Sketch runtime state — per-workspace (autosaved session, sketches, exported runs); not source
+/.atompp/
+
+# Unsigned app artifacts pulled from the release CI and signed locally (see docs/RELEASING.md §7)
+/UNSIGNED-*.app.zip
+
 # Node / OS noise
 node_modules/
 .DS_Store
 
@@ -118,9 +118,47 @@ files). Costs shown are planning estimates from list prices — the provider bil
 
 | Phase | Deliverable |
 |---|---|
-| **SK2** | **Tool-using nodes**: a node can run the full `agent.js` loop (read/edit/run with Keep-Undo review + per-run checkpoint) so a sketched flow actually edits the workspace; live streamed output in the inspector; run history. |
-| **SK3** | **Topologies**: coordinator/hierarchical patterns (a queen node that dispatches + collects, ruflo-style), conditional edges, retry/verify loops; per-flow token budgets with early stop. |
-| **SK4** | **Interop**: import/export ruflo swarm configs; publish sketches as shareable templates; sketch → `atompp.ai` chat-agent handoff ("run this flow on the current repo"). |
+| **SK1.3** | **Prompt → whole flow** (shipped): type a plain-English description into the (empty) board and the active model designs a complete DAG — `generateFlow()` returns `{goal, nodes, edges}`, normalized to a loadable sketch and auto-laid-out. Empty canvas = *build*; populated canvas = *edit* (the existing ops command). |
+| **SK2** | **Tool-using + connector nodes**: a node runs the full `agent.js` loop (read/edit/run with Keep-Undo review) so a sketched flow edits the workspace; **connector nodes actually act** — Telegram/Slack post, email send, webhook call, file write — behind credentials + per-flow permission (see §4). |
+| **SK3** | **Triggers & topologies**: a `scheduler`/`webhook-trigger` root fires the flow on a **cron cadence / inbound event** (Managed-Agents-style scheduled deployment); coordinator/hierarchical patterns, conditional edges, retry/verify loops; per-flow token budgets. |
+| **SK4** | **Interop**: import/export ruflo swarm configs; publish sketches as shareable templates; sketch → `atompp.ai` chat-agent handoff. |
+
+## 4. Node tiers: text → tools → connectors → triggers
+
+Not every node is the same *kind* of thing. The catalog now spans four execution tiers; SK1 runs them
+all as **text-only** (a connector emits the payload it *would* send; a trigger emits the context it
+*would* fire with), and later phases make the side-effecting tiers real — each with the safety it needs.
+
+| Tier | Examples | SK1 (today) | Later — what "real" needs |
+|---|---|---|---|
+| **Text** | coder, researcher, news-collector, copywriter, editor-in-chief | one LLM turn, in/out text | — (this is the whole SK1 model) |
+| **Tool / file** | file-writer, and any node run through `agent.js` | outputs the file + contents it *would* write | SK2: writes via the same **Keep/Undo review + per-run checkpoint** the chat agent uses |
+| **Connector (actuator)** | telegram-publisher, email-sender, slack-publisher, webhook-caller | outputs the exact message/email/HTTP payload it *would* send | SK2: real send. Needs **(a)** credentials in SecretStorage/keychain (bot token, SMTP creds — never in the sketch file), **(b)** a **per-flow send permission** the user grants once (sending is outward-facing — mirrors the harness "Explicit permission" rule: publishing/messaging requires a clear yes), **(c)** an **allowlist** (which chat/recipient/host), **(d)** a dry-run preview (show the message, click Send) |
+| **Trigger** | scheduler (cron), webhook-trigger | the ROOT node; outputs the run context ("collect news since the last run at <time>") | SK3: a **scheduled/triggered run** — cron cadence or inbound webhook fires the downstream DAG unattended. Maps onto the Managed-Agents *scheduled deployment* pattern (cron + per-firing run records) or a local scheduler; ties into the run-persistence archive so every firing is logged |
+
+**Why the tiering is the point:** it keeps SK1 shippable and safe (nothing sends, nothing runs on a
+timer — you can design and cost a Telegram-publishing pipeline today and see exactly what it *would*
+post), while giving a clear, honest path to real automation where each dangerous capability (send,
+write, schedule) is gated by the credential + permission model it deserves. The BYOK rule is unchanged
+— connectors use the *user's own* integration credentials; Atom++ never proxies or stores the content.
+
+### Worked example (what the generator produces)
+Prompt: *"5 agents collect recent AI & agentic-AI news; a head-of-press-release edits them; a
+copywriter verifies and composes one post; publish it to Telegram; run it daily."* →
+
+```
+daily-trigger (scheduler)
+  → [ai-research · agentic · products · funding · safety]  (5 news-collectors, parallel)
+      → press-desk (press-editor)
+        → copywriter (copywriter)
+          → editor-approval (editor-in-chief)
+            → telegram-post (telegram-publisher)
+```
+
+Today that runs text-only: the collectors produce cited news summaries, the copywriter composes the
+post, and `telegram-post` outputs the exact Markdown message it *would* send — metered, costed, and
+persisted. SK2 turns `telegram-post` into a real send (bot token + "allow send to @channel"); SK3
+makes `daily-trigger` actually fire the flow every morning.
 
 ## 3. Attribution & licensing
 Agent names/roles derived from ruflo's `.claude/agents/` library (MIT © 2024–2026 ruvnet) — metadata
 
@@ -787,6 +787,12 @@
         placeholder="Goal of this flow — every agent sees it (e.g. “Build and test a rate limiter”)"
       />
       <button id="save">Save</button>
+      <button
+        id="export"
+        title="Export this run as a Markdown document you can share"
+      >
+        Export
+      </button>
       <select
         id="tplSel"
         title="Load a ready-made template (or drag one from the palette)"
@@ -929,6 +935,8 @@ <h3 id="modalTitle"></h3>
         consensus: "#b48ead",
         performance: "#e5a56b",
         data: "#61c8af",
+        content: "#d99ae0",
+        connectors: "#e0b062",
         specialized: "#9aa5ce",
       };
 
@@ -949,6 +957,8 @@ <h3 id="modalTitle"></h3>
       let truncByNode = {}; // nodeId -> true when the node hit the per-node token cap
       let turnsByNode = {}; // nodeId -> how many turns it took (auto-continuation)
       let ACTIVE_TIERS = null; // {fast,balanced,powerful} model ids for the active provider
+      let persistTimer = null;
+      let persistReady = false; // gate autosave until the initial session restore is done
       let pan = { x: 40, y: 20 };
       let zoom = 1;
       const clampZoom = (z) => Math.max(0.2, Math.min(2.5, z));
@@ -1329,7 +1339,11 @@ <h3 id="modalTitle"></h3>
           svg.appendChild(p);
         }
         $("tNodes").textContent = nodes.length;
+        $("cmd").placeholder = nodes.length
+          ? "Ask the board…  e.g. “add a security-auditor after coder”, “set every agent to Opus 4.8”"
+          : "Describe a flow to build…  e.g. “5 agents collect AI news, a copywriter composes a post, publish to Telegram”";
         refreshTotals();
+        schedulePersist(); // every mutation flows through render(); debounced so drags coalesce
       }
 
       function tryConnect(from, to) {
@@ -1616,6 +1630,13 @@ <h3 id="modalTitle"></h3>
       $("stop").onclick = () => vs.postMessage({ type: "stop" });
       $("save").onclick = () =>
         vs.postMessage({ type: "save", sketch: serialize() });
+      // name/goal don't go through render(), so persist them directly.
+      $("name").oninput = schedulePersist;
+      $("goal").oninput = schedulePersist;
+      $("export").onclick = () => {
+        if (!Object.keys(usageByNode).length && !nodes.length) return;
+        vs.postMessage({ type: "exportMarkdown", session: fullSession() });
+      };
       $("loadSel").onchange = () => {
         const v = $("loadSel").value;
         $("loadSel").value = "";
@@ -1659,6 +1680,7 @@ <h3 id="modalTitle"></h3>
         turnsByNode = {};
         select(null);
         render();
+        persistNow(); // overwrite the saved session so a reopen doesn't restore the cleared graph
         notify("Sketch cleared.", "info");
       };
 
@@ -1757,11 +1779,76 @@ <h3 id="modalTitle"></h3>
         if (e.target === $("modal")) closeModal(false); // click the backdrop = cancel
       };
 
+      // ---------- session autosave (never lose a paid run on reload) ----------
+      // Bundle the canvas + the last run's results and mirror it to disk (.atompp/.session.json,
+      // written by the extension). This is app-internal restore state, not a deliverable.
+      function fullSession() {
+        const s = serialize(); // { name, goal, nodes, edges }
+        return {
+          name: s.name,
+          goal: s.goal,
+          nodes: s.nodes,
+          edges: s.edges,
+          results: {
+            outputs: outputsByNode,
+            usage: usageByNode,
+            turns: turnsByNode,
+            trunc: truncByNode,
+          },
+        };
+      }
+      function schedulePersist() {
+        if (!persistReady) return;
+        if (persistTimer) clearTimeout(persistTimer);
+        persistTimer = setTimeout(() => {
+          persistTimer = null;
+          vs.postMessage({ type: "persist", session: fullSession() });
+        }, 800); // debounce drags/typing into one write
+      }
+      function persistNow() {
+        if (!persistReady) return;
+        if (persistTimer) {
+          clearTimeout(persistTimer);
+          persistTimer = null;
+        }
+        vs.postMessage({ type: "persist", session: fullSession() });
+      }
+      // Restore the canvas + last-run meters from a saved session (on reopen). Results are kept
+      // only for surviving node ids so a hand-edited/renamed graph can't graft stale outputs.
+      function restoreSession(sess) {
+        const s = sanitizeSketch(sess, { keepUnknown: true }); // never drop the user's own run
+        if (!s.nodes.length) return false;
+        $("name").value = s.name;
+        $("goal").value = s.goal;
+        nodes = s.nodes;
+        edges = s.edges;
+        seq = nodes.reduce(
+          (mx, n) =>
+            Math.max(mx, parseInt(String(n.id).replace(/\D/g, "")) || 0),
+          0,
+        );
+        const ids = new Set(nodes.map((n) => n.id));
+        const pick = (o) =>
+          Object.fromEntries(
+            Object.entries(o || {}).filter(([k]) => ids.has(k)),
+          );
+        const r = sess.results || {};
+        usageByNode = pick(r.usage);
+        outputsByNode = pick(r.outputs);
+        turnsByNode = pick(r.turns);
+        truncByNode = pick(r.trunc);
+        select(null);
+        render();
+        fitView();
+        return true;
+      }
+
       // Loaded sketches come from on-disk JSON (hand-editable) or templates — coerce to a safe,
       // renderable shape so a malformed/hostile file can't break the canvas, collide node ids, or
       // inject a prototype-polluting key. Drops unknown-agent nodes and dangling/self/dup edges.
-      function sanitizeSketch(s) {
+      function sanitizeSketch(s, opts) {
         s = s && typeof s === "object" ? s : {};
+        const keepUnknown = !!(opts && opts.keepUnknown);
         const str = (v, d) => (typeof v === "string" ? v : d || "");
         const num = (v) => (typeof v === "number" && isFinite(v) ? v : 0);
         const nodes = [];
@@ -1770,7 +1857,10 @@ <h3 id="modalTitle"></h3>
           if (!n || typeof n !== "object") continue;
           const id = String(n.id == null ? "" : n.id);
           if (!id || id.indexOf("__") === 0 || ids.has(id)) continue; // empty / __proto__ / dup
-          if (!CAT.byId.has(n.agentId)) continue; // unknown agent
+          // Restoring the user's own session keeps unknown-agent nodes (an extension update may have
+          // renamed/removed an agent id) so a catalog change can't wipe a paid run — render() falls
+          // back to generic styling. Loading templates/files still drops unknown agents.
+          if (!keepUnknown && !CAT.byId.has(n.agentId)) continue;
           ids.add(id);
           nodes.push({
             id,
@@ -1971,8 +2061,14 @@ <h3 id="modalTitle"></h3>
         cmdBusy = true;
         $("cmdbar").classList.add("busy");
         $("cmdRun").disabled = true;
-        setStatus("Thinking…", "info");
-        vs.postMessage({ type: "command", text, sketch: serialize() });
+        // Empty canvas → BUILD a whole flow from the prompt; populated canvas → EDIT it with ops.
+        if (nodes.length) {
+          setStatus("Thinking…", "info");
+          vs.postMessage({ type: "command", text, sketch: serialize() });
+        } else {
+          setStatus("Designing your flow…", "info");
+          vs.postMessage({ type: "generate", text });
+        }
       }
       function endCommand() {
         cmdBusy = false;
@@ -2022,7 +2118,17 @@ <h3 id="modalTitle"></h3>
                 (t) =>
                   '<option value="' + esc(t.id) + '">' + esc(t.name) + "</option>",
               ).join("");
-            render();
+            // Restore the canvas + last run's results so a folder reopen doesn't lose work.
+            let restored = false;
+            if (m.session) restored = restoreSession(m.session);
+            if (!restored) render();
+            persistReady = true; // arm autosave only after restore, so it can't clobber the save
+            if (restored)
+              notify(
+                "Restored your last session" +
+                  (Object.keys(usageByNode).length ? " (with run results)" : ""),
+                "info",
+              );
             break;
           }
           case "runStart":
@@ -2065,7 +2171,7 @@ <h3 id="modalTitle"></h3>
             const n = nodes.find((n) => n.id === m.id);
             if (n) n._status = "done";
             usageByNode[m.id] = m.usage;
-            outputsByNode[m.id] = m.preview || "";
+            outputsByNode[m.id] = m.output || ""; // full text; feeds autosave + the inspector
             if (m.truncated) truncByNode[m.id] = true;
             if (m.turns) turnsByNode[m.id] = m.turns;
             if (selId === m.id) select(m.id);
@@ -2110,12 +2216,16 @@ <h3 id="modalTitle"></h3>
             }
             if (selId) select(selId);
             render();
+            persistNow(); // the run's results are the expensive data — save them immediately
             break;
           }
           case "runError":
             setRunning(false);
             flashErr(m.message);
             break;
+          case "exported":
+            notify("Exported run → " + (m.rel || "Markdown"), "success");
+            break;
           case "uiError":
             // A save/load/clipboard/command failure — NOT a run outcome, so don't touch run state.
             endCommand();
@@ -2132,6 +2242,40 @@ <h3 id="modalTitle"></h3>
             }
             applyOps(m.ops);
             break;
+          case "generatedFlow": {
+            endCommand();
+            $("cmd").value = "";
+            if (running) {
+              notify("Flow ignored — a run is in progress.", "warn");
+              break;
+            }
+            const g = sanitizeSketch(m.sketch);
+            if (!g.nodes.length) {
+              notify("The generated flow was empty — try more detail.", "warn");
+              break;
+            }
+            $("name").value = g.name;
+            $("goal").value = g.goal;
+            nodes = g.nodes;
+            edges = g.edges;
+            seq = nodes.reduce(
+              (mx, n) =>
+                Math.max(mx, parseInt(String(n.id).replace(/\D/g, "")) || 0),
+              0,
+            );
+            usageByNode = {};
+            outputsByNode = {};
+            truncByNode = {};
+            turnsByNode = {};
+            select(null);
+            autoLayout(); // the generated nodes have no positions — arrange + fit
+            persistNow();
+            notify(
+              "Built a " + nodes.length + "-agent flow from your prompt.",
+              "success",
+            );
+            break;
+          }
           case "saved":
             $("loadSel").innerHTML =
               '<option value="">Load…</option>' +