@meistrari/remy-cli 1.15.0 → 1.17.0

package/README.md

@@ -54,6 +54,8 @@ Published files and Tela Pages appear in the timeline. File artifacts include th
 
 When Remy creates a plan, the session shows its checklist in the timeline and keeps `Plan <done>/<total>` with the current item pinned above the composer. Updates change the same checklist instead of producing repeated rows, and an unfinished plan remains visible after reconnecting or between turns. The collapsed timeline shows up to five plan items; press `Ctrl+O` for the complete checklist and activity detail.
 
+Enter `/compact` to admit a durable main-thread context compaction control without sending a human message. Remy reports request admission immediately and shows the eventual completed, no-op, failed, or unknown provider result in retained activity. Compaction waits for a safe point and does not interrupt active work or jump ahead of an earlier Next message.
+
 Drag to select visible text in any Remy view; Remy copies it to the local clipboard and emits OSC 52 for terminal or remote-session clipboard support, then clears the selection highlight. Published file artifacts show their filename and muted, full web preview URL; open the URL in a browser to select that artifact in its session. Tela Page rows retain their canonical Page URL. Remy does not fetch or print artifact bytes. When the conversation has focus, press `Tab` to return to the composer.
 
 | Control | Result |
@@ -61,6 +63,7 @@ Drag to select visible text in any Remy view; Remy copies it to the local clipbo
 | `Esc` | Interrupt the active turn; the session stays open. |
 | `/complete` | Complete an open session after its active turn stops. |
 | `/cancel` | Cancel the current session, including an active turn. |
+| `/compact` | Admit a main-thread context compaction request without sending a message; the provider result appears in retained activity. |
 | `/sessions` | Return to the dashboard. |
 | `/new` | Start another new-session flow. |
 | `/logout` | Sign out of Remy after confirmation. |
