@sealant/mend 0.36.0-next.632 → 0.36.0-next.645

package/README.md

@@ -171,6 +171,8 @@ mend refresh [project]                fetch origin's branches into the store
 mend land <session> [--branch b] [--no-pr] [--title t] | --check
                                       push the change to origin, open or update its pull request
 mend pull <session> [--force]         fetch the change into this clone as mend/<name>
+mend workspace replace <session> [--yes]
+                                      replace a workspace that started before Mend 0.36
 
 services
 mend service run|add|connect|list|logs|restart|stop|init
@@ -193,7 +195,8 @@ mend members                          who belongs to your organization, and thei
 mend invite [--role member|owner] [--email <address>] [--days <n>]
                                       print a one-time invitation link
 mend folder list|create|push|rm       your organization's folders
-mend session share <session> on|off   shared control: let everyone who can see a session steer it
+mend session share <session> on|off [--yes]
+                                      shared control: each turn runs on its sender's login
 
 this machine
 mend operator org list|create|rename|invite-owner

package/dist/{chunk-OHOMU7JP.js → chunk-ASHAV3UV.js}

@@ -26965,13 +26965,17 @@ var sameGrant = (left, right) => {
 var LAUNCH_WAITING_PREFIX = "waiting \xB7 the previous session in this worktree";
 var LAUNCH_WAITING_SAVING = `${LAUNCH_WAITING_PREFIX} is saving`;
 var LAUNCH_BOOTING = "booting";
+var LAUNCH_QUEUED = "queued \xB7 waiting for a worker";
+var LAUNCH_BUILDING_PREFIX = "building the workspace image";
 var LAUNCH_PREPARING = "preparing the workspace \xB7 no runtime yet \xB7 after an update, building the image takes about 8 minutes";
 var LAUNCH_BUILDING_IMAGE_LEGACY = "building the workspace image (first launch after an update, ~8 min)";
 var LAUNCH_PHASE_PREFIXES = [
   LAUNCH_WAITING_PREFIX,
   LAUNCH_BOOTING,
+  LAUNCH_QUEUED,
   LAUNCH_PREPARING,
-  LAUNCH_BUILDING_IMAGE_LEGACY
+  LAUNCH_BUILDING_IMAGE_LEGACY,
+  LAUNCH_BUILDING_PREFIX
 ];
 var phaseWordsOf = (summary) => {
   for (const prefix of LAUNCH_PHASE_PREFIXES) {
@@ -26995,6 +26999,12 @@ var launchPhaseOf = (summary) => {
     return { kind: "waiting-previous", words: phase.words };
   }
   if (phase.words.startsWith(LAUNCH_BOOTING)) return { kind: "booting", words: phase.words };
+  if (phase.words.startsWith(LAUNCH_QUEUED)) return { kind: "queued", words: phase.words };
+  if (phase.words === LAUNCH_BUILDING_IMAGE_LEGACY)
+    return { kind: "preparing", words: phase.words };
+  if (phase.words.startsWith(LAUNCH_BUILDING_PREFIX)) {
+    return { kind: "building", words: phase.words };
+  }
   return { kind: "preparing", words: phase.words };
 };
 
@@ -28028,6 +28038,12 @@ var NativeIngestCursor = Schema_exports.Struct({
   lastEntryUuid: Schema_exports.NullOr(Schema_exports.String),
   lineCount: Schema_exports.Int
 });
+var LivePerson = class extends Schema_exports.Class("LivePerson")({
+  accountId: Schema_exports.String,
+  /** Their name as the instance knows it. */
+  name: Schema_exports.String
+}) {
+};
 var Session = class extends Schema_exports.Class("Session")({
   id: SessionId,
   projectId: ProjectId,
@@ -28108,6 +28124,32 @@ var Session = class extends Schema_exports.Class("Session")({
   sharedControlEnabledAt: Schema_exports.NullOr(Timestamp).pipe(
     Schema_exports.withConstructorDefault(Effect_exports.succeed(null))
   ),
+  /**
+   * When shared control was first turned on, kept after it is turned off (docs/adr/0016,
+   * decision 9): a session once shared runs on no one's memory and credits nobody until it ends.
+   */
+  sharedControlEverAt: Schema_exports.NullOr(Timestamp).pipe(
+    Schema_exports.withDecodingDefaultKey(Effect_exports.succeed(null)),
+    Schema_exports.withConstructorDefault(Effect_exports.succeed(null))
+  ),
+  /**
+   * The people with a process live in the session's executor as their own user, in a per-person
+   * executor (docs/adr/0016, decision 13): filled by the API's session list and view only, in the
+   * same query; empty everywhere else, in a shared executor, and from older servers.
+   */
+  livePeople: Schema_exports.Array(LivePerson).pipe(
+    Schema_exports.withDecodingDefaultKey(Effect_exports.succeed([])),
+    Schema_exports.withConstructorDefault(Effect_exports.succeed([]))
+  ),
+  /**
+   * The session's executor waits to be replaced (docs/adr/0016, decision 14): `marked` or
+   * `retiring`; null otherwise. Read with `livePeople`, in the same query, so a client asks for the
+   * retirement's detail only when there is one. Null everywhere else and from older servers.
+   */
+  workspaceRetirement: Schema_exports.NullOr(Schema_exports.Literals(["marked", "retiring"])).pipe(
+    Schema_exports.withDecodingDefaultKey(Effect_exports.succeed(null)),
+    Schema_exports.withConstructorDefault(Effect_exports.succeed(null))
+  ),
   /**
    * Whether the harness left a conversation behind — a transcript Mend captured at settle or
    * found in the live harness home. False is a dead end: nothing to resume, nothing to hand
@@ -28364,6 +28406,62 @@ var LinuxIdentity = class extends Schema_exports.Class("LinuxIdentity")({
   uid: Schema_exports.Number
 }) {
 };
+var WorkspaceRetirementStopKind = Schema_exports.Literals([
+  "terminal",
+  "shell",
+  "service",
+  "turn",
+  "process",
+  "container",
+  "unchecked"
+]);
+var WorkspaceRetirementStop = class extends Schema_exports.Class(
+  "WorkspaceRetirementStop"
+)({
+  kind: WorkspaceRetirementStopKind,
+  /**
+   * What it is, as observed: a session's label, a Service's name, a process's command name and
+   * pid, a container's name, or why something could not be checked. Empty for a process or a
+   * container when the viewer is not the change's owner: they see its kind only.
+   */
+  label: Schema_exports.String
+}) {
+};
+var WorkspaceRetirementState = Schema_exports.Literals(["marked", "retiring"]);
+var WorkspaceRetirement = class extends Schema_exports.Class("WorkspaceRetirement")({
+  state: WorkspaceRetirementState,
+  /** The executor started before Mend 0.36 (no layout recorded for its launch). */
+  preRelease: Schema_exports.Boolean,
+  /** The account whose launch made the executor: the only one whose joins and turns it takes. */
+  launcher: Schema_exports.NullOr(Schema_exports.String),
+  /** What would stop if it were replaced now; empty when nothing would. */
+  stops: Schema_exports.Array(WorkspaceRetirementStop),
+  /** Why the last automatic replacement did not go ahead, as observed; null when none was tried. */
+  reason: Schema_exports.NullOr(Schema_exports.String),
+  /**
+   * When what runs in the executor was last checked beyond Mend's own records (processes Mend did
+   * not start, the sidecar's containers); null when only Mend's records were read.
+   */
+  checkedAt: Schema_exports.NullOr(Timestamp),
+  /**
+   * What the viewer was shown, as one token: "Replace this workspace now" names it, so Mend ends
+   * nothing that was not listed (the replacement is refused if more would stop now).
+   */
+  fingerprint: Schema_exports.String,
+  /** The viewer may replace it now: they own the change, and no agent turn is in flight. */
+  canReplace: Schema_exports.Boolean
+}) {
+};
+var PreReleaseMemory = class extends Schema_exports.Class("PreReleaseMemory")({
+  /** The capture it read, by its place on the worktree's chain. */
+  captureN: Schema_exports.Number,
+  provisional: Schema_exports.Boolean,
+  creditedTo: Schema_exports.NullOr(Schema_exports.String),
+  decidedBy: Schema_exports.Literals(["home-record", "only-person", "nobody", "nothing"]),
+  /** Memory paths credited to nobody: two or more people's sessions shared the home. */
+  notCredited: Schema_exports.Array(Schema_exports.String)
+}) {
+};
 
 // ../../packages/domain/src/workbench/host-user-namespaces.ts
 var HOST_USER_NAMESPACE_FILES = [
@@ -28439,7 +28537,7 @@ var ProjectClusterBindingsSnapshot = class extends Schema_exports.Class(
 }) {
 };
 
-// ../../node_modules/.pnpm/@sealant+api-contracts-next@0.39.0-next.695_effect@4.0.0-beta.93/node_modules/@sealant/api-contracts-next/dist/workspace-environment.js
+// ../../node_modules/.pnpm/@sealant+api-contracts-next@0.39.0-next.706_effect@4.0.0-beta.93/node_modules/@sealant/api-contracts-next/dist/workspace-environment.js
 var RESERVED_NAMES = new Map([
   // Identity/process roots the daemon and shells own.
   ...[
@@ -28610,7 +28708,17 @@ var SessionProcess = class extends Schema_exports.Class("SessionProcess")({
     Schema_exports.withConstructorDefault(Effect_exports.succeed(null))
   ),
   exitedAt: Schema_exports.NullOr(Timestamp),
-  updatedAt: Timestamp
+  updatedAt: Timestamp,
+  /**
+   * The Mend account whose Linux user the process runs as in a person-layout executor
+   * (docs/adr/0016, decision 1: "the person a process runs as is recorded on the process when it
+   * starts"). Null for a process that runs as root (a `shared` executor), on rows from before it
+   * was recorded, and where older servers omit it.
+   */
+  runsAs: Schema_exports.NullOr(Schema_exports.String).pipe(
+    Schema_exports.withDecodingDefaultKey(Effect_exports.succeed(null)),
+    Schema_exports.withConstructorDefault(Effect_exports.succeed(null))
+  )
 }) {
 };
 
@@ -29067,6 +29175,98 @@ var SlackLinkedMentionJob = Schema_exports.Struct({
   linkedAt: Schema_exports.String
 });
 
+// ../../packages/domain/src/workbench/shared-workspace.ts
+var listed = (names) => names.length <= 1 ? names[0] ?? "" : `${names.slice(0, -1).join(", ")} and ${names[names.length - 1] ?? ""}`;
+var joinWorktreeLine = (others) => others.length <= 1 ? `${others[0] ?? "Another person"}'s session is running in this worktree. You share its workspace: everything you run runs as you, on your own logins, but either of you can read the other's files, logins included.` : `${listed(others)}'s sessions are running in this worktree. You share its workspace: everything you run runs as you, on your own logins, but any of you can read the others' files, logins included.`;
+var JOIN_SHARED_HOME_LINE = "Another person's session is running in this worktree, in a workspace that shares one home: what you start there runs on the logins and Git identity of whoever started that workspace, not yours.";
+var sharedWorkspaceLine = (livePeople, viewer) => {
+  if (livePeople.length < 2) return null;
+  const others = livePeople.filter((person) => person.accountId !== viewer).map((p) => p.name);
+  if (others.length === livePeople.length) {
+    return `Shared workspace: ${listed(others)} \xB7 each runs as themselves \xB7 ${others.length === 2 ? "either can read the other's files" : "any of them can read the others' files"}.`;
+  }
+  return others.length === 1 && livePeople.length === 2 ? `Shared workspace with ${others[0]} \xB7 each of you runs as yourself \xB7 either of you can read the other's files.` : `Shared workspace with ${listed(others)} \xB7 each of you runs as yourself \xB7 any of you can read the others' files.`;
+};
+var SHARED_CONTROL_LINE = "Each turn runs on its sender's login. From now until this session ends, the agent uses no one's personal memory or instructions. The conversation so far, including what your agent loaded before, becomes visible to whoever steers.";
+var SHARED_CONTROL_LINE_OWNER_LOGINS = "Each turn runs on your provider logins and Git access, whoever sends it.";
+var sharedControlLine = (turnsOnSendersLogin) => turnsOnSendersLogin ? SHARED_CONTROL_LINE : SHARED_CONTROL_LINE_OWNER_LOGINS;
+var sharedControlConfirm = (turnsOnSendersLogin) => ({
+  title: "Turn on shared control?",
+  body: turnsOnSendersLogin ? SHARED_CONTROL_LINE : `Everyone who can see this project can send turns, answer approvals and interrupt. ${SHARED_CONTROL_LINE_OWNER_LOGINS}`,
+  confirm: "Turn on",
+  cancel: "Keep it off"
+});
+var workspaceRetirementLine = (retirement, launcherName) => {
+  if (retirement.state === "retiring") {
+    return "Replacing this workspace so that each person runs as themselves \xB7 nothing new starts until it has been saved and replaced";
+  }
+  const started = retirement.preRelease ? "This workspace started before Mend 0.36 and shares one home" : "This workspace shares one home";
+  const reason = retirement.reason === null ? "" : ` \xB7 ${retirement.reason}`;
+  return `${started} \xB7 it takes only ${launcherName}'s sessions and turns until it is replaced${reason}`;
+};
+var STOP_WORDS = {
+  terminal: "terminal session (ends resumable)",
+  shell: "shell",
+  service: "Service started by hand",
+  turn: "agent turn in flight",
+  process: "process Mend did not start",
+  container: "running container",
+  unchecked: "could not check"
+};
+var REPLACE_WORKSPACE_ACTION = "Replace this workspace now";
+var timeOf3 = (at) => `${at.toISOString().slice(11, 16)} UTC`;
+var retirementStopLines = (retirement) => {
+  const checked = retirement.checkedAt === null ? "Checked: Mend's records only \xB7 processes Mend did not start and running containers not checked yet" : `Checked at ${timeOf3(retirement.checkedAt)}: Mend's records, the processes in the workspace and its running containers`;
+  const found = retirement.stops.length === 0 ? ["Found nothing that would stop."] : retirement.stops.map(
+    (stop) => stop.label === "" ? STOP_WORDS[stop.kind] : `${STOP_WORDS[stop.kind]} \xB7 ${stop.label}`
+  );
+  return [checked, ...found, "Mend starts the launching session's mend.toml Services again."];
+};
+
+// ../../packages/domain/src/workbench/steering.ts
+var ConversationWaitWork = Schema_exports.Struct({
+  kind: Schema_exports.Literals([
+    "task",
+    "paused-task",
+    "sub-agent",
+    "terminal",
+    "goal",
+    "wakeup",
+    "monitor",
+    "cron",
+    "unknown"
+  ]),
+  /** The harness's own id: what ending it names. */
+  id: Schema_exports.String,
+  description: Schema_exports.NullOr(Schema_exports.String),
+  /**
+   * The person the process runs as, or the session's owner, can end it from the waiting line
+   * (Claude's task stop, a monitor's included, Codex's terminal terminate and goal clear). A
+   * wakeup ends on its own within an hour; a scheduled prompt and what the harness would not say
+   * are waited for at most `CONVERSATION_WAIT_BOUNDS_MS`.
+   */
+  endable: Schema_exports.Boolean
+});
+var ConversationWait = class extends Schema_exports.Class("ConversationWait")({
+  sessionId: SessionId,
+  /** The turn that waits; the turns behind it wait with it. */
+  turnId: AgentTurnId,
+  /** Whose process finishes its work: the person it runs as. */
+  runsAs: Schema_exports.NullOr(Schema_exports.String),
+  /** Whose turn waits. */
+  sender: Schema_exports.String,
+  /** A turn still runs in the process. */
+  openTurn: Schema_exports.Boolean,
+  work: Schema_exports.Array(ConversationWaitWork),
+  /** The waiting line, in words: "Waits for Alice's 2 background tasks … before Bob's turn starts." */
+  line: Schema_exports.String,
+  since: Timestamp
+}) {
+};
+var CONVERSATION_WAIT_BOUNDS_MS = {
+  cron: 10 * 6e4
+};
+
 // ../../packages/domain/src/workbench/tour.ts
 var TourStop = class extends Schema_exports.Class("TourStop")({
   title: Schema_exports.String,
@@ -29475,6 +29675,120 @@ var GATEWAY_STATUSES = /* @__PURE__ */ new Set([
 ]);
 var mayStillBeWorking = (error) => error instanceof MendRequestError && (error.kind === "timeout" || error.kind === "dropped" || error.kind === "http" && error.status !== null && GATEWAY_STATUSES.has(error.status));
 
+// src/shared-workspace.ts
+var checkedAtOf = (retirement) => {
+  if (retirement.checkedAt === null) return null;
+  const at = new Date(retirement.checkedAt);
+  return Number.isNaN(at.getTime()) ? null : at;
+};
+var retirementEvidenceLines = (retirement) => retirementStopLines({ stops: retirement.stops, checkedAt: checkedAtOf(retirement) });
+var workspaceReadsOf = (session) => ({
+  waiting: (session.livePeople ?? []).length > 0 && session.sharedControlEnabledAt !== void 0 && session.sharedControlEnabledAt !== null,
+  retirement: session.workspaceRetirement !== void 0 && session.workspaceRetirement !== null
+});
+var hasPersonFacts = (sessions) => sessions.some(
+  (session) => (session.livePeople ?? []).length > 0 || session.workspaceRetirement !== void 0 && session.workspaceRetirement !== null
+);
+var worktreeListsPeople = (sessions, worktreeId) => sessions.some(
+  (session) => session.worktreeId === worktreeId && (session.livePeople ?? []).length > 0
+);
+var othersLiveInWorktree = (sessions, worktreeId, viewer) => {
+  if (viewer === null) return [];
+  const names = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    if (session.worktreeId !== worktreeId) continue;
+    for (const person of session.livePeople ?? []) {
+      if (person.accountId !== viewer) names.set(person.accountId, person.name);
+    }
+  }
+  return [...names.values()];
+};
+var worktreeJoinLine = (sessions, worktreeId, viewer) => {
+  const others = othersLiveInWorktree(sessions, worktreeId, viewer);
+  if (others.length > 0) return joinWorktreeLine(others);
+  if (viewer === null || worktreeListsPeople(sessions, worktreeId)) return null;
+  const anotherLive = sessions.some(
+    (session) => session.worktreeId === worktreeId && session.status !== void 0 && LIVE_STATUSES.has(session.status) && session.ownerUserId !== void 0 && session.ownerUserId !== null && session.ownerUserId !== viewer
+  );
+  return anotherLive ? JOIN_SHARED_HOME_LINE : null;
+};
+var launcherNameOf = (launcher, livePeople, members) => livePeople.find((person) => person.accountId === launcher)?.name ?? members.find((member) => member.userId === launcher)?.name ?? "its launcher";
+var sessionWorkspaceLines = (facts) => {
+  const { retirement } = facts;
+  return {
+    shared: sharedWorkspaceLine(facts.livePeople, facts.viewer),
+    waiting: facts.wait?.line ?? null,
+    retirement: retirement === null ? null : workspaceRetirementLine(
+      retirement,
+      launcherNameOf(retirement.launcher, facts.livePeople, facts.members)
+    ),
+    // Only the change's owner replaces it, and only while it is marked: a retiring one is
+    // already being replaced.
+    replace: retirement === null || !retirement.canReplace || retirement.state !== "marked" ? null : {
+      action: REPLACE_WORKSPACE_ACTION,
+      command: `mend workspace replace ${facts.sessionId.slice(0, 8)}`,
+      stops: retirementEvidenceLines(retirement)
+    }
+  };
+};
+var workspaceLineList = (lines) => [
+  ...lines.shared === null ? [] : [lines.shared],
+  ...lines.waiting === null ? [] : [lines.waiting],
+  ...lines.retirement === null ? [] : [lines.retirement],
+  ...lines.replace === null ? [] : [
+    `${lines.replace.action} \xB7 ${lines.replace.command}`,
+    ...lines.replace.stops.map((stop) => `  ${stop}`)
+  ]
+];
+var wrapWords = (text, width) => {
+  const limit = Math.max(8, width);
+  const lines = [];
+  let current = "";
+  for (const raw of text.split(/\s+/)) {
+    if (raw === "") continue;
+    let word = raw;
+    while (word.length > limit) {
+      if (current !== "") {
+        lines.push(current);
+        current = "";
+      }
+      lines.push(word.slice(0, limit));
+      word = word.slice(limit);
+    }
+    if (current === "") current = word;
+    else if (current.length + 1 + word.length <= limit) current = `${current} ${word}`;
+    else {
+      lines.push(current);
+      current = word;
+    }
+  }
+  if (current !== "") lines.push(current);
+  return lines;
+};
+var confirmPlan = (args2, interactive) => args2.includes("--yes") || args2.includes("-y") ? "confirmed" : interactive ? "ask" : "refuse";
+var sharedControlConfirmLines = (turnsOnSendersLogin) => {
+  const confirm = sharedControlConfirm(turnsOnSendersLogin);
+  return [confirm.title, confirm.body];
+};
+var sharedControlQuestion = (turnsOnSendersLogin) => {
+  const confirm = sharedControlConfirm(turnsOnSendersLogin);
+  return `${confirm.confirm.toLowerCase()}? (n: ${confirm.cancel.toLowerCase()})`;
+};
+var replaceConfirmLines = (retirement) => [
+  `${REPLACE_WORKSPACE_ACTION}?`,
+  ...retirementEvidenceLines(retirement).map((stop) => `  ${stop}`)
+];
+var askYesNo = async (question) => {
+  const readline = await import("node:readline/promises");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+};
+
 // src/workbench-events.ts
 var createSseParser = () => {
   let buffer = "";
@@ -29553,6 +29867,10 @@ export {
   servicesHoldLine,
   validateSecretFilePath,
   terminalReadOnlyLine,
+  sharedControlLine,
+  sharedControlConfirm,
+  workspaceRetirementLine,
+  REPLACE_WORKSPACE_ACTION,
   WORKTREE_REMOVAL_FORCE_HINT,
   HARNESS_COMMANDS,
   pendingId,
@@ -29582,6 +29900,19 @@ export {
   noAnswerError,
   GATEWAY_STATUSES,
   mayStillBeWorking,
+  workspaceReadsOf,
+  hasPersonFacts,
+  worktreeListsPeople,
+  worktreeJoinLine,
+  launcherNameOf,
+  sessionWorkspaceLines,
+  workspaceLineList,
+  wrapWords,
+  confirmPlan,
+  sharedControlConfirmLines,
+  sharedControlQuestion,
+  replaceConfirmLines,
+  askYesNo,
   createSseParser,
   eventFamilies
 };