@timqi/pier 0.1.3 → 0.1.5

package/dist/cli.js

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 // What `pier` does when typed. Dispatch only, and no server imports until a
 // command needs them: `pier service install` must not open a database.
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import { accessSync, constants, realpathSync } from "node:fs";
+import { request } from "node:http";
+import { constants as osConstants } from "node:os";
 import { delimiter, join, resolve } from "node:path";
 import { parseArgs } from "node:util";
 import { fileURLToPath } from "node:url";
@@ -21,6 +23,11 @@ Usage
   pier restart                finish running turns first, then restart the service
   pier reload                 re-read channel config and recycle idle sessions
   pier backup                 snapshot pier.db before a manual update
+  pier vault run [ENV=NAME | NAME]... -- <command> [args...]
+                              run a command with named secrets in its env
+  pier slack <subcommand> ... Slack from a shell, token from the vault (pier slack --help)
+  pier task <command> ...     subagents and scheduled tasks from a shell (pier task --help)
+  pier web search|fetch ...   the public web through the provider's hosted tools (pier web --help)
   pier --version | --help
 
 Options for "service install"
@@ -33,13 +40,24 @@ The workbench is behind a password generated on first run and printed once.
 Under systemd that print lands in the journal: journalctl --user -u pier -e
 `;
 const say = (message) => void process.stdout.write(`${message}\n`);
-const fail = (message) => {
-    process.stderr.write(`pier: ${message}\n`);
+/** Every socket route answers from memory and the database, so a Pier that
+ *  takes longer than this is stuck, and an agent's shell must not hang with it. */
+const SOCKET_TIMEOUT_MS = 30_000;
+/** `/web` is the one route that waits on a provider: its own 90 s ceiling
+ *  (`websearch/run.ts`) answers first, so this only catches a stuck Pier. */
+const WEB_TIMEOUT_MS = 120_000;
+/** Typed on the binding: only then does a call narrow the code after it. */
+const die = (message) => {
+    process.stderr.write(`${message}\n`);
     process.exit(2);
 };
+const fail = (message) => die(`pier: ${message}`);
+const argv = process.argv.slice(2);
 const parsed = (() => {
     try {
         return parseArgs({
+            // `slack`, `task` and `web` own their options; only the name is parsed here.
+            args: argv[0] === "slack" || argv[0] === "task" || argv[0] === "web" ? [argv[0]] : argv,
             allowPositionals: true,
             strict: true,
             options: {
@@ -59,7 +77,8 @@ const parsed = (() => {
 })();
 const { values, positionals } = parsed;
 const [command, subcommand, ...extra] = positionals;
-if (extra.length)
+// `vault run` reads process.argv itself: parseArgs cannot say where the `--` was.
+if (command !== "vault" && extra.length)
     fail(`unexpected argument "${extra[0]}"`);
 const allowOnly = (allowed, usage) => {
     const invalid = Object.keys(values).find((key) => !allowed.includes(key));
@@ -100,6 +119,20 @@ else if (command === "update") {
 else if (command === "tools") {
     await tools(subcommand);
 }
+else if (command === "vault") {
+    await vault(subcommand, argv);
+}
+else if (command === "slack") {
+    await slack(argv.slice(1));
+}
+else if (command === "task") {
+    const { runTaskCli } = await import("./tasks/cli.js");
+    process.exitCode = await runTaskCli(argv.slice(1), (params) => askPier("/task", { params }));
+}
+else if (command === "web") {
+    const { runWebCli } = await import("./websearch/cli.js");
+    process.exitCode = await runWebCli(argv.slice(1), (params) => askPier("/web", { params }, WEB_TIMEOUT_MS));
+}
 else if (command === "restart" || command === "reload") {
     if (subcommand)
         fail(`unexpected argument "${subcommand}"`);
@@ -196,7 +229,130 @@ async function backup() {
     const path = backupDb(version, PIER_DB);
     process.stdout.write(path ? `backed up ${path}\n` : `no database yet — nothing to back up.\n`);
 }
-function commandPath(name) {
+/** Everything after `--` runs with the named secrets in its env — plain values
+ *  directly, `vt://` records through `vt inject`, which swaps them after the
+ *  operator's approval. Nothing here prints a value. */
+async function vault(action, argv) {
+    const usage = "usage: pier vault run [ENV=NAME | NAME]... -- <command> [args...]";
+    const split = argv.indexOf("--");
+    const cmd = argv.slice(split + 1);
+    if (action !== "run" || split < 2 || !cmd.length)
+        die(usage);
+    // `NAME` alone is `NAME=NAME`: names are env-var shaped so the common case needs no mapping.
+    const wanted = argv.slice(2, split).map((spec) => {
+        const parts = spec.split("=");
+        const [env, name = env] = parts;
+        if (parts.length > 2 || !env || !name || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(env))
+            die(usage);
+        return [env, name];
+    });
+    if (!wanted.length)
+        die(usage);
+    const values = await resolveSecrets([...new Set(wanted.map(([, name]) => name))]);
+    return inject(wanted, values, cmd);
+}
+/** `cmd` with each secret in its env; `approve` records go through `vt inject`,
+ *  which swaps them after approval. Never returns: the child's exit is ours. */
+function inject(wanted, values, cmd) {
+    const env = { ...process.env };
+    const records = [];
+    for (const [envName, name] of wanted) {
+        const hit = values[name];
+        env[envName] = hit.value;
+        if (hit.kind === "record")
+            records.push(envName);
+    }
+    let [file, ...args] = cmd;
+    if (records.length) {
+        if (!findCommand("vt")) {
+            const names = wanted.filter(([envName]) => records.includes(envName)).map(([, name]) => name);
+            die(`vault: vt is required for ${names.join(", ")} (approve level) and was not found`);
+        }
+        // Only the record-carrying variables are swapped; everything else passes through untouched.
+        [file, ...args] = ["vt", "inject", "--only-env", records.join(","), "--", ...cmd];
+    }
+    const child = spawn(file, args, { stdio: "inherit", env });
+    for (const signal of ["SIGINT", "SIGTERM"])
+        process.on(signal, () => child.kill(signal));
+    child.on("error", (err) => die(`vault: ${cmd[0]}: ${err.message}`));
+    child.on("exit", (code, signal) => {
+        // The shell's convention for a signal death, so a caller sees the same number it would without us.
+        process.exit(code ?? 128 + (signal ? osConstants.signals[signal] : 0));
+    });
+    return new Promise(() => { });
+}
+/** One request to the running Pier over its socket, signed with the caller's
+ *  session (`PIER_SESSION_ID`, the harness variable mapped by the shim). Not
+ *  running, silent, unreadable, or an identity or body Pier refuses, is one
+ *  `pier:` line and exit 2 before any route reads the answer. */
+async function askPier(path, body, timeout = SOCKET_TIMEOUT_MS) {
+    const { PIER_SOCK } = await import("./paths.js");
+    const answer = await new Promise((done, reject) => {
+        let responded = false;
+        const req = request({ socketPath: PIER_SOCK, method: "POST", path, headers: { "content-type": "application/json" }, timeout }, (res) => {
+            responded = true;
+            let raw = "";
+            const unreadable = () => reject(new Error(`unreadable answer from ${PIER_SOCK} (status ${String(res.statusCode ?? 0)})`));
+            res.on("data", (chunk) => (raw += chunk.toString()));
+            // A connection cut mid-body reports on the response, and `end` never comes.
+            res.on("error", unreadable);
+            res.on("end", () => {
+                try {
+                    done({ status: res.statusCode ?? 0, body: JSON.parse(raw) });
+                }
+                catch {
+                    unreadable();
+                }
+            });
+        });
+        req.on("timeout", () => req.destroy(new Error(`Pier did not answer within ${String(timeout / 1000)} s`)));
+        // A 413 arrives while the body is still being written; the EPIPE after it is not the news.
+        req.on("error", (err) => responded || reject(err));
+        req.end(JSON.stringify({ ...body, sessionId: process.env.PIER_SESSION_ID }));
+    }).catch((err) => 
+    // A crash leaves the file with nobody behind it: that is "not running" too.
+    err.code === "ENOENT" || err.code === "ECONNREFUSED"
+        ? fail(`Pier is not running (no ${PIER_SOCK})`)
+        : fail(err.message));
+    if (answer.status === 400 || answer.status === 403 || answer.status === 413)
+        fail(answer.body.error ?? `socket answered ${String(answer.status)}`);
+    return answer;
+}
+/** The running Pier's answer for `names`, every name present; any failure is
+ *  one `vault:` line and exit 2, so an agent reads words, not an empty variable. */
+async function resolveSecrets(names) {
+    const { status, body } = await askPier("/resolve", { names });
+    if (status === 404)
+        die(`vault: ${body.error ?? "unknown name"} — file it at ${body.file ?? "the Console (Settings → Vault)"}`);
+    const values = body.values;
+    if (status !== 200 || !values)
+        die(`vault: ${body.error ?? `socket answered ${String(status)}`}`);
+    const missing = names.find((name) => !values[name]);
+    if (missing)
+        die(`vault: no secret named ${missing}`);
+    return values;
+}
+/** `$SLACK_BOT_TOKEN` when set (the re-exec below, or a test); otherwise the
+ *  vault's `SLACK_TOKEN`. An `approve` record is only readable inside `vt
+ *  inject`, so the command re-runs itself under it — the agent never sees
+ *  the vault. Lazy: `--help` and usage errors never touch the socket. */
+async function slack(args) {
+    const token = async () => {
+        const given = process.env.SLACK_BOT_TOKEN;
+        if (given)
+            return given;
+        const values = await resolveSecrets(["SLACK_TOKEN"]);
+        const hit = values.SLACK_TOKEN;
+        if (hit.kind === "plain")
+            return hit.value;
+        // argv[1], not `pier` on PATH: the same build that is running answers.
+        return inject([["SLACK_BOT_TOKEN", "SLACK_TOKEN"]], values, [process.execPath, ...process.execArgv, process.argv[1], "slack", ...args]);
+    };
+    const { runSlackCli } = await import("./channels/slack-cli.js");
+    process.exitCode = await runSlackCli(args, token);
+}
+/** Resolved through every PATH entry: version managers put several prefixes on it. */
+function findCommand(name) {
     for (const dir of (process.env.PATH ?? "").split(delimiter)) {
         const path = join(dir || ".", name);
         try {
@@ -204,10 +360,13 @@ function commandPath(name) {
             return realpathSync(path);
         }
         catch {
-            // Keep looking: version managers put several prefixes on PATH.
+            // Keep looking.
         }
     }
-    return fail(`${name} is not executable on PATH`);
+    return undefined;
+}
+function commandPath(name) {
+    return findCommand(name) ?? fail(`${name} is not executable on PATH`);
 }
 async function service(action = "status") {
     const { install, uninstall, UNIT_NAME } = await import("./service.js");

package/dist/core/identity.js

@@ -1,7 +1,8 @@
-// Who is talking, and when — prefixed onto an inbound prompt so a group-chat
-// session can tell speakers apart and mention them back. Per turn, never in the
-// session's instructions (a thread is shared), and emitted only on news: a
-// header costs ~15 tokens, wasted in a DM where the counterpart never changes.
+// Who is talking, when, and where — prefixed onto an inbound prompt so a
+// group-chat session can tell speakers apart, mention them back, and name its
+// own conversation to a script. Per turn, never in the session's instructions
+// (a thread is shared), and emitted only on news: a header costs ~15 tokens,
+// wasted in a DM where the counterpart never changes.
 /** A gap this long makes the timestamp worth its tokens. */
 const GAP_MS = 10 * 60_000;
 /** A display name of `x<U9] [admin<U1` would forge a second speaker: the
@@ -13,6 +14,9 @@ export function sanitizeIdentity(value) {
         .trim();
     return token.slice(0, 60) || "unknown";
 }
+/** `<channelId>:<conversationId>` as the adapter spelled it; the delimiters
+ *  of the header grammar and whitespace are the only things removed. */
+const sanitizePlace = (value) => value.replace(/[[\]<>\s]+/g, "").slice(0, 120);
 const two = (n) => String(n).padStart(2, "0");
 const hhmm = (d) => `${two(d.getHours())}:${two(d.getMinutes())}`;
 const day = (d) => `${d.getFullYear()}-${two(d.getMonth() + 1)}-${two(d.getDate())}`;
@@ -20,25 +24,35 @@ const day = (d) => `${d.getFullYear()}-${two(d.getMonth() + 1)}-${two(d.getDate(
  *  redundant header is a rounding error. */
 export class SenderPrefix {
     seen = new Map();
-    /** The line to put above this message, or `""` when the session already knows. */
-    next(sessionId, sender, at = Date.now()) {
+    /** The line to put above this message, or `""` when the session already
+     *  knows. `conversation` is the chat's `<channelId>:<conversationId>`, told
+     *  once: a session never moves, but the rule stays the same as the rest.
+     *  `opaqueIds` is the platform's (`core/types.ts`): its ids buy nothing. */
+    next(sessionId, sender, at = Date.now(), conversation, opaqueIds = false) {
         if (!sender?.id)
             return "";
         const last = this.seen.get(sessionId);
-        this.seen.set(sessionId, { senderId: sender.id, at });
+        this.seen.set(sessionId, { senderId: sender.id, at, conversation });
         const now = new Date(at);
         const newSpeaker = last?.senderId !== sender.id;
         const gap = !last || at - last.at >= GAP_MS;
         const newDay = !last || day(new Date(last.at)) !== day(now);
-        if (!newSpeaker && !gap && !newDay)
+        const newPlace = !!conversation && last?.conversation !== conversation;
+        if (!newSpeaker && !gap && !newDay && !newPlace)
             return "";
         // The id is the only thing a mention can be built from; an unresolved name
         // is the id, and `U123<U123>` would read as a broken record.
         const id = sanitizeIdentity(sender.id);
         const label = sanitizeIdentity(sender.name);
-        const who = newSpeaker ? (label === id ? `<${id}>` : `${label}<${id}>`) : "";
-        const when = gap || newDay ? `${newDay ? `${day(now)} ` : ""}${hhmm(now)}` : "";
-        return `[${[who, when].filter(Boolean).join(" ")}]`;
+        const named = opaqueIds ? label : label === id ? `<${id}>` : `${label}<${id}>`;
+        const who = newSpeaker ? named : "";
+        // A bare name has no `<>` to be told apart by, so it is only unambiguous
+        // next to the time: with opaque ids the clock is written whenever it is.
+        const clock = gap || newDay || (opaqueIds && !!who);
+        const when = clock ? `${newDay ? `${day(now)} ` : ""}${hhmm(now)}` : "";
+        const place = opaqueIds ? conversation?.split(":")[0] : conversation;
+        const where = newPlace && place ? sanitizePlace(place) : "";
+        return `[${[who, when, where].filter(Boolean).join(" ")}]`;
     }
     forget(sessionId) {
         this.seen.delete(sessionId);
@@ -47,17 +61,26 @@ export class SenderPrefix {
 export const withPrefix = (prefix, text) => prefix ? `${prefix}\n${text}` : text;
 // Only the shapes `next()` emits, newline included: a human typing
 // `[14:23] on my way` is body text and must come back untouched.
-const HEADER = /^\[(?:([^\n[\]<>]*)<([^\n[\]<>]+)>)? ?((?:\d{4}-\d{2}-\d{2} )?\d{1,2}:\d{2})?\]\n/;
+const TIME = String.raw `(?<when>(?:\d{4}-\d{2}-\d{2} )?\d{1,2}:\d{2})`;
+const WITH_ID = new RegExp(String.raw `^\[(?:(?<name>[^\n[\]<>]*)<(?<id>[^\n[\]<>]+)>)? ?${TIME}? ?(?<where>[a-z]+:[^\s[\]<>]+)?\]\n`);
+/** The opaque-ids shape: a name with no `<>`, told apart from body text by the
+ *  time that always follows it, and a platform with no conversation after it.
+ *  A line of its own reading `[meeting 14:23]` is the price. */
+const NAMED = new RegExp(String.raw `^\[(?<name>[^\n[\]<>]*?) ${TIME}(?: (?<where>[a-z]+))?\]\n`);
 /** Read back a header this module wrote: the prefix is for the model, and a
  *  surface showing a stored message renders the speaker its own way. */
 export function splitSpeaker(text) {
-    const m = HEADER.exec(text);
-    if (!m?.[2] && !m?.[3])
+    const head = WITH_ID.exec(text);
+    const { id, when, where } = head?.groups ?? {};
+    // A name on its own proves nothing: try the shape that requires a time.
+    const m = id || when || where ? head : NAMED.exec(text);
+    if (!m?.groups)
         return { text };
     return {
-        ...(m[1] ? { name: m[1] } : {}),
-        ...(m[2] ? { id: m[2] } : {}),
-        ...(m[3] ? { when: m[3] } : {}),
+        ...(m.groups.name ? { name: m.groups.name } : {}),
+        ...(m.groups.id ? { id: m.groups.id } : {}),
+        ...(m.groups.when ? { when: m.groups.when } : {}),
+        ...(m.groups.where ? { where: m.groups.where } : {}),
         text: text.slice(m[0].length),
     };
 }
@@ -85,3 +108,24 @@ export function readableTitle(title) {
         .trim();
     return said || title;
 }
+/** How a session is named where it is announced (a push, a handoff): its
+ *  readable title, else its directory. Never empty — a listing that could
+ *  not answer must not silence the message. One line: every caller puts it
+ *  inside emphasis or a button, where a newline breaks the markup. */
+export const sessionLabel = (s) => readableTitle(s?.title)?.replace(/\s+/g, " ").trim() || s?.cwd.split("/").filter(Boolean).at(-1) || "Pier session";
+/** Distinct directories, newest session first: the ground `projectCwds` picks
+ *  from. */
+export const distinctCwds = (list) => [...new Set([...list].sort((a, b) => b.createdAt - a.createdAt).map((s) => s.cwd))];
+/** The distinct directories less the worktrees: `wt` puts a checkout beside its
+ *  repository as `<repo>.<branch>`, and the next conversation about a project
+ *  belongs in the project. A worktree with no such sibling stays. What every
+ *  directory picker — web New-session menu, Settings scope, IM panel — offers. */
+export function projectCwds(list) {
+    const all = distinctCwds(list);
+    const known = new Set(all);
+    return all.filter((cwd) => {
+        const slash = cwd.lastIndexOf("/");
+        const dot = cwd.indexOf(".", slash + 2); // not a leading dot: `.pier` is a name
+        return dot < 0 || !known.has(cwd.slice(0, dot));
+    });
+}

package/dist/core/reply.js

@@ -24,10 +24,14 @@ conventions:
   including humans talking to each other: stay silent rather than acknowledge
   what was not addressed to you.
 
-A message may start with \`[name<id> time]\` — the sender, added by Pier, not
-typed by them. It appears only on a change — new speaker, a ~10-minute gap, a
-new day — so the last one still applies; a gap alone shows as time only, like
-\`[14:23]\`. Use that \`id\` to mention someone; never ask for their own.
+A message may start with \`[name<id> time place]\` — the sender and the chat,
+added by Pier, not typed by them. It appears only on a change — new speaker, a
+~10-minute gap, a new day — so the last one still applies; a gap alone shows as
+time only, like \`[14:23]\`. Use that \`id\` to mention someone; never ask for
+their own. \`place\` is \`<platform>:<conversation>\` (Slack:
+\`slack:<channel>/<thread_ts>\`), said once per session: the channel and thread a
+script takes. Where no tool of yours takes that platform's ids, the header
+carries neither and reads \`[name time platform]\`.
 `;
 /** Deployment facts an agent cannot discover: a guessed path is wrong wherever
  *  `PIER_HOME` moved and fails as "nothing is configured"; GPT models carry
@@ -56,14 +60,7 @@ export function originLabel(origin) {
     if (origin.kind !== "task-message") {
         return origin.kind === "task-delegation" ? "\u25b6 delegated task" : "\u21a9 task callback";
     }
-    const kinds = {
-        steer: "\u270e steer",
-        follow_up: "\uff0b follow-up",
-        progress: "\u25c7 progress",
-        decision: "\u2753 decision needed",
-        reply: "\u21a9 reply",
-    };
-    return `from a subagent \u00b7 ${kinds[origin.messageKind] ?? origin.messageKind}`;
+    return `from a supervisor \u00b7 ${origin.messageKind === "steer" ? "\u270e steer" : "\uff0b follow-up"}`;
 }
 /** Is a turn coming once this note is posted? On IM the note is the only
  *  message that turn has to wear the 👀; an error note reports a turn that
@@ -106,6 +103,8 @@ export const quietLabel = (silence) => silence ? `stayed silent — ${silence}`
 export const isSilentReply = (reply) => !reply.text.trim() && reply.suggestions.length === 0;
 /** How a reasoning level is spelled wherever a human reads it. */
 export const thinkingLabel = (level) => level === "xhigh" ? "Extra high" : level[0].toUpperCase() + level.slice(1);
+/** `max` characters, the last one an ellipsis when something was cut. */
+export const cut = (text, max) => (text.length > max ? `${text.slice(0, max - 1)}…` : text);
 /** 1200 → "1.2K", 12_000 → "12K" — absolute token counts read badly inline. */
 export const compact = (n) => {
     if (n < 1000)
@@ -130,7 +129,12 @@ const MAX_SUGGESTIONS = 5;
 /** A deliberate non-answer. Stripped here so an adapter needs no new concept:
  *  an empty turn already posts nothing and retires its per-turn UI. The reason
  *  stays in the transcript, auditable without being broadcast. */
-const SILENT = /<silent>([\s\S]*?)<\/silent>/gi;
+// A model has been seen emitting `<s<U+200B>ilent>`: zero-width characters inside
+// the tag, which would post the literal tag to a channel instead of silence.
+const ZW = String.raw `[\u200B-\u200D\u2060\uFEFF]*`;
+const tag = (literal) => literal.split("").join(ZW);
+const SILENT = new RegExp(`${tag("<silent>")}([\\s\\S]*?)${tag("</silent>")}`, "gi");
+const SILENT_TAG = new RegExp(`<(\\/?)${tag("silent>")}`, "gi");
 /** Why the agent stayed quiet; hidden from the chat, shown on the workbench,
  *  where a silent turn must not look like a broken one. */
 export function silentReason(markdown) {
@@ -193,8 +197,8 @@ export function stableBlockEnd(markdown, from = 0) {
         else if (open && run[0] === open[0] && run.length >= open.length && !fence?.[2]?.trim())
             open = "";
         if (!open && (!run || silent)) {
-            for (const tag of line.matchAll(/<(\/?)silent>/gi))
-                silent = !tag[1];
+            for (const t of line.matchAll(SILENT_TAG))
+                silent = !t[1];
         }
         pending = -1;
         prev = line;

package/dist/core/router.js

@@ -52,6 +52,7 @@ export class Router {
     hub;
     resolve;
     sessionIdOf;
+    chatKeyOf;
     byKey = new Map();
     bySession = new Map();
     /** Resolves in flight: two surfaces asking at once must share one session
@@ -70,10 +71,14 @@ export class Router {
     /** The durable chat → session mapping, read before opening: a chat and the
      *  workbench asking for one transcript must share one lock and one object.
      *  Undefined for a chat that has none yet. */
-    sessionIdOf = () => undefined) {
+    sessionIdOf = () => undefined, 
+    /** The inverse: the durable chat of a session an alias is opening, so the
+     *  chat is the delivery key from the first turn (wired in main.ts). */
+    chatKeyOf = () => undefined) {
         this.hub = hub;
         this.resolve = resolve;
         this.sessionIdOf = sessionIdOf;
+        this.chatKeyOf = chatKeyOf;
     }
     registerChannel(channel) {
         this.channels.set(channel.id, channel);
@@ -233,7 +238,11 @@ export class Router {
                 // triggers, so the answer has a visible cause. The hub carries it whole.
                 if (payload.type === "system-input") {
                     const channel = this.channels.get(key.channelId);
-                    channel?.notify(key.conversationId, { text: digest(payload.text), origin: payload.origin })
+                    channel?.notify(key.conversationId, {
+                        text: digest(payload.text),
+                        origin: payload.origin,
+                        at: payload.at,
+                    })
                         .catch((err) => {
                         log.error(`notify ${key.channelId} failed`, err);
                         this.hub.emit(session.id, {
@@ -263,6 +272,13 @@ export class Router {
             }),
         };
         this.bySession.set(session.id, attached);
+        // The durable chat outranks the alias that happened to open the session
+        // first (a restart, the web speaking first), same rule as `reached`.
+        const chat = isAlias(key) ? this.chatKeyOf(session.id) : undefined;
+        if (chat) {
+            this.byKey.set(keyOf(chat), session);
+            attached.key = chat;
+        }
     }
     /** An adapter's send is several platform calls (chunks, then attachments),
      *  so two answers left to overlap interleave in the chat. Per conversation:
@@ -567,7 +583,11 @@ export class Router {
             this.refuseDraining(msg.key);
         this.spokenTo?.(session.id);
         const { action, text } = decide(msg, session.state);
-        const prompt = withPrefix(this.senders.next(session.id, msg.sender), text);
+        // A chat is named so the agent can hand it to a script (skills/pier-slack);
+        // an alias names nothing a shell could reach.
+        const where = isAlias(msg.key) ? undefined : keyOf(msg.key);
+        const opaque = this.channels.get(msg.key.channelId)?.opaqueIds;
+        const prompt = withPrefix(this.senders.next(session.id, msg.sender, Date.now(), where, opaque), text);
         log.debug(`${action} ${keyOf(msg.key)} → session ${session.id} (${String(prompt.length)} chars)`);
         // A rejected call surfaces on the event stream, never as a throw across the seam.
         session[action](prompt).catch((err) => {

package/dist/db.js

@@ -271,6 +271,39 @@ const MIGRATIONS = [
   );
   -- Every row goes so the next scan re-reads each transcript and fills the table above.
   DELETE FROM session_index;
+  `,
+    // 23 — the vault: named secrets `pier vault run` injects into one command.
+    `
+  -- name is an env-var name (^[A-Z][A-Z0-9_]{0,63}$). value is a sealed
+  -- envelope (auto) or a vt:// record (approve): the shape is the level.
+  CREATE TABLE vault (
+    name TEXT PRIMARY KEY,
+    value TEXT NOT NULL,
+    updated_at INTEGER NOT NULL
+  );
+  `,
+    // 24 — channel credentials move into the vault under fixed names (channels/config.ts).
+    `
+  -- The blob moves verbatim: same DEK, no decrypt, so this runs locked like
+  -- every migration. A name filed in the vault first wins (DO NOTHING); the
+  -- channel copy is dropped either way.
+  WITH moved(platform, path, name) AS (VALUES
+    ('slack', '$.token', 'SLACK_TOKEN'), ('slack', '$.appToken', 'SLACK_APP_TOKEN'),
+    ('lark', '$.token', 'LARK_APP_ID'), ('lark', '$.appToken', 'LARK_APP_SECRET'))
+  INSERT INTO vault(name, value, updated_at)
+    SELECT moved.name, json_extract(channels.json, moved.path), CAST(strftime('%s', 'now') AS INTEGER) * 1000
+    FROM moved JOIN channels ON channels.platform = moved.platform
+    WHERE json_extract(channels.json, moved.path) <> ''
+    ON CONFLICT(name) DO NOTHING;
+  UPDATE channels SET json = json_remove(json, '$.token', '$.appToken');
+  `,
+    // 25 — the mid-run decision channel is gone; a control message is steer or follow_up.
+    `DELETE FROM task_messages WHERE json_extract(json, '$.kind') IN ('progress', 'decision', 'reply');`,
+    // 26 — a session created from the panel is re-created from its own launch
+    // record (channels/conversations.ts); the index serves the session → thread lookups.
+    `
+  ALTER TABLE conversations ADD COLUMN launch TEXT;
+  CREATE INDEX conversations_session ON conversations(session_id);
   `,
 ];
 /** `BEGIN IMMEDIATE`: taking the write lock up front turns a race with another