@proagentstore/cli 0.4.56 → 0.4.57

package/dist/browser-runner/coding/headless.js

@@ -60,6 +60,16 @@ export class HeadlessSession {
     run = "idle";
     /** Claude Code's own session id (from the init event) — used to --resume. */
     claudeSessionId = null;
+    /**
+     * The cloud's context brief, until the first turn spends it (ADR 0005, #693). Null once
+     * delivered, and null from the start when the engine resumed its own conversation.
+     *
+     * Consumed ONCE, by construction rather than by convention: it is cleared in the same expression
+     * that reads it. A brief re-sent on every turn would be the "unbounded brief… a token bill that
+     * grows every turn" the ADR names as the cost of owning the conversation, and it would also start
+     * contradicting the engine's own memory of the turns since.
+     */
+    pendingSeed = null;
     /** "stream-json" for Claude (structured) · "raw" for any other CLI (stdout capture). */
     mode;
     cmdBin;
@@ -181,6 +191,17 @@ export class HeadlessSession {
     get resumedConversation() {
         return this.mode === "stream-json" && this.claudeSessionId !== null;
     }
+    /**
+     * Did this engine come up cold AND with a brief to lead its first turn (ADR 0005, #693)?
+     *
+     * Read by `/coding/start` so the sentence the user is shown is one this side CONFIRMED. It is
+     * armed-not-delivered: the brief goes out with the first `input()`, which may never arrive if
+     * the session is closed first. That is why the cloud's wording is "it was given a brief" — true
+     * the moment the engine holds one — and never "it has read your history".
+     */
+    get seededConversation() {
+        return this.pendingSeed !== null;
+    }
     constructor(config) {
         this.config = config;
         this.engineLabel = `${config.clientType}:${config.id}`;
@@ -188,6 +209,10 @@ export class HeadlessSession {
         this.claudeSessionId = readState(config.statePath, config.id) ?? (config.resumeFrom ? readState(config.statePath, config.resumeFrom) : null);
         // Claude is the structured engine; everything else is a raw CLI.
         this.mode = config.clientType === "claude" ? "stream-json" : "raw";
+        // AFTER both lines above, because `resumedConversation` reads them: the brief is the fallback,
+        // so an engine that found its own conversation drops it unread rather than being handed a
+        // summary of the conversation it is already in.
+        this.pendingSeed = this.resumedConversation ? null : config.seed?.trim() || null;
         const { bin, args } = parseCommand(config.command);
         // When no explicit command is configured, fall back to THIS engine's default
         // command (codex/gemini/grok/…) — not a hard-coded "claude", which would drive a
@@ -381,8 +406,17 @@ export class HeadlessSession {
     input(text, opts = {}) {
         // The Engine reads the preamble, the pane the short marker; the instruction stays evidence.
         const sent = authoredTurn(text, opts.author);
+        // The brief leads the turn and is spent in the reading (#693). It goes to the ENGINE only:
+        // the pane gets the one-line marker below, because the transcript is what the owner and the
+        // Pilot re-read through `/coding/capture` and twelve thousand characters of reconstructed
+        // history would evict the live output they are looking at — the same budget argument
+        // `turn-author.ts` makes for its two-word marker.
+        const seed = this.pendingSeed;
+        this.pendingSeed = null;
         if (!this.alive)
             this.start();
+        if (seed)
+            this.push("[pags] a context brief from ProAgentStore's record was delivered with this turn — a reconstruction, not the previous conversation");
         this.push(`\n❯ [${stamp()}] ${authorTag(opts.author)}${text}`); // ❯ — your turn, timestamped
         this.run = "thinking";
         const now = Date.now();
@@ -390,16 +424,19 @@ export class HeadlessSession {
         this.turnStartedAt = now;
         this.sawOutputSinceInput = false; // arm the persistent-raw idle heuristic for THIS turn
         try {
+            // Brief first, instruction second, and never the other way round: it is background for
+            // the request, and an engine that reads the request last acts on the request.
+            const withSeed = seed ? `${seed}\n\n${sent}` : sent;
             if (this.mode === "stream-json") {
                 // `role` stays "user" — the only role this protocol accepts, which is why the
                 // disambiguation rides in the text instead (#505).
-                const msg = JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text: sent }] } });
+                const msg = JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text: withSeed }] } });
                 this.proc?.stdin?.write(`${msg}\n`);
             }
             else {
                 // Raw CLI: spawn THIS turn. See `oneShot` — there is no persistent process to
                 // write to, because a non-interactive binary would never have read it.
-                this.runOneShot(sent);
+                this.runOneShot(withSeed);
             }
         }
         catch {

package/dist/browser-runner/coding/runtime.js

@@ -117,6 +117,7 @@ export class CodingRuntime {
                 env: input.env,
                 statePath: defaultStatePath(this.reposBaseDir),
                 resumeFrom: input.resumeFrom,
+                seed: input.seed,
                 ghScope: input.ghScope,
                 bin: input.bin,
             });
@@ -126,8 +127,12 @@ export class CodingRuntime {
         // clears its own key on that exit. Reporting after would say "started clean" about a launch
         // that did carry a conversation, and the transcript (which shows the crash) would disagree.
         const resumed = session.resumedConversation;
+        // Read alongside `resumed`, and BEFORE `start()` for the same reason: a bad `--resume` that
+        // kills the process on spawn clears the engine's key, and a seed answer read afterwards would
+        // describe a different launch from the one the caller asked about.
+        const seeded = session.seededConversation;
         session.start();
-        return { ...this.snapshot(input.sessionId), resumed };
+        return { ...this.snapshot(input.sessionId), resumed, seeded };
     }
     /**
      * The pane the brain reasons over + the inferred run state.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-  "version": "0.4.56",
+  "version": "0.4.57",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",