@piagent/platform 1.16.3 → 1.18.0

package/packages/piagent-webui/dist/client/index.html

@@ -7,7 +7,7 @@
     <meta name="csp-nonce" content="__PIAGENT_CSP_NONCE__" />
     <meta name="piagent-webui-mode" content="__PIAGENT_WEBUI_MODE__" />
     <title>Piagent WebUI</title>
-    <script type="module" crossorigin src="/assets/index-DJGByyfL.js"></script>
+    <script type="module" crossorigin src="/assets/index-BGxsZHB5.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Z91z6SlN.css">
   </head>
   <body>

package/packages/piagent-webui/gateway/gateway-service.ts

@@ -20,6 +20,7 @@ import {
 } from "./profile-state.ts";
 import { buildSessionCatalog, projectRefForCwd } from "./session-catalog.ts";
 import { suggestPaths } from "./path-suggestions.ts";
+import { GitBranchError, listBranches, switchBranch, type SwitchRequest } from "./git-branches.ts";
 import { listAgentCommands } from "../../piagent-core/runtime/resources/agent-resources.mjs";
 import { sessionRefForPath } from "../ownership/session-refs.ts";
 import { SessionMetadataStore } from "./session-metadata-store.ts";
@@ -229,6 +230,8 @@ export async function startPiagentGateway(options: {
       ?? (await runtimes!.listSessions()).find((info) => typeof info.cwd === "string" && projectRefForCwd(key, info.cwd) === projectRef)?.cwd
       ?? (relay ? (await relay.folders()).find((folder) => projectRefForCwd(key, folder) === projectRef) : undefined);
     const relayPost = (path: string, body: unknown) => relay!.json("POST", path, body);
+    const runningInProject = async (projectRef: string) => (await hubCatalog()).sessions.filter((row) => row.projectRef === projectRef
+      && !row.archived && ["running", "waiting-approval", "paused"].includes(row.liveState)).length;
     const commands = new SessionCommandController({ catalog: hubCatalog, runtimes, metadata,
       store: new SessionCommandStore(state.root, key), events,
       // Resolved at call time: the attachment registry is built after this
@@ -303,6 +306,29 @@ export async function startPiagentGateway(options: {
         const root = await projectFolder(projectRef);
         return root ? { commands: listAgentCommands({ cwd: root }) } : null;
       },
+      // The project's Git branches and a switch between them. A switch waits
+      // until no conversation in the folder runs (company ones included): the
+      // agent would find its files changed under it.
+      listBranches: async (projectRef) => {
+        const root = await projectFolder(projectRef);
+        if (!root) return null;
+        const [list, running] = await Promise.all([listBranches(root), runningInProject(projectRef)]);
+        return list ? { ...list, running } : { repository: false, running };
+      },
+      switchBranch: async (projectRef, request) => {
+        const root = await projectFolder(projectRef);
+        if (!root) return null;
+        const value = request as Partial<SwitchRequest> | null;
+        if (!value || typeof value !== "object" || Array.isArray(value) || typeof value.branch !== "string"
+          || Object.keys(value).some((name) => !["branch", "create", "remote"].includes(name))
+          || (value.create !== undefined && typeof value.create !== "boolean")
+          || (value.remote !== undefined && value.remote !== null && typeof value.remote !== "string")) throw new GitBranchError("branch-request-invalid");
+        if (!(await listBranches(root))) throw new GitBranchError("not-a-git-repository");
+        if (await runningInProject(projectRef) > 0) throw new GitBranchError("branch-switch-blocked-running");
+        const head = await switchBranch(root, { branch: value.branch, create: value.create === true, remote: value.remote ?? null });
+        events.publish("catalog.changed", { reasonCode: "git-branch-switched" });
+        return { head, branches: await listBranches(root) };
+      },
       updates: { status: () => updates!.status(), check: () => updates!.check(), apply: (request) => updates!.apply(request) },
       answerSessionQuestion: (sessionRef, questionRef, answer) => company(sessionRef)
         ? relayPost(`/api/v1/sessions/${encodeURIComponent(sessionRef)}/questions/${encodeURIComponent(questionRef)}/answer`, answer)

package/packages/piagent-webui/gateway/git-branches.ts

@@ -0,0 +1,94 @@
+import { execFile } from "node:child_process";
+
+import { readGitHead, type GitHead } from "./git-head.ts";
+
+// The branches of a project folder and a switch between them, for the branch
+// menu in the dashboard. Git itself does the switch (`git switch`), so it
+// refuses exactly what it refuses in a Terminal: local changes a checkout
+// would overwrite, a name that already exists, a branch that is not there.
+export type Branch = { name: string; current: boolean; remote: string | null; committedAt: string | null };
+export type BranchList = { repository: true; head: GitHead | null; branches: Branch[]; truncated: boolean; changedFiles: number };
+export type SwitchRequest = { branch: string; create?: boolean; remote?: string | null };
+
+const GIT = process.platform === "darwin" ? "/usr/bin/git" : "git";
+const LIMIT = 200;
+const SEP = "\u0000";
+
+export class GitBranchError extends Error {
+  readonly detail: string | null;
+  constructor(code: string, detail: string | null = null) { super(code); this.detail = detail; }
+}
+
+function git(cwd: string, args: string[], timeout = 15_000): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile(GIT, ["-C", cwd, ...args], { timeout, maxBuffer: 4 * 1024 * 1024, windowsHide: true,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_OPTIONAL_LOCKS: "0", LC_ALL: "C" } }, (error, stdout, stderr) => {
+      if (error) reject(Object.assign(error, { stderr: String(stderr ?? "") }));
+      else resolve(String(stdout));
+    });
+  });
+}
+
+// A branch name git accepts that cannot be read as an option.
+export async function validBranchName(cwd: string, name: string): Promise<boolean> {
+  if (!name || name.length > 200 || name.startsWith("-") || /[\u0000-\u001f\u007f]/.test(name)) return false;
+  try { await git(cwd, ["check-ref-format", "--branch", name], 5_000); return true; } catch { return false; }
+}
+
+export async function listBranches(cwd: string): Promise<BranchList | null> {
+  const head = readGitHead(cwd);
+  if (!head) {
+    try { await git(cwd, ["rev-parse", "--git-dir"], 5_000); } catch { return null; }
+  }
+  let refs: string;
+  try {
+    refs = await git(cwd, ["for-each-ref", "--sort=-committerdate", `--count=${LIMIT * 2}`,
+      "--format=%(refname)%00%(committerdate:iso-strict)", "refs/heads", "refs/remotes"]);
+  } catch { return null; }
+  const local = new Map<string, Branch>(), remote: Branch[] = [];
+  for (const line of refs.split("\n")) {
+    const [ref, date] = line.split(SEP);
+    if (!ref) continue;
+    const committedAt = date && Number.isFinite(Date.parse(date)) ? new Date(date).toISOString() : null;
+    if (ref.startsWith("refs/heads/")) {
+      const name = ref.slice("refs/heads/".length);
+      local.set(name, { name, current: !head?.detached && head?.name === name, remote: null, committedAt });
+    } else if (ref.startsWith("refs/remotes/")) {
+      const rest = ref.slice("refs/remotes/".length), slash = rest.indexOf("/");
+      if (slash <= 0 || rest.endsWith("/HEAD")) continue;
+      remote.push({ name: rest.slice(slash + 1), current: false, remote: rest.slice(0, slash), committedAt });
+    }
+  }
+  // A remote branch shows only when no local branch has its name: switching
+  // to it creates the local branch that tracks it.
+  const offered = remote.filter((item) => !local.has(item.name)).filter((item, index, all) =>
+    all.findIndex((other) => other.name === item.name) === index);
+  const all = [...local.values(), ...offered];
+  let changedFiles = 0;
+  try { changedFiles = (await git(cwd, ["status", "--porcelain=v1", "--untracked-files=no"], 10_000)).split("\n").filter(Boolean).length; }
+  catch { /* the count is advisory */ }
+  return { repository: true, head, branches: all.slice(0, LIMIT), truncated: all.length > LIMIT, changedFiles };
+}
+
+function failure(error: unknown): GitBranchError {
+  const stderr = String((error as { stderr?: unknown })?.stderr ?? "");
+  const detail = stderr.split("\n").map((line) => line.trim()).filter(Boolean).slice(0, 6).join("\n").slice(0, 600) || null;
+  if (/would be overwritten by checkout|Please commit your changes or stash them/i.test(stderr)) return new GitBranchError("branch-switch-local-changes", detail);
+  if (/already exists/i.test(stderr)) return new GitBranchError("branch-exists", detail);
+  if (/invalid reference|did not match any|not a commit|no such branch/i.test(stderr)) return new GitBranchError("branch-not-found", detail);
+  if (/you need to resolve your current index first|unmerged|in the middle of/i.test(stderr)) return new GitBranchError("branch-switch-unfinished-merge", detail);
+  if ((error as { killed?: boolean })?.killed) return new GitBranchError("branch-switch-timeout", detail);
+  return new GitBranchError("branch-switch-failed", detail);
+}
+
+export async function switchBranch(cwd: string, request: SwitchRequest): Promise<GitHead | null> {
+  const name = request.branch.trim();
+  if (!(await validBranchName(cwd, name))) throw new GitBranchError("branch-name-invalid");
+  const remote = request.remote ?? null;
+  if (remote !== null && (!/^[A-Za-z0-9._-]{1,100}$/.test(remote) || request.create)) throw new GitBranchError("branch-request-invalid");
+  const args = request.create ? ["switch", "-c", name]
+    : remote ? ["switch", "-c", name, "--track", `${remote}/${name}`]
+      : ["switch", name];
+  try { await git(cwd, args, 60_000); } catch (error) { throw failure(error); }
+  return readGitHead(cwd);
+}

package/packages/piagent-webui/gateway/git-head.ts

@@ -0,0 +1,52 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export type GitHead = { name: string; detached: boolean };
+
+const MAX_DEPTH = 40;
+
+// The branch a project folder stands on, read from the repository's HEAD file
+// rather than by running git: the catalog asks for every project each time the
+// dashboard refreshes, and a file read costs nothing. A linked worktree's
+// `.git` is a file naming its own git directory, which holds its own HEAD.
+// Null when the folder is not inside a repository or HEAD cannot be read.
+export function readGitHead(cwd: string): GitHead | null {
+  if (!cwd) return null;
+  let folder = path.resolve(cwd);
+  for (let depth = 0; depth < MAX_DEPTH; depth += 1) {
+    const dotGit = path.join(folder, ".git");
+    let stat: fs.Stats | null = null;
+    try { stat = fs.statSync(dotGit); } catch { /* keep walking up */ }
+    if (stat) return headAt(stat.isDirectory() ? dotGit : linkedGitDir(dotGit, folder));
+    const parent = path.dirname(folder);
+    if (parent === folder) return null;
+    folder = parent;
+  }
+  return null;
+}
+
+function linkedGitDir(dotGitFile: string, folder: string): string | null {
+  try {
+    const match = /^gitdir:\s*(.+?)\s*$/m.exec(fs.readFileSync(dotGitFile, "utf8").slice(0, 4096));
+    return match ? path.resolve(folder, match[1]) : null;
+  } catch { return null; }
+}
+
+function headAt(gitDir: string | null): GitHead | null {
+  if (!gitDir) return null;
+  let head: string;
+  try { head = fs.readFileSync(path.join(gitDir, "HEAD"), "utf8").slice(0, 1024).trim(); } catch { return null; }
+  const ref = /^ref:\s*refs\/heads\/(.+)$/.exec(head);
+  if (ref) return { name: ref[1], detached: false };
+  if (/^[0-9a-f]{40,64}$/i.test(head)) return { name: head.slice(0, 7), detached: true };
+  return null;
+}
+
+// One read per project folder while a catalog is built.
+export function gitHeadReader(): (cwd: string) => GitHead | null {
+  const seen = new Map<string, GitHead | null>();
+  return (cwd) => {
+    if (!seen.has(cwd)) seen.set(cwd, readGitHead(cwd));
+    return seen.get(cwd)!;
+  };
+}

package/packages/piagent-webui/gateway/session-catalog.ts

@@ -6,6 +6,7 @@ import { workflowCommandPattern } from "../../piagent-core/runtime/workflows/web
 import type { Catalog, SessionRow } from "../contracts/generated/session-catalog-v1.ts";
 import type { MetadataSnapshot, SessionMetadata } from "./session-metadata-store.ts";
 import { projectRefForCwd, sessionRefForPath } from "../ownership/session-refs.ts";
+import { gitHeadReader, type GitHead } from "./git-head.ts";
 
 export { projectRefForCwd, sessionRefForPath } from "../ownership/session-refs.ts";
 
@@ -105,7 +106,8 @@ function revision(key: Buffer, value: unknown): string {
 }
 
 function row(key: Buffer, info: PiSessionInfo, metadata: SessionMetadata | undefined, metadataReason: string | null,
-  ownership?: SessionOwnerProjection, sessionOptions?: SessionOptionProjection): SessionRow {
+  ownership?: SessionOwnerProjection, sessionOptions?: SessionOptionProjection, gitHead?: GitHead | null): SessionRow {
+  const gitBranch = gitHead ? { name: display(gitHead.name, 200, "HEAD"), detached: gitHead.detached } : null;
   const projectLabel = display(info.cwd ? path.basename(info.cwd) : "", 120, "Unknown project");
   const projected = projectedSessionTitle(info);
   return {
@@ -123,6 +125,7 @@ function row(key: Buffer, info: PiSessionInfo, metadata: SessionMetadata | undef
     unread: metadata?.unread ?? false,
     composerAvailable: metadata?.archived ? false : ownership?.composerAvailable ?? false,
     needsAttention: metadata?.archived ? false : ownership?.needsAttention ?? false,
+    ...(gitBranch ? { gitBranch } : {}),
     ...(sessionOptions?.managedHelpers ? {managedHelpers:{...sessionOptions.managedHelpers,
       active: ownership?.liveState === 'idle' ? 0 : ownership?.liveState === 'running' || ownership?.liveState === 'waiting-approval' ? sessionOptions.managedHelpers.active : null}} : {}),
     ...(sessionOptions?.managedThinkingLevels ? {managedThinkingLevels:sessionOptions.managedThinkingLevels} : {}),
@@ -138,6 +141,7 @@ function row(key: Buffer, info: PiSessionInfo, metadata: SessionMetadata | undef
       : ownership?.owner ?? { kind: "none", ownerEpoch: null, gatewayInstanceRef: null, runtimeInstanceRef: null, continuity: "unknown" },
     sessionRevision: revision(key, [info.path, info.modified.toISOString(), info.messageCount, info.name ?? null, metadata?.revision ?? null,
       sessionOptions?.modelLabel ?? null, sessionOptions?.thinkingLevel ?? "unknown", sessionOptions?.managedHelpers, sessionOptions?.managedThinkingLevels, sessionOptions?.managedPermission ?? null, sessionOptions?.managedPlan, sessionOptions?.managedProcess,
+      gitBranch,
       metadata?.archived ? "archived" : ownership ? [ownership.state, ownership.liveState, ownership.owner.kind,
         ownership.owner.ownerEpoch, ownership.owner.runtimeInstanceRef, ownership.reasonCode] : "offline"]),
     reasonCode: metadata?.archived ? metadataReason : ownership?.reasonCode ?? metadataReason
@@ -151,16 +155,18 @@ export async function buildSessionCatalog(options: {
   readMetadata?(): MetadataSnapshot;
   readOwnership?(sessionRef: string): SessionOwnerProjection;
   readSessionOptions?(info: PiSessionInfo): SessionOptionProjection;
+  readGitHead?(cwd: string): GitHead | null;
   limit?: number;
 }): Promise<Catalog> {
   const limit = Math.max(1, Math.min(200, options.limit ?? 200));
   try {
     const found = (await options.listSessions()).filter(isUserConversationSession);
+    const readHead = options.readGitHead ?? gitHeadReader();
     const metadata = options.readMetadata?.() ?? { state: "ready", revision: null, sessions: new Map(), reasonCode: null };
     const sessions = found.map((info) => {
       const sessionRef = sessionRefForPath(options.key, info.path);
       return row(options.key, info, metadata.sessions.get(sessionRef), metadata.reasonCode, options.readOwnership?.(sessionRef),
-        options.readSessionOptions?.(info));
+        options.readSessionOptions?.(info), readHead(info.cwd));
     }).sort((left, right) => Number(right.pinned) - Number(left.pinned)
       || Date.parse(right.updatedAt) - Date.parse(left.updatedAt)).slice(0, limit);
     return {

package/packages/piagent-webui/gateway/session-operation-lifecycle.ts

@@ -18,9 +18,10 @@ export type SessionOperationObservation = Readonly<{
 
 const DEFAULT_RETRY_POLICY: SessionOperationRetryPolicy = Object.freeze({
   // Pi's provider retry is useful before a response exists, but a long retry
-  // chain burns quota and keeps the browser in Working. One automatic retry
-  // absorbs an ordinary transient failure without replaying a persistent one.
-  maximumAttempts: 1,
+  // chain burns quota and keeps the browser in Working. Two automatic retries
+  // (the company turn retry's budget, managed/request-stream.mjs) absorb a transient
+  // failure without replaying a persistent one for long.
+  maximumAttempts: 2,
   maximumDelayMs: 8_000
 });
 
@@ -145,6 +146,12 @@ export class SessionOperationLifecycle {
       if (this.#phase === "pending") this.#phase = "running";
     }
 
+    // Replay safety belongs to the model call that failed: Pi retries only
+    // that call, after the tools of earlier ones ran once. A new answer
+    // starts clean; output or a tool of this answer makes it unsafe.
+    if (type === "message_start" && event?.message?.role === "assistant") {
+      this.#visibleAssistantOutput = false; this.#toolCallObserved = false;
+    }
     if (type === "message_update") {
       const update = event?.assistantMessageEvent;
       if (update?.type === "text_delta" && hasVisibleText(update.delta)) this.#visibleAssistantOutput = true;

package/packages/piagent-webui/server/loopback-server.ts

@@ -72,9 +72,15 @@ export async function startLoopbackServer(options: {
   answerSessionQuestion?: (sessionRef: string, questionRef: string, answer: unknown) => unknown | Promise<unknown>;
   suggestPaths?: (projectRef: string, query: string) => unknown | Promise<unknown>;
   listCommands?: (projectRef: string) => unknown | Promise<unknown>;
+  listBranches?: (projectRef: string) => unknown | Promise<unknown>;
+  switchBranch?: (projectRef: string, request: unknown) => unknown | Promise<unknown>;
   updates?: UpdateRoutes;
   bootstrapTtlMs?: number;
   sessionTtlMs?: number;
+  // Requests a minute from one address before it has a browser session (the
+  // page, its assets, the bootstrap). A test harness opening dozens of fresh
+  // pages from one address raises it; Piagent itself never does.
+  anonymousRequestsPerMinute?: number;
 }): Promise<LoopbackServer> {
   const assets = new Map(loadStaticBundle(options.staticRoot));
   const styleNonce = randomBytes(16).toString("base64");
@@ -112,7 +118,7 @@ export async function startLoopbackServer(options: {
     if (now - rate.windowStart >= 60_000) Object.assign(rate, { windowStart: now, requests: 0, bootstrapFailures: 0 });
     rate.requests += 1; rates.set(rateKey, rate);
     while (rates.size > 128) rates.delete(rates.keys().next().value as string);
-    if (rate.requests > (browserSession ? SESSION_REQUESTS_PER_MINUTE : REQUESTS_PER_MINUTE)) return errorResponse(response, 429, "rate-limit");
+    if (rate.requests > (browserSession ? SESSION_REQUESTS_PER_MINUTE : options.anonymousRequestsPerMinute ?? REQUESTS_PER_MINUTE)) return errorResponse(response, 429, "rate-limit");
     let url: URL;
     try { url = new URL(request.url ?? "/", origin); }
     catch { return errorResponse(response, 400, "invalid-url"); }
@@ -294,7 +300,8 @@ export async function startLoopbackServer(options: {
       catch { return errorResponse(response, 503, "attachment-runtime-unavailable"); }
     }
 
-    // The main agent's questions to the member, and Piagent's own updates.
+    // The main agent's questions to the member, a project's Git branches, and
+    // Piagent's own updates.
     if (await routeMemberRequest({ request, response, url, origin, requestOrigin, auth, now, consumeControl }, options)) return;
 
     if (request.method === "POST" && url.pathname.startsWith("/api/v1/approvals/") && url.pathname.endsWith("/decision") && options.executeApproval) {

package/packages/piagent-webui/server/member-routes.ts

@@ -12,6 +12,7 @@ const MAX_CONTROL_BODY_BYTES = 70_000;
 const CURSOR = /^[A-Za-z0-9][A-Za-z0-9._~-]{0,159}$/;
 const QUESTION_PATH = /^\/api\/v1\/sessions\/([^/]+)\/questions(?:\/([^/]+)\/answer)?$/;
 const PROJECT_PATH = /^\/api\/v1\/projects\/([^/]+)\/(paths|commands)$/;
+const BRANCH_PATH = /^\/api\/v1\/projects\/([^/]+)\/branches(\/switch)?$/;
 
 export type UpdateRoutes = {
   // What is installed, what is available, and the last update run.
@@ -34,6 +35,10 @@ type Options = {
   suggestPaths?: (projectRef: string, query: string) => unknown | Promise<unknown>;
   // The project's and the member's commands and skills; null as above.
   listCommands?: (projectRef: string) => unknown | Promise<unknown>;
+  // The project's Git branches, and a switch to one of them (or a new one);
+  // null as above.
+  listBranches?: (projectRef: string) => unknown | Promise<unknown>;
+  switchBranch?: (projectRef: string, request: unknown) => unknown | Promise<unknown>;
   updates?: UpdateRoutes;
 };
 
@@ -53,6 +58,11 @@ async function jsonBody(context: Context, code: string): Promise<{ ok: true; val
   catch (error) { errorResponse(context.response, (error as Error).message === "body-limit" ? 413 : 400, code); return { ok: false }; }
 }
 
+const BRANCH_STATUS: Record<string, number> = {
+  "branch-request-invalid": 400, "branch-name-invalid": 400, "not-a-git-repository": 404, "branch-not-found": 404,
+  "branch-switch-blocked-running": 409, "branch-switch-local-changes": 409, "branch-exists": 409, "branch-switch-unfinished-merge": 409
+};
+
 const UPDATE_STATUS: Record<string, number> = {
   "update-not-installable": 409, "update-blocked-running": 409, "update-already-running": 409,
   "update-version-changed": 409, "update-not-available": 409, "update-request-invalid": 400
@@ -96,6 +106,34 @@ export async function routeMemberRequest(context: Context, options: Options): Pr
     return true;
   }
 
+  const branches = BRANCH_PATH.exec(url.pathname);
+  if (branches && (request.method === "GET" && !branches[2] && options.listBranches || request.method === "POST" && branches[2] && options.switchBranch)) {
+    const projectRef = decodeURIComponent(branches[1]);
+    if (request.method === "GET") {
+      if (!auth.authenticate(request)) { errorResponse(response, 401, "authentication-required"); return true; }
+      if (!CURSOR.test(projectRef)) { errorResponse(response, 400, "invalid-project-ref"); return true; }
+      try {
+        const value = await options.listBranches!(projectRef);
+        if (value === null) errorResponse(response, 404, "project-not-found"); else jsonResponse(response, 200, value);
+      } catch { errorResponse(response, 503, "branches-unavailable"); }
+      return true;
+    }
+    if (!authorizeChange(context)) return true;
+    if (!CURSOR.test(projectRef)) { errorResponse(response, 400, "invalid-project-ref"); return true; }
+    const body = await jsonBody(context, "branch-request-invalid");
+    if (!body.ok) return true;
+    try {
+      const value = await options.switchBranch!(projectRef, body.value);
+      if (value === null) errorResponse(response, 404, "project-not-found"); else jsonResponse(response, 200, value);
+    } catch (error) {
+      const code = error instanceof Error ? error.message : "branch-switch-failed";
+      const detail = (error as { detail?: unknown })?.detail;
+      jsonResponse(response, BRANCH_STATUS[code] ?? 500, { error: { code: BRANCH_STATUS[code] || code === "branch-switch-failed" || code === "branch-switch-timeout" ? code : "branch-switch-failed",
+        ...(typeof detail === "string" ? { detail } : {}) } });
+    }
+    return true;
+  }
+
   if (!options.updates || !url.pathname.startsWith("/api/v1/updates")) return false;
   const updates = options.updates;
   if (request.method === "GET" && url.pathname === "/api/v1/updates") {

package/schemas/piagent-webui/session-catalog-v1.schema.json

@@ -99,6 +99,9 @@
         "managedProcess": { "type": "object", "additionalProperties": false, "required": ["outcome", "verified", "reviewed", "blockingOpen"], "properties": {
           "outcome": { "enum": ["no_change", "interrupted", "disputed", "blocking_open", "unverified", "review_unavailable", "unreviewed", "clean"] },
           "verified": { "type": "boolean" }, "reviewed": { "type": "boolean" }, "blockingOpen": { "type": "integer", "minimum": 0, "maximum": 1000 }, "planSkipped": { "const": true } } },
+        "gitBranch": { "type": "object", "additionalProperties": false, "required": ["name", "detached"], "properties": {
+          "name": { "type": "string", "minLength": 1, "maxLength": 200, "pattern": "^[^\\u0000-\\u001F\\u007F]*$" },
+          "detached": { "type": "boolean" } } },
         "modelLabel": { "$ref": "common-v1.schema.json#/$defs/nullableDisplayText" },
         "thinkingLevel": { "enum": ["off", "minimal", "low", "medium", "high", "xhigh", "max", "unknown"] },
         "contextUsage": { "$ref": "#/$defs/contextUsage" },

package/scripts/configure-model-scope.sh

@@ -135,6 +135,7 @@ const codexModels = [
 
 const claudeModels = [
   "anthropic/claude-haiku-4-5:low",
+  "anthropic/claude-haiku-5-5:medium",
   "anthropic/claude-sonnet-4-5:high",
   "anthropic/claude-sonnet-4-6:max",
   "anthropic/claude-sonnet-5:xhigh",

package/templates/global/settings.json

@@ -27,7 +27,8 @@
     "anthropic/claude-opus-4-8:xhigh",
     "anthropic/claude-fable-5:xhigh",
     "anthropic/claude-sonnet-5-5:high",
-    "anthropic/claude-opus-5-5:high"
+    "anthropic/claude-opus-5-5:high",
+    "anthropic/claude-haiku-5-5:medium"
   ],
   "compaction": {
     "enabled": true,