@abot-ai/runtime 1.6.0 → 1.8.0

package/dist/src/sessions/snapshot.js

@@ -0,0 +1,105 @@
+import { clientVisibleMessages, filterMessagesAfter, createMessageRequestIdResolver, toEpochMs, toMessageIdForUi, toSnapshotMessage, toSnapshotRequest } from "./record/projection.js";
+function encodeAnchor(sessionId, message, direction) {
+    return Buffer.from(JSON.stringify({ sessionId, id: message.id, createdAt: message.createdAt, direction })).toString("base64url");
+}
+function decodeAnchor(cursor, sessionId) {
+    try {
+        const anchor = JSON.parse(Buffer.from(cursor, "base64url").toString());
+        if (anchor.sessionId !== sessionId)
+            throw new Error();
+        if (typeof anchor.id !== "string" || typeof anchor.createdAt !== "string")
+            throw new Error();
+        if (!["older", "newer"].includes(anchor.direction))
+            throw new Error();
+        return anchor;
+    }
+    catch {
+        throw new Error("history_cursor_stale");
+    }
+}
+function messageWindow(sessionId, messages, page, resolveRequestId) {
+    const limit = page.limit;
+    if (!Number.isSafeInteger(limit) || limit < 1)
+        throw new Error("history_page_size_invalid");
+    let start = Math.max(0, messages.length - limit);
+    let end = messages.length;
+    if (page.targetMessageId != null) {
+        const target = messages.findIndex((message) => {
+            if (String(toMessageIdForUi(message.id)) !== page.targetMessageId)
+                return false;
+            if (page.targetCreatedAt == null)
+                return true;
+            if (toEpochMs(message.createdAt) !== page.targetCreatedAt)
+                return false;
+            return (resolveRequestId(message) || "") === (page.targetRequestId || "");
+        });
+        if (target >= 0) {
+            start = target;
+            end = Math.min(messages.length, start + limit);
+        }
+    }
+    else if (page.targetRequestId) {
+        const target = messages.findIndex((message) => resolveRequestId(message) === page.targetRequestId);
+        if (target >= 0) {
+            start = target;
+            end = Math.min(messages.length, start + limit);
+        }
+    }
+    if (page.cursor) {
+        const anchor = decodeAnchor(page.cursor, sessionId);
+        const index = messages.findIndex((message) => message.id === anchor.id && message.createdAt === anchor.createdAt);
+        if (index < 0)
+            throw new Error("history_cursor_stale");
+        start = anchor.direction === "older" ? Math.max(0, index - limit) : index + 1;
+        end = anchor.direction === "older" ? index : Math.min(messages.length, start + limit);
+    }
+    const selected = messages.slice(start, end);
+    return {
+        selected,
+        nextCursor: start > 0 && selected.length ? encodeAnchor(sessionId, selected[0], "older") : null,
+        newerCursor: end < messages.length && selected.length ? encodeAnchor(sessionId, selected.at(-1), "newer") : null,
+    };
+}
+function isRequiredPageRequest(request, ids, waitingRequestId, continuation = false) {
+    if (ids.has(request.requestId))
+        return true;
+    if (continuation)
+        return false;
+    if (request.requestId === waitingRequestId)
+        return true;
+    if (request.status === "streaming")
+        return true;
+    return request.status === "awaiting_approval";
+}
+export function projectSessionSnapshot(session, options = {}) {
+    const visible = clientVisibleMessages(session.messages);
+    const requests = session.requests ?? [];
+    const resolveRequestId = createMessageRequestIdResolver(requests);
+    const base = {
+        sessionId: session.id, title: session.title,
+        ...(session.kind ? { kind: session.kind } : {}),
+        ...(session.project ? { project: session.project } : {}),
+    };
+    // The default projection is kept intact for existing session consumers.
+    if (!options.page && !options.identitiesOnly)
+        return {
+            ...base,
+            messages: filterMessagesAfter(visible, options.afterMessageId).map((message) => toSnapshotMessage(session.id, message, requests, resolveRequestId)),
+            requests: options.includeRequests === false ? [] : requests.map(toSnapshotRequest),
+            nextCursor: null,
+        };
+    const messageIndex = visible.map((message) => ({
+        id: toMessageIdForUi(message.id), role: message.role, createdAt: toEpochMs(message.createdAt),
+        requestId: resolveRequestId(message),
+    }));
+    if (options.identitiesOnly)
+        return { ...base, messages: [], requests: [], nextCursor: null, messageIndex };
+    const page = messageWindow(session.id, visible, options.page, resolveRequestId);
+    const messages = page.selected.map((message) => toSnapshotMessage(session.id, message, requests, resolveRequestId));
+    const ids = new Set(messages.map((message) => message.requestId));
+    return {
+        ...base, messages, messageIndex, nextCursor: page.nextCursor, newerCursor: page.newerCursor,
+        requests: options.includeRequests === false ? [] : requests
+            .filter((request) => isRequiredPageRequest(request, ids, options.page?.waitingRequestId, Boolean(options.page?.cursor))).map(toSnapshotRequest),
+    };
+}

