@stigmer/react 3.1.5 → 3.1.6

package/src/session/SessionViewer.tsx

@@ -24,6 +24,7 @@ import { SelectionStore } from "../internal/store/selection-store.js";
 import { useWorkspaceEditors, isVirtualEntryId } from "../internal/store/index.js";
 import { ThreadSelectionContext } from "../execution/ThreadSelectionContext.js";
 import { useSelectedThreadItem } from "../execution/useThreadSelection.js";
+import { isTerminalPhase } from "../execution/execution-phases.js";
 import { MessageThread, type MessageThreadSlots } from "../execution/MessageThread.js";
 import { FileChangeProgressBar } from "../execution/FileChangeProgressBar.js";
 import { FileReviewDock } from "../execution/FileReviewDock.js";
@@ -1126,6 +1127,18 @@ function SessionPanelRegion({
     ],
   );
 
+  // Cloud sessions with a git workspace push approved changes back to a
+  // branch/PR, so the Changes facet is offered from the start with an honest
+  // pre-push state. Deliberately NOT for local sessions: local mode edits the
+  // user's own working tree and never writes back (the runner configures no
+  // push credentials there) — promising a PR would be a lie.
+  const expectsWriteBack =
+    flow.executionTarget === "cloud" &&
+    flow.workspace.entries.some((entry) => entry.type === "git");
+  const displayPhase =
+    flow.displayExecution?.status?.phase ??
+    ExecutionPhase.EXECUTION_PHASE_UNSPECIFIED;
+
   // The session facets (Config / Changes / Artifacts / Usage / Inspect) as
   // injected rail views — the full inspector feature set inside one panel.
   const railViews = useSessionRailViews({
@@ -1138,6 +1151,8 @@ function SessionPanelRegion({
     onOpenPlan,
     onOpenArtifact,
     onActivateArtifact,
+    expectsWriteBack,
+    changesSettled: isTerminalPhase(displayPhase),
   });
 
   // Explorer-footer folder attach (desktop only — needs the native picker).

package/src/session/__tests__/useSessionRailViews.test.tsx

@@ -80,6 +80,18 @@ describe("useSessionRailViews", () => {
     ]);
   });
 
