@proagentstore/cli 0.4.64 → 0.4.66

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

@@ -428,7 +428,26 @@ export class HeadlessSession {
             }
         });
     }
-    /** Send a user turn. `author` names who wrote it, because `role` cannot — see turn-author.ts (#505). */
+    /**
+     * Does the engine carry its own conversation into THIS turn (#693 slice 2)?
+     *
+     * The boundary ADR 0005 draws, stated where the runner applies it: the platform's record is the
+     * source of truth and the engine's own memory is an optimisation preferred when it is there. It is
+     * there for a PERSISTENT process (Claude's stream-json session, a persistent REPL), which holds
+     * every turn since it started, and for a structured Codex turn that will resume its explicit
+     * thread (#848). A one-shot raw process has nothing: each turn is a new process.
+     */
+    get holdsConversationThisTurn() {
+        return this.adapter.persistent || this.codexResumeThreadId !== null;
+    }
+    /**
+     * Send a user turn. `author` names who wrote it, because `role` cannot — see turn-author.ts (#505).
+     *
+     * `replay` is the cloud's per-turn composition of the platform's record (#693 slice 2). It is spent
+     * only when {@link holdsConversationThisTurn} is false, so an engine with its own memory is never
+     * handed a summary of the conversation it is already in; when spent it replaces the one-shot
+     * session-start brief, being the same record composed later.
+     */
     input(text, opts = {}) {
         // The Engine reads the preamble, the pane the short marker; the instruction stays evidence.
         const sent = authoredTurn(text, opts.author);
@@ -437,11 +456,14 @@ export class HeadlessSession {
         // 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;
+        const replay = this.holdsConversationThisTurn ? null : opts.replay?.trim() || null;
+        const seed = replay ?? this.pendingSeed;
         this.pendingSeed = null;
         if (!this.alive)
             this.start();
-        if (seed)
+        if (replay)
+            this.push("[pags] this engine keeps no memory between turns, so ProAgentStore's record of the conversation so far was delivered with this turn — a reconstruction, not the engine's own memory");
+        else 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";

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

@@ -216,7 +216,7 @@ export class CodingRuntime {
             case "message":
                 // Narrowed rather than trusted: this runner is a published package any caller can
                 // POST to, and an unrecognised author must read as "unstated", not become a label.
-                session.input(action.text, { author: asTurnAuthor(action.author) });
+                session.input(action.text, { author: asTurnAuthor(action.author), replay: typeof action.replay === "string" ? action.replay : undefined });
                 break;
             case "keys": {
                 // A snapshot is no longer the whole answer (#448). `key()` records the attempt and

package/dist/index.js

@@ -1298,6 +1298,13 @@ function partitionByPin(instances, thisNode, alsoKnownAs = []) {
   for (const inst of instances) (isEligible(inst, thisNode, alsoKnownAs) ? here : elsewhere).push(inst);
   return { here, elsewhere };
 }
+function pinnedAway(held, instances, thisNode, alsoKnownAs = []) {
+  const pins = new Map(instances.map((i) => [i.id, i.config?.runnerNode]));
+  return [...held].filter((id) => {
+    const pin = pins.get(id);
+    return !!pin && pin !== thisNode && !alsoKnownAs.includes(pin);
+  });
+}
 function registrationStatus(attached, registered) {
   const ids = [...attached];
   const have = ids.filter((id) => registered.has(id)).length;
@@ -1311,6 +1318,7 @@ function instanceLabel(inst) {
 function reattachPlan(request, state) {
   const target = typeof request?.attach === "string" && request.attach ? request.attach : null;
   const force = target !== null && request?.force === true;
+  if (!state.watching && !target) return { target, unblock: false, detach: false, force: false, release: true };
   if (!state.watching && !(target && state.scope.includes(target))) {
     return {
       target,
@@ -1459,6 +1467,13 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     const named = typeof request?.attach === "string" ? request.attach : "";
     const plan = reattachPlan(request, { held: attached.has(named), blocked: blocked.has(named), watching: watchInstances, scope: instanceIds });
     if (plan.refuse) return { status: 409, result: { error: plan.refuse } };
+    if (plan.release) {
+      const res = await requestPags("GET", "/v1/instances/my/instances", { ...opts, pagsToken });
+      const released = pinnedAway(attached.keys(), res.instances ?? [], runnerNode, machine.names);
+      for (const id of released) detach(id, `${id.slice(0, 8)}\u2026 (pinned to another machine now)`);
+      if (released.length && attached.size === 0) writeLine("This `pags up --instance` holds no agent now \u2014 close it, or restart it without --instance.");
+      return { status: 200, result: { attached: [...attached.keys()], released } };
+    }
     if (plan.target) {
       if (plan.unblock) blocked.delete(plan.target);
       if (plan.detach) detach(plan.target);

package/package.json

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