mixdog 1.1.2 → 1.2.1

package/src/session-runtime/turn/turn-run.mjs

@@ -1,10 +1,11 @@
 /**
  * src/session-runtime/turn/turn-run.mjs - one user turn end to end: viewer
- * forwarding, turn open (abort controller, timing, worktree snapshot, warmup
- * arming), session preparation, the askSession callback bridge, and the
- * settlement that always runs. The phases live under turn-run/.
+ * forwarding, turn open (abort controller, timing, warmup arming), session
+ * preparation (workspace provisioning, then the worktree review snapshot), the
+ * askSession callback bridge, and the settlement that always runs. The phases
+ * live under turn-run/.
  */
-import { beginTurnSnapshot, cancelTurnSnapshot, completeTurnSnapshot } from '../../runtime/shared/turn-snapshot.mjs';
+import { beginTurnSnapshot, completeTurnSnapshot } from '../../runtime/shared/turn-snapshot.mjs';
 import { runWithCwdOverride } from '../../runtime/shared/user-cwd.mjs';
 import { createTurnTranscript } from './turn-run/transcript.mjs';
 import { createTurnTimingFactory } from './turn-run/turn-timing.mjs';
@@ -23,7 +24,6 @@ export function createTurnRunner(deps) {
     endComputerExecution = async () => false,
     deferComputerSessionRelease = () => false,
     beginTurnSnapshotForTurn = beginTurnSnapshot,
-    cancelTurnSnapshotForTurn = cancelTurnSnapshot,
     completeTurnSnapshotForTurn = completeTurnSnapshot,
     turnCleanupSettleMs = 2_000,
     getConfig = () => null,
@@ -35,7 +35,6 @@ export function createTurnRunner(deps) {
     createSnapshot: createSnapshotTrackerFactory({
       getCurrentCwd,
       beginTurnSnapshotForTurn,
-      cancelTurnSnapshotForTurn,
       completeTurnSnapshotForTurn,
       turnCleanupSettleMs,
     }),
@@ -93,7 +92,7 @@ export function createTurnRunner(deps) {
     if (attachedSession?.remoteAttached) return forwardAttachedPrompt(attachedSession, prompt, options);
     const turn = openTurn(options);
     try {
-      const session0 = await prepareSession(turn, prompt);
+      const session0 = await prepareSession(turn, prompt, options);
       const turnContext = await dispatchPromptSubmit(turn, session0, prompt, options);
       const result = await mgr.askSession(
         session0.id,

package/src/session-runtime/webhook-session-run.mjs

@@ -35,6 +35,10 @@ export async function runWebhookSession({
   workflow = null,
   attachments = null,
   signal = null,
+  // Endpoint-authored instructions: the run's ONLY skill-selection input.
+  // `prompt` also carries the fenced external payload, which must never
+  // select a skill; absent means nothing selects.
+  skillSelection = '',
 }) {
   const endpoint = String(name || '').trim();
   const body = String(prompt || '').trim();
@@ -63,9 +67,17 @@ export async function runWebhookSession({
   // askOpts.signal is the parent-abort link: it is cascaded onto the turn
   // controller, so aborting it stops the in-flight provider/tool work instead
   // of leaving a timed-out delivery's session running with live side effects.
-  const ask = (turnContent) =>
-    askSession(session.id, turnContent, null, null, projectCwd || undefined, undefined, signal ? { signal } : {});
-  // Agents the run delegates to report back; each result is the next turn.
-  const result = await runAutomationTurns(session.id, () => ask(content), ask);
+  const ask = (turnContent, askOpts) =>
+    askSession(session.id, turnContent, null, null, projectCwd || undefined, undefined, {
+      ...askOpts,
+      ...(signal ? { signal } : {}),
+    });
+  // Agents the run delegates to report back; each result is the next turn
+  // (runAutomationTurns marks those turns as task notifications).
+  const result = await runAutomationTurns(
+    session.id,
+    () => ask(content, { skillSelection: String(skillSelection ?? '') }),
+    ask
+  );
   return { sessionId: session.id, result: String(result?.content || '') };
 }

package/src/session-runtime/workflow-agents-api/agent-route.mjs

@@ -3,7 +3,7 @@ import { hasOwn } from '../../runtime/shared/object.mjs';
 import { isHiddenAgent } from '../../runtime/agent/orchestrator/internal-agents.mjs';
 import { normalizeWorkflowRoute } from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
 import { ensureProviderEnabled } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
-import { selectionFastCapable } from '../route-state.mjs';
+import { resolveRouteContextState, selectionFastCapable } from '../route-state.mjs';
 import { canonicalizeAgentRouteStorage, withAgentDisabled } from '../../runtime/shared/agent-route-config.mjs';
 import { agentEditorId } from './shared.mjs';
 
@@ -43,19 +43,31 @@ export function createAgentRouteApi(deps) {
       clean(selectedRoute.provider) === clean(stored.provider) && clean(selectedRoute.model) === clean(stored.model);
     const inheritedEffort = sameModel ? stored.effort || null : null;
     const inheritedModelParameters = sameModel ? stored.modelParameters || {} : {};
-    const inheritedContextPercent = sameModel ? stored.contextPercent : undefined;
+    // A requested percent replaces the stored exact window and requested
+    // tokens replace the stored percent.
+    const requestsPercent = requested.contextPercent !== undefined;
+    const requestsTokens = requested.contextTokens !== undefined;
+    const inheritedContextPercent = sameModel && !requestsTokens ? stored.contextPercent : undefined;
+    const inheritedContextTokens = sameModel && !requestsPercent ? stored.contextTokens : undefined;
     selectedRoute = {
       ...selectedRoute,
       effort: requested.effort !== undefined ? selectedRoute.effort : inheritedEffort,
       fast: requested.fast !== undefined ? selectedRoute.fast === true : sameModel && stored.fast === true,
+      // Main's modelSettings bucket must not decide an agent's Auto effort.
+      autoEffort:
+        requested.autoEffort !== undefined ? requested.autoEffort !== false : !sameModel || stored.autoEffort !== false,
       modelParameters:
         requested.modelParameters !== undefined ? selectedRoute.modelParameters : inheritedModelParameters,
       // resolveRoute reads contextPercent from Main's modelSettings bucket;
       // an agent route owns its own.
-      contextPercent: requested.contextPercent !== undefined ? requested.contextPercent : inheritedContextPercent,
+      contextPercent: requestsPercent ? requested.contextPercent : inheritedContextPercent,
+      contextTokens: requestsTokens ? requested.contextTokens : inheritedContextTokens,
     };
     await ensureProvidersReady(ensureProviderEnabled(getConfig(), selectedRoute.provider));
     const modelMeta = await lookupModelMeta(selectedRoute.provider, selectedRoute.model);
+    // Stored clamped, and not at all at the default window, as for Main.
+    const contextState = resolveRouteContextState(selectedRoute, modelMeta);
+    if (contextState.contextDefaultPercent !== undefined) selectedRoute.contextTokens = contextState.contextTokens;
     const fastCapable = selectionFastCapable(
       selectedRoute.provider,
       modelMeta,

package/src/session-runtime/workspace/admission-gate.mjs

@@ -0,0 +1,197 @@
+/**
+ * Process-wide admission gate shared by Lead workspace transitions, turn
+ * admission and worker spawning.
+ *
+ * - A transition and a worker spawn of the same Lead never overlap: a
+ *   transition refuses while a spawn is being prepared, a spawn refuses while
+ *   a transition is in flight.
+ * - Turns and transitions are mutually exclusive: an admitted turn is
+ *   registered until it settles; a turn that arrives while its own session
+ *   transitions, or while another session changes the checkout its cwd lies
+ *   in (a held checkout folder), waits for that change to settle. A checkout
+ *   folder can only be held while no other session's admitted turn runs in it.
+ * - Each worktree-bound Lead's execution root, which every worker of that Lead
+ *   runs in.
+ */
+import { worktreeError } from '../../runtime/shared/worktrees/contract.mjs';
+import { throwIfAborted } from '../../runtime/shared/worktrees/git.mjs';
+import { isWithin } from '../../runtime/shared/worktrees/paths.mjs';
+
+/** @type {Map<string, { txId: string, settled: Promise<void> }>} Lead session id → in-flight transition. */
+const transitions = new Map();
+/** @type {Map<string, number>} Lead session id → spawns being prepared. */
+const spawns = new Map();
+/** @type {Map<string, string>} Lead session id → bound worktree execution root. */
+const cwdLocks = new Map();
+/** @type {Map<symbol, { sessionId: string, cwd: () => string }>} Admitted turns (live cwd). */
+const turns = new Map();
+/** @type {Map<symbol, { sessionId: string, folder: string, settled: Promise<void> }>} Checkouts being changed. */
+const folderHolds = new Map();
+
+const key = (sessionId) => String(sessionId || '').trim();
+
+function latch() {
+  let resolve;
+  const settled = new Promise((done) => {
+    resolve = done;
+  });
+  return { settled, resolve };
+}
+
+function once(fn) {
+  let done = false;
+  return () => {
+    if (done) return;
+    done = true;
+    fn();
+  };
+}
+
+const within = (folder, cwd) => Boolean(folder && cwd) && isWithin(folder, cwd);
+
+/**
+ * Enter a transition for `sessionId`; the returned function leaves it.
+ * @returns {() => void}
+ */
+export function beginWorkspaceTransition(sessionId, txId) {
+  const id = key(sessionId);
+  if (!id) throw new TypeError('workspace transition requires a session id.');
+  if (transitions.has(id)) {
+    throw worktreeError('WORKTREE_BUSY_JOBS', 'Another workspace change is in progress for this session.', {
+      reason: 'transition',
+    });
+  }
+  if ((spawns.get(id) || 0) > 0) {
+    throw worktreeError('WORKTREE_BUSY_JOBS', undefined, { reason: 'workers', starting: spawns.get(id) });
+  }
+  const gate = latch();
+  transitions.set(id, { txId: String(txId || 'tx'), settled: gate.settled });
+  return once(() => {
+    transitions.delete(id);
+    gate.resolve();
+  });
+}
+
+/**
+ * Hold `folder` (a checkout root) while its branch changes or a merge lands
+ * in it. Refuses (WORKTREE_BUSY_JOBS, `folder-in-use`) while another session's
+ * admitted turn runs inside it, and (`transition`) while another change holds
+ * an overlapping checkout; turns arriving meanwhile wait (admitTurn). The
+ * holder's own turns are its own business (the Lead busy check).
+ * @param {string|null} sessionId The changing session; '' / null for a session-less change.
+ * @returns {() => void} Release.
+ */
+export function holdCheckoutFolder(sessionId, folder) {
+  const id = key(sessionId);
+  const users = new Set();
+  for (const turn of turns.values()) {
+    if (turn.sessionId !== id && within(folder, turn.cwd())) users.add(turn.sessionId);
+  }
+  if (users.size) {
+    throw worktreeError('WORKTREE_BUSY_JOBS', 'Other sessions are working in the project folder.', {
+      reason: 'folder-in-use',
+      sessions: [...users],
+    });
+  }
+  if ([...folderHolds.values()].some((hold) => within(hold.folder, folder) || within(folder, hold.folder))) {
+    throw worktreeError('WORKTREE_BUSY_JOBS', 'Another branch change is in progress in the project folder.', {
+      reason: 'transition',
+    });
+  }
+  const token = Symbol('checkout-folder');
+  const gate = latch();
+  folderHolds.set(token, { sessionId: id, folder, settled: gate.settled });
+  return once(() => {
+    folderHolds.delete(token);
+    gate.resolve();
+  });
+}
+
+function admissionBlocker(id, cwd) {
+  const own = transitions.get(id);
+  if (own) return own.settled;
+  const path = cwd();
+  for (const hold of folderHolds.values()) {
+    if (hold.sessionId !== id && within(hold.folder, path)) return hold.settled;
+  }
+  return null;
+}
+
+function settledOrAborted(promise, signal) {
+  if (!signal) return promise;
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      try {
+        throwIfAborted(signal);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    signal.addEventListener('abort', abort, { once: true });
+    promise.then(() => {
+      signal.removeEventListener('abort', abort);
+      resolve();
+    });
+  });
+}
+
+/**
+ * Admit one turn of `sessionId`, whose live cwd is `cwd()`: waits while the
+ * session itself transitions or another session holds the checkout the cwd
+ * lies in, then registers the turn until the returned release is called.
+ * An abort while waiting rejects and registers nothing.
+ * @param {{ sessionId: string, cwd: () => string, signal?: AbortSignal }} input
+ * @returns {Promise<() => void>}
+ */
+export async function admitTurn({ sessionId, cwd, signal }) {
+  const id = key(sessionId);
+  for (let blocker = admissionBlocker(id, cwd); blocker; blocker = admissionBlocker(id, cwd)) {
+    throwIfAborted(signal);
+    await settledOrAborted(blocker, signal);
+  }
+  throwIfAborted(signal);
+  const token = Symbol('turn');
+  turns.set(token, { sessionId: id, cwd });
+  return once(() => turns.delete(token));
+}
+
+/**
+ * Admit one worker spawn preparation for the Lead(s) in `sessionIds`.
+ * @param {Array<string|null|undefined>} sessionIds Owner and caller session ids.
+ * @returns {() => void}
+ */
+export function enterWorkerSpawn(sessionIds) {
+  const ids = [...new Set(sessionIds.map(key).filter(Boolean))];
+  if (ids.some((id) => transitions.has(id))) {
+    throw worktreeError('WORKTREE_BUSY_JOBS', 'The Lead workspace is changing; spawn the worker after it settles.', {
+      reason: 'transition',
+    });
+  }
+  for (const id of ids) spawns.set(id, (spawns.get(id) || 0) + 1);
+  let left = false;
+  return () => {
+    if (left) return;
+    left = true;
+    for (const id of ids) {
+      const next = (spawns.get(id) || 1) - 1;
+      if (next > 0) spawns.set(id, next);
+      else spawns.delete(id);
+    }
+  };
+}
+
+/** Record (or clear with null) the worktree root a Lead's workers must run in. */
+export function setWorkspaceCwdLock(sessionId, cwd) {
+  const id = key(sessionId);
+  if (!id) return;
+  if (cwd) cwdLocks.set(id, String(cwd));
+  else cwdLocks.delete(id);
+}
+
+/** The locked worker cwd for the first Lead id that has one, or null. */
+export function workspaceCwdLock(sessionIds) {
+  for (const id of sessionIds.map(key)) {
+    if (id && cwdLocks.has(id)) return cwdLocks.get(id);
+  }
+  return null;
+}

package/src/session-runtime/workspace/project-branches.mjs

@@ -0,0 +1,136 @@
+/**
+ * Session-less branch operations on a registered Project's folder (a New
+ * Task draft, the source-control dock): its branch menu, a guarded checkout
+ * and a guarded merge. They act only on a registered Project (a repository
+ * subfolder Project included) and hold the checkout (withProjectFolder) while
+ * git changes it.
+ */
+import { branchMenuEntries, projectWorkspace, worktreeError } from '../../runtime/shared/worktrees/contract.mjs';
+
+function requireText(value, name) {
+  if (typeof value !== 'string' || !value.trim()) throw new TypeError(`${name} must be a non-empty string.`);
+  return value.trim();
+}
+
+/**
+ * WORKTREE_UNSUPPORTED_REPO when the project folder has no checked-out branch
+ * to merge into; WORKTREE_TARGET_MISMATCH when the confirmed `target` (null:
+ * none confirmed) is no longer the checked-out branch.
+ */
+export function assertMergeTarget(currentBranch, target) {
+  if (!currentBranch) {
+    throw worktreeError('WORKTREE_UNSUPPORTED_REPO', 'The project folder has no checked-out branch to merge into.');
+  }
+  if (target !== null && target !== currentBranch) {
+    throw worktreeError(
+      'WORKTREE_TARGET_MISMATCH',
+      `The project folder is now on "${currentBranch}"; confirm the merge again.`,
+      { target, current: currentBranch }
+    );
+  }
+}
+
+/**
+ * @param {object} deps
+ * @param {() => Promise<any>} deps.backend The managed-worktree backend.
+ * @param {(path: string) => Promise<any>} deps.inspectProject
+ * @param {(path: string) => Promise<string|null>} deps.findRegisteredProject
+ * @param {<T>(sessionId: string|null, folder: string, fn: () => Promise<T>) => Promise<T>} deps.withProjectFolder
+ */
+export function createProjectBranchOps({ backend, inspectProject, findRegisteredProject, withProjectFolder }) {
+  /** WORKTREE_PROJECT_UNKNOWN unless `projectPath` is a registered Project. */
+  async function registeredProject(projectPath) {
+    const path = requireText(projectPath, 'projectPath');
+    const registered = await findRegisteredProject(path);
+    if (!registered) throw worktreeError('WORKTREE_PROJECT_UNKNOWN', undefined, { projectPath: path });
+    return registered;
+  }
+
+  /**
+   * A Project's branch menu with no session: the project folder's workspace
+   * and the real occupancy (current / session / external / free).
+   */
+  async function getProjectBranchMenu({ projectPath } = {}) {
+    const path = await registeredProject(projectPath);
+    const project = await inspectProject(path);
+    const menu = await (await backend()).listBranchOccupancy({ projectPath: path, sessionId: null });
+    return {
+      workspace: projectWorkspace({
+        projectPath: path,
+        repoCommonDir: project.repoCommonDir,
+        branch: project.currentBranch,
+      }),
+      branches: branchMenuEntries(menu.branches, menu.occupancy),
+      occupancy: menu.occupancy,
+      retainedWorktree: null,
+    };
+  }
+
+  /**
+   * Check out (or create) `branch` in a Project folder with no session: the
+   * same guarded path a session's branch change takes — refused while another
+   * session works in the checkout, which is held until the switch is done;
+   * the manager's repository lock, occupancy and no-carry (dirty) checks.
+   */
+  async function selectProjectBranch({
+    projectPath,
+    branch,
+    create = false,
+    remote = false,
+    startPoint = null,
+    detach = null,
+  } = {}) {
+    const path = await registeredProject(projectPath);
+    if (detach !== null) {
+      // A history entry checked out detached: the same guard, no branch.
+      if (branch !== undefined || create === true || remote === true || startPoint !== null) {
+        throw new TypeError('detach excludes branch, create, remote and startPoint.');
+      }
+      const commit = requireText(detach, 'detach');
+      const project = await inspectProject(path);
+      return withProjectFolder(null, project.topLevel || path, async () =>
+        (await backend()).checkoutProjectBranch({ projectPath: path, detach: commit })
+      );
+    }
+    const name = requireText(branch, 'branch');
+    if (create === true && remote === true) throw new TypeError('create and remote are exclusive.');
+    if (startPoint !== null && create !== true) throw new TypeError('startPoint needs create.');
+    const project = await inspectProject(path);
+    if (create !== true && remote !== true && project.currentBranch === name) return { branch: name, changed: false };
+    return withProjectFolder(null, project.topLevel || path, async () => {
+      const backendApi = await backend();
+      return backendApi.checkoutProjectBranch({
+        projectPath: path,
+        branch: name,
+        create: create === true,
+        remote: remote === true,
+        ...(startPoint !== null ? { startPoint: requireText(startPoint, 'startPoint') } : {}),
+      });
+    });
+  }
+
+  /**
+   * Merge a local branch into a Project folder's checked-out branch with no
+   * session: `target` is the branch the user confirmed and must still be
+   * checked out (WORKTREE_TARGET_MISMATCH); refused while another session
+   * works in that checkout, which is held (turn admission waits) until the
+   * merge is done.
+   */
+  async function mergeProjectBranch({ projectPath, branch, target } = {}) {
+    const path = await registeredProject(projectPath);
+    const source = requireText(branch, 'branch');
+    const confirmedTarget = requireText(target, 'target');
+    const project = await inspectProject(path);
+    assertMergeTarget(project.currentBranch, confirmedTarget);
+    return withProjectFolder(null, project.topLevel || path, async () =>
+      (await backend()).mergeBranchIntoProject({
+        projectPath: path,
+        source,
+        target: confirmedTarget,
+        confirmed: true,
+      })
+    );
+  }
+
+  return { getProjectBranchMenu, selectProjectBranch, mergeProjectBranch };
+}