@agentshouse/kit 0.1.0-alpha.16 → 0.1.0-alpha.17

package/README.md

@@ -10,7 +10,7 @@ On Linux `amd64` or `arm64` with a working Docker Engine, run the published,
 versioned bootstrap once:
 
 ```sh
-bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.16/connect-linux.sh)
+bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.17/connect-linux.sh)
 ```
 
 The release asset pins one immutable multi-architecture image digest. It creates
@@ -760,11 +760,13 @@ prompt's stop reason through the contract's own table to one of four turn
 outcomes: completed, interrupted, refused by the provider, or exhausted. A stop
 reason the contract does not name, including a vendor-specific one a different
 contract names, fails the turn as `kit_adapter_contract_mismatch` rather than
-being guessed. It sends the request
-as the first prompt block, followed by current House guidance fetched through
-the Run connection. Missing or unreadable guidance refuses the turn; the
-launcher does not copy the private Routine instruction into the acquisition
-request. It forwards only adapter-classified User-visible assistant
+being guessed. After committing the Run, and again on every resumption, the
+Kit reads what the Session was started for from House's
+`/kit/runs/<run>/request` with the Session credential: the Routine Request with
+its input, references, requester and the pinned revision's instruction, or the
+sealed conversation turn. It sends that as the first prompt block, followed by
+current House guidance fetched through the Run connection, so the Agent calls
+nothing to learn it. An unreadable request or guidance refuses the turn. It forwards only adapter-classified User-visible assistant
 text back over the local channel, and leaves reasoning, tool traces, and
 terminal output where they are. The supervised process's own House calls travel
 that same channel through the `house` CLI. The Kit holds the WorkerRunToken, replaces it in place when
@@ -910,8 +912,8 @@ receiving a complete byte stream, validating any reported size, and writing the
 file. A lost acknowledgement preserves the completed local file for House's
 idempotent admission and later cleanup. Failed files remain pending; House's
 all-files-ready gate keeps their turn unprocessed.
-The provider receives absolute local paths beside the owning messages, both in
-its initial prompt and in `session_get_request`. The cache persists across
+The provider receives absolute local paths beside the owning messages in its
+first prompt. The cache persists across
 turns; only House-authorized terminal Run cleanup removes its Run directory.
 
 The accepted attachment's retained original is separate from that cache. The Kit
@@ -936,8 +938,8 @@ outcome it handled, and exits non-zero while any of them is unsaved.
 One `kit worker run` then takes one House-authorized resumption, or otherwise
 acquires one waiting Run, and supervises exactly that WorkerSession. A resumed
 conversation loads its retained native provider session through ACP
-`session/load`, receives the current input from House through
-`session_get_request`, and executes one turn. Historical output replayed during
+`session/load`, receives the current input House answers for the Run in its
+first prompt, and executes one turn. Historical output replayed during
 loading is not emitted as new assistant output. Missing or rejected provider
 continuation never starts a replacement provider conversation in the same Run.
 

package/bootstrap.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
-  "version": "0.1.0-alpha.16",
+  "version": "0.1.0-alpha.17",
   "hosts": {
     "linux": {
-      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.16/connect-linux.sh)",
+      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.17/connect-linux.sh)",
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.16/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.17/connect-linux.sh"
       },
       "workspace": {
         "argument": "--workspace",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.1.0-alpha.16",
+  "version": "0.1.0-alpha.17",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/adapter-mcp.js

@@ -29,16 +29,3 @@ export async function commandHouseInstructions(bridge) {
   }
   return frame.result.instructions;
 }
-
-export async function commandHouseRequest(bridge) {
-  const frame = await commandHouseReply(bridge, { method: "tools/call", params: { name: "session_get_request", arguments: {} } });
-  if (frame.error !== undefined || frame.result?.isError === true) throw new KitRefusal("kit_run_input_unreadable");
-  try {
-    const content = frame.result.content;
-    const input = JSON.parse(content.find((item) => item.type === "text").text);
-    if (typeof input !== "object" || input === null || Array.isArray(input)) throw new Error();
-    return input;
-  } catch {
-    throw new KitRefusal("kit_run_input_unreadable");
-  }
-}

package/src/contract.js

@@ -1,6 +1,6 @@
 import { CLAUDE_PASTED_CODE, CODEX_DEVICE_CODE, GROK_DEVICE_CODE } from "./agent-logins.js";
 
-export const KIT_CONTRACT_VERSION = "2026-09-28-working-copies";
+export const KIT_CONTRACT_VERSION = "2026-09-28-first-prompt";
 export const KIT_CAPTURE_BATCH_MAX = 100;
 export const COMMAND_INPUT_MAX_BYTES = 4 * 1024;
 export const AUTHORIZATION_OUTPUT_MAX_BYTES = 4 * 1024;