@@ -99,6 +102,14 @@ The branch-suggestion flow belongs to the interactive new-session wizard (`remy`
 remy --session <session-id>
 ```
 
+To submit a follow-up immediately, add one quoted positional `prompt`:
+
+```bash
+remy --session <session-id> "Add regression coverage for that fix"
+```
+
+Remy sends the prompt as **Steer**, then opens the conversation. Omitting the prompt only attaches. An explicitly empty prompt is rejected. Use `--` before a prompt beginning with `--` to treat it as text.
+
 ### Automate a session
 
 `remy new` and `remy --session` use JSON Lines output automatically when standard input or output is not a terminal. Pass `--no-tui` to choose that mode explicitly; `--json` also selects it.
@@ -108,8 +119,11 @@ Opaque session and message metadata returned by the API is accepted for compatib
 ```bash
 remy new --no-tui --repository owner/repository "Add a health check endpoint"
 remy --session <session-id> --json
+remy --session <session-id> --no-tui "Add regression coverage for that fix"
 ```
 
+With a follow-up prompt, Remy submits it once and streams JSON Lines until that message reaches a terminal outcome, even if a previous message is cached locally. It exits with status `0` for a completed turn or `1` for another terminal outcome or an API failure. A follow-up does not emit a `created` record because the session already exists. If the local session cache becomes unavailable after admission, Remy warns once and continues observing the accepted follow-up in memory. Do not resubmit the prompt because of that warning; local resume metadata may remain stale. These commands require prior sign-in and can be used by scripts or other agents.
+
 For a newly created session, Remy writes a `created` record, event-name records as they arrive, then a `terminal` record when the submitted turn settles. A completed turn exits with status `0`; another terminal outcome exits with status `1`.
 
 ```json
@@ -151,7 +165,7 @@ remy logout [--api-url <url>]
 remy whoami
 remy dashboard
 remy new [--repository <owner/name> ... --installation <id> --model <name> --reasoning-effort <low|medium|high|xhigh> --attach <path> ... --no-tui --json] <prompt>
-remy --session <session-id> [--no-tui] [--json]
+remy --session <session-id> [--no-tui] [--json] [prompt]
 ```
 
 Run `remy <command> --help` for flags and command-specific usage. `remy whoami` prints the saved signed-in identity and organization.

package/dist/remy.js

@@ -32214,6 +32214,10 @@ var interruptAgentCommandSchema = runningCommandBaseSchema.extend({
   turnId: zod_default2.string().min(1).optional(),
   reason: zod_default2.string().min(1).optional()
 }).strict();
+var compactContextAgentCommandSchema = runningCommandBaseSchema.extend({
+  type: zod_default2.literal("agent.compact-context"),
+  commandId: commandIdSchema
+}).strict();
 var stopAgentCommandSchema = runningCommandBaseSchema.extend({
   type: zod_default2.literal("agent.stop"),
   reason: zod_default2.string().min(1).optional()
@@ -32227,6 +32231,7 @@ var respondUserInputAgentCommandSchema = runningCommandBaseSchema.extend({
 var agentCommandSchema = zod_default2.union([
   sendPromptCommandSchema,
   interruptAgentCommandSchema,
+  compactContextAgentCommandSchema,
   stopAgentCommandSchema,
   respondUserInputAgentCommandSchema
 ]);
@@ -32420,6 +32425,12 @@ var agentTurnEndStatusSchema = zod_default2.enum(["completed", "failed", "cancel
 var agentSubagentStatusSchema = zod_default2.enum(["completed", "failed", "cancelled"]);
 var agentContextCompactionTriggerSchema = zod_default2.enum(["manual", "auto", "unknown"]);
 var agentContextCompactionStatusSchema = zod_default2.enum(["completed", "failed"]);
+var agentContextCompactionRequestResultSchema = zod_default2.discriminatedUnion("status", [
+  zod_default2.object({ status: zod_default2.literal("completed") }).strict(),
+  zod_default2.object({ status: zod_default2.literal("no_op"), reason: zod_default2.string() }).strict(),
+  zod_default2.object({ status: zod_default2.literal("failed"), error: agentErrorSchema }).strict(),
+  zod_default2.object({ status: zod_default2.literal("unknown") }).strict()
+]);
 var agentErrorSourceSchema = zod_default2.enum(["provider", "runtime", "transport", "unknown"]);
 var agentSkillScopeSchema = zod_default2.enum(["user", "repository", "system", "admin"]);
 var agentSkillSchema = zod_default2.object({
@@ -32672,6 +32683,13 @@ var contextCompactionCompletedAgentEventSchema = agentTurnEventBaseSchema.extend
     error: agentErrorSchema.optional()
   }).strict()
 }).strict();
+var contextCompactionRequestCompletedAgentEventSchema = agentEventBaseSchema.extend({
+  type: zod_default2.literal("context.compaction.request.completed"),
+  payload: zod_default2.object({
+    commandId: zod_default2.string().min(1),
+    result: agentContextCompactionRequestResultSchema
+  }).strict()
+}).strict();
 var userInputRequestedAgentEventSchema = agentTurnEventBaseSchema.extend({
   type: zod_default2.literal("user-input.requested"),
   payload: zod_default2.object({
@@ -32724,6 +32742,7 @@ var agentEventSchema = zod_default2.discriminatedUnion("type", [
   contextUpdatedAgentEventSchema,
   contextCompactionStartedAgentEventSchema,
   contextCompactionCompletedAgentEventSchema,
+  contextCompactionRequestCompletedAgentEventSchema,
   userInputRequestedAgentEventSchema,
   userInputResolvedAgentEventSchema,
   errorAgentEventSchema
@@ -32912,6 +32931,13 @@ var interruptSessionResponseSchema = exports_external2.strictObject({
     type: exports_external2.literal("agent.interrupt")
   })
 });
+var compactSessionContextResponseSchema = exports_external2.strictObject({
+  command: exports_external2.strictObject({
+    id: exports_external2.string(),
+    sequence: exports_external2.number().int().positive(),
+    type: exports_external2.literal("agent.compact-context")
+  })
+});
 var withdrawSessionMessageResponseSchema = exports_external2.strictObject({
   command: exports_external2.strictObject({
     id: exports_external2.string(),
@@ -33082,6 +33108,24 @@ async function interruptSession({
     throw new CodingAgentProtocolError("Session interrupt response did not match the public API contract.", { cause: parsed.error });
   return parsed.data.command;
 }
+async function compactSessionContext({
+  client,
+  sessionId,
+  idempotencyKey
+}) {
+  const response = await client.request(`/v1/sessions/${encodeURIComponent(sessionId)}/compact`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "Idempotency-Key": idempotencyKey
+    },
+    body: "{}"
+  });
+  const parsed = compactSessionContextResponseSchema.safeParse(await parseJson2(response, "Session context compaction response was not valid JSON."));
+  if (!parsed.success)
+    throw new CodingAgentProtocolError("Session context compaction response did not match the public API contract.", { cause: parsed.error });
+  return parsed.data.command;
+}
 async function completeSession({ client, sessionId }) {
   const response = await client.request(`/v1/sessions/${encodeURIComponent(sessionId)}/complete`, { method: "PUT" });
   const parsed = sessionDetailResponseSchema.safeParse(await parseJson2(response, "Session completion response was not valid JSON."));
@@ -34022,6 +34066,9 @@ var wrappedContextCompactionStartedAgentEventSchema = contextCompactionStartedAg
 var wrappedContextCompactionCompletedAgentEventSchema = contextCompactionCompletedAgentEventSchema.extend({
   type: zod_default2.literal("agent.context.compaction.completed")
 }).strict();
+var wrappedContextCompactionRequestCompletedAgentEventSchema = contextCompactionRequestCompletedAgentEventSchema.extend({
+  type: zod_default2.literal("agent.context.compaction.request.completed")
+}).strict();
 var wrappedUserInputRequestedAgentEventSchema = userInputRequestedAgentEventSchema.extend({
   type: zod_default2.literal("agent.user-input.requested")
 }).strict();
@@ -34056,11 +34103,31 @@ var wrappedAgentEventSchema = zod_default2.discriminatedUnion("type", [
   wrappedContextUpdatedAgentEventSchema,
   wrappedContextCompactionStartedAgentEventSchema,
   wrappedContextCompactionCompletedAgentEventSchema,
+  wrappedContextCompactionRequestCompletedAgentEventSchema,
   wrappedUserInputRequestedAgentEventSchema,
   wrappedUserInputResolvedAgentEventSchema,
   wrappedErrorAgentEventSchema
 ]);
 
+// ../../packages/agents-protocol/src/agent-identity.ts
+function normalizeAgentSubagentIdentity(identity) {
+  return {
+    actorId: identity.actorId,
+    subagentId: identity.subagentId,
+    parentActorId: identity.parentActorId,
+    origin: identity.origin,
+    parentToolCallId: identity.parentToolCallId ?? (identity.origin.type === "tool_call" ? identity.origin.toolCallId : undefined)
+  };
+}
+function agentSubagentIdentitiesEqual(left, right) {
+  const normalizedLeft = normalizeAgentSubagentIdentity(left);
+  const normalizedRight = normalizeAgentSubagentIdentity(right);
+  return normalizedLeft.actorId === normalizedRight.actorId && normalizedLeft.subagentId === normalizedRight.subagentId && normalizedLeft.parentActorId === normalizedRight.parentActorId && normalizedLeft.parentToolCallId === normalizedRight.parentToolCallId && (normalizedLeft.origin.type === "tool_call" ? normalizedRight.origin.type === "tool_call" && normalizedLeft.origin.toolCallId === normalizedRight.origin.toolCallId : normalizedRight.origin.type === "provider_task" && normalizedLeft.origin.taskId === normalizedRight.origin.taskId);
+}
+function agentRuntimeIdentityKey(event) {
+  return `${event.sessionId.length}:${event.sessionId}:${event.providerSessionId.length}:${event.providerSessionId}`;
+}
+
 // src/sessions/projection.ts
 var sessionMessageCreatedEventSchema = exports_external2.object({
   type: exports_external2.literal("session.message.created"),
@@ -34389,11 +34456,7 @@ function projectAgentTurnEnded({ state, event, occurredAt, retainedEventId }) {
     retainedTurnEnds: { ...state.retainedTurnEnds, [event.turnId]: { actorType: event.actor.type, outcome: event.payload.status } },
     messageTurns: Object.fromEntries(Object.entries(state.messageTurns).map(([messageId, turn]) => [messageId, turn.turnId === event.turnId ? { ...turn, outcome: event.payload.status } : turn]))
   } : state;
-  const card = event.actor.type === "main" ? event.payload.status === "failed" ? { kind: "failure", weight: "signal", title: "Remy turn failed", summary: "Turn failed." } : { kind: "lifecycle", weight: "noise", title: "Remy turn ended", summary: `Turn ${event.payload.status}.` } : createChildActivityCard({
-    identity: event.actor,
-    activityTitle: event.payload.status === "failed" ? "Turn failed" : "Turn ended",
-    card: event.payload.status === "failed" ? { kind: "failure", weight: "signal", summary: providerText(event.payload.error?.message, "Turn failed.") } : { kind: "lifecycle", weight: "noise", summary: `Turn ${event.payload.status}.` }
-  });
+  const card = toAgentActivityCard(event);
   return appendActivity({ state: stateWithTurnOutcome, retainedEventId, occurredAt, card });
 }
 function projectDurableAgentEvent({ state, event, occurredAt, retainedEventId }) {
@@ -34538,7 +34601,7 @@ function toMainAgentActivityCard(event) {
     case "agent.turn.started":
       return { kind: "lifecycle", weight: "noise", title: "Remy turn started", summary: "Turn started." };
     case "agent.turn.ended":
-      return event.payload.status === "failed" ? { kind: "failure", weight: "signal", title: "Remy turn failed", summary: providerText(event.payload.error?.message, "Turn failed.") } : { kind: "lifecycle", weight: "noise", title: "Remy turn ended", summary: `Turn ${event.payload.status}.` };
+      return event.payload.status === "failed" ? { kind: "failure", weight: "signal", title: "Remy turn failed", summary: "Turn failed." } : { kind: "lifecycle", weight: "noise", title: "Remy turn ended", summary: `Turn ${event.payload.status}.` };
     case "agent.work.observed":
       return { kind: "progress", weight: "noise", title: "Work progress", summary: "Remy updated its work plan.", detail: jsonDetail(event.payload.observations) };
     case "agent.message.started":
@@ -34574,6 +34637,16 @@ function toMainAgentActivityCard(event) {
       return { kind: "reasoning", weight: "noise", title: "Context compaction started", summary: "Remy is compacting context." };
     case "agent.context.compaction.completed":
       return event.payload.status === "failed" ? { kind: "failure", weight: "signal", title: "Context compaction failed", summary: providerText(event.payload.error?.message, "Context compaction failed.") } : { kind: "reasoning", weight: "noise", title: "Context compaction completed", summary: "Remy compacted context." };
+    case "agent.context.compaction.request.completed": {
+      const result = event.payload.result;
+      if (result.status === "completed")
+        return { kind: "progress", weight: "signal", title: "Context compaction completed", summary: "The provider completed manual context compaction." };
+      if (result.status === "no_op")
+        return { kind: "progress", weight: "signal", title: "Context not compacted", summary: providerText(result.reason, "The provider did not compact context.") };
+      if (result.status === "failed")
+        return { kind: "failure", weight: "signal", title: "Context compaction failed", summary: providerText(result.error.message, "Context compaction failed.") };
+      return { kind: "progress", weight: "signal", title: "Context compaction result unknown", summary: "The provider result could not be correlated." };
+    }
     case "agent.user-input.requested":
       return { kind: "approval-question", weight: "signal", title: "Remy needs input", summary: providerText(event.payload.prompt, "Remy needs input."), detail: jsonDetail(event.payload.questions) };
     case "agent.user-input.resolved":
@@ -34659,6 +34732,7 @@ function toChildAgentActivityCard({ event, identity }) {
     case "agent.session.skills.updated":
     case "agent.session.state.changed":
     case "agent.session.ended":
+    case "agent.context.compaction.request.completed":
     case "agent.user-input.resolved":
     case "agent.error":
       throw new SessionProjectionProtocolError(`Cannot attribute non-child session event type ${event.type} to a subagent.`);
@@ -34701,7 +34775,7 @@ ${card.detail}`;
 function childActivityIdentity(event) {
   if (event.type === "agent.subagent.started" || event.type === "agent.subagent.progress" || event.type === "agent.subagent.ended") {
     if (event.actor.type === "subagent") {
-      if (!subagentLifecycleIdentityMatches({ actor: event.actor, payload: event.payload }))
+      if (!agentSubagentIdentitiesEqual(event.actor, event.payload))
         throw new SessionProjectionProtocolError(`Retained session event type ${event.type} carried contradictory subagent actor and payload identity.`);
       return {
         ...event.actor,
@@ -34723,14 +34797,6 @@ function childActivityIdentity(event) {
   }
   return;
 }
-function subagentLifecycleIdentityMatches({ actor, payload }) {
-  return actor.actorId === payload.actorId && actor.subagentId === payload.subagentId && actor.parentActorId === payload.parentActorId && actor.parentToolCallId === payload.parentToolCallId && subagentOriginsMatch(actor.origin, payload.origin);
-}
-function subagentOriginsMatch(left, right) {
-  if (left.type === "tool_call")
-    return right.type === "tool_call" && left.toolCallId === right.toolCallId;
-  return right.type === "provider_task" && left.taskId === right.taskId;
-}
 function recordAgentLineageEvent({
   state,
   event,
@@ -34746,7 +34812,7 @@ function recordAgentLineageEvent({
       return state;
     throw error93;
   }
-  const runtimeBase = lineageRuntimeBase(parsed);
+  const runtimeBase = agentRuntimeIdentityKey(parsed);
   let childLineage = state.childLineage;
   if (parsed.type === "agent.session.started" || parsed.type === "agent.session.ended") {
     const boundaryKey = `${runtimeBase}:${lengthPrefixed(parsed.eventId)}`;
@@ -34805,7 +34871,7 @@ function recordAgentLineageEvent({
   return stampResolvedAttribution({ state: nextState, retainedEventId, fact, owner: resolution.owner });
 }
 function resolveBodyFactAgainstOwners(owners, fact) {
-  const candidates = owners.filter((owner) => owner.runtimeScope === fact.runtimeScope && childIdentityMatches(owner.identity, fact.identity));
+  const candidates = owners.filter((owner) => owner.runtimeScope === fact.runtimeScope && agentSubagentIdentitiesEqual(owner.identity, fact.identity));
   const turnCandidates = candidates.filter((owner) => owner.childTurnIds.has(fact.turnId));
   if (turnCandidates.length === 1)
     return { status: "known", owner: turnCandidates[0] };
@@ -34837,9 +34903,6 @@ function stampResolvedAttribution({ state, retainedEventId, fact, owner }) {
   }
   return state;
 }
-function lineageRuntimeBase(event) {
-  return `${lengthPrefixed(event.sessionId)}:${lengthPrefixed(event.providerSessionId)}`;
-}
 function lineageRuntimeScope({ runtimeBase, epoch }) {
   return `${runtimeBase}:${epoch}`;
 }
@@ -34852,9 +34915,6 @@ function isChildLineageFact(fact) {
 function isSubagentLifecycleType(type) {
   return type === "agent.subagent.started" || type === "agent.subagent.progress" || type === "agent.subagent.ended";
 }
-function childIdentityMatches(left, right) {
-  return left.actorId === right.actorId && left.subagentId === right.subagentId && left.parentActorId === right.parentActorId && left.parentToolCallId === right.parentToolCallId && subagentOriginsMatch(left.origin, right.origin);
-}
 function childIdentityCanAnchor(identity) {
   return identity.actorId !== identity.parentActorId && (identity.origin.type !== "tool_call" || identity.parentToolCallId === undefined || identity.parentToolCallId === identity.origin.toolCallId);
 }
@@ -34888,9 +34948,9 @@ function reconcileChildLineage(state) {
     if (parent && ownerHasActorAncestor(parent, fact.identity.actorId))
       return;
     const samePlacement = owners.filter((owner2) => owner2.runtimeScope === fact.runtimeScope && owner2.owningMainTurnId === owningMainTurnId && owner2.parent === parent && owner2.identity.actorId === fact.identity.actorId && owner2.identity.subagentId === fact.identity.subagentId);
-    if (samePlacement.some((owner2) => !childIdentityMatches(owner2.identity, fact.identity)))
+    if (samePlacement.some((owner2) => !agentSubagentIdentitiesEqual(owner2.identity, fact.identity)))
       return;
-    const existing = samePlacement.find((owner2) => childIdentityMatches(owner2.identity, fact.identity));
+    const existing = samePlacement.find((owner2) => agentSubagentIdentitiesEqual(owner2.identity, fact.identity));
     if (existing)
       return existing;
     const owner = {
@@ -34924,7 +34984,7 @@ function reconcileChildLineage(state) {
       const toolTurn = mainTurnForToolOrigin(fact);
       if (toolTurn === undefined)
         continue;
-      const owner = owners.find((candidate) => candidate.runtimeScope === fact.runtimeScope && candidate.parent === null && candidate.owningMainTurnId === toolTurn && childIdentityMatches(candidate.identity, fact.identity)) ?? createOwner({ fact, owningMainTurnId: toolTurn, parent: null });
+      const owner = owners.find((candidate) => candidate.runtimeScope === fact.runtimeScope && candidate.parent === null && candidate.owningMainTurnId === toolTurn && agentSubagentIdentitiesEqual(candidate.identity, fact.identity)) ?? createOwner({ fact, owningMainTurnId: toolTurn, parent: null });
       if (owner) {
         ownerByFactOrder.set(fact.order, owner);
         owner.childTurnIds.add(fact.turnId);
@@ -34937,7 +34997,7 @@ function reconcileChildLineage(state) {
     for (const fact of childFacts) {
       if (ownerByFactOrder.has(fact.order))
         continue;
-      const candidates = owners.filter((owner2) => owner2.runtimeScope === fact.runtimeScope && childIdentityMatches(owner2.identity, fact.identity));
+      const candidates = owners.filter((owner2) => owner2.runtimeScope === fact.runtimeScope && agentSubagentIdentitiesEqual(owner2.identity, fact.identity));
       const turnCandidates = candidates.filter((owner2) => owner2.childTurnIds.has(fact.turnId));
       const owner = turnCandidates.length === 1 ? turnCandidates[0] : candidates.length === 1 ? candidates[0] : undefined;
       if (!owner || fact.eventType === "agent.subagent.started")
@@ -35013,12 +35073,16 @@ function ownerPath(owner) {
   return path;
 }
 function childAttributionEqual(left, right) {
-  if (left.status !== right.status || left.activityTitle !== right.activityTitle || !childIdentityMatches(left.identity, right.identity)) {
+  if (left === right)
+    return true;
+  if (!left || !right)
+    return false;
+  if (left.status !== right.status || left.activityTitle !== right.activityTitle || left.identity.name !== right.identity.name || !agentSubagentIdentitiesEqual(left.identity, right.identity)) {
     return false;
   }
   if (left.status === "unresolved" || right.status === "unresolved")
     return true;
-  return left.ownerKey === right.ownerKey && left.owningMainTurnId === right.owningMainTurnId && left.path.length === right.path.length && left.path.every((identity, index) => childIdentityMatches(identity, right.path[index]));
+  return left.ownerKey === right.ownerKey && left.owningMainTurnId === right.owningMainTurnId && left.path.length === right.path.length && left.path.every((identity, index) => identity.name === right.path[index].name && agentSubagentIdentitiesEqual(identity, right.path[index]));
 }
 function terminalSafeSingleLine(value) {
   return stripAnsi(value).replace(/\s+/gu, " ").trim();
@@ -35251,6 +35315,7 @@ function createRemoteSessionController(dependencies) {
   let stopped = false;
   let state;
   let cachedLastRetainedEventId;
+  let cacheUnavailable = false;
   let reasoningPreviewState = initialReasoningPreviewState();
   let reasoningConnectionGeneration = 0;
   let reasoningHistorySequenceFloor = -1;
@@ -35259,7 +35324,10 @@ function createRemoteSessionController(dependencies) {
     ready = new Promise((resolve) => {
       resolveReady = resolve;
     });
-    const cache = await readSessionCache(cachePath);
+    const cache = await readSessionCache(cachePath).catch((error93) => {
+      handleCacheError(error93);
+      return null;
+    });
     cachedLastRetainedEventId = input.mode === "live" ? input.lastRetainedEventId ?? cache?.lastRetainedEventId : undefined;
     state = createSessionViewState({
       detail: input.detail,
@@ -35486,6 +35554,8 @@ function createRemoteSessionController(dependencies) {
     };
   }
   async function writeCache() {
+    if (cacheUnavailable)
+      return;
     const currentState = getState();
     const cache = {
       version: 1,
@@ -35495,7 +35565,13 @@ function createRemoteSessionController(dependencies) {
       ...currentState.activeMessageId ? { activeMessageId: currentState.activeMessageId } : {},
       updatedAt: new Date().toISOString()
     };
-    await writeSessionCache({ path: cachePath, cache });
+    await writeSessionCache({ path: cachePath, cache }).catch(handleCacheError);
+  }
+  function handleCacheError(error93) {
+    if (!dependencies.onCacheError)
+      throw error93;
+    cacheUnavailable = true;
+    dependencies.onCacheError(error93);
   }
   function publishState(frame) {
     const update = { state: getState(), ...frame ? { frame } : {} };
@@ -37990,6 +38066,7 @@ var composerSlashCommands = [
   { value: "/sessions", description: "Back to the session list" },
   { value: "/complete", description: "Finish this session" },
   { value: "/cancel", description: "Cancel this session" },
+  { value: "/compact", description: "Compact main-thread context" },
   { value: "/new", description: "Start a new session" },
   { value: "/logout", description: "Sign out of Remy" },
   { value: "/help", description: "Show what you can do here" },
@@ -38001,6 +38078,7 @@ async function createSessionTui({
   controller,
   submitMessage,
   requestInterrupt,
+  requestCompact,
   requestComplete,
   requestCancel,
   repositoryLabel,
@@ -38242,6 +38320,7 @@ async function createSessionTui({
     let admittedSubmissions = [];
     let stopState = { kind: "idle" };
     let lifecycleRequestState = { kind: "idle" };
+    let contextCompactionRequestState = { kind: "idle" };
     let helpVisible = false;
     let logoutConfirmationOpen = false;
     let latestState = controller.getState();
@@ -38592,6 +38671,12 @@ async function createSessionTui({
         handleLifecycleRequest("cancel");
         return true;
       }
+      if (command === "/compact") {
+        composer.setText("");
+        composerDraft = { ...composerDraft, text: "" };
+        await handleCompactionRequest();
+        return true;
+      }
       if (command === "/logout") {
         composer.setText("");
         composerDraft = { ...composerDraft, text: "" };
@@ -38679,6 +38764,39 @@ async function createSessionTui({
       }
       render();
     }
+    async function handleCompactionRequest() {
+      if (contextCompactionRequestState.kind === "requesting")
+        return;
+      if (latestState.aggregateStatus !== "open") {
+        composerFeedback = "This session is already terminal.";
+        render();
+        return;
+      }
+      const idempotencyKey = contextCompactionRequestState.kind === "delivery-unknown" ? contextCompactionRequestState.idempotencyKey : crypto.randomUUID();
+      contextCompactionRequestState = { kind: "requesting", idempotencyKey };
+      composerFeedback = "Requesting context compaction\u2026";
+      render();
+      try {
+        await requestCompact({ idempotencyKey });
+        if (!destroyed) {
+          contextCompactionRequestState = { kind: "admitted" };
+          composerFeedback = "Context compaction request admitted. Result will appear in the timeline.";
+        }
+      } catch (error93) {
+        if (!destroyed) {
+          const message = error93 instanceof Error ? error93.message : String(error93);
+          if (isKnownClientRejection(error93)) {
+            contextCompactionRequestState = { kind: "idle" };
+            composerFeedback = `Could not request context compaction: ${message}`;
+          } else {
+            contextCompactionRequestState = { kind: "delivery-unknown", idempotencyKey };
+            composerFeedback = `Context compaction admission is unknown: ${message}. Run /compact again to retry the same request.`;
+          }
+        }
+      }
+      if (!destroyed)
+        render();
+    }
     async function handleLifecycleRequest(operation) {
       if (lifecycleRequestState.kind === "pending")
         return;
@@ -38805,6 +38923,7 @@ var helpEntries = [
   { group: "command", token: "/sessions", description: "back to the session list" },
   { group: "command", token: "/complete", description: "finish this session" },
   { group: "command", token: "/cancel", description: "cancel this session" },
+  { group: "command", token: "/compact", description: "compact main-thread context" },
   { group: "command", token: "/logout", description: "sign out of Remy" },
   { group: "command", token: "/exit", description: "leave Remy" },
   { group: "key", token: "esc", description: "stop Remy\u2019s current turn" },
@@ -39022,19 +39141,7 @@ function activityGlyph({ kind, inFlight }) {
   return { glyph: "\u2713", color: PALETTE.dimText };
 }
 function activityCardsHaveEqualDisclosure(left, right) {
-  return left.kind === right.kind && left.title === right.title && left.summary === right.summary && left.detail === right.detail && left.detailFormat === right.detailFormat && canonicalValuesEqual(left.attribution, right.attribution);
-}
-function canonicalValuesEqual(left, right) {
-  if (Object.is(left, right))
-    return true;
-  if (Array.isArray(left) || Array.isArray(right)) {
-    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => canonicalValuesEqual(value, right[index]));
-  }
-  if (typeof left !== "object" || left === null || typeof right !== "object" || right === null)
-    return false;
-  const leftEntries = Object.entries(left);
-  const rightEntries = Object.entries(right);
-  return leftEntries.length === rightEntries.length && leftEntries.every(([key, value], index) => rightEntries[index]?.[0] === key && canonicalValuesEqual(value, rightEntries[index]?.[1]));
+  return left.kind === right.kind && left.title === right.title && left.summary === right.summary && left.detail === right.detail && left.detailFormat === right.detailFormat && childAttributionEqual(left.attribution, right.attribution);
 }
 function renderActivityGroup({ items, activityExpanded }) {
   if (items.length === 0)
@@ -39235,6 +39342,12 @@ function renderComposerStatus({ admittedSubmissions }) {
 
 `);
 }
+function isKnownClientRejection(error93) {
+  if (typeof error93 !== "object" || error93 === null || !("status" in error93))
+    return false;
+  const status = error93.status;
+  return typeof status === "number" && status >= 400 && status < 500;
+}
 async function createDefaultRenderer3() {
   return await createRemyRenderer();
 }
@@ -39495,7 +39608,7 @@ var compactMarkRows = 9;
 var compactMinWidth = 48;
 var compactMinHeight = 20;
 var markBrightnessGain = 4.2;
-var remyCliVersion = "1.15.0";
+var remyCliVersion = "1.17.0";
 async function showRemySplash({
   createRenderer = createRemyRenderer,
   durationMs = splashDurationMs,
@@ -39868,7 +39981,7 @@ async function dispatchCliCommandWithShutdown({
     });
   }
   if (command.name === "session")
-    return await attachSession({ dependencies, sessionId: command.sessionId, noTui: command.noTui, json: command.json });
+    return await attachSession({ dependencies, sessionId: command.sessionId, noTui: command.noTui, json: command.json, prompt: command.prompt });
   return await createNewSession({ dependencies, command });
 }
 function createCliShutdown({ abortSignal }) {
@@ -40775,12 +40888,30 @@ async function attachSession({
   dependencies,
   sessionId,
   noTui,
-  json: json3
+  json: json3,
+  prompt
 }) {
   const operations = await createSessionOperations(dependencies);
   const detail = await operations.getSession({ client: operations.client, sessionId });
   const repositories = detail.repositories.map((repository) => ({ id: repository.id, fullName: repository.full_name }));
   const cache = await (dependencies.readSessionCache ?? readSessionCache)(resolveSessionCachePathForCommand({ dependencies, sessionId }));
+  let activeMessageId = cache?.activeMessageId;
+  let cacheWarningReported = false;
+  const onCacheError = prompt === undefined ? undefined : () => {
+    if (cacheWarningReported)
+      return;
+    cacheWarningReported = true;
+    dependencies.output.writeStderr(`Local session cache is unavailable; continuing to observe the accepted follow-up. Do not resubmit the prompt.
+`);
+  };
+  if (prompt !== undefined) {
+    throwIfAborted2(dependencies.abortSignal);
+    const appended = await operations.appendSessionMessage({
+      client: operations.client,
+      input: { sessionId, text: prompt, fileIds: [], mode: "steer", idempotencyKey: randomUUID5() }
+    });
+    activeMessageId = appended.message.id;
+  }
   await (dependencies.writeSessionCache ?? writeSessionCache)({
     path: resolveSessionCachePathForCommand({ dependencies, sessionId }),
     cache: {
@@ -40788,20 +40919,25 @@ async function attachSession({
       sessionId,
       repositories,
       ...cache?.lastRetainedEventId ? { lastRetainedEventId: cache.lastRetainedEventId } : {},
-      ...cache?.activeMessageId ? { activeMessageId: cache.activeMessageId } : {},
+      ...activeMessageId ? { activeMessageId } : {},
       updatedAt: new Date().toISOString()
     }
+  }).catch((error93) => {
+    if (!onCacheError)
+      throw error93;
+    onCacheError();
   });
   return await runAttachedSession({
     dependencies,
     operations,
     sessionId,
     repositories,
-    activeMessageId: cache?.activeMessageId,
+    activeMessageId,
     start: { mode: "cold-resume", detail },
     noTui,
     json: json3,
-    emitCreated: false
+    emitCreated: false,
+    onCacheError
   });
 }
 async function runAttachedSession({
@@ -40813,7 +40949,8 @@ async function runAttachedSession({
   start,
   noTui,
   json: json3,
-  emitCreated
+  emitCreated,
+  onCacheError
 }) {
   if (dependencies.abortSignal?.aborted)
     throw dependencies.abortSignal.reason ?? new Error("interrupted");
@@ -40823,6 +40960,7 @@ async function runAttachedSession({
     repositories,
     ...activeMessageId ? { activeMessageId } : {},
     environment: dependencies.environment,
+    onCacheError,
     getSession: async ({ sessionId: id }) => await operations.getSession({ client: operations.client, sessionId: id }),
     listSessionEvents: async ({ sessionId: id, limit, after, signal }) => await operations.listSessionEvents({ client: operations.client, sessionId: id, limit, after, signal }),
     openEventStream: ({ sessionId: id, lastRetainedEventId, signal, onSynchronized }) => operations.streamSessionEvents({ client: operations.client, sessionId: id, lastRetainedEventId, signal, onSynchronized })
@@ -40898,6 +41036,9 @@ async function runAttachedSession({
             requestInterrupt: async ({ idempotencyKey }) => {
               await operations.interruptSession({ client: operations.client, sessionId, idempotencyKey });
             },
+            requestCompact: async ({ idempotencyKey }) => {
+              await operations.compactSessionContext({ client: operations.client, sessionId, idempotencyKey });
+            },
             requestComplete: async () => {
               const detail = await operations.completeSession({ client: operations.client, sessionId });
               controller.updateDetail(detail);
@@ -41024,6 +41165,7 @@ async function createSessionOperations(dependencies, { onAuthenticated } = {}) {
       appendSessionMessage: dependencies.appendSessionMessage ?? appendSessionMessage,
       cancelSession: dependencies.cancelSession ?? cancelSession,
       completeSession: dependencies.completeSession ?? completeSession,
+      compactSessionContext: dependencies.compactSessionContext ?? compactSessionContext,
       interruptSession: dependencies.interruptSession ?? interruptSession,
       getSession: dependencies.getSession ?? getSession,
       listSessionEvents: dependencies.listSessionEvents ?? listSessionEvents,
@@ -41044,6 +41186,7 @@ async function createSessionOperations(dependencies, { onAuthenticated } = {}) {
     appendSessionMessage: dependencies.appendSessionMessage ?? appendSessionMessage,
     cancelSession: dependencies.cancelSession ?? cancelSession,
     completeSession: dependencies.completeSession ?? completeSession,
+    compactSessionContext: dependencies.compactSessionContext ?? compactSessionContext,
     interruptSession: dependencies.interruptSession ?? interruptSession,
     getSession: dependencies.getSession ?? getSession,
     listSessionEvents: dependencies.listSessionEvents ?? listSessionEvents,
@@ -41200,10 +41343,15 @@ Options:
 `;
   }
   if (topic === "session") {
-    return `Usage: remy --session <session-id> [options]
+    return `Usage: remy --session <session-id> [options] [prompt]
 
 Attach to an existing remote session. An interactive terminal opens the session view; --no-tui streams output instead.
 
+Arguments:
+  prompt                                  Submit a follow-up as Steer before attaching
+
+With a prompt, JSON output waits for that message's turn result. Use -- before a prompt beginning with --.
+
 Options:
   --no-tui                                Do not open the interactive terminal view
   --json                                  Write session updates as JSON
@@ -41235,8 +41383,8 @@ Usage:
 Commands:
   remy                                      Open interactive dashboard
   remy dashboard                            Open interactive dashboard
-  remy --session <session-id> [--no-tui] [--json]
-                                            Attach to a session
+  remy --session <session-id> [--no-tui] [--json] [prompt]
+                                            Attach to a session, optionally submitting a follow-up
   remy new [--repository <owner/name> ... --installation <id> --model <name> --reasoning-effort <low|medium|high|xhigh> --attach <path> ... --no-tui --json] <prompt>
                                             Create a session
   remy login [--env production|staging] [--api-url <url> --auth-api-url <url> --requester-application-id <uuid> --target-application-id <uuid>]
@@ -41268,14 +41416,32 @@ function parseSessionAttach(argv) {
   const sessionId = argv[0];
   if (!sessionId || sessionId.startsWith("--"))
     throw new Error("--session requires a session ID.");
-  const flags = parseFlags(argv.slice(1));
-  if (typeof flags["no-tui"] === "string" || typeof flags.json === "string")
-    throw new Error("--no-tui and --json do not accept values.");
-  for (const flag of Object.keys(flags)) {
-    if (flag !== "no-tui" && flag !== "json")
-      throw new Error(`Unknown --session flag --${flag}.`);
+  let noTui = false;
+  let json3 = false;
+  let prompt;
+  let positionalOnly = false;
+  for (const token of argv.slice(1)) {
+    if (!positionalOnly && token === "--") {
+      positionalOnly = true;
+      continue;
+    }
+    if (!positionalOnly && token === "--no-tui") {
+      noTui = true;
+      continue;
+    }
+    if (!positionalOnly && token === "--json") {
+      json3 = true;
+      continue;
+    }
+    if (!positionalOnly && token.startsWith("--"))
+      throw new Error(`Unknown --session flag ${token}.`);
+    if (prompt !== undefined)
+      throw new Error("--session accepts one prompt. Quote the full prompt as a single argument.");
+    if (!token.trim())
+      throw new Error("A follow-up prompt must not be empty.");
+    prompt = token;
   }
-  return { name: "session", sessionId, noTui: flags["no-tui"] === true, json: flags.json === true };
+  return { name: "session", sessionId, noTui, json: json3, ...prompt === undefined ? {} : { prompt } };
 }
 function parseNewCommand(argv) {
   const repositories = [];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meistrari/remy-cli",
-    "version": "1.15.0",
+    "version": "1.17.0",
     "description": "Remy, the Coding Agent terminal client.",
     "type": "module",
     "bin": {