@agent-teams/engineering-foundation 0.20.0 → 1.0.0

package/README.md

@@ -15,8 +15,8 @@ verifies the allowed owner status before planning, applying, or recovering.
 Consumers cannot provide templates, hooks, callbacks, commands, or definition
 plugins.
 
-Document authoring is available through
-`@agent-teams/engineering-foundation/document-authoring`. Its catalog and Plan
+Reusable document authoring is available directly from
+`@agent-teams/document-authoring`. Its catalog and Plan
 compiler are read-only; publication and recovery are separate explicit
 operations behind the shared Foundation transaction barrier. The catalog
 rebuilds a stable snapshot from an explicit data-only profile, consumer metadata
@@ -26,7 +26,7 @@ not a Foundation capability and never runs as part of `check`.
 
 ```ts
 import { buildDocumentationCatalog } from
-  "@agent-teams/engineering-foundation/document-authoring";
+  "@agent-teams/document-authoring";
 
 const catalog = await buildDocumentationCatalog({
   consumerRoot: process.cwd(),
@@ -65,13 +65,6 @@ agent-teams-docs new --type adr --id ADR-0083 \
 agent-teams-docs check --consumer /repo
 ```
 
-Foundation's legacy `docs` CLI namespace remains executable only as a frozen
-compatibility surface. Human invocations emit the stable diagnostic code
-`FOUNDATION_DOCS_CLI_DEPRECATED`; JSON invocations retain their published
-stdout, stderr, envelope, and exit-code contract. The legacy namespace must not
-receive new commands, options, orchestration behavior, or Docs Protocol imports.
-Removal requires the evidence defined by
-[ADR-0033](../../docs/decisions/0033-freeze-legacy-foundation-docs-cli.md).
 The canonical current workflow and JSON contract are in the
 [document authoring protocol](../../docs/architecture/document-authoring-protocol.md#canonical-agent-and-operator-cli).
 
@@ -98,7 +91,7 @@ capabilities:
 
 Capability presence means enabled. Source architecture, documentation, ADR,
 contract-evolution, suppression, public API, and repository-security checks are
-adopted independently with consumer-owned policy and qualification evidence.
+adopted independently with consumer-owned policy and capability-qualification evidence.
 Installing or upgrading this package never enables them automatically.
 
 `quality.executable-specifications` optionally validates a consumer-owned JSON
@@ -140,19 +133,20 @@ mutation in required pull-request CI.
 
 ### Recoverable known-file transactions
 
-The `@agent-teams/engineering-foundation/mutation` entrypoint exports the closed
-`foundation.replace-known-file/v1` protocol. It can create an absent file or
+The `@agent-teams/repository-mutation` package exports the closed
+`agent-teams.repository-mutation.known-file/v1` protocol. It can create an absent file or
 replace a regular file only when its bytes and mode match an accepted exact
 preimage. A shared Foundation barrier, versioned journal, repeated CAS checks,
 strict directory durability, conditional rollback, and exact-build recovery
 make a serialized multi-file update recoverable without claiming impossible
 cross-file atomicity. Unknown content, aliases, symlinks, hard links, path
-collisions, and unsupported Windows durability fail closed.
+collisions, and unsupported Windows durability fail closed. Foundation retains
+its local-mode admission and domain error mapping while holding the same leaf
+lease; the old Foundation mutation facade is not retained.
 
-Every command that accepts `--json` or `--format json` returns one JSON value on
-success and failure. Generic command failures use
-`foundation-command-error/v1`; document commands keep their command-specific
-envelopes.
+Every Foundation command that accepts `--json` or `--format json` returns one
+JSON value on success and failure. Command failures use
+`foundation-command-error/v1`.
 
 Property suites may import deterministic seed and replay helpers from the package
 root while keeping `fast-check` in the consumer's development dependencies.
@@ -165,6 +159,14 @@ agent-teams-foundation scaffold-apply plans/example.json --consumer /repo --json
 agent-teams-foundation scaffold-recover --consumer /repo --json
 ```
 
+Programmatic callers may bind mutation to expected consumer descriptors with
+`recoverFilesystemScaffold(consumerRoot, { projectId, configPath,
+targetCatalogPath, compositionId })`. Foundation snapshots the immutable v1
+value, validates paths against the published v1 schema exactly, and requires
+exact string agreement with the stored journal before reading authority or
+continuing recovery. The one-argument API and CLI are unchanged;
+`inspectFoundationTransactionAwareMode` remains the read-only advisory preflight.
+
 The current built-in Composition is a testing-only conformance fixture. Product
 package and feature recipes, structured updates, and Nx integration require
-separate qualification before they become available.
+separate capability qualification before they become available.

package/assets/windows-managed-process/WindowsManagedProcess.cs

@@ -0,0 +1,497 @@
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+
+namespace AgentTeams.Foundation
+{
+    public static class WindowsManagedProcess
+    {
+        private const uint CREATE_SUSPENDED = 0x00000004;
+        private const uint CREATE_UNICODE_ENVIRONMENT = 0x00000400;
+        private const uint EXTENDED_STARTUPINFO_PRESENT = 0x00080000;
+        private const uint STARTF_USESTDHANDLES = 0x00000100;
+        private const uint JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x00002000;
+        private const uint WAIT_OBJECT_0 = 0;
+        private const uint WAIT_FAILED = 0xffffffff;
+        private const int JobObjectBasicAccountingInformation = 1;
+        private const int JobObjectExtendedLimitInformation = 9;
+        private const int STD_INPUT_HANDLE = -10;
+        private const int STD_OUTPUT_HANDLE = -11;
+        private const int STD_ERROR_HANDLE = -12;
+        private const int MAX_COMMAND_LINE_CHARACTERS = 32766;
+        private static readonly IntPtr PROC_THREAD_ATTRIBUTE_JOB_LIST =
+            new IntPtr(0x0002000D);
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct PROCESS_INFORMATION
+        {
+            public IntPtr hProcess;
+            public IntPtr hThread;
+            public uint dwProcessId;
+            public uint dwThreadId;
+        }
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        private struct STARTUPINFO
+        {
+            public uint cb;
+            public string lpReserved;
+            public string lpDesktop;
+            public string lpTitle;
+            public uint dwX;
+            public uint dwY;
+            public uint dwXSize;
+            public uint dwYSize;
+            public uint dwXCountChars;
+            public uint dwYCountChars;
+            public uint dwFillAttribute;
+            public uint dwFlags;
+            public ushort wShowWindow;
+            public ushort cbReserved2;
+            public IntPtr lpReserved2;
+            public IntPtr hStdInput;
+            public IntPtr hStdOutput;
+            public IntPtr hStdError;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct STARTUPINFOEX
+        {
+            public STARTUPINFO StartupInfo;
+            public IntPtr lpAttributeList;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct JOBOBJECT_BASIC_LIMIT_INFORMATION
+        {
+            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 JOBOBJECT_BASIC_ACCOUNTING_INFORMATION
+        {
+            public long TotalUserTime;
+            public long TotalKernelTime;
+            public long ThisPeriodTotalUserTime;
+            public long ThisPeriodTotalKernelTime;
+            public uint TotalPageFaultCount;
+            public uint TotalProcesses;
+            public uint ActiveProcesses;
+            public uint TotalTerminatedProcesses;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct IO_COUNTERS
+        {
+            public ulong ReadOperationCount;
+            public ulong WriteOperationCount;
+            public ulong OtherOperationCount;
+            public ulong ReadTransferCount;
+            public ulong WriteTransferCount;
+            public ulong OtherTransferCount;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION
+        {
+            public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
+            public IO_COUNTERS IoInfo;
+            public UIntPtr ProcessMemoryLimit;
+            public UIntPtr JobMemoryLimit;
+            public UIntPtr PeakProcessMemoryUsed;
+            public UIntPtr 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 job, int informationClass, IntPtr information, uint informationLength);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        private static extern bool QueryInformationJobObject(
+            IntPtr job, int informationClass, IntPtr information,
+            uint informationLength, IntPtr returnLength);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        private static extern bool TerminateJobObject(IntPtr job, uint exitCode);
+
+        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        private static extern bool CreateProcess(
+            string applicationName, StringBuilder commandLine,
+            IntPtr processAttributes, IntPtr threadAttributes, bool inheritHandles,
+            uint creationFlags, IntPtr environment, string currentDirectory,
+            ref STARTUPINFOEX startupInfo, out PROCESS_INFORMATION processInformation);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        private static extern bool InitializeProcThreadAttributeList(
+            IntPtr attributeList, int attributeCount, uint flags, ref IntPtr size);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        private static extern bool UpdateProcThreadAttribute(
+            IntPtr attributeList, uint flags, IntPtr attribute, IntPtr value,
+            UIntPtr size, IntPtr previousValue, IntPtr returnSize);
+
+        [DllImport("kernel32.dll")]
+        private static extern void DeleteProcThreadAttributeList(IntPtr attributeList);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        private static extern uint ResumeThread(IntPtr thread);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        private static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        private static extern bool GetExitCodeProcess(IntPtr process, out uint exitCode);
+
+        [DllImport("kernel32.dll")]
+        private static extern IntPtr GetStdHandle(int standardHandle);
+
+        [DllImport("kernel32.dll")]
+        private static extern bool CloseHandle(IntPtr handle);
+
+        private static string Quote(string value)
+        {
+            if (value.Length > 0 && value.IndexOfAny(new[] { ' ', '\t', '"' }) < 0)
+            {
+                return value;
+            }
+            var output = new StringBuilder("\"");
+            var slashes = 0;
+            foreach (var character in value)
+            {
+                if (character == '\\')
+                {
+                    slashes += 1;
+                    continue;
+                }
+                if (character == '"')
+                {
+                    output.Append('\\', slashes * 2 + 1);
+                    output.Append(character);
+                    slashes = 0;
+                    continue;
+                }
+                output.Append('\\', slashes);
+                slashes = 0;
+                output.Append(character);
+            }
+            output.Append('\\', slashes * 2);
+            output.Append('"');
+            return output.ToString();
+        }
+
+        private static StringBuilder BuildCommandLine(string executable, string[] arguments)
+        {
+            var commandLine = new StringBuilder(Quote(executable));
+            foreach (var argument in arguments)
+            {
+                commandLine.Append(' ').Append(Quote(argument));
+            }
+            if (commandLine.Length > MAX_COMMAND_LINE_CHARACTERS)
+            {
+                throw new ArgumentException(
+                    "The managed Windows process bootstrap command line exceeds " +
+                    MAX_COMMAND_LINE_CHARACTERS + " characters.");
+            }
+            return commandLine;
+        }
+
+        private static IntPtr BuildEnvironmentBlock(string[] entries)
+        {
+            var copy = entries == null ? new string[0] : (string[])entries.Clone();
+            Array.Sort(copy, StringComparer.OrdinalIgnoreCase);
+            string previousName = null;
+            foreach (var entry in copy)
+            {
+                var separator = entry == null ? -1 : entry.IndexOf('=');
+                if (separator <= 0 || entry.IndexOf('\0') >= 0)
+                {
+                    throw new ArgumentException(
+                        "The managed Windows process environment contains an invalid entry.");
+                }
+                var name = entry.Substring(0, separator);
+                if (previousName != null &&
+                    StringComparer.OrdinalIgnoreCase.Equals(previousName, name))
+                {
+                    throw new ArgumentException(
+                        "The managed Windows process environment contains a duplicate name.");
+                }
+                previousName = name;
+            }
+            return Marshal.StringToHGlobalUni(string.Join("\0", copy) + "\0\0");
+        }
+
+        private static uint ActiveProcessCount(IntPtr job)
+        {
+            var accounting = new JOBOBJECT_BASIC_ACCOUNTING_INFORMATION();
+            var length = Marshal.SizeOf(accounting);
+            var pointer = Marshal.AllocHGlobal(length);
+            try
+            {
+                if (!QueryInformationJobObject(
+                    job, JobObjectBasicAccountingInformation,
+                    pointer, (uint)length, IntPtr.Zero))
+                {
+                    throw new Win32Exception(
+                        Marshal.GetLastWin32Error(), "QueryInformationJobObject failed");
+                }
+                accounting = (JOBOBJECT_BASIC_ACCOUNTING_INFORMATION)
+                    Marshal.PtrToStructure(
+                        pointer, typeof(JOBOBJECT_BASIC_ACCOUNTING_INFORMATION));
+                return accounting.ActiveProcesses;
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(pointer);
+            }
+        }
+
+        private static void TerminateRemainingProcessesAndWait(IntPtr job)
+        {
+            if (ActiveProcessCount(job) > 0 && !TerminateJobObject(job, 1))
+            {
+                throw new Win32Exception(
+                    Marshal.GetLastWin32Error(), "TerminateJobObject failed");
+            }
+            var stopwatch = Stopwatch.StartNew();
+            while (ActiveProcessCount(job) > 0)
+            {
+                if (stopwatch.ElapsedMilliseconds >= 5000)
+                {
+                    throw new TimeoutException(
+                        "Windows Job Object descendants did not terminate within 5000 ms");
+                }
+                Thread.Sleep(10);
+            }
+        }
+
+        private static void ConfirmContainment(string confirmationPath)
+        {
+            var temporaryPath = confirmationPath + ".tmp";
+            File.WriteAllText(temporaryPath, "CONTAINED", new UTF8Encoding(false));
+            File.Move(temporaryPath, confirmationPath);
+        }
+
+        private static bool CancelAssignedIfRequested(
+            string cancellationPath, string confirmationPath, IntPtr job)
+        {
+            if (!File.Exists(cancellationPath))
+            {
+                return false;
+            }
+            TerminateRemainingProcessesAndWait(job);
+            ConfirmContainment(confirmationPath);
+            return true;
+        }
+
+        private static bool LaunchSucceeded(string launchPath)
+        {
+            try
+            {
+                return File.Exists(launchPath) &&
+                    File.ReadAllText(launchPath) == "STARTED";
+            }
+            catch (IOException)
+            {
+                // The host publishes the marker atomically enough for durability,
+                // but Windows may briefly deny a concurrent read while it closes.
+                return false;
+            }
+        }
+
+        private static void ConfigureKillOnClose(IntPtr job)
+        {
+            var limits = new JOBOBJECT_EXTENDED_LIMIT_INFORMATION();
+            limits.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
+            var length = Marshal.SizeOf(limits);
+            var pointer = Marshal.AllocHGlobal(length);
+            try
+            {
+                Marshal.StructureToPtr(limits, pointer, false);
+                if (!SetInformationJobObject(
+                    job, JobObjectExtendedLimitInformation, pointer, (uint)length))
+                {
+                    throw new Win32Exception(
+                        Marshal.GetLastWin32Error(), "SetInformationJobObject failed");
+                }
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(pointer);
+            }
+        }
+
+        public static int Run(
+            string executable, string hostPath, string requestPath,
+            string currentDirectory,
+            string[] environmentEntries,
+            string cancellationPath, string confirmationPath, string launchPath)
+        {
+            var commandLine = BuildCommandLine(
+                executable, new[] { hostPath, requestPath });
+            var job = IntPtr.Zero;
+            var environmentBlock = IntPtr.Zero;
+            var attributeList = IntPtr.Zero;
+            var jobHandleValue = IntPtr.Zero;
+            var attributeListInitialized = false;
+            var assigned = false;
+            var process = new PROCESS_INFORMATION();
+            try
+            {
+                job = CreateJobObject(IntPtr.Zero, null);
+                if (job == IntPtr.Zero)
+                {
+                    throw new Win32Exception(
+                        Marshal.GetLastWin32Error(), "CreateJobObject failed");
+                }
+                ConfigureKillOnClose(job);
+
+                var attributeListSize = IntPtr.Zero;
+                InitializeProcThreadAttributeList(
+                    IntPtr.Zero, 1, 0, ref attributeListSize);
+                attributeList = Marshal.AllocHGlobal(attributeListSize);
+                if (!InitializeProcThreadAttributeList(
+                    attributeList, 1, 0, ref attributeListSize))
+                {
+                    throw new Win32Exception(
+                        Marshal.GetLastWin32Error(),
+                        "InitializeProcThreadAttributeList failed");
+                }
+                attributeListInitialized = true;
+                jobHandleValue = Marshal.AllocHGlobal(IntPtr.Size);
+                Marshal.WriteIntPtr(jobHandleValue, job);
+                if (!UpdateProcThreadAttribute(
+                    attributeList, 0, PROC_THREAD_ATTRIBUTE_JOB_LIST,
+                    jobHandleValue, new UIntPtr((uint)IntPtr.Size),
+                    IntPtr.Zero, IntPtr.Zero))
+                {
+                    throw new Win32Exception(
+                        Marshal.GetLastWin32Error(),
+                        "UpdateProcThreadAttribute JOB_LIST failed");
+                }
+
+                var startup = new STARTUPINFOEX();
+                startup.StartupInfo.cb = (uint)Marshal.SizeOf(startup);
+                startup.StartupInfo.dwFlags = STARTF_USESTDHANDLES;
+                startup.StartupInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
+                startup.StartupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
+                startup.StartupInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
+                startup.lpAttributeList = attributeList;
+                environmentBlock = BuildEnvironmentBlock(environmentEntries);
+                if (!CreateProcess(
+                    executable, commandLine, IntPtr.Zero, IntPtr.Zero, true,
+                    CREATE_SUSPENDED | CREATE_UNICODE_ENVIRONMENT | EXTENDED_STARTUPINFO_PRESENT,
+                    environmentBlock, currentDirectory, ref startup, out process))
+                {
+                    throw new Win32Exception(
+                        Marshal.GetLastWin32Error(), "CreateProcess failed");
+                }
+
+                // PROC_THREAD_ATTRIBUTE_JOB_LIST makes Job Object membership an
+                // atomic property of successful process creation. From here on,
+                // closing or terminating the job contains every possible child.
+                assigned = true;
+
+                if (ResumeThread(process.hThread) == WAIT_FAILED)
+                {
+                    throw new Win32Exception(
+                        Marshal.GetLastWin32Error(), "ResumeThread failed");
+                }
+
+                while (true)
+                {
+                    var waitResult = WaitForSingleObject(process.hProcess, 10);
+                    if (waitResult == WAIT_OBJECT_0)
+                    {
+                        break;
+                    }
+                    if (waitResult == WAIT_FAILED)
+                    {
+                        throw new Win32Exception(
+                            Marshal.GetLastWin32Error(), "WaitForSingleObject failed");
+                    }
+                    // Once the trusted host has attempted the requested launch,
+                    // an already observed host failure outranks cancellation.
+                    if (LaunchSucceeded(launchPath) &&
+                        CancelAssignedIfRequested(cancellationPath, confirmationPath, job))
+                    {
+                        return 0;
+                    }
+                }
+
+                uint exitCode;
+                if (!GetExitCodeProcess(process.hProcess, out exitCode))
+                {
+                    throw new Win32Exception(
+                        Marshal.GetLastWin32Error(), "GetExitCodeProcess failed");
+                }
+                TerminateRemainingProcessesAndWait(job);
+                ConfirmContainment(confirmationPath);
+                return unchecked((int)exitCode);
+            }
+            catch (Exception executionError)
+            {
+                try
+                {
+                    if (assigned)
+                    {
+                        TerminateRemainingProcessesAndWait(job);
+                    }
+                    ConfirmContainment(confirmationPath);
+                }
+                catch (Exception containmentError)
+                {
+                    throw new AggregateException(
+                        "Windows process execution and containment both failed",
+                        executionError, containmentError);
+                }
+                throw;
+            }
+            finally
+            {
+                if (process.hThread != IntPtr.Zero)
+                {
+                    CloseHandle(process.hThread);
+                }
+                if (process.hProcess != IntPtr.Zero)
+                {
+                    CloseHandle(process.hProcess);
+                }
+                if (jobHandleValue != IntPtr.Zero)
+                {
+                    Marshal.FreeHGlobal(jobHandleValue);
+                }
+                if (environmentBlock != IntPtr.Zero)
+                {
+                    Marshal.FreeHGlobal(environmentBlock);
+                }
+                if (attributeListInitialized)
+                {
+                    DeleteProcThreadAttributeList(attributeList);
+                }
+                if (attributeList != IntPtr.Zero)
+                {
+                    Marshal.FreeHGlobal(attributeList);
+                }
+                if (job != IntPtr.Zero)
+                {
+                    CloseHandle(job);
+                }
+            }
+        }
+    }
+}

package/assets/windows-managed-process/bootstrap.ps1

@@ -0,0 +1,45 @@
+$ErrorActionPreference = "Stop"
+$ProgressPreference = "SilentlyContinue"
+$FailurePhase = "helper-source-read"
+
+function ConvertTo-ExtendedLengthPath([string]$Path) {
+  if ($Path.StartsWith('\\?\')) {
+    return $Path
+  }
+  if (-not [System.IO.Path]::IsPathRooted($Path)) {
+    throw "Windows managed-process helper path must be absolute."
+  }
+  if ($Path.StartsWith('\\')) {
+    return '\\?\UNC\' + $Path.Substring(2)
+  }
+  return '\\?\' + $Path
+}
+
+try {
+  $helperSource = [System.IO.File]::ReadAllText(
+    (ConvertTo-ExtendedLengthPath (
+      Join-Path $PSScriptRoot "WindowsManagedProcess.cs")))
+  $FailurePhase = "helper-compile"
+  Add-Type -TypeDefinition $helperSource -Language CSharp
+  $FailurePhase = "bootstrap-request"
+  $bootstrapRequest = [Console]::In.ReadToEnd() | ConvertFrom-Json
+  if ([int]$bootstrapRequest.schemaVersion -ne 1) {
+    throw "Unsupported Windows managed-process bootstrap schema."
+  }
+  $FailurePhase = "managed-run"
+  $exitCode = [AgentTeams.Foundation.WindowsManagedProcess]::Run(
+    [string]$bootstrapRequest.nodeExecutable,
+    [string]$bootstrapRequest.processHostPath,
+    [string]$bootstrapRequest.requestPath,
+    [string]$bootstrapRequest.hostWorkingDirectory,
+    [string[]]$bootstrapRequest.environmentEntries,
+    [string]$bootstrapRequest.cancellationPath,
+    [string]$bootstrapRequest.confirmationPath,
+    [string]$bootstrapRequest.launchPath)
+  exit $exitCode
+} catch {
+  [Console]::Error.WriteLine(
+    "Windows Job Object runner failed [phase=" + $FailurePhase + "]: " +
+      $_.Exception.Message)
+  exit 1
+}

package/dist/canonical-json.d.ts

@@ -1,12 +1,2 @@
-type CanonicalJsonPrimitive = boolean | null | number | string;
-export type CanonicalJsonValue = CanonicalJsonPrimitive | readonly CanonicalJsonValue[] | {
-    readonly [key: string]: CanonicalJsonValue;
-};
-export declare class CanonicalJsonError extends Error {
-    constructor(message: string);
-}
-export declare function canonicalJson(value: CanonicalJsonValue): string;
-export declare function sha256Bytes(value: Uint8Array): `sha256:${string}`;
-export declare function sha256Json(value: CanonicalJsonValue): `sha256:${string}`;
-export {};
+export { canonicalJson, sha256Bytes, sha256Json } from "@agent-teams/repository-mutation";
 //# sourceMappingURL=canonical-json.d.ts.map

package/dist/canonical-json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canonical-json.d.ts","sourceRoot":"","sources":["../src/canonical-json.ts"],"names":[],"mappings":"AAEA,KAAK,sBAAsB,GAAG,OAAO,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,CAAC;AAC/D,MAAM,MAAM,kBAAkB,GAC1B,sBAAsB,GACtB,SAAS,kBAAkB,EAAE,GAC7B;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,kBAAkB,CAAA;CAAE,CAAC;AAEnD,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,YAAmB,OAAO,EAAE,MAAM,EAGjC;CACF;AA+KD,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAE/D;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,MAAM,EAAE,CAEjE;AAMD,wBAAgB,UAAU,CAAC,KAAK,EAAE,kBAAkB,GAAG,UAAU,MAAM,EAAE,CAExE"}
+{"version":3,"file":"canonical-json.d.ts","sourceRoot":"","sources":["../src/canonical-json.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,WAAW,EACX,UAAU,EACX,MAAM,kCAAkC,CAAC"}