@borgee/agents-host 0.2.44 → 0.2.62

package/README.md

@@ -27,7 +27,7 @@ Borgee channel message
 - local-config multi-agent startup
 - one isolated `AgentsHost` per effective agent key
 - per-channel conversation memory via each provider's native session mechanism
-- one draft progress message per turn when a provider emits public progress
+- one message per turn, posted once the turn ends, with what the agent is doing reported on the ephemeral activity rail meanwhile
 - hot reload for host config and agent file add / update / remove
 
 **Out of scope:**
@@ -479,38 +479,35 @@ successfully applied snapshot running.
 Each Borgee channel is mapped 1:1 to a provider-native session while it stays
 active:
 
-- **Claude**: one persistent `@agentclientprotocol/claude-agent-acp` subprocess
-  is shared by a single `AgentsHost`, with one ACP session per Borgee channel.
-  Same-channel turns are serialized; different channels keep isolated ACP
-  sessions. Ordinary threads keep the shared runtime workspace cwd, while
-  eligible `task_assignment` threads switch the real ACP session cwd to that
-  same hidden local task-scoped workspace. The host persists the
-  channel→ACP-session map in its state root, restores same-host continuity with
-  ACP `session/resume` when available, retries stale restores with a fresh
-  session immediately, and injects the per-channel local context paths through
-  Claude ACP `_meta.systemPrompt.append`.
+- **Claude**: one persistent `@agentclientprotocol/claude-agent-acp` subprocess is shared by a single `AgentsHost`, with one ACP session per Borgee channel. Same-channel turns are serialized; different channels keep isolated ACP sessions. The real ACP session cwd now comes from the resolved channel workspace `~/.borgee/channels/<encoded-channel-id>/workspace`. Task threads only switch execution onto an explicit existing `execution.local_directory`; otherwise they stay discussion-only on `~/.borgee/channels/<encoded-thread-id>/scratch/workspace`, and ACP permission requests are denied so filesystem and shell tools stay unavailable. The host persists the channel→ACP-session map in its state root, restores same-host continuity with ACP `session/resume` when available, retries stale restores with a fresh session immediately, and injects the per-channel local context paths through Claude ACP `_meta.systemPrompt.append`.
 - **Codex**: one persistent `@agentclientprotocol/codex-acp` subprocess is
   shared by a single `AgentsHost`, with one ACP session per Borgee channel. When
   the current turn has a materialized channel context payload, Codex refreshes a
   same-directory `AGENTS.md` project document inside a provider-visible
   per-channel projection directory and exposes that directory to Codex through
-  ACP `additionalDirectories`. Ordinary threads keep the shared runtime
-  workspace as the ACP session cwd, while eligible `task_assignment` threads
-  switch the real ACP session cwd to a hidden local task workspace under
-  `<startup-workspace>/.borgee-task-workspaces/<thread>/<task>/`; that local
-  writable workspace is explicitly not a claim that the target repository is
-  already checked out there. The host persists the channel→ACP-session map in
-  its state root and attempts ACP `session/resume` first when the adapter
-  advertises it, otherwise `session/load`.
+  ACP `additionalDirectories`. The real ACP session cwd now comes from the
+  resolved channel workspace `~/.borgee/channels/<encoded-channel-id>/workspace`.
+  Task threads only switch execution onto an explicit existing
+  `execution.local_directory`; otherwise they stay discussion-only on
+  `~/.borgee/channels/<encoded-thread-id>/scratch/workspace`, and ACP
+  permission requests are denied so filesystem and shell tools stay
+  unavailable. The host persists the
+  channel→ACP-session map in its state root and attempts ACP `session/resume`
+  first when the adapter advertises it, otherwise `session/load`.
 - **Copilot**: one persistent `copilot --acp` subprocess is shared by a single
   `AgentsHost`, with one ACP session per Borgee channel. Same-channel turns are
-  serialized; different channels keep isolated ACP sessions. Ordinary threads
-  keep the shared runtime workspace cwd, while eligible `task_assignment`
-  threads switch the real ACP session cwd to that same hidden local
-  task-scoped workspace. The host persists the channel→ACP-session map in its
-  state root and restores same-host continuity with ACP `session/resume` when
-  available, otherwise `session/load` plus local replay cleanup on runtimes
-  that advertise only load support.
+  serialized; different channels keep isolated ACP sessions. The real ACP
+  session cwd now comes from the resolved channel workspace
+  `~/.borgee/channels/<encoded-channel-id>/workspace` by default. Task threads
+  only switch execution onto an explicit existing `execution.local_directory`;
+  otherwise they stay discussion-only on
+  `~/.borgee/channels/<encoded-thread-id>/scratch/workspace`, and ACP
+  permission requests are denied so filesystem and shell tools stay
+  unavailable. The
+  host persists the channel→ACP-session map in its state root and restores
+  same-host continuity with ACP `session/resume` when available, otherwise
+  `session/load` plus local replay cleanup on runtimes that advertise only
+  load support.
 
 We keep no transcript or history store of our own — only the native session id each provider should try to reopen next time. The transcripts themselves live in each CLI's own on-disk session store: `~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl` for Claude, `~/.codex/sessions/<yyyy>/<mm>/<dd>/rollout-<timestamp>-<threadId>.jsonl` for Codex, and `~/.copilot/session-state/<guid>/` for Copilot. Because those stores are on disk rather than in the adapter process, a session can be reopened later by a *different* process on the same machine — which is what makes conversation memory survive both a host restart and the idle recycle below. Continuity is same-machine and same-`$HOME` only: another machine, or a different home directory, has no session to reopen.
 