+  it("offers Changes pre-push when a write-back is expected, without a zero badge", () => {
+    const { result } = renderViews({ expectsWriteBack: true });
+    const changes = result.current.find((v) => v.id === "changes");
+    expect(changes, "cloud git sessions get the facet before any push").toBeTruthy();
+    expect(changes?.badge).toBeUndefined();
+  });
+
+  it("hides Changes when no write-back exists and none is expected", () => {
+    const { result } = renderViews({ expectsWriteBack: false });
+    expect(result.current.some((v) => v.id === "changes")).toBe(false);
+  });
+
   it("surfaces Artifacts with a count badge", () => {
     artifactsState.hasArtifacts = true;
     artifactsState.artifactCount = 4;

package/src/session/facets/ChangesTab.tsx

@@ -6,20 +6,42 @@ import { WriteBackCard } from "../../execution/WriteBackCard.js";
 
 export interface ChangesTabProps {
   readonly executions: readonly AgentExecution[];
+  /**
+   * Whether this session is expected to push its approved changes back to a
+   * git remote — a CLOUD session with at least one git workspace entry (local
+   * sessions edit the user's own working tree and never write back). Enables
+   * the pre-write-back states below, so the facet answers "where does my work
+   * go?" before any push exists. Defaults to `false`: a bare `ChangesTab`
+   * stays the pure write-back list it always was.
+   */
+  readonly expectsWriteBack?: boolean;
+  /**
+   * Whether the session's latest execution is settled (terminal). Selects
+   * between the pre-write-back states: a live turn shows the "will be pushed
+   * here" promise, a settled one shows the honest "nothing pushed yet".
+   * Only consulted when {@link expectsWriteBack} is set and no write-back
+   * exists yet.
+   */
+  readonly isSettled?: boolean;
 }
 
 /**
- * Changes facet for the session panel — the session's git write-backs
- * (branch/commit/PR), one `WriteBackCard` per entry.
+ * Changes facet for the session panel — the definitive "where did my work go"
+ * surface: the session's git write-backs (branch/commit/PR), one
+ * `WriteBackCard` per entry, with honest pre-push states for cloud git
+ * sessions whose write-back hasn't happened yet.
  *
  * Local file changes deliberately do NOT render here: they live in the
  * transcript, where each stamped edit row shows its diff in place and the
  * per-turn decision bar carries the review controls and file list
- * (`FileReviewCard`). Duplicating them in a side panel gave the same change a
- * third rendering with no added authority. The facet therefore only surfaces
- * once a write-back exists (see `useSessionRailViews`).
+ * (`FileReviewCard`). This facet is exclusively the git OUTCOME surface —
+ * what was reviewed there lands here as a branch and pull request.
  */
-export function ChangesTab({ executions }: ChangesTabProps) {
+export function ChangesTab({
+  executions,
+  expectsWriteBack = false,
+  isSettled = false,
+}: ChangesTabProps) {
   const { writeBacks, hasWriteBacks } = useSessionWriteBacks(executions);
 
   if (hasWriteBacks) {
@@ -34,6 +56,21 @@ export function ChangesTab({ executions }: ChangesTabProps) {
     );
   }
 
+  if (expectsWriteBack) {
+    return (
+      <div className="flex flex-col items-center justify-center px-4 py-8 text-center">
+        <p className="text-xs text-muted-foreground">
+          {isSettled
+            ? "No changes have been pushed yet. When the agent changes files " +
+              "and you approve them, they are pushed to a branch and pull " +
+              "request here."
+            : "Changes stay in the session workspace while you review them. " +
+              "Approved changes are pushed to a branch and pull request here."}
+        </p>
+      </div>
+    );
+  }
+
   return (
     <div className="flex flex-col items-center justify-center px-4 py-8 text-center">
       <p className="text-xs text-muted-foreground">

package/src/session/facets/__tests__/ChangesTab.test.tsx

@@ -35,4 +35,27 @@ describe("ChangesTab", () => {
     expect(screen.getByText(/no changes yet/i)).toBeTruthy();
     expect(screen.getByText(/pull requests/i)).toBeTruthy();
   });
+
+  // Pre-push states for a session expected to write back (cloud + git):
+  // live turns promise where approved work will land; a settled execution
+  // reports honestly that nothing was pushed.
+  it("renders the in-review promise while a write-back is expected and the session is live", () => {
+    render(<ChangesTab executions={[]} expectsWriteBack isSettled={false} />);
+    expect(screen.getByText(/stay in the session workspace/i)).toBeTruthy();
+    expect(screen.getByText(/pushed to a branch and pull request here/i)).toBeTruthy();
+  });
+
+  it("renders the nothing-pushed state when expected but the execution settled without a push", () => {
+    render(<ChangesTab executions={[]} expectsWriteBack isSettled />);
+    expect(screen.getByText(/no changes have been pushed yet/i)).toBeTruthy();
+  });
+
+  it("write-backs take precedence over the pre-push states", () => {
+    writeBacksReturn.writeBacks = [{ writeBack: { workspaceEntryName: "w1" } }];
+    writeBacksReturn.hasWriteBacks = true;
+
+    render(<ChangesTab executions={[]} expectsWriteBack />);
+    expect(screen.getByTestId("write-back-card")).toBeTruthy();
+    expect(screen.queryByText(/no changes/i)).toBeNull();
+  });
 });

package/src/session/useSessionRailViews.tsx

@@ -54,6 +54,21 @@ export interface UseSessionRailViewsOptions {
    * @default true
    */
   readonly includeExecutionFacets?: boolean;
+  /**
+   * Whether the session is expected to push approved changes to a git remote
+   * (a cloud session with git workspace entries). When `true` the Changes
+   * facet is offered from the start — with an honest pre-push state — instead
+   * of only materializing once a write-back exists, so "where does my work
+   * go?" always has an answer. See {@link ChangesTabProps.expectsWriteBack}.
+   * @default false
+   */
+  readonly expectsWriteBack?: boolean;
+  /**
+   * Whether the session's latest execution is settled (terminal) — forwarded
+   * to the Changes facet's pre-push states. See {@link ChangesTabProps.isSettled}.
+   * @default false
+   */
+  readonly changesSettled?: boolean;
 }
 
 /**
@@ -77,6 +92,8 @@ export function useSessionRailViews({
   onOpenArtifact,
   onActivateArtifact,
   includeExecutionFacets = true,
+  expectsWriteBack = false,
+  changesSettled = false,
 }: UseSessionRailViewsOptions): readonly SurfaceRailView[] {
   const { hasWriteBacks, writeBackCount } = useSessionWriteBacks(allExecutions);
   const { hasArtifacts, artifactCount } = useSessionArtifacts(allExecutions);
@@ -94,13 +111,22 @@ export function useSessionRailViews({
     }
 
     if (includeExecutionFacets) {
-      if (hasWriteBacks) {
+      // Offered when a write-back exists OR the session is expected to
+      // produce one — the facet then carries an honest pre-push state
+      // instead of being invisible until the first push.
+      if (hasWriteBacks || expectsWriteBack) {
         views.push({
           id: "changes",
           label: "Changes",
           icon: <ChangesIcon />,
-          badge: writeBackCount,
-          content: <ChangesTab executions={allExecutions} />,
+          badge: writeBackCount > 0 ? writeBackCount : undefined,
+          content: (
+            <ChangesTab
+              executions={allExecutions}
+              expectsWriteBack={expectsWriteBack}
+              isSettled={changesSettled}
+            />
+          ),
         });
       }
 
@@ -145,6 +171,8 @@ export function useSessionRailViews({
   }, [
     sessionConfig,
     includeExecutionFacets,
+    expectsWriteBack,
+    changesSettled,
     hasWriteBacks,
     writeBackCount,
     hasArtifacts,

package/src/workflow/picker/__tests__/recents.test.ts

@@ -81,10 +81,10 @@ describe("TaskKindRecentsStore", () => {
 
   it("filters out invalid entries from localStorage", () => {
     const data = [
-      { kind: "valid_kind", timestamp: Date.now() },
-      { kind: 123, timestamp: Date.now() }, // invalid: kind is not string
-      { timestamp: Date.now() }, // invalid: missing kind
-      { kind: "another_valid", timestamp: Date.now() },
+      { kind: "valid_kind", timestamp: 2 },
+      { kind: 123, timestamp: 3 }, // invalid: kind is not string
+      { timestamp: 4 }, // invalid: missing kind
+      { kind: "another_valid", timestamp: 1 },
     ];
     globalThis.localStorage.setItem(TEST_KEY, JSON.stringify(data));