instar 1.3.597 → 1.3.598

package/dist/core/PlacementResponderReader.d.ts

@@ -0,0 +1,45 @@
+/**
+ * PlacementResponderReader — resolves WHICH machine served a reply, for the
+ * RealChannelDriver's injected `resolveResponderMachine` seam
+ * (docs/specs/live-user-channel-proof-standard.md §5.6 — the deterministic
+ * cross-machine proof). It maps a (surface, channelId) to the topic that
+ * `GET /pool/placement?topic=N` is keyed on, reads the authoritative owner, and
+ * returns that machine id.
+ *
+ * Why this is the right reader: `/pool/placement` is the authoritative placement
+ * surface (it proxies to the lease-holder, so any machine can answer), and its
+ * `owner` field is the machine currently serving the topic — exactly "who replied"
+ * after a transfer. We read `owner` (not `pinnedTo`): a pin is the INTENT to place;
+ * `owner` is who actually holds it. For the capstone that distinction is the whole
+ * point — a pin that didn't move the seat is the original bug.
+ *
+ * Parameterized for testability: the HTTP GET + the (surface, channelId)→topicId
+ * mapping are injected, so this is unit-testable with no live server. MUST NOT throw
+ * on a transient read error — it returns null so the RealChannelDriver degrades to an
+ * unattributed reply rather than failing the whole scenario.
+ */
+import type { Surface } from './LiveTestArtifactStore.js';
+export interface PlacementResult {
+    owner: string | null;
+    ownerNickname?: string | null;
+}
+export interface PlacementResponderReaderDeps {
+    /**
+     * Map (surface, channelId) → the topic id `/pool/placement` is keyed on. For
+     * telegram, channelId IS the topic. For slack, the caller injects the
+     * channel→topic resolution (the SlackAdapter's session keying). Return null when
+     * the channel doesn't map to a placement-tracked topic.
+     */
+    topicForChannel: (surface: Surface, channelId: string) => string | null;
+    /** GET /pool/placement?topic=<id> → the placement (owner). Throwing/transient errors are tolerated. */
+    fetchPlacement: (topicId: string) => Promise<PlacementResult | null>;
+    logger?: (m: string) => void;
+}
+export declare class PlacementResponderReader {
+    private readonly d;
+    constructor(deps: PlacementResponderReaderDeps);
+    private log;
+    /** The function shape RealChannelDriver injects: (surface, channelId) → machine id | null. */
+    resolve: (surface: Surface, channelId: string) => Promise<string | null>;
+}
+//# sourceMappingURL=PlacementResponderReader.d.ts.map

package/dist/core/PlacementResponderReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlacementResponderReader.d.ts","sourceRoot":"","sources":["../../src/core/PlacementResponderReader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAQH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAE1D,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,4BAA4B;IAC3C;;;;;OAKG;IACH,eAAe,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IACxE,uGAAuG;IACvG,cAAc,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;IACrE,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAED,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAA+B;gBACrC,IAAI,EAAE,4BAA4B;IAE9C,OAAO,CAAC,GAAG;IAEX,8FAA8F;IAC9F,OAAO,GAAU,SAAS,OAAO,EAAE,WAAW,MAAM,KAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiB3E;CACH"}

package/dist/core/PlacementResponderReader.js