package/dist/src/sessions/types.d.ts

@@ -130,6 +130,8 @@ export type SessionSnapshot = {
     messages: SessionSnapshotMessage[];
     requests: SessionSnapshotRequest[];
     nextCursor: string | null;
+    newerCursor?: string | null;
+    messageIndex?: import("./snapshot.js").SessionMessageIdentity[];
 };
 export type SessionDeleteResult = {
     sessionId: string;

package/dist/src/shared/passive-observation-self-exclusion.d.ts

@@ -0,0 +1,5 @@
+import type { PassiveObservationSource } from "./passive-observation.js";
+/** Application-wide exclusions have no user-configurable collection control. */
+export declare function isOwnObservationApplication(app: string): boolean;
+/** Mandatory self-exclusion is independent of the user's application rules. */
+export declare function isOwnApplicationObservation(source: PassiveObservationSource): boolean;

package/dist/src/shared/passive-observation-self-exclusion.js

@@ -0,0 +1,37 @@
+// Include the previous title so tabs opened before an update are also excluded.
+const OWN_WEB_UI_TITLES = ["ABot Runtime — Workspace", "ABot Runtime"];
+const BROWSER_WINDOW_NAMES = [
+    "Mozilla Firefox",
+    "Mozilla Firefox (Private Browsing)",
+    "Google Chrome",
+    "Chromium",
+    "Microsoft Edge",
+    "Brave",
+    "Safari",
+];
+const BROWSER_WINDOW_SUFFIXES = BROWSER_WINDOW_NAMES.flatMap((browser) => [
+    ` — ${browser}`,
+    ` - ${browser}`,
+]);
+function isOwnWebUiWindowTitle(title) {
+    if (typeof title !== "string")
+        return false;
+    if (OWN_WEB_UI_TITLES.includes(title))
+        return true;
+    const suffix = BROWSER_WINDOW_SUFFIXES.find((candidate) => title.endsWith(candidate));
+    if (!suffix)
+        return false;
+    return OWN_WEB_UI_TITLES.includes(title.slice(0, -suffix.length));
+}
+/** Application-wide exclusions have no user-configurable collection control. */
+export function isOwnObservationApplication(app) {
+    // The Windows collector emits ProcessName (ABot), without .exe or an install path.
+    // QA and packaged installations retain this identity while using ABot.exe.
+    return app.toLowerCase() === "abot";
+}
+/** Mandatory self-exclusion is independent of the user's application rules. */
+export function isOwnApplicationObservation(source) {
+    if (isOwnObservationApplication(source.app))
+        return true;
+    return isOwnWebUiWindowTitle(source.title);
+}

package/dist/src/shared/tool-selection.d.ts

@@ -0,0 +1,2 @@
+/** Matches the existing wildcard, owner, tool, and qualified tool selectors. */
+export declare function matchesToolSelectionId(ownerId: string, toolName: string, configuredId: string): boolean;

package/dist/src/shared/tool-selection.js

@@ -0,0 +1,7 @@
+/** Matches the existing wildcard, owner, tool, and qualified tool selectors. */
+export function matchesToolSelectionId(ownerId, toolName, configuredId) {
+    return (configuredId === "*" ||
+        configuredId === ownerId ||
+        configuredId === toolName ||
+        configuredId === `${ownerId}.${toolName}`);
+}

package/dist/src/shared/windows-file-io/authority-script.d.ts

@@ -0,0 +1 @@
+export declare const WINDOWS_FILESYSTEM_AUTHORITY: string;

package/dist/src/shared/windows-file-io/authority-script.js

@@ -0,0 +1,94 @@
+export const WINDOWS_FILESYSTEM_AUTHORITY = String.raw `
+public static partial class AbotFilesystem {
+  static string NativePath(string path) {
+    string full = Path.GetFullPath(path);
+    if (full.StartsWith(@"\\?\") || full.StartsWith(@"\\.\")) throw new FsFault("filesystem_invalid_path");
+    if (full.StartsWith(@"\\")) return @"\??\UNC\" + full.Substring(2);
+    if (full.Length < 3 || full[1] != ':' || full[2] != '\\') throw new FsFault("filesystem_invalid_path");
+    return @"\??\" + full;
+  }
+  static string FinalPath(SafeFileHandle handle) {
+    var value = new StringBuilder(32768);
+    uint length = GetFinalPathNameByHandle(handle, value, (uint)value.Capacity, 0);
+    Check(length != 0);
+    if (length >= value.Capacity) throw new FsFault("filesystem_invalid_path");
+    string path = value.ToString();
+    if (path.StartsWith(@"\\?\UNC\")) return @"\\" + path.Substring(8);
+    if (path.StartsWith(@"\\?\")) return path.Substring(4);
+    throw new FsFault("filesystem_path_changed");
+  }
+  static SafeFileHandle OpenRoot(Dictionary<string,object> request) {
+    string path = Path.GetFullPath(Text(request, "rootPath"));
+    SafeFileHandle root = OpenHandle(null, NativePath(path), true, 1, 0x80000000, 7);
+    try {
+      if (!String.Equals(FinalPath(root).TrimEnd('\\'), path.TrimEnd('\\'), StringComparison.OrdinalIgnoreCase))
+        throw new FsFault("filesystem_path_changed");
+      var expected = request["rootIdentity"] as Dictionary<string,object>;
+      if (expected == null || !MatchesIdentity(Identity(root), expected)) throw new FsFault("filesystem_path_changed");
+      return root;
+    } catch { root.Dispose(); throw; }
+  }
+  static string[] Components(Dictionary<string,object> request) {
+    string relative = Text(request, "relativePath");
+    if (relative == "") return new string[0];
+    string[] parts = relative.Split('/');
+    foreach (string part in parts) ValidateComponent(part);
+    return parts;
+  }
+  static void ValidateComponent(string name) {
+    if (name.Length == 0 || name == "." || name == "..") throw new FsFault("filesystem_invalid_path");
+    if (name.EndsWith(".") || name.EndsWith(" ")) throw new FsFault("filesystem_invalid_path");
+    foreach (char c in name) {
+      if (c < 32 || "\\/:*?\"<>|".IndexOf(c) >= 0) throw new FsFault("filesystem_invalid_path");
+    }
+    string stem = name.Split('.')[0].ToUpperInvariant();
+    if (stem == "CON" || stem == "PRN" || stem == "AUX" || stem == "NUL" ||
+      stem == "CONIN$" || stem == "CONOUT$") throw new FsFault("filesystem_invalid_path");
+    if (stem.Length == 4 && (stem.StartsWith("COM") || stem.StartsWith("LPT")) &&
+      "123456789\u00b9\u00b2\u00b3".IndexOf(stem[3]) >= 0) throw new FsFault("filesystem_invalid_path");
+  }
+  sealed class DirectoryChain : IDisposable {
+    public readonly SafeFileHandle Root;
+    readonly List<SafeFileHandle> children = new List<SafeFileHandle>();
+    public SafeFileHandle Current { get { return children.Count == 0 ? Root : children[children.Count-1]; } }
+    public DirectoryChain(Dictionary<string,object> request) { Root = OpenRoot(request); }
+    public void Walk(string[] parts, int count, bool create) {
+      for (int i=0;i<count;i++) children.Add(OpenHandle(Current, parts[i], true, create ? 3u : 1u, 0x80000000, 7));
+    }
+    public void Dispose() { for (int i=children.Count-1;i>=0;i--) children[i].Dispose(); Root.Dispose(); }
+  }
+  static ulong FileId(FileInfo info) {
+    ulong id=((ulong)info.IndexHigh << 32) | info.IndexLow;
+    if (id == 0) throw new FsFault("filesystem_safe_io_unsupported");
+    return id;
+  }
+  static Dictionary<string,object> Identity(SafeFileHandle file) {
+    FileInfo info; Check(GetFileInformationByHandle(file, out info));
+    BasicInfo basic = Basic(file);
+    return Record("device", info.Volume.ToString(), "inode", FileId(info).ToString(),
+      "birthtimeNs", ((basic.Created - 116444736000000000L) * 100L).ToString());
+  }
+  static bool MatchesIdentity(Dictionary<string,object> left, Dictionary<string,object> right) {
+    foreach (string key in new [] {"device", "inode", "birthtimeNs"}) {
+      if (!right.ContainsKey(key) || !Object.Equals(left[key], right[key])) return false;
+    }
+    return true;
+  }
+  static Dictionary<string,object> Metadata(SafeFileHandle file) {
+    FileInfo info; Check(GetFileInformationByHandle(file, out info));
+    BasicInfo basic = Basic(file);
+    ulong size = ((ulong)info.SizeHigh << 32) | info.SizeLow;
+    if (size > 9007199254740991UL) throw new FsFault("file_too_large");
+    return Record("device", info.Volume.ToString(), "inode", FileId(info).ToString(),
+      "size", (long)size, "mode", (basic.Attributes & 1) != 0 ? 292 : 438,
+      "modifiedNs", ((basic.Modified - 116444736000000000L) * 100L).ToString(),
+      "changedNs", ((basic.Changed - 116444736000000000L) * 100L).ToString());
+  }
+  static bool SameMetadata(Dictionary<string,object> left, Dictionary<string,object> right) {
+    foreach (string key in new [] {"device", "inode", "size", "mode", "modifiedNs", "changedNs"}) {
+      if (!right.ContainsKey(key) || Convert.ToString(left[key]) != Convert.ToString(right[key])) return false;
+    }
+    return true;
+  }
+}
+`;

package/dist/src/shared/windows-file-io/native-script.d.ts

@@ -0,0 +1,2 @@
+/** Windows handle primitives. Trusted source only; request data is passed as JSON. */
+export declare const WINDOWS_FILESYSTEM_NATIVE: string;

package/dist/src/shared/windows-file-io/native-script.js

@@ -0,0 +1,120 @@
+/** Windows handle primitives. Trusted source only; request data is passed as JSON. */
+export const WINDOWS_FILESYSTEM_NATIVE = String.raw `
+using System;
+using System.IO;
+using System.Text;
+using System.Linq;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using System.Security.AccessControl;
+using System.Security.Principal;
+using System.Web.Script.Serialization;
+using Microsoft.Win32.SafeHandles;
+
+public sealed class FsFault : Exception {
+  public readonly string Code;
+  public FsFault(string code) : base(code) { Code = code; }
+}
+public static partial class AbotFilesystem {
+  [StructLayout(LayoutKind.Sequential)] struct UnicodeString { public ushort Length, MaximumLength; public IntPtr Buffer; }
+  [StructLayout(LayoutKind.Sequential)] struct ObjectAttributes {
+    public int Length; public IntPtr Root, Name; public uint Attributes; public IntPtr Security, Qos;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct IoStatus { public IntPtr Status, Information; }
+  [StructLayout(LayoutKind.Sequential)] struct BasicInfo {
+    public long Created, Accessed, Modified, Changed; public uint Attributes;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct FileInfo {
+    public uint Attributes; public System.Runtime.InteropServices.ComTypes.FILETIME Created, Accessed, Modified;
+    public uint Volume, SizeHigh, SizeLow, Links, IndexHigh, IndexLow;
+  }
+  [DllImport("ntdll.dll")] static extern int NtCreateFile(out SafeFileHandle file, uint access,
+    ref ObjectAttributes attributes, out IoStatus status, IntPtr allocation, uint fileAttributes,
+    uint share, uint disposition, uint options, IntPtr ea, uint eaLength);
+  [DllImport("ntdll.dll")] static extern uint RtlNtStatusToDosError(int status);
+  [DllImport("ntdll.dll")] static extern int NtSetInformationFile(SafeFileHandle file,
+    out IoStatus status, IntPtr info, uint length, int kind);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool GetFileInformationByHandle(SafeFileHandle file, out FileInfo info);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool GetFileInformationByHandleEx(SafeFileHandle file, int kind, IntPtr data, uint length);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool SetFileInformationByHandle(SafeFileHandle file, int kind, ref BasicInfo info, uint length);
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern uint GetFinalPathNameByHandle(SafeFileHandle file, StringBuilder name, uint length, uint flags);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool SetFilePointerEx(SafeFileHandle file, long position, out long result, uint method);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool ReadFile(SafeFileHandle file, byte[] bytes, uint count, out uint read, IntPtr overlapped);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool WriteFile(SafeFileHandle file, byte[] bytes, uint count, out uint written, IntPtr overlapped);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool FlushFileBuffers(SafeFileHandle file);
+  [DllImport("advapi32.dll")] static extern uint GetSecurityInfo(SafeFileHandle file, int kind, uint information,
+    out IntPtr owner, out IntPtr group, out IntPtr dacl, out IntPtr sacl, out IntPtr descriptor);
+  [DllImport("advapi32.dll")] static extern uint SetSecurityInfo(SafeFileHandle file, int kind, uint information,
+    IntPtr owner, IntPtr group, IntPtr dacl, IntPtr sacl);
+  [DllImport("advapi32.dll", SetLastError=true)] static extern bool GetSecurityDescriptorControl(IntPtr descriptor, out ushort control, out uint revision);
+  [DllImport("kernel32.dll")] static extern IntPtr LocalFree(IntPtr value);
+
+  static void Check(bool success) { if (!success) NativeFailure((uint)Marshal.GetLastWin32Error()); }
+  static bool IsNotDirectoryError(uint code) { return code == 267; } // ERROR_DIRECTORY
+  static void NativeFailure(uint code) {
+    if (IsNotDirectoryError(code)) throw new FsFault("not_a_directory");
+    if (code == 2 || code == 3) throw new FsFault("file_not_found");
+    if (code == 80 || code == 183) throw new FsFault("filesystem_target_changed");
+    if (code == 5 || code == 32 || code == 33) throw new FsFault("filesystem_access_denied");
+    throw new FsFault("filesystem_native_operation_failed");
+  }
+  static void CheckNt(int status) { if (status < 0) NativeFailure(RtlNtStatusToDosError(status)); }
+  static SafeFileHandle OpenHandle(SafeFileHandle root, string name, bool directory,
+    uint disposition, uint access, uint share, byte[] securityDescriptor = null, bool deleteOnClose = false) {
+    IntPtr text = Marshal.StringToHGlobalUni(name), unicodePointer = IntPtr.Zero, securityPointer = IntPtr.Zero;
+    try {
+      int length = Encoding.Unicode.GetByteCount(name);
+      if (length > 65532) throw new FsFault("filesystem_invalid_path");
+      UnicodeString unicode = new UnicodeString { Length=(ushort)length, MaximumLength=(ushort)(length+2), Buffer=text };
+      unicodePointer = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(UnicodeString)));
+      Marshal.StructureToPtr(unicode, unicodePointer, false);
+      if (securityDescriptor != null) {
+        securityPointer = Marshal.AllocHGlobal(securityDescriptor.Length);
+        Marshal.Copy(securityDescriptor, 0, securityPointer, securityDescriptor.Length);
+      }
+      ObjectAttributes attributes = new ObjectAttributes {
+        Length=Marshal.SizeOf(typeof(ObjectAttributes)), Root=root == null ? IntPtr.Zero : root.DangerousGetHandle(),
+        Name=unicodePointer, Attributes=0x40, Security=securityPointer
+      };
+      SafeFileHandle file;
+      IoStatus status;
+      int result = NtCreateFile(out file, access | 0x100000, ref attributes, out status,
+        IntPtr.Zero, 0x80, share, disposition, 0x200020u | (directory ? 1u : 0x40u) | (deleteOnClose ? 0x1000u : 0u), IntPtr.Zero, 0);
+      if (result < 0) { if (file != null) file.Dispose(); CheckNt(result); }
+      try {
+        FileInfo info; Check(GetFileInformationByHandle(file, out info));
+        if ((info.Attributes & 0x400) != 0) throw new FsFault("filesystem_path_changed");
+        if (((info.Attributes & 0x10) != 0) != directory) throw new FsFault("filesystem_path_changed");
+        return file;
+      } catch { file.Dispose(); throw; }
+    } finally {
+      if (securityPointer != IntPtr.Zero) Marshal.FreeHGlobal(securityPointer);
+      if (unicodePointer != IntPtr.Zero) Marshal.FreeHGlobal(unicodePointer);
+      Marshal.FreeHGlobal(text);
+    }
+  }
+  static BasicInfo Basic(SafeFileHandle file) {
+    IntPtr buffer = Marshal.AllocHGlobal(40);
+    try { Check(GetFileInformationByHandleEx(file, 0, buffer, 40)); return (BasicInfo)Marshal.PtrToStructure(buffer, typeof(BasicInfo)); }
+    finally { Marshal.FreeHGlobal(buffer); }
+  }
+  static Dictionary<string,object> Record(params object[] pairs) {
+    var result = new Dictionary<string,object>();
+    for (int i=0;i<pairs.Length;i+=2) result.Add((string)pairs[i], pairs[i+1]);
+    return result;
+  }
+  static string Text(Dictionary<string,object> request, string key) {
+    object value;
+    if (!request.TryGetValue(key, out value) || !(value is string)) throw new FsFault("filesystem_invalid_request");
+    return (string)value;
+  }
+  static int Limit(Dictionary<string,object> request, string key, int maximum) {
+    object value;
+    if (!request.TryGetValue(key, out value) || !(value is int)) throw new FsFault("filesystem_invalid_request");
+    int number = (int)value;
+    if (number < 0 || number > maximum) throw new FsFault("filesystem_invalid_request");
+    return number;
+  }
+}
+`;

package/dist/src/shared/windows-file-io/read-bytes-script.d.ts

@@ -0,0 +1 @@
+export declare const WINDOWS_FILE_READ_BYTES: string;

package/dist/src/shared/windows-file-io/read-bytes-script.js

@@ -0,0 +1,18 @@
+export const WINDOWS_FILE_READ_BYTES = String.raw `
+public static partial class AbotFilesystem {
+  static byte[] ReadBytes(SafeFileHandle file, long position, int length) {
+    long actual; Check(SetFilePointerEx(file, position, out actual, 0));
+    if (actual != position) throw new FsFault("filesystem_read_incomplete");
+    var bytes = new byte[length];
+    int offset = 0;
+    while (offset < length) {
+      var chunk = new byte[Math.Min(65536, length-offset)];
+      uint read; Check(ReadFile(file, chunk, (uint)chunk.Length, out read, IntPtr.Zero));
+      if (read == 0 || read > chunk.Length) throw new FsFault("filesystem_read_incomplete");
+      Buffer.BlockCopy(chunk, 0, bytes, offset, (int)read);
+      offset += (int)read;
+    }
+    return bytes;
+  }
+}
+`;

package/dist/src/shared/windows-job-object.d.ts

@@ -0,0 +1,2 @@
+/** The shell owns the sole non-inherited job handle; closing it ends its descendants. */
+export declare const WINDOWS_EXEC_JOB_SOURCE: string;

package/dist/src/shared/windows-job-object.js

@@ -0,0 +1,66 @@
+/** The shell owns the sole non-inherited job handle; closing it ends its descendants. */
+export const WINDOWS_EXEC_JOB_SOURCE = String.raw `
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+
+public static class AbotExecJob {
+  private static IntPtr job = IntPtr.Zero;
+
+  [StructLayout(LayoutKind.Sequential)]
+  private struct BasicLimits {
+    public long PerProcessUserTimeLimit;
+    public long PerJobUserTimeLimit;
+    public uint LimitFlags;
+    public UIntPtr MinimumWorkingSetSize;
+    public UIntPtr MaximumWorkingSetSize;
+    public uint ActiveProcessLimit;
+    public UIntPtr Affinity;
+    public uint PriorityClass;
+    public uint SchedulingClass;
+  }
+  [StructLayout(LayoutKind.Sequential)]
+  private struct IoCounters {
+    public ulong ReadOperationCount, WriteOperationCount, OtherOperationCount;
+    public ulong ReadTransferCount, WriteTransferCount, OtherTransferCount;
+  }
+  [StructLayout(LayoutKind.Sequential)]
+  private struct ExtendedLimits {
+    public BasicLimits BasicLimitInformation;
+    public IoCounters IoInfo;
+    public UIntPtr ProcessMemoryLimit, JobMemoryLimit;
+    public UIntPtr PeakProcessMemoryUsed, PeakJobMemoryUsed;
+  }
+
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  private static extern IntPtr CreateJobObject(IntPtr attributes, string name);
+  [DllImport("kernel32.dll", SetLastError = true)]
+  private static extern bool SetInformationJobObject(IntPtr handle, int kind,
+    ref ExtendedLimits limits, uint size);
+  [DllImport("kernel32.dll", SetLastError = true)]
+  private static extern bool AssignProcessToJobObject(IntPtr handle, IntPtr process);
+  [DllImport("kernel32.dll")]
+  private static extern IntPtr GetCurrentProcess();
+  [DllImport("kernel32.dll")]
+  private static extern bool CloseHandle(IntPtr handle);
+
+  public static void Attach() {
+    if (job != IntPtr.Zero) throw new InvalidOperationException("Already attached");
+    IntPtr candidate = CreateJobObject(IntPtr.Zero, null);
+    if (candidate == IntPtr.Zero) throw new Win32Exception(Marshal.GetLastWin32Error());
+    try {
+      ExtendedLimits limits = new ExtendedLimits();
+      limits.BasicLimitInformation.LimitFlags = 0x00002000; // KILL_ON_JOB_CLOSE
+      if (!SetInformationJobObject(candidate, 9, ref limits,
+          (uint)Marshal.SizeOf(typeof(ExtendedLimits))))
+        throw new Win32Exception(Marshal.GetLastWin32Error());
+      if (!AssignProcessToJobObject(candidate, GetCurrentProcess()))
+        throw new Win32Exception(Marshal.GetLastWin32Error());
+      job = candidate;
+      candidate = IntPtr.Zero;
+    } finally {
+      if (candidate != IntPtr.Zero) CloseHandle(candidate);
+    }
+  }
+}
+`;

package/dist/src/web-ui/app/ARCHITECTURE.md

@@ -216,6 +216,20 @@ The server checks synchronous owner admission, refuses busy or externally owned
 environments, and refreshes its gateway through the owning lifecycle callback.
 Browser reload and saved selection are not evidence of live activation.
 
+Plugin configuration uses the existing manifest defaults and secret declarations.
+`components/plugins/configuration-fields.js` owns the shared install/edit form;
+`configuration-editor.js` keeps an editing dialog outside dashboard replacement.
+Installation drafts move their existing controls during rendering rather than
+serializing password values. Environment/workspace navigation respects unfinished
+configuration, and writes keep the existing external mutation guard.
+
+`plugin-configuration-service.ts` owns saved-value validation and the redacted
+projection. Its private store is installation-scoped, outside plugin packages,
+and survives removal. Saves and Apply acquire the canonical Runtime-file lock
+then the private-store lock. The plugin loader captures local values once per
+compiled configuration lifetime, preserving previous-owner rollback without
+changing plugin SDK or manifest contracts. No process environment is mutated.
+
 ### Additive model setup
 
 Configuration composes a separate Provider / Model / Ready dialog in

package/dist/src/web-ui/app/app-bootstrap.js

@@ -36,7 +36,7 @@ export async function bootstrapWebApp({
     captureHandoffNavigation: createSparkHandoffNavigation({ state, getEnvironmentId: () => dom.environmentSelect.value,
       shell, conversation: navigation?.conversation, onNavigationChange: () => routes?.sync() }),
     onOpenSchedule: (jobId) => schedules.openJob(jobId) });
-  navigation?.bindings.setEnvironmentChangePreparation(spark.prepareEnvironmentChange);
+  navigation?.bindings.setEnvironmentChangePreparation(spark.prepareEnvironmentChange, spark.refreshComposerSubmissionState);
   notifications?.setCompanionChat?.(spark);
   const automations = createAutomationsFeature({
     dom, client, shell, realtime,
@@ -61,6 +61,16 @@ export async function bootstrapWebApp({
     : null;
   onNavigationReady(routes);
   routes?.bind();
+  let preferenceViewsReady = false;
+  function synchronizePreferences() {
+    selection.loadPreferences();
+    if (!preferenceViewsReady) return;
+    selection.applyModelSelection();
+    selection.renderPermissionMode();
+    void dashboard.refresh();
+    void navigation?.conversation.loadSessions();
+  }
+  preferences.subscribe?.(synchronizePreferences);
   selection.loadPreferences();
   shell.load();
   homeComposer.setWorkspace(shell.activeWorkspace());
@@ -88,6 +98,7 @@ export async function bootstrapWebApp({
       ? saved
       : fallback;
   preferences.saveEnvironmentId(dom.environmentSelect.value);
+  navigation?.bindings.initializeEnvironment?.();
   learning?.environmentChanged();
   spark.environmentChanged();
   learning?.setWorkspace(shell.activeWorkspace());
@@ -108,6 +119,8 @@ export async function bootstrapWebApp({
     await spark.open(initialAddress.searchParams.get("message") || undefined, sparkNotificationReference(initialAddress));
   dashboard.setReady();
   notifications?.setReady();
+  preferenceViewsReady = true;
+  synchronizePreferences();
 }
 
 export async function startWebApp(options) {

package/dist/src/web-ui/app/app-state.js

@@ -27,13 +27,6 @@ export function createAppState() {
     modelProfiles: [],
     defaultModelProfileId: "",
     runtimeAvailability: { status: "loading" },
-    pendingAttachments: [],
-    pendingAttachmentUploadCounts: new Map(),
-    composerAttachmentGeneration: 0,
-    composerSending: false,
-    composerQueueDrainingScopes: new Set(),
-    composerQueueRecoveredReleaseTokens: new Set(),
-    activeComposerQueueRecovery: null,
     sessionQuery: "",
   };
 }