@@ -40,6 +40,10 @@ export function runOutcomePath(run) {
   return `/kit/runs/${encodeURIComponent(run)}/outcome`;
 }
 
+export function runRequestPath(run) {
+  return `/kit/runs/${encodeURIComponent(run)}/request`;
+}
+
 export const KIT_SESSIONS_REPORT_PATH = "/kit/sessions/report";
 export const KIT_SESSIONS_REPORT_MAX = 256;
 

package/src/house.js

@@ -29,6 +29,7 @@ import {
   MCP_PROTOCOL_VERSION,
   WORKER_RUN_TOKEN_MARGIN_MS,
   runOutcomePath,
+  runRequestPath,
   secretInputPath,
   SECRET_VALUE_MAX,
   sessionInteractionsPath,
@@ -734,11 +735,7 @@ export async function reportLogin(session, login, outcome, signal = session.sign
 }
 
 const envelope = declarationReader("kit_acquire_rejected");
-
-function routineInput(value, declaration) {
-  if (typeof value !== "string" || Array.from(value).length > 20_000) envelope.refuse(declaration);
-  return value;
-}
+const input = declarationReader("kit_run_input_unreadable");
 
 function acquiredRoute(value, declaration) {
   const route = envelope.plain(value, declaration);
@@ -756,79 +753,82 @@ function acquiredRoute(value, declaration) {
 
 function conversationText(value, declaration) {
   if (value === null) return null;
-  if (typeof value !== "string" || value.length > 4096) envelope.refuse(declaration);
+  if (typeof value !== "string" || value.length > 4096) input.refuse(declaration);
   return value;
 }
 
 function conversationMessage(value, declaration) {
-  const message = envelope.plain(value, declaration);
+  const message = input.plain(value, declaration);
   const text = conversationText(message.text, `${declaration}.text`);
   const caption = conversationText(message.caption, `${declaration}.caption`);
-  if (!Array.isArray(message.files)) envelope.refuse(`${declaration}.files`);
+  if (!Array.isArray(message.files)) input.refuse(`${declaration}.files`);
   const files = message.files.map((value, index) => {
     const name = `${declaration}.files[${index}]`;
-    const file = envelope.plain(value, name);
+    const file = input.plain(value, name);
     if (file.bytes !== null && (!Number.isSafeInteger(file.bytes) || file.bytes < 0)) {
-      envelope.refuse(`${name}.bytes`);
+      input.refuse(`${name}.bytes`);
     }
     return {
-      path: envelope.text(file.path, `${name}.path`, 2048),
-      media_kind: envelope.text(file.media_kind, `${name}.media_kind`, 128),
-      media_type: file.media_type === null ? null : envelope.text(file.media_type, `${name}.media_type`, 255),
+      path: input.text(file.path, `${name}.path`, 2048),
+      media_kind: input.text(file.media_kind, `${name}.media_kind`, 128),
+      media_type: file.media_type === null ? null : input.text(file.media_type, `${name}.media_type`, 255),
       bytes: file.bytes,
     };
   });
-  if (!text && !caption && files.length === 0) envelope.refuse(declaration);
+  if (!text && !caption && files.length === 0) input.refuse(declaration);
   return {
-    message_id: envelope.text(message.message_id, `${declaration}.message_id`, 128),
+    message_id: input.text(message.message_id, `${declaration}.message_id`, 128),
     text, caption, files,
   };
 }
 
-function acquiredRequest(acquired, declaration) {
-  if (acquired.kind === "conversation") {
-    if (acquired.origin !== "user") envelope.refuse(`${declaration}.origin`);
-    const conversation = envelope.plain(acquired.conversation, `${declaration}.conversation`);
-    const turn = envelope.plain(conversation.turn, `${declaration}.conversation.turn`);
+function runRequest(answer) {
+  const request = input.plain(answer, "request");
+  if (request.kind === "conversation") {
+    if (request.origin !== "user") input.refuse("request.origin");
+    const turn = input.plain(request.turn, "request.turn");
     return {
+      kind: "conversation",
       origin: "user",
-      conversation: {
-        turn: {
-          id: envelope.text(turn.id, `${declaration}.conversation.turn.id`, 128),
-          sequence: envelope.positiveCount(turn.sequence, `${declaration}.conversation.turn.sequence`),
-          messages: envelope.filled(turn.messages, `${declaration}.conversation.turn.messages`)
-            .map((message, index) => conversationMessage(message, `${declaration}.conversation.turn.messages[${index}]`)),
-        },
+      turn: {
+        id: input.text(turn.id, "request.turn.id", 128),
+        sequence: input.positiveCount(turn.sequence, "request.turn.sequence"),
+        messages: input.filled(turn.messages, "request.turn.messages")
+          .map((message, index) => conversationMessage(message, `request.turn.messages[${index}]`)),
       },
     };
   }
-  if (acquired.kind !== "routine") envelope.refuse(`${declaration}.kind`);
-  const request = envelope.plain(acquired.request, `${declaration}.request`);
-  const routine = envelope.plain(acquired.routine, `${declaration}.routine`);
+  if (request.kind !== "routine") input.refuse("request.kind");
+  const routine = input.plain(request.routine, "request.routine");
+  if (typeof request.payload !== "string" || Array.from(request.payload).length > 20_000) input.refuse("request.payload");
+  if (!Array.isArray(request.references)) input.refuse("request.references");
   return {
-    origin: envelope.text(acquired.origin, `${declaration}.origin`, 32),
+    kind: "routine",
+    origin: input.text(request.origin, "request.origin", 32),
     routine: {
-      name: envelope.text(routine.name, `${declaration}.routine.name`, 256),
-      version: envelope.positiveCount(routine.version, `${declaration}.routine.version`),
+      name: input.text(routine.name, "request.routine.name", 256),
+      version: input.positiveCount(routine.version, "request.routine.version"),
     },
-    payload: routineInput(request.payload, `${declaration}.request.payload`),
-    requested_by: envelope.text(
-      request.requested_by,
-      `${declaration}.request.requested_by`,
-      128,
-    ),
-    requested_at: envelope.text(
-      request.requested_at,
-      `${declaration}.request.requested_at`,
-      64,
-    ),
-    deliver_at:
-      request.deliver_at === null
-        ? null
-        : envelope.text(request.deliver_at, `${declaration}.request.deliver_at`, 64),
+    instruction: input.text(request.instruction, "request.instruction", 256 * 1024),
+    payload: request.payload,
+    references: request.references.map((reference, index) => input.plain(reference, `request.references[${index}]`)),
+    requested_by: input.text(request.requested_by, "request.requested_by", 128),
+    requested_at: input.text(request.requested_at, "request.requested_at", 64),
+    deliver_at: request.deliver_at === null ? null : input.text(request.deliver_at, "request.deliver_at", 64),
   };
 }
 
+export async function readRunRequest(session, run, token, signal = session.signal) {
+  return runRequest(await houseRequest(
+    session.house,
+    `Bearer ${token}`,
+    runRequestPath(run),
+    {},
+    session.dependencies,
+    signal,
+  ));
+}
+
 function acquiredAssignment(value, declaration) {
   const acquired = envelope.plain(value, declaration);
   const bridge = envelope.plain(acquired.session, `${declaration}.session`);
@@ -857,7 +857,6 @@ function acquiredAssignment(value, declaration) {
       token: envelope.text(bridge.bridge_token, `${declaration}.session.bridge_token`, 512),
       expiresAt: Date.parse(expiresAt),
     },
-    request: acquiredRequest(acquired, declaration),
   };
 }
 

package/src/inbound.js

@@ -134,13 +134,9 @@ export async function reconcileInbound(directory, session) {
 }
 
 export async function localRequest(directory, run, request) {
-  const turn = request?.conversation?.turn ?? (request?.kind === "conversation" ? request.turn : null);
-  if (turn === null || turn === undefined) return request;
+  if (request.kind !== "conversation") return request;
   const result = structuredClone(request);
-  const localTurn = result.conversation?.turn ?? result.turn;
-  if (!Array.isArray(localTurn.messages)) throw new KitRefusal("kit_run_input_unreadable");
-  for (const message of localTurn.messages) {
-    if (!Array.isArray(message.files)) throw new KitRefusal("kit_run_input_unreadable");
+  for (const message of result.turn.messages) {
     for (const file of message.files) {
       const parts = typeof file.path === "string" ? file.path.split("/") : [];
       if (parts.length !== 4 || parts[0] !== ROOT || parts[1] !== run || !UUID.test(parts[1]) || !UUID.test(parts[2]) || !segment(parts[3])) {
@@ -161,15 +157,3 @@ export async function localRequest(directory, run, request) {
   }
   return result;
 }
-
-export async function localReply(directory, run, frame, reply) {
-  if (frame.method !== "tools/call" || frame.params?.name !== "session_get_request" || reply.error || reply.result?.isError) return reply;
-  const result = structuredClone(reply);
-  for (const item of result.result?.content ?? []) {
-    if (item.type !== "text") continue;
-    let input;
-    try { input = JSON.parse(item.text); } catch { throw new KitRefusal("kit_run_input_unreadable"); }
-    item.text = JSON.stringify(await localRequest(directory, run, input));
-  }
-  return result;
-}

package/src/launcher.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { commandHouseInstructions, commandHouseRequest } from "./adapter-mcp.js";
+import { commandHouseInstructions } from "./adapter-mcp.js";
 import {
   compiledContract,
   initializeCommandAdapter,
@@ -191,13 +191,12 @@ async function runTurn(channel, start, bridge, turn) {
       loading = false;
     }
     await configureSession(acp, contract, providerSessionId, start.adapter);
-    const request = start.request === null ? await commandHouseRequest(bridge) : start.request;
     turn.adapterSession = true;
     turn.cancel = () => acp.cancel({ sessionId: providerSessionId });
     const prompted = await acp.request("session/prompt", {
       sessionId: providerSessionId,
       prompt: [
-        { type: "text", text: JSON.stringify(request) },
+        { type: "text", text: JSON.stringify(start.request) },
         { type: "text", text: instructions },
         ...workingCopyContext(start.working_copies),
       ],

package/src/worker.js

@@ -14,7 +14,7 @@ import { openBridge } from "./bridge.js";
 import { assistantBlocks } from "./blocks.js";
 import { retryConversationFiles } from "./conversation-originals.js";
 import { openAssistantDrafts } from "./draft.js";
-import { localReply, localRequest, reconcileInbound } from "./inbound.js";
+import { localRequest, reconcileInbound } from "./inbound.js";
 import { localFiles } from "./local-files.js";
 import { inheritedEnvironment } from "./command.js";
 import { watchKitWork } from "./kit-work-stream.js";
@@ -52,6 +52,7 @@ import {
   observeSessionStart,
   observeSessionStop,
   openSession,
+  readRunRequest,
   replaceSessionAuthority,
   reportContinuation,
   reportInterruptOutcome,
@@ -292,12 +293,12 @@ async function openRunBridge(context, bound, authority, start) {
     settle: handed((interaction, outcome) => settleInteraction(context, interaction, outcome)),
     forward: handed((frame, signal) =>
       localFiles(async (sent) =>
-        localReply(context.directory, bound.run, sent, await callHouseMcp(
+        callHouseMcp(
           context.session,
           await sessionAuthority(context.session, bound.session, authority, signal),
           sent,
           signal,
-        )), context.session.dependencies, signal)(frame)),
+        ), context.session.dependencies, signal)(frame)),
   });
   return { bridge, drafts, ended };
 }
@@ -467,7 +468,7 @@ async function prepareAssignment(context, assignment, resumed) {
     reported: null,
   };
   const authority = { token: assignment.session.token, expiresAt: assignment.session.expiresAt };
-  const opened = await openRunBridge(context, bound, authority, {
+  const start = {
     working_directory: assignment.workingDirectory,
     working_copies: await appliedWorkingCopies(context),
     execution_authority: context.configuration.executionAuthority,
@@ -479,10 +480,16 @@ async function prepareAssignment(context, assignment, resumed) {
       effort: route.effort,
       environment: {},
     },
-    request: await localRequest(context.directory, assignment.run, assignment.request),
+    request: null,
     provider_session: assignment.providerSessionId ?? null,
-  });
-  return { bound, opened };
+  };
+  const opened = await openRunBridge(context, bound, authority, start);
+  const request = async () => {
+    const token = await sessionAuthority(context.session, bound.session, authority);
+    start.request = await localRequest(context.directory, bound.run,
+      await readRunRequest(context.session, bound.run, token));
+  };
+  return { bound, opened, request };
 }
 
 async function refuseContinuation(context, command, failure) {
@@ -523,11 +530,12 @@ async function superviseAssignment(context, assignment, resumed = false) {
     if (undecided(context, refusal)) throw refusal;
     return refuseAssignment(context, assignment, failure);
   }
-  const { bound, opened } = prepared;
+  const { bound, opened, request } = prepared;
   return superviseBound(context, bound, opened, async (spawn) => {
     if (!resumed) await commitRun(context.session, assignment.run);
     spawn.committed = true;
     await writeBinding(context.directory, bound);
+    await request();
     await createSession(context.runtime, {
       session: bound.tmux,
       workingDirectory: assignment.workingDirectory,
@@ -549,7 +557,7 @@ async function superviseResumption(context, command) {
   }
   return superviseAssignment(context, {
     ...command, agentId: held.agentId, workingDirectory: held.workingDirectory,
-    conversation: held.conversation, providerSessionId: held.providerSessionId, request: null,
+    conversation: held.conversation, providerSessionId: held.providerSessionId,
   }, true);
 }