@@ -0,0 +1,46 @@
+/**
+ * PlacementResponderReader — resolves WHICH machine served a reply, for the
+ * RealChannelDriver's injected `resolveResponderMachine` seam
+ * (docs/specs/live-user-channel-proof-standard.md §5.6 — the deterministic
+ * cross-machine proof). It maps a (surface, channelId) to the topic that
+ * `GET /pool/placement?topic=N` is keyed on, reads the authoritative owner, and
+ * returns that machine id.
+ *
+ * Why this is the right reader: `/pool/placement` is the authoritative placement
+ * surface (it proxies to the lease-holder, so any machine can answer), and its
+ * `owner` field is the machine currently serving the topic — exactly "who replied"
+ * after a transfer. We read `owner` (not `pinnedTo`): a pin is the INTENT to place;
+ * `owner` is who actually holds it. For the capstone that distinction is the whole
+ * point — a pin that didn't move the seat is the original bug.
+ *
+ * Parameterized for testability: the HTTP GET + the (surface, channelId)→topicId
+ * mapping are injected, so this is unit-testable with no live server. MUST NOT throw
+ * on a transient read error — it returns null so the RealChannelDriver degrades to an
+ * unattributed reply rather than failing the whole scenario.
+ */
+export class PlacementResponderReader {
+    d;
+    constructor(deps) { this.d = deps; }
+    log(m) { this.d.logger?.(`[placement-responder-reader] ${m}`); }
+    /** The function shape RealChannelDriver injects: (surface, channelId) → machine id | null. */
+    resolve = async (surface, channelId) => {
+        const topicId = this.d.topicForChannel(surface, channelId);
+        if (!topicId) {
+            this.log(`no placement-tracked topic for ${surface}:${channelId}`);
+            return null;
+        }
+        try {
+            const p = await this.d.fetchPlacement(topicId);
+            return p?.owner ?? null;
+        }
+        catch (err) {
+            // @silent-fallback-ok: a transient /pool/placement read failure degrades this
+            // best-effort responder-machine lookup to null — the RealChannelDriver then
+            // proceeds with an unattributed reply rather than throwing the whole scenario.
+            // The failure is logged with topic context; it is not a gating/authority path.
+            this.log(`fetchPlacement failed for topic ${topicId}: ${err instanceof Error ? err.message : String(err)}`);
+            return null;
+        }
+    };
+}
+//# sourceMappingURL=PlacementResponderReader.js.map

package/dist/core/PlacementResponderReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlacementResponderReader.js","sourceRoot":"","sources":["../../src/core/PlacementResponderReader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AA4BH,MAAM,OAAO,wBAAwB;IAClB,CAAC,CAA+B;IACjD,YAAY,IAAkC,IAAI,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IAE1D,GAAG,CAAC,CAAS,IAAU,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,gCAAgC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAEtF,8FAA8F;IAC9F,OAAO,GAAG,KAAK,EAAE,OAAgB,EAAE,SAAiB,EAA0B,EAAE;QAC9E,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,eAAe,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QAC3D,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,IAAI,CAAC,GAAG,CAAC,kCAAkC,OAAO,IAAI,SAAS,EAAE,CAAC,CAAC;YACnE,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,CAAC;YACH,MAAM,CAAC,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;YAC/C,OAAO,CAAC,EAAE,KAAK,IAAI,IAAI,CAAC;QAC1B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,8EAA8E;YAC9E,4EAA4E;YAC5E,+EAA+E;YAC/E,+EAA+E;YAC/E,IAAI,CAAC,GAAG,CAAC,mCAAmC,OAAO,KAAK,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC5G,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC,CAAC;CACH"}

package/dist/core/SlackLiveSender.d.ts

@@ -0,0 +1,65 @@
+/**
+ * SlackLiveSender — the real Slack `SurfaceSender` for the live-test harness
+ * (docs/specs/live-user-channel-proof-standard.md §5.4). It posts a message into a
+ * Slack channel AS A NON-AGENT IDENTITY (a user/second-bot token, NOT Echo's own bot
+ * — Echo never replies to itself) and then waits for the AGENT's reply by polling the
+ * channel history for a message from the agent's bot user id.
+ *
+ * Parameterization is deliberate: the sender takes an already-constructed
+ * `SlackApiClient` (carrying the non-Echo sender token) + the agent's bot user id. So
+ * the CODE is complete and unit-testable here; the only thing that has to be provided
+ * at wiring time is the sender CREDENTIAL (a user token / second-bot token in the
+ * demo workspace). That credential is the one piece that may need provisioning — the
+ * logic does not.
+ *
+ * `awaitReply` identifies the agent's reply DETERMINISTICALLY (a message strictly
+ * after the sent ts whose author is the agent's bot user id), never a fuzzy guess, and
+ * resolves null on timeout (the harness records that as a FAIL with reason). The
+ * responder-MACHINE attribution (the cross-machine proof) is NOT done here — that is
+ * the RealChannelDriver's injected placement reader; this sender only returns the
+ * reply text + id.
+ */
+import type { SurfaceSender } from './RealChannelDriver.js';
+import type { SendResult, ReplyResult } from './LiveTestHarness.js';
+/** Minimal Slack client surface this sender needs (matches SlackApiClient.call). */
+export interface SlackCaller {
+    call(method: string, params?: Record<string, unknown>): Promise<{
+        ok?: boolean;
+        ts?: string;
+        messages?: Array<{
+            ts: string;
+            user?: string;
+            bot_id?: string;
+            text?: string;
+            subtype?: string;
+        }>;
+        [k: string]: unknown;
+    }>;
+}
+export interface SlackLiveSenderDeps {
+    /** A SlackApiClient constructed with the NON-AGENT sender token (the user-role identity). */
+    api: SlackCaller;
+    /** The agent's (Echo's) Slack bot user id — awaitReply waits for a reply authored by THIS id. */
+    agentBotUserId: string;
+    /** Poll cadence while awaiting a reply. Default 2000ms. */
+    pollIntervalMs?: number;
+    /** Injected for tests; defaults to real timers / clock. */
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+    logger?: (m: string) => void;
+}
+export declare class SlackLiveSender implements SurfaceSender {
+    private readonly d;
+    constructor(deps: SlackLiveSenderDeps);
+    private now;
+    private sleep;
+    private log;
+    send(channelId: string, text: string): Promise<SendResult>;
+    awaitReply(channelId: string, opts: {
+        timeoutMs: number;
+        afterMessageId?: string;
+    }): Promise<Omit<ReplyResult, 'responderMachineId'> | null>;
+    /** Find the FIRST agent-authored message strictly after `after` (oldest-first). */
+    private findAgentReply;
+}
+//# sourceMappingURL=SlackLiveSender.d.ts.map