@@ -525,7 +522,7 @@ When a restore does fail, the run does not break: the stale session id is droppe
 - **A different machine or a different `$HOME`.** The session store is local, so continuity never crosses hosts.
 - **A stale Copilot session lock.** The Copilot CLI does not reliably unlink its `inuse.<pid>.lock` on an unclean exit ([github/copilot-cli#3255](https://github.com/github/copilot-cli/issues/3255), still open), so a force-killed process can leave a lock that makes the next restore believe the session is still in use. The idle teardown mitigates this: it gives the CLI a 5-second SIGTERM grace before any SIGKILL — twenty times the grace a fatal teardown uses — precisely so the CLI has time to unlink that lock. This is an internal default, not a knob.
 - **A very large Copilot transcript.** Long-running channels can hit upstream resume bugs: slow or memory-hungry resume ([#4251](https://github.com/github/copilot-cli/issues/4251)), a session that becomes unloadable once `events.jsonl` outgrows the V8 maximum string length ([#4325](https://github.com/github/copilot-cli/issues/4325)), and a resume-triggered compaction hang ([#4138](https://github.com/github/copilot-cli/issues/4138)). A Copilot resume may also reset the model back to the default ([#4397](https://github.com/github/copilot-cli/issues/4397)).
-- **Our own mapping rules, which are stricter than the CLI's.** We only reuse a persisted session id when the session's working directory *and* the set of directories exposed to it still match. So an ordinary channel turn and an eligible `task_assignment` turn — which runs in its own task workspace — deliberately do not share a session, and the switch between them starts a fresh one even though the CLI could still load the old session.
+- **Our own mapping rules, which are stricter than the CLI's.** We only reuse a persisted session id when the session's working directory *and* the set of directories exposed to it still match. So if the resolved channel workspace path changes, or if the injected provider-visible directory set changes, the host deliberately drops the old mapping and starts a fresh session even though the CLI could still load it.
 
 If you would rather keep the adapter process resident than take any of that, set `PROVIDER_IDLE_SHUTDOWN_MINUTES=0`, raise the window, or roll the behavior back entirely with `AGENTS_HOST_INTERNAL_DISABLED_COMPATIBILITY_GATES=provider-idle-shutdown`.
 

package/dist/agents-host.d.ts

@@ -27,9 +27,12 @@ export declare class AgentsHost {
      */
     private readonly recordedAgentSessionByTask;
     private readonly attentionSnapshotByChannel;
+    private readonly compactionSnapshotByChannel;
+    private readonly activeCompactionByChannel;
+    private readonly compactionSnapshotLoadedChannels;
+    private readonly compactionSnapshotWriteQueueByChannel;
     private readonly missedCollaborationDiagnosticByChannel;
-    private readonly progressChannelQueues;
-    private readonly progressDrafts;
+    private readonly channelTurnQueues;
     private readonly collaborationDrafts;
     private readonly collaborationChannels;
     private readonly participantDirectoryByUserId;
@@ -99,7 +102,12 @@ export declare class AgentsHost {
     private confirmProtocolMessage;
     private findChannelHistoryMessageById;
     private resolveAttentionStatePath;
+    private resolveCompactionStatePath;
     private buildDefaultAttentionSnapshot;
+    private ensureCompactionSnapshotLoaded;
+    private commitCompactionSnapshot;
+    private enqueueCompactionSnapshotCommit;
+    private noteCompactionProgress;
     /**
      * Record which provider session worked this task, as agent.session_id.
      *
@@ -117,6 +125,7 @@ export declare class AgentsHost {
     private revalidateAttentionSnapshotForTurn;
     private getAttentionSnapshotForTurn;
     private isHumanWakeFiltered;
+    private isOrdinaryAgentWakeFiltered;
     private applyAttentionUpdate;
     private commitAttentionSnapshot;
     private resolveTaskThreadCollaborationContractForTurn;
@@ -126,16 +135,29 @@ export declare class AgentsHost {
     private noteWakeSuppressedAttentionPolicy;
     private runUngatedTurn;
     private executeTurn;
+    /**
+     * Opens this turn's report on the activity rail.
+     *
+     * The generation is captured here, where the turn's own is, and every report
+     * is checked against the channel's current turn before it leaves. That is what
+     * keeps a superseded turn from announcing a boundary for a turn that no longer
+     * exists — including its ending, which a window opened before it was replaced
+     * would otherwise carry out on its behalf.
+     *
+     * Every turn reports, including the silent and deferred ones that deliver
+     * nothing to the channel. The rail writes nothing anywhere, and the question
+     * it answers — whether anything is happening in this channel — is worth the
+     * same answer for a turn that keeps its reply to itself.
+     */
+    private beginTurnActivity;
     private canAcceptTurnOutput;
     private canAcceptCompletedTurnOutput;
     private canContinueSharedProtocol;
-    private enqueueProgressChannelTurn;
-    private ensureProgressDraft;
+    private enqueueChannelTurn;
     private publishCollaborationDraft;
     private finalizeCollaborationDraft;
     private clearCollaborationDraft;
     private readCollaborationDraft;
-    private discardDraft;
     private supersedeActiveTurn;
     private invalidateChannelTurn;
     private rememberRecentTurn;