@inneranimalmedia/agentsam-sdk 2.6.9 → 2.6.11

package/packages/agentsam-queue-control/test/queue-control.test.mjs

@@ -4,6 +4,17 @@ import assert from 'node:assert/strict';
 import {
   QueueControl,
   MemoryQueueAdapter,
+  CloudflareQueueBindingAdapter,
+  CloudflareQueueApiAdapter,
+  canClaimJobLease,
+  claimJobLease,
+  computeRetryDelayMs,
+  createJobEnvelope,
+  createRetrySchedule,
+  delaySecondsForAvailableAt,
+  jobExecutionIdentity,
+  refreshJobLease,
+  releaseJobLease,
   buildQueueTopology,
   resolvePhysicalQueue,
   routeWork,
@@ -98,3 +109,302 @@ test('infrastructure provisioning is approval-gated by default', async () => {
   assert.equal(result.provider, 'memory');
   assert.ok(result.created.includes('demo-test-jobs'));
 });
+
+
+test('job envelopes support delayed availability without making early work runnable', async () => {
+  const adapter = new MemoryQueueAdapter();
+  const control = new QueueControl({
+    adapter,
+    topology: buildQueueTopology({ namespace: 'demo', environment: 'test' }),
+  });
+  const queue = resolvePhysicalQueue(control.topology, 'deployments');
+  const createdAt = 1_000;
+  const availableAt = 1_060;
+  const result = await control.enqueue({
+    account_id: 'acct_real',
+    kind: 'deploy.cloudflare',
+  }, {
+    created_at: createdAt,
+    availableAt,
+  });
+
+  assert.equal(result.job.available_at, availableAt);
+  assert.equal((await adapter.pull(queue, 10, { now: 1_059 })).length, 0);
+  assert.equal(adapter.depth(queue), 1);
+  assert.equal((await adapter.pull(queue, 10, { now: 1_060 })).length, 1);
+});
+
+test('retry scheduling uses bounded exponential backoff with injectable jitter', () => {
+  const job = createJobEnvelope({
+    account_id: 'acct_real',
+    kind: 'repository.index',
+    created_at: 1_000,
+    retry: {
+      max_attempts: 3,
+      initial_delay_ms: 1_000,
+      max_delay_ms: 10_000,
+      backoff: 'exponential',
+      jitter: true,
+    },
+  });
+
+  assert.equal(computeRetryDelayMs(job.retry, 1, () => 0), 500);
+  assert.equal(computeRetryDelayMs(job.retry, 2, () => 1), 2_000);
+
+  const retry = createRetrySchedule(job, { now_ms: 1_000_000, random: () => 1 });
+  assert.equal(retry.retryable, true);
+  assert.equal(retry.job.status, 'retry_scheduled');
+  assert.equal(retry.job.attempt, 1);
+  assert.equal(retry.available_at, 1_001);
+
+  const exhausted = createRetrySchedule({ ...job, attempt: 2 }, { now_ms: 1_000_000 });
+  assert.equal(exhausted.retryable, false);
+  assert.equal(exhausted.exhausted, true);
+});
+
+test('local queue failures are re-enqueued for a future deterministic retry', async () => {
+  const adapter = new MemoryQueueAdapter();
+  const control = new QueueControl({
+    adapter,
+    topology: buildQueueTopology({ namespace: 'demo', environment: 'test' }),
+  });
+  control.register('repository.*', async () => {
+    throw new Error('temporary');
+  });
+
+  await control.enqueue({ account_id: 'acct_real', kind: 'repository.index' }, {
+    created_at: 1_000,
+    retry: { max_attempts: 3, initial_delay_ms: 1_000, max_delay_ms: 1_000, jitter: false },
+  });
+  const queue = resolvePhysicalQueue(control.topology, 'indexing');
+  const [job] = await adapter.pull(queue, 1, { now: 1_000 });
+  const [result] = await control.consume([job]);
+
+  assert.equal(result.ok, false);
+  assert.equal(result.retry.scheduled, true);
+  assert.equal(result.retry.provider_managed, false);
+  assert.equal(adapter.depth(queue), 1);
+  assert.equal((await adapter.pull(queue, 1, { now: result.retry.available_at - 1 })).length, 0);
+  assert.equal((await adapter.pull(queue, 1, { now: result.retry.available_at })).length, 1);
+});
+
+test('Cloudflare queue binding maps available_at to delaySeconds and rejects delays beyond provider limit', async () => {
+  const calls = [];
+  const adapter = new CloudflareQueueBindingAdapter({
+    bindings: {
+      default: {
+        async send(body, options) { calls.push({ body, options }); },
+      },
+    },
+  });
+  const job = createJobEnvelope({
+    account_id: 'acct_real',
+    kind: 'deploy.cloudflare',
+    created_at: 1_000,
+    available_at: 1_600,
+  });
+
+  const receipt = await adapter.publish('demo', job, { now: 1_000 });
+  assert.equal(receipt.delay_seconds, 600);
+  assert.equal(calls[0].options.delaySeconds, 600);
+  assert.equal(delaySecondsForAvailableAt(87_400, 1_000), 86_400);
+  assert.throws(() => delaySecondsForAvailableAt(87_401, 1_000), /exceeds_24h/);
+});
+
+test('provider-managed retries receive a deterministic retry delay instead of immediate polling', async () => {
+  const adapter = new MemoryQueueAdapter();
+  const control = new QueueControl({
+    adapter,
+    topology: buildQueueTopology({ namespace: 'demo', environment: 'test' }),
+  });
+  control.register('deploy.*', async () => {
+    throw new Error('pending');
+  });
+  const job = createJobEnvelope({
+    account_id: 'acct_real',
+    kind: 'deploy.cloudflare',
+    logical_queue: 'deployments',
+    retry: { max_attempts: 3, initial_delay_ms: 2_000, max_delay_ms: 2_000, jitter: false },
+  });
+  let retryOptions = null;
+  const message = {
+    body: job,
+    attempts: 1,
+    retry(options) { retryOptions = options; },
+  };
+
+  const [result] = await control.consume([message]);
+  assert.equal(result.retry.provider_managed, true);
+  assert.equal(result.retry.delay_seconds, 2);
+  assert.deepEqual(retryOptions, { delaySeconds: 2 });
+});
+
+
+test('job execution identity always carries a stable idempotency key and run/step attribution', () => {
+  const job = createJobEnvelope({
+    id: 'job_fixed',
+    account_id: 'acct_real',
+    kind: 'embeddings.generate',
+    run_id: 'arun_parent',
+    step_id: 'step_embed',
+  });
+  assert.equal(job.idempotency_key, 'job_fixed');
+  assert.deepEqual(jobExecutionIdentity(job), {
+    job_id: 'job_fixed',
+    run_id: 'arun_parent',
+    step_id: 'step_embed',
+    attempt: 0,
+    idempotency_key: 'job_fixed',
+    lease_owner: null,
+    lease_expires_at: null,
+    lease_generation: 0,
+  });
+
+  const explicit = createJobEnvelope({
+    id: 'job_other',
+    account_id: 'acct_real',
+    kind: 'deploy.cloudflare',
+    idempotency_key: 'deploy:commit:abc123',
+  });
+  assert.equal(explicit.idempotency_key, 'deploy:commit:abc123');
+});
+
+test('lease contract supports claim, refresh, release, crash expiry, and rejects live double claims', () => {
+  const job = createJobEnvelope({
+    account_id: 'acct_real',
+    kind: 'repository.index',
+    created_at: 1_000,
+  });
+  const claimed = claimJobLease(job, { owner: 'worker-a', now: 1_000, ttl_seconds: 30 });
+  assert.equal(claimed.status, 'claimed');
+  assert.equal(claimed.lease_owner, 'worker-a');
+  assert.equal(claimed.lease_expires_at, 1_030);
+  assert.equal(claimed.lease_generation, 1);
+  assert.equal(canClaimJobLease(claimed, { owner: 'worker-b', now: 1_010 }), false);
+  assert.throws(
+    () => claimJobLease(claimed, { owner: 'worker-b', now: 1_010 }),
+    /job_lease_held/,
+  );
+
+  const refreshed = refreshJobLease(claimed, { owner: 'worker-a', now: 1_010, ttl_seconds: 30 });
+  assert.equal(refreshed.lease_expires_at, 1_040);
+  assert.throws(
+    () => refreshJobLease(refreshed, { owner: 'worker-a', now: 1_041, ttl_seconds: 30 }),
+    /job_lease_expired/,
+  );
+
+  assert.equal(canClaimJobLease(refreshed, { owner: 'worker-b', now: 1_041 }), true);
+  const reclaimed = claimJobLease(refreshed, { owner: 'worker-b', now: 1_041, ttl_seconds: 30 });
+  assert.equal(reclaimed.lease_generation, 2);
+  assert.equal(reclaimed.lease_owner, 'worker-b');
+
+  const released = releaseJobLease(reclaimed, { owner: 'worker-b', status: 'queued' });
+  assert.equal(released.lease_owner, null);
+  assert.equal(released.lease_expires_at, null);
+  assert.equal(released.status, 'queued');
+});
+
+
+test('provider-managed retry exhaustion stops requeueing instead of polling forever', async () => {
+  const adapter = new MemoryQueueAdapter();
+  const control = new QueueControl({
+    adapter,
+    topology: buildQueueTopology({ namespace: 'demo', environment: 'test' }),
+  });
+  control.register('deploy.*', async () => {
+    throw new Error('still pending');
+  });
+  const job = createJobEnvelope({
+    account_id: 'acct_real',
+    kind: 'deploy.cloudflare',
+    logical_queue: 'deployments',
+    retry: { max_attempts: 3, initial_delay_ms: 1_000, max_delay_ms: 1_000, jitter: false },
+  });
+  let retried = false;
+  let acked = false;
+  const [result] = await control.consume([{
+    body: job,
+    attempts: 3,
+    retry() { retried = true; },
+    ack() { acked = true; },
+  }]);
+  assert.equal(retried, true);
+  assert.equal(acked, false);
+  assert.deepEqual(result.retry, {
+    scheduled: false,
+    exhausted: true,
+    provider_managed: true,
+    delegated_to_provider_dlq: true,
+    attempt: 3,
+    delay_ms: 1000,
+    delay_seconds: 1,
+  });
+});
+
+test('exhausted local retries are materialized as a deterministic dead-letter job', async () => {
+  const topology = buildQueueTopology({ namespace: 'acp', environment: 'test' });
+  const adapter = new MemoryQueueAdapter();
+  const control = new QueueControl({ adapter, topology });
+  control.register('always.fail', async () => {
+    throw Object.assign(new Error('boom'), { code: 'provider_unavailable' });
+  });
+
+  const job = createJobEnvelope({
+    id: 'job_exhaust_local',
+    account_id: 'acct_1',
+    kind: 'always.fail',
+    logical_queue: 'jobs',
+    retry: {
+      max_attempts: 1,
+      backoff: 'fixed',
+      initial_delay_ms: 0,
+      max_delay_ms: 0,
+      jitter: false,
+    },
+  });
+
+  const [result] = await control.consume([job]);
+  assert.equal(result.ok, false);
+  assert.equal(result.retry.exhausted, true);
+  assert.equal(result.retry.dead_lettered, true);
+
+  const dlq = resolvePhysicalQueue(topology, 'dead_letter');
+  const [dead] = await adapter.pull(dlq, 1);
+  assert.equal(dead.kind, 'dead_letter');
+  assert.equal(dead.payload.original_job.id, 'job_exhaust_local');
+  assert.equal(dead.payload.failure.code, 'provider_unavailable');
+  assert.equal(dead.metadata.dead_letter, true);
+});
+
+test('Cloudflare consumer provisioning carries the topology dead-letter queue', async () => {
+  const requests = [];
+  const adapter = new CloudflareQueueApiAdapter({
+    cloudflareAccountId: 'acct_cf',
+    apiToken: 'token',
+    fetchImpl: async (url, init = {}) => {
+      requests.push({ url, init });
+      if (init.method === 'POST' && url.endsWith('/consumers')) {
+        return Response.json({ success: true, result: { consumer_id: 'consumer_1' } });
+      }
+      if (init.method === 'POST') {
+        const name = JSON.parse(init.body).queue_name;
+        return Response.json({ success: true, result: { queue_id: name + '_id', queue_name: name } });
+      }
+      return Response.json({ success: true, result: [] });
+    },
+  });
+
+  const topology = buildQueueTopology({ namespace: 'acp', environment: 'prod' });
+  const jobsQueue = resolvePhysicalQueue(topology, 'jobs');
+  await adapter.ensureTopology(topology, {
+    consumers: {
+      [jobsQueue]: { script_name: 'agentsam-acp-consumer', max_retries: 3 },
+    },
+  });
+
+  const consumerRequest = requests.find((row) => row.url.endsWith('/consumers'));
+  assert.ok(consumerRequest);
+  const body = JSON.parse(consumerRequest.init.body);
+  assert.equal(body.dead_letter_queue, resolvePhysicalQueue(topology, 'dead_letter'));
+  assert.equal(body.settings.max_retries, 3);
+});

package/packages/agentsam-queue-control/test/sqlite-adapter.test.mjs

@@ -0,0 +1,91 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+import { createLocalSqliteDatabase } from '../../../src/local/sqlite.js';
+import { applyRuntimeMigrations } from '../../../src/local/migrations.js';
+import {
+  SqliteQueueAdapter,
+  QueueControl,
+  buildQueueTopology,
+  createJobEnvelope,
+} from '../src/index.js';
+
+async function fixture() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-queue-sqlite-'));
+  const db = await createLocalSqliteDatabase(path.join(dir, 'agentsam.sqlite'));
+  await applyRuntimeMigrations(db);
+  return { dir, db, close: () => db.close() };
+}
+
+test('SQLite adapter persists delayed work and leases due jobs without polling models', async (t) => {
+  const fx = await fixture();
+  t.after(fx.close);
+  const topology = buildQueueTopology({ namespace: 'test', environment: 'local' });
+  const adapter = new SqliteQueueAdapter({ database: fx.db, leaseOwner: 'worker-a', leaseTtlSeconds: 30 });
+  const control = new QueueControl({ adapter, topology });
+
+  const enqueued = await control.enqueue(
+    { kind: 'repository.index', account_id: 'acct_1' },
+    {
+      account_id: 'acct_1',
+      id: 'job_delayed',
+      available_at: 120,
+      created_at: 100,
+      idempotency_key: 'idx:repo:a',
+    },
+  );
+  const queue = enqueued.plan.physical_queue;
+
+  assert.equal(await adapter.depth(queue), 1);
+  assert.deepEqual(await adapter.pull(queue, 1, { now: 119 }), []);
+
+  const first = await adapter.pull(queue, 1, { now: 120, owner: 'worker-a', ttl_seconds: 30 });
+  assert.equal(first.length, 1);
+  assert.equal(first[0].status, 'claimed');
+  assert.equal(first[0].lease_owner, 'worker-a');
+  assert.equal(first[0].lease_expires_at, 150);
+  assert.equal(first[0].lease_generation, 1);
+
+  assert.deepEqual(await adapter.pull(queue, 1, { now: 149, owner: 'worker-b' }), []);
+
+  const reclaimed = await adapter.pull(queue, 1, { now: 150, owner: 'worker-b', ttl_seconds: 20 });
+  assert.equal(reclaimed.length, 1);
+  assert.equal(reclaimed[0].lease_owner, 'worker-b');
+  assert.equal(reclaimed[0].lease_generation, 2);
+
+  const ack = await adapter.ack(reclaimed[0], { status: 'completed', result: { indexed: 3 }, now: 151 });
+  assert.equal(ack.updated, 1);
+  assert.equal(await adapter.depth(queue), 0);
+  assert.equal((await adapter.get('job_delayed')).status, 'completed');
+});
+
+test('SQLite adapter deduplicates stable idempotency keys across repeated enqueue attempts', async (t) => {
+  const fx = await fixture();
+  t.after(fx.close);
+  const adapter = new SqliteQueueAdapter({ database: fx.db });
+  const queue = 'agentsam-local-jobs';
+
+  const first = createJobEnvelope({
+    id: 'job_a',
+    account_id: 'acct_1',
+    kind: 'deployment.poll',
+    idempotency_key: 'deploy:123',
+    created_at: 10,
+  });
+  const duplicate = createJobEnvelope({
+    id: 'job_b',
+    account_id: 'acct_1',
+    kind: 'deployment.poll',
+    idempotency_key: 'deploy:123',
+    created_at: 11,
+  });
+
+  assert.equal((await adapter.publish(queue, first)).accepted, 1);
+  const second = await adapter.publish(queue, duplicate);
+  assert.equal(second.accepted, 0);
+  assert.equal(second.deduplicated, true);
+  assert.equal(second.existing_job_id, 'job_a');
+  assert.equal(await adapter.depth(queue), 1);
+});

package/packages/agentsam-rapid-rust/README.md

@@ -3,3 +3,6 @@
 Native Rust CLI source for `agentsam rust` / `agentsam-rapid-rust`.
 
 It scaffolds Cloudflare `workers-rs` projects, performs local Wasm checks/builds, runs Wrangler locally, and gates live deployment behind an explicit `--yes`. Compiled binaries are not committed; use `scripts/build_rapid_rust_cli.py` to build/install one.
+
+<!-- agentsam:trademark-notice -->
+> Independent project. Not affiliated with, endorsed by, or sponsored by Cloudflare, Inc. or by any other company whose products are named here. Cloudflare is a registered trademark of Cloudflare, Inc. Other names are trademarks of their respective owners. See [TRADEMARKS](https://github.com/SamPrimeaux/agentsam-sdk/blob/main/TRADEMARKS.md).

package/packages/agentsam-repository/README.md

@@ -13,3 +13,6 @@ It owns deterministic repository identity and Merkle behavior that must be reusa
 It does **not** own authenticated account sessions, CLI commands, UI rendering, knowledge retrieval, deployment orchestration, or product application state. Those layers consume this package through explicit imports.
 
 The workspace is private while the extraction stabilizes. Cross-repository consumers should continue using the published `@inneranimalmedia/agentsam-sdk` facade until this package receives its own release policy.
+
+<!-- agentsam:trademark-notice -->
+> Independent project. Not affiliated with, endorsed by, or sponsored by Cloudflare, Inc. or by any other company whose products are named here. Cloudflare is a registered trademark of Cloudflare, Inc. Other names are trademarks of their respective owners. See [TRADEMARKS](https://github.com/SamPrimeaux/agentsam-sdk/blob/main/TRADEMARKS.md).

package/packages/agentsam-repository/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-repository",
-  "version": "2.6.9",
+  "version": "2.6.11",
   "description": "Portable AgentSam repository identity, Merkle, semantic file metadata, persistence, and repository graph runtime contracts.",
   "type": "module",
   "main": "./src/index.js",

package/packages/agentsam-vault/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-vault",
-  "version": "2.6.9",
+  "version": "2.6.11",
   "type": "module",
   "description": "AgentSam credential vault core — contracts, AES-GCM crypto, provider registry, resolver. UI lives in agentsam-key-manager.",
   "main": "./src/index.js",

package/packages/agentsam-workbench/README.md

@@ -22,3 +22,46 @@ values are withheld. Cross-origin and sandboxed iframe contents are not inspecte
 their host frame may be selected as a contextual resource. Mark semantic ancestors
 with `data-agentsam-resource` and excluded controls with `data-annotation-control`.
 Local Studio stages the annotation in its active conversation draft for review.
+
+
+## Conversation and runtime surfaces
+
+`AgentConversationSurface` is the portable thread + persistent-composer ownership
+boundary. Product apps provide state and actions; the surface guarantees that
+moving between an empty conversation and an active thread does not replace the
+composer DOM ownership.
+
+`AgentRuntimeField` projects `@inneranimalmedia/agentsam-loading-scene` into the
+same surface. A lead thread and each co-worker may bind separate controllers, so
+parallel work can show independent semantic scenes and task narration without
+duplicating renderer code in product apps.
+
+```tsx
+<AgentConversationSurface
+  empty={messages.length === 0}
+  runtime={<AgentRuntimeField controller={runtimeController} />}
+  thread={<AgentThread messages={messages} />}
+  composer={<AgentComposer {...composerProps} />}
+/>
+```
+
+The workbench owns presentation mechanics. The host still owns model/provider
+selection, tool execution, persistence, permissions, runtime events, queueing and
+cancel semantics.
+
+## Widgets
+
+`@inneranimalmedia/agentsam-workbench/widgets` is the shared widget surface:
+`WidgetFrame` (size/state chrome around any widget body), `useCountdown`, and
+`CountdownWidget`. Widget identity — kind, sizes, data source, deep link — comes
+from the framework-neutral contracts in `@inneranimalmedia/agentsam-contracts/widgets`.
+
+Countdown time authority is an absolute deadline, not accumulated interval
+ticks: remaining time is derived from `Date.now()` on every render tick, so a
+sleeping or backgrounded tab cannot corrupt the timer. Import
+`@inneranimalmedia/agentsam-workbench/widgets/widgets.css` once in the host;
+the widget tokens inherit the host theme.
+
+Widgets are app-native primitives, not installable prebuilds — the host decides
+where a widget appears and what its data means. Local Studio's `/widgets`
+utilities surface is the proof consumer.

package/packages/agentsam-workbench/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inneranimalmedia/agentsam-workbench",
-  "version": "2.6.9",
+  "version": "2.6.11",
   "description": "Reusable AgentSam workbench primitives for agent threads, composer, browser, terminal and resizable work surfaces.",
   "type": "module",
   "main": "./dist/index.js",
@@ -36,16 +36,26 @@
     "./agent/mini-agentsam.css": "./dist/agent/mini-agentsam.css",
     "./agent/contextual-composer.css": "./dist/agent/contextual-composer.css",
     "./agent/tool-permission.css": "./dist/agent/tool-permission.css",
-    "./project-control.css": "./dist/project-control.css"
+    "./project-control.css": "./dist/project-control.css",
+    "./manufacturing": {
+      "types": "./dist/manufacturing/index.d.ts",
+      "import": "./dist/manufacturing/index.js"
+    },
+    "./widgets": {
+      "types": "./dist/widgets/index.d.ts",
+      "import": "./dist/widgets/index.js"
+    },
+    "./widgets/widgets.css": "./dist/widgets/widgets.css"
   },
   "scripts": {
-    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "typecheck": "node scripts/ensure-local-deps.mjs && tsc --noEmit -p tsconfig.json",
     "test": "node --test test/*.test.mjs",
     "build": "node scripts/build.mjs",
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@inneranimalmedia/agentsam-contracts": "2.6.9"
+    "@inneranimalmedia/agentsam-contracts": "2.6.11",
+    "@inneranimalmedia/agentsam-loading-scene": "2.6.11"
   },
   "peerDependencies": {
     "react": ">=18",

package/packages/agentsam-workbench/src/agent/AgentConversationSurface.tsx

@@ -0,0 +1,108 @@
+import type { CSSProperties, ReactNode } from 'react';
+
+export type AgentConversationSurfaceProps = {
+  empty?: boolean;
+  thread: ReactNode;
+  composer: ReactNode;
+  emptyState?: ReactNode;
+  runtime?: ReactNode;
+  status?: ReactNode;
+  className?: string;
+  bodyClassName?: string;
+  composerClassName?: string;
+  style?: CSSProperties;
+};
+
+/**
+ * Portable thread + persistent composer surface.
+ *
+ * The composer slot is never conditionally removed when a conversation moves
+ * from empty/startup to active. Hosts can restyle the surface, but the DOM
+ * ownership contract remains stable across web/desktop/product adapters.
+ */
+export function AgentConversationSurface({
+  empty = false,
+  thread,
+  composer,
+  emptyState,
+  runtime,
+  status,
+  className,
+  bodyClassName,
+  composerClassName,
+  style,
+}: AgentConversationSurfaceProps) {
+  return (
+    <section
+      className={className}
+      data-agent-conversation-surface=""
+      data-agent-conversation-empty={empty ? 'true' : 'false'}
+      style={{
+        position: 'relative',
+        display: 'flex',
+        minWidth: 0,
+        minHeight: 0,
+        flex: 1,
+        flexDirection: 'column',
+        overflow: 'hidden',
+        ...style,
+      }}
+    >
+      {runtime}
+
+      <div
+        className={bodyClassName}
+        data-agent-conversation-body=""
+        data-agent-conversation-body-empty={empty ? 'true' : 'false'}
+        style={{
+          display: 'flex',
+          minWidth: 0,
+          minHeight: 0,
+          flex: '1 1 auto',
+          flexDirection: 'column',
+          overflow: 'hidden',
+        }}
+      >
+        {empty ? (
+          emptyState ? (
+            <div
+              data-agent-conversation-empty-state=""
+              style={{
+                display: 'flex',
+                minWidth: 0,
+                minHeight: 0,
+                flex: '1 1 auto',
+                alignItems: 'center',
+                justifyContent: 'center',
+              }}
+            >
+              {emptyState}
+            </div>
+          ) : null
+        ) : (
+          thread
+        )}
+      </div>
+
+      {status ? (
+        <div data-agent-conversation-status="" style={{ flexShrink: 0 }}>
+          {status}
+        </div>
+      ) : null}
+
+      <div
+        className={composerClassName}
+        data-agent-conversation-composer=""
+        style={{
+          position: 'relative',
+          zIndex: 2,
+          width: '100%',
+          flexShrink: 0,
+        }}
+      >
+        {composer}
+      </div>
+
+    </section>
+  );
+}

package/packages/agentsam-workbench/src/agent/AgentPanel.tsx

@@ -3,6 +3,7 @@ import type { AgentMessage, ModelOption } from '@inneranimalmedia/agentsam-contr
 import { AgentThread } from './Thread';
 import { AgentComposer } from './Composer';
 import { AgentModelSelect } from './ModelSelect';
+import { AgentConversationSurface } from './AgentConversationSurface';
 
 export interface AgentPanelProps {
   messages: AgentMessage[];
@@ -24,17 +25,33 @@ export function AgentPanel(props: AgentPanelProps) {
   const modelControl = props.models?.length && props.selectedModelId && props.onModelChange
     ? <AgentModelSelect value={props.selectedModelId} models={props.models} onChange={props.onModelChange} />
     : null;
+  const thread = (
+    <AgentThread
+      messages={props.messages}
+      streaming={props.streaming}
+      renderMessage={props.renderMessage}
+      empty={props.empty}
+    />
+  );
+  const composer = (
+    <AgentComposer
+      value={props.draft}
+      onChange={props.onDraftChange}
+      onSend={props.onSend}
+      onCancel={props.onCancel}
+      streaming={props.streaming}
+      toolbarStart={modelControl}
+    />
+  );
+
   return (
     <section className={props.className} data-agent-panel="">
       {props.header}
-      <AgentThread messages={props.messages} streaming={props.streaming} renderMessage={props.renderMessage} empty={props.empty} />
-      <AgentComposer
-        value={props.draft}
-        onChange={props.onDraftChange}
-        onSend={props.onSend}
-        onCancel={props.onCancel}
-        streaming={props.streaming}
-        toolbarStart={modelControl}
+      <AgentConversationSurface
+        empty={props.messages.length === 0}
+        thread={thread}
+        composer={composer}
+        emptyState={props.empty}
       />
     </section>
   );