package/dist/core/SlackLiveSender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlackLiveSender.d.ts","sourceRoot":"","sources":["../../src/core/SlackLiveSender.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEpE,oFAAoF;AACpF,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;QAC9D,EAAE,CAAC,EAAE,OAAO,CAAC;QACb,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,QAAQ,CAAC,EAAE,KAAK,CAAC;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QAClG,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;KACtB,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,mBAAmB;IAClC,6FAA6F;IAC7F,GAAG,EAAE,WAAW,CAAC;IACjB,iGAAiG;IACjG,cAAc,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2DAA2D;IAC3D,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAED,qBAAa,eAAgB,YAAW,aAAa;IACnD,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAsB;gBAC5B,IAAI,EAAE,mBAAmB;IAErC,OAAO,CAAC,GAAG;YACG,KAAK;IAGnB,OAAO,CAAC,GAAG;IAEL,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAU1D,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,oBAAoB,CAAC,GAAG,IAAI,CAAC;IAelJ,mFAAmF;YACrE,cAAc;CAkB7B"}

package/dist/core/SlackLiveSender.js

@@ -0,0 +1,77 @@
+/**
+ * SlackLiveSender — the real Slack `SurfaceSender` for the live-test harness
+ * (docs/specs/live-user-channel-proof-standard.md §5.4). It posts a message into a
+ * Slack channel AS A NON-AGENT IDENTITY (a user/second-bot token, NOT Echo's own bot
+ * — Echo never replies to itself) and then waits for the AGENT's reply by polling the
+ * channel history for a message from the agent's bot user id.
+ *
+ * Parameterization is deliberate: the sender takes an already-constructed
+ * `SlackApiClient` (carrying the non-Echo sender token) + the agent's bot user id. So
+ * the CODE is complete and unit-testable here; the only thing that has to be provided
+ * at wiring time is the sender CREDENTIAL (a user token / second-bot token in the
+ * demo workspace). That credential is the one piece that may need provisioning — the
+ * logic does not.
+ *
+ * `awaitReply` identifies the agent's reply DETERMINISTICALLY (a message strictly
+ * after the sent ts whose author is the agent's bot user id), never a fuzzy guess, and
+ * resolves null on timeout (the harness records that as a FAIL with reason). The
+ * responder-MACHINE attribution (the cross-machine proof) is NOT done here — that is
+ * the RealChannelDriver's injected placement reader; this sender only returns the
+ * reply text + id.
+ */
+export class SlackLiveSender {
+    d;
+    constructor(deps) { this.d = deps; }
+    now() { return (this.d.now ?? Date.now)(); }
+    async sleep(ms) {
+        return (this.d.sleep ?? ((m) => new Promise((r) => setTimeout(r, m))))(ms);
+    }
+    log(m) { this.d.logger?.(`[slack-live-sender] ${m}`); }
+    async send(channelId, text) {
+        const res = await this.d.api.call('chat.postMessage', { channel: channelId, text });
+        if (!res.ts) {
+            // A post with no ts is a real failure — surface it (the harness records a driver
+            // error FAIL), never fabricate a messageId.
+            throw new Error(`chat.postMessage returned no ts (ok=${res.ok}) — message not posted`);
+        }
+        return { messageId: res.ts };
+    }
+    async awaitReply(channelId, opts) {
+        const deadline = this.now() + opts.timeoutMs;
+        const pollMs = this.d.pollIntervalMs ?? 2000;
+        const after = opts.afterMessageId; // a Slack ts string; lexicographic compare works for ts
+        // Poll at least once even if timeoutMs is ~0.
+        for (let first = true; first || this.now() < deadline; first = false) {
+            const reply = await this.findAgentReply(channelId, after);
+            if (reply)
+                return reply;
+            if (this.now() >= deadline)
+                break;
+            await this.sleep(pollMs);
+        }
+        this.log(`no agent reply in ${channelId} within ${opts.timeoutMs}ms`);
+        return null;
+    }
+    /** Find the FIRST agent-authored message strictly after `after` (oldest-first). */
+    async findAgentReply(channelId, after) {
+        const res = await this.d.api.call('conversations.history', {
+            channel: channelId,
+            ...(after ? { oldest: after, inclusive: false } : {}),
+            limit: 100,
+        });
+        const messages = res.messages ?? [];
+        // conversations.history returns newest-first; scan oldest-first so we return the
+        // EARLIEST agent reply after the prompt (deterministic).
+        const oldestFirst = [...messages].sort((a, b) => (a.ts < b.ts ? -1 : a.ts > b.ts ? 1 : 0));
+        for (const m of oldestFirst) {
+            if (after && !(m.ts > after))
+                continue; // strictly-after guard (belt + suspenders vs `oldest`)
+            if (m.user !== this.d.agentBotUserId)
+                continue; // only the AGENT's reply
+            const text = m.text ?? '';
+            return { text, messageId: m.ts };
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=SlackLiveSender.js.map

package/dist/core/SlackLiveSender.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlackLiveSender.js","sourceRoot":"","sources":["../../src/core/SlackLiveSender.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "instar",
-  "version": "1.3.597",
+  "version": "1.3.598",
   "description": "Coherence infrastructure for self-evolving AI agents — on the Claude Code or Codex subscription you already have.",
   "type": "module",
   "main": "dist/index.js",

package/src/data/builtin-manifest.json

@@ -1,8 +1,8 @@
 {
   "$schema": "./builtin-manifest.schema.json",
   "schemaVersion": 1,
-  "generatedAt": "2026-06-16T10:44:35.492Z",
-  "instarVersion": "1.3.597",
+  "generatedAt": "2026-06-16T12:37:17.394Z",
+  "instarVersion": "1.3.598",
   "entryCount": 201,
   "entries": {
     "hook:session-start": {

package/upgrades/1.3.598.md

@@ -0,0 +1,24 @@
+# Upgrade Guide — vNEXT
+
+<!-- assembled-by: assemble-next-md -->
+<!-- bump: patch -->
+
+## What Changed
+
+Two more pure building blocks for the live-test harness (spec live-user-channel-proof-standard §5.4/§5.6), ships DARK (not wired):
+- `SlackLiveSender` — a real Slack `SurfaceSender`: posts as a non-agent identity via `chat.postMessage`, awaits the agent's reply by polling `conversations.history` (deterministic: a message strictly after the prompt, authored by the agent's bot user id). Parameterized on the sender token so only the credential needs provisioning.
+- `PlacementResponderReader` — the injectable `resolveResponderMachine` for RealChannelDriver: maps (surface, channelId)→topic, reads `/pool/placement` `owner` (the machine that actually holds the seat — the cross-machine proof), tolerates read errors (returns null).
+
+## What to Tell Your User
+
+Nothing yet — internal infrastructure for the gold-standard live-testing harness, ships dark (no runtime surface, no behavior change). The payoff is when the harness drives the real Slack channel and proves which machine served the reply.
+
+## Summary of New Capabilities
+
+None user-facing. Internally: the real Slack drive + the cross-machine "which machine answered" reader that the live-test harness needs. No new routes, no config, no flags.
+
+## Evidence
+
+- `tests/unit/SlackLiveSender.test.ts` — 7 tests: post→ts, no-ts throw, agent-reply-after-prompt, ignores non-agent + stale messages, poll-until-appears, timeout→null, no-afterId.
+- `tests/unit/PlacementResponderReader.test.ts` — 7 tests: telegram channel==topic, owner reflects seat move, slack channel→topic mapping, no-topic→null (no fetch), owner-null→null, fetch-error→null, arrow-bound detached reference.
+- `tsc --noEmit` clean. instar-dev gate green.

package/upgrades/side-effects/live-test-slack-sender.md

@@ -0,0 +1,29 @@
+# Side-Effects Review — Live-test Slack sender + placement responder reader
+
+**Slug:** live-test-slack-sender
+**Spec:** docs/specs/live-user-channel-proof-standard.md §5.4 (Platform-Sanctioned Automation) + §5.6 (deterministic cross-machine proof)
+**Files:** src/core/SlackLiveSender.ts, src/core/PlacementResponderReader.ts, tests/unit/SlackLiveSender.test.ts, tests/unit/PlacementResponderReader.test.ts
+**Posture:** ships DARK — two pure/injectable building blocks, NOT wired into server.ts. No route, no runtime construction. Stacked on the driver core (PR #1195).
+
+## What it is
+- **SlackLiveSender** — a real Slack `SurfaceSender`: posts a message AS A NON-AGENT identity (a user/second-bot token, injected) via `chat.postMessage`, and `awaitReply` polls `conversations.history` for the AGENT's reply (a message strictly after the sent ts authored by the agent's bot user id). Deterministic match; null on timeout; throws (never fabricates an id) if a post returns no ts.
+- **PlacementResponderReader** — the injectable `resolveResponderMachine` for RealChannelDriver: maps (surface, channelId)→topic, reads `GET /pool/placement` `owner`, returns the serving machine id. Tolerates read errors (returns null). Reads `owner` (who holds the seat), NOT `pinnedTo` (the intent) — the distinction IS the capstone.
+
+## Phase 1 — Principle check (signal vs authority)
+Neither module is a decision point. SlackLiveSender is transport (post + poll); PlacementResponderReader is a read that returns a machine id. Neither blocks, filters, or gates anything — they produce data the harness asserts on. No brittle blocking authority added. Compliant.
+
+## Phase 4 — Side-effects answers
+1. **Over-block** — n/a (no block surface). Worst case: SlackLiveSender's reply-match is too strict and misses a genuine agent reply → the scenario records a FAIL/no-reply. Mitigation: it matches on the agent's bot user id (the deterministic author), and polls the full window.
+2. **Under-block** — n/a. A risk: matching a STALE agent message as the reply. Mitigated by the strictly-after-ts guard (both via `oldest`+`inclusive:false` AND an explicit `m.ts > after` belt-and-suspenders) and oldest-first scan returning the EARLIEST post-prompt agent message.
+3. **Level-of-abstraction fit** — correct: both are the concrete adapters the harness's injected seams (`SurfaceSender`, `resolveResponderMachine`) were designed for. They wrap existing surfaces (`SlackApiClient`, `/pool/placement`) rather than reinventing them.
+4. **Signal vs authority** — compliant (transport + read, no authority). See Phase 1.
+5. **Interactions** — none yet (dark, unwired). SlackLiveSender uses a SEPARATE sender token from Echo's bot, so it can't be confused with Echo's own outbound; it reads history read-only. PlacementResponderReader only GETs placement. No shadowing/double-fire.
+6. **External surfaces** — when wired, SlackLiveSender WILL post a real message into a Slack channel (the demo workspace) and PlacementResponderReader WILL GET the local placement route. In THIS increment: no wiring, so no external surface. The sender token/identity is the one piece that needs provisioning (a user/second-bot token in the demo workspace) — the code is parameterized on it.
+7. **Multi-machine posture** — PlacementResponderReader IS the multi-machine attribution: it reads the authoritative `/pool/placement` (proxied to the lease-holder), so it answers "which machine served this" correctly regardless of which machine runs the harness. SlackLiveSender is machine-agnostic (talks to Slack's API). No single-machine assumption.
+8. **Rollback cost** — trivial: dark, unwired. Revert the commit.
+
+## No-deferrals
+The Telegram live sender + the runner route are the NEXT tracked increment (CMT-1568, `.instar/plans/live-test-harness-drivers-BUILD.md`), not a deferral of this one. This increment is complete + fully unit-tested (14 tests). The Slack/Telegram SENDER-IDENTITY provisioning (a user token / demo bot) is an external-credential dependency tracked in the plan, explicitly NOT a code deferral — the code is parameterized so only the credential is missing.
+
+## Phase 5 — Second-pass review
+Not required: neither module adds a block/allow decision, a session-lifecycle action, a sentinel/guard/gate/watchdog, or a coherence/trust surface (the Phase-5 triggers). Both are transport/read adapters. The driver core that DOES touch the §5.3 block (DemoChannelRegistry) had its second-pass in PR #1195.