@osfactory/har 0.20.0 → 0.21.0

package/dist/index.js

@@ -765,14 +765,14 @@ var require_url_state_machine = __commonJS({
       return url.replace(/\u0009|\u000A|\u000D/g, "");
     }
     function shortenPath(url) {
-      const path52 = url.path;
-      if (path52.length === 0) {
+      const path53 = url.path;
+      if (path53.length === 0) {
         return;
       }
-      if (url.scheme === "file" && path52.length === 1 && isNormalizedWindowsDriveLetter(path52[0])) {
+      if (url.scheme === "file" && path53.length === 1 && isNormalizedWindowsDriveLetter(path53[0])) {
         return;
       }
-      path52.pop();
+      path53.pop();
     }
     function includesCredentials(url) {
       return url.username !== "" || url.password !== "";
@@ -6351,14 +6351,14 @@ __export(fileFromPath_exports, {
   fileFromPathSync: () => fileFromPathSync,
   isFile: () => isFile
 });
-function createFileFromPath(path52, { mtimeMs, size }, filenameOrOptions, options = {}) {
+function createFileFromPath(path53, { mtimeMs, size }, filenameOrOptions, options = {}) {
   let filename;
   if (isPlainObject_default2(filenameOrOptions)) {
     [options, filename] = [filenameOrOptions, void 0];
   } else {
     filename = filenameOrOptions;
   }
-  const file = new FileFromPath({ path: path52, size, lastModified: mtimeMs });
+  const file = new FileFromPath({ path: path53, size, lastModified: mtimeMs });
   if (!filename) {
     filename = file.name;
   }
@@ -6367,13 +6367,13 @@ function createFileFromPath(path52, { mtimeMs, size }, filenameOrOptions, option
     lastModified: file.lastModified
   });
 }
-function fileFromPathSync(path52, filenameOrOptions, options = {}) {
-  const stats = (0, import_fs5.statSync)(path52);
-  return createFileFromPath(path52, stats, filenameOrOptions, options);
+function fileFromPathSync(path53, filenameOrOptions, options = {}) {
+  const stats = (0, import_fs5.statSync)(path53);
+  return createFileFromPath(path53, stats, filenameOrOptions, options);
 }
-async function fileFromPath2(path52, filenameOrOptions, options) {
-  const stats = await import_fs5.promises.stat(path52);
-  return createFileFromPath(path52, stats, filenameOrOptions, options);
+async function fileFromPath2(path53, filenameOrOptions, options) {
+  const stats = await import_fs5.promises.stat(path53);
+  return createFileFromPath(path53, stats, filenameOrOptions, options);
 }
 var import_fs5, import_path5, import_node_domexception, __classPrivateFieldSet5, __classPrivateFieldGet6, _FileFromPath_path, _FileFromPath_start, MESSAGE, FileFromPath;
 var init_fileFromPath = __esm({
@@ -6451,9 +6451,9 @@ var init_control_config = __esm({
 // src/core/telemetry-config.ts
 function getPreferencePath() {
   if (process.env.HAR_TELEMETRY_CONFIG_PATH) {
-    return path35.resolve(process.env.HAR_TELEMETRY_CONFIG_PATH);
+    return path36.resolve(process.env.HAR_TELEMETRY_CONFIG_PATH);
   }
-  return path35.join(os9.homedir(), ".har", "telemetry.json");
+  return path36.join(os9.homedir(), ".har", "telemetry.json");
 }
 function parseEnvOverride(raw) {
   if (raw === void 0 || raw === "") return void 0;
@@ -6474,10 +6474,10 @@ function normalizeSignals(enabled, raw) {
 function readTelemetryPreference() {
   const preferencePath = getPreferencePath();
   try {
-    if (!fs35.existsSync(preferencePath)) {
+    if (!fs36.existsSync(preferencePath)) {
       return { enabled: true, signals: { ...DEFAULT_SIGNALS_ON } };
     }
-    const parsed = JSON.parse(fs35.readFileSync(preferencePath, "utf8"));
+    const parsed = JSON.parse(fs36.readFileSync(preferencePath, "utf8"));
     const enabled = parsed.enabled !== false;
     return {
       enabled,
@@ -6500,8 +6500,8 @@ function writeTelemetryPreference(enabled, signals2) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   const preferencePath = getPreferencePath();
-  fs35.mkdirSync(path35.dirname(preferencePath), { recursive: true });
-  fs35.writeFileSync(preferencePath, JSON.stringify(preference, null, 2) + "\n");
+  fs36.mkdirSync(path36.dirname(preferencePath), { recursive: true });
+  fs36.writeFileSync(preferencePath, JSON.stringify(preference, null, 2) + "\n");
   return preference;
 }
 function isTelemetryEnabled() {
@@ -6516,13 +6516,13 @@ function getTelemetrySignals() {
 function getTelemetryPreferencePath() {
   return getPreferencePath();
 }
-var fs35, os9, path35, DEFAULT_SIGNALS_ON, DEFAULT_SIGNALS_OFF, TELEMETRY_SIGNALS;
+var fs36, os9, path36, DEFAULT_SIGNALS_ON, DEFAULT_SIGNALS_OFF, TELEMETRY_SIGNALS;
 var init_telemetry_config = __esm({
   "src/core/telemetry-config.ts"() {
     "use strict";
-    fs35 = __toESM(require("fs"));
+    fs36 = __toESM(require("fs"));
     os9 = __toESM(require("os"));
-    path35 = __toESM(require("path"));
+    path36 = __toESM(require("path"));
     DEFAULT_SIGNALS_ON = {
       metrics: true,
       logs: true,
@@ -6563,15 +6563,15 @@ __export(otel_hooks_exports, {
 });
 function getOtelHooksHome() {
   if (process.env.HAR_OTEL_HOOKS_HOME) {
-    return path41.resolve(process.env.HAR_OTEL_HOOKS_HOME);
+    return path42.resolve(process.env.HAR_OTEL_HOOKS_HOME);
   }
-  return path41.join(os12.homedir(), ".har", "otel-hooks");
+  return path42.join(os12.homedir(), ".har", "otel-hooks");
 }
 function getOtelHooksConfigPath(hooksHome = getOtelHooksHome()) {
-  return path41.join(hooksHome, "otel_config.json");
+  return path42.join(hooksHome, "otel_config.json");
 }
 function getOtelHooksWrapperPath(hooksHome = getOtelHooksHome()) {
-  return path41.join(hooksHome, "run-otel-hook.sh");
+  return path42.join(hooksHome, "run-otel-hook.sh");
 }
 function buildOtelHooksConfig(options) {
   const enabled = options?.enabled ?? isTelemetryEnabled();
@@ -6590,18 +6590,18 @@ function buildOtelHooksConfig(options) {
   };
 }
 function writeOtelHooksConfig(config2, hooksHome = getOtelHooksHome()) {
-  fs39.mkdirSync(hooksHome, { recursive: true });
+  fs40.mkdirSync(hooksHome, { recursive: true });
   const configPath = getOtelHooksConfigPath(hooksHome);
   const payload = {
     _comment: "Managed by har telemetry \u2014 do not edit by hand; use: har telemetry on|off",
     ...config2
   };
-  fs39.writeFileSync(configPath, `${JSON.stringify(payload, null, 2)}
+  fs40.writeFileSync(configPath, `${JSON.stringify(payload, null, 2)}
 `);
   return configPath;
 }
 function writeOtelHooksWrapper(otelHookCommand, hooksHome = getOtelHooksHome()) {
-  fs39.mkdirSync(hooksHome, { recursive: true });
+  fs40.mkdirSync(hooksHome, { recursive: true });
   const wrapperPath = getOtelHooksWrapperPath(hooksHome);
   const script = `#!/usr/bin/env bash
 # Managed by har telemetry \u2014 invokes opentelemetry-hooks with HAR config home.
@@ -6609,9 +6609,9 @@ set -euo pipefail
 export IDE_OTEL_HOOK_HOME="${hooksHome}"
 exec "${otelHookCommand}" "$@"
 `;
-  fs39.writeFileSync(wrapperPath, script, { mode: 493 });
+  fs40.writeFileSync(wrapperPath, script, { mode: 493 });
   try {
-    fs39.chmodSync(wrapperPath, 493);
+    fs40.chmodSync(wrapperPath, 493);
   } catch {
   }
   return wrapperPath;
@@ -6691,10 +6691,10 @@ function runSetupAgent(agent, otelHookCommand, hooksHome) {
   };
 }
 function rewriteHookCommandsToWrapper(filePath, wrapperPath) {
-  if (!fs39.existsSync(filePath)) return false;
+  if (!fs40.existsSync(filePath)) return false;
   let raw;
   try {
-    raw = fs39.readFileSync(filePath, "utf8");
+    raw = fs40.readFileSync(filePath, "utf8");
   } catch {
     return false;
   }
@@ -6733,16 +6733,16 @@ function rewriteHookCommandsToWrapper(filePath, wrapperPath) {
     return changed;
   };
   if (!walk(parsed)) return false;
-  fs39.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
+  fs40.writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}
 `);
   return true;
 }
 function rewriteKnownHookRegistrations(wrapperPath) {
   const home = os12.homedir();
   const candidates = [
-    path41.join(home, ".cursor", "hooks.json"),
-    path41.join(home, ".claude", "settings.json"),
-    path41.join(home, ".codex", "hooks.json")
+    path42.join(home, ".cursor", "hooks.json"),
+    path42.join(home, ".claude", "settings.json"),
+    path42.join(home, ".codex", "hooks.json")
   ];
   for (const filePath of candidates) {
     try {
@@ -6755,7 +6755,7 @@ function ensureOtelHooks(options) {
   const hooksHome = getOtelHooksHome();
   const errors = [];
   const agentsSetup = [];
-  fs39.mkdirSync(hooksHome, { recursive: true });
+  fs40.mkdirSync(hooksHome, { recursive: true });
   let otelHookCommand = resolveOtelHookCommand();
   if (!otelHookCommand) {
     const installed = tryInstallPackage();
@@ -6824,14 +6824,14 @@ function ensureOtelHooks(options) {
 function disableOtelHooksExport() {
   return writeOtelHooksConfig(buildOtelHooksConfig({ enabled: false }));
 }
-var import_child_process9, fs39, os12, path41, OTEL_HOOKS_PACKAGE, OTEL_HOOKS_AGENTS;
+var import_child_process9, fs40, os12, path42, OTEL_HOOKS_PACKAGE, OTEL_HOOKS_AGENTS;
 var init_otel_hooks = __esm({
   "src/core/otel-hooks.ts"() {
     "use strict";
     import_child_process9 = require("child_process");
-    fs39 = __toESM(require("fs"));
+    fs40 = __toESM(require("fs"));
     os12 = __toESM(require("os"));
-    path41 = __toESM(require("path"));
+    path42 = __toESM(require("path"));
     init_control_config();
     init_telemetry_config();
     OTEL_HOOKS_PACKAGE = "opentelemetry-hooks==0.14.0";
@@ -10035,8 +10035,8 @@ var require_utils2 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path52) {
-      let input = path52;
+    function removeDotSegments(path53) {
+      let input = path53;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -10288,8 +10288,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path52, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path52 && path52 !== "/" ? path52 : void 0;
+        const [path53, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path53 && path53 !== "/" ? path53 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -13682,12 +13682,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f2;
     };
-    function addFormats(ajv, list, fs44, exportName) {
+    function addFormats(ajv, list, fs45, exportName) {
       var _a3;
       var _b2;
       (_a3 = (_b2 = ajv.opts.code).formats) !== null && _a3 !== void 0 ? _a3 : _b2.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f2 of list)
-        ajv.addFormat(f2, fs44[f2]);
+        ajv.addFormat(f2, fs45[f2]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -14787,15 +14787,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path52 = [graph[toModel].parent, toModel];
+      const path53 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path52.unshift(graph[cur].parent);
+        path53.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path52;
+      fn.conversion = path53;
       return fn;
     }
     module2.exports = function(fromModel) {
@@ -20725,7 +20725,7 @@ var require_iso2022 = __commonJS({
 // node_modules/chardet/index.js
 var require_chardet = __commonJS({
   "node_modules/chardet/index.js"(exports2, module2) {
-    var fs44 = require("fs");
+    var fs45 = require("fs");
     var utf8 = require_utf8();
     var unicode = require_unicode();
     var mbcs = require_mbcs();
@@ -20799,28 +20799,28 @@ var require_chardet = __commonJS({
       var fd;
       var handler = function(err, buffer) {
         if (fd) {
-          fs44.closeSync(fd);
+          fs45.closeSync(fd);
         }
         if (err) return cb(err, null);
         cb(null, self.detect(buffer, opts));
       };
       if (opts && opts.sampleSize) {
-        fd = fs44.openSync(filepath, "r"), sample = Buffer.allocUnsafe(opts.sampleSize);
-        fs44.read(fd, sample, 0, opts.sampleSize, null, function(err) {
+        fd = fs45.openSync(filepath, "r"), sample = Buffer.allocUnsafe(opts.sampleSize);
+        fs45.read(fd, sample, 0, opts.sampleSize, null, function(err) {
           handler(err, sample);
         });
         return;
       }
-      fs44.readFile(filepath, handler);
+      fs45.readFile(filepath, handler);
     };
     module2.exports.detectFileSync = function(filepath, opts) {
       if (opts && opts.sampleSize) {
-        var fd = fs44.openSync(filepath, "r"), sample2 = Buffer.allocUnsafe(opts.sampleSize);
-        fs44.readSync(fd, sample2, 0, opts.sampleSize);
-        fs44.closeSync(fd);
+        var fd = fs45.openSync(filepath, "r"), sample2 = Buffer.allocUnsafe(opts.sampleSize);
+        fs45.readSync(fd, sample2, 0, opts.sampleSize);
+        fs45.closeSync(fd);
         return self.detect(sample2, opts);
       }
-      return self.detect(fs44.readFileSync(filepath), opts);
+      return self.detect(fs45.readFileSync(filepath), opts);
     };
     module2.exports.detectAll = function(buffer, opts) {
       if (typeof opts !== "object") {
@@ -24285,16 +24285,16 @@ var require_os_tmpdir = __commonJS({
     var isWindows = process.platform === "win32";
     var trailingSlashRe = isWindows ? /[^:]\\$/ : /.\/$/;
     module2.exports = function() {
-      var path52;
+      var path53;
       if (isWindows) {
-        path52 = process.env.TEMP || process.env.TMP || (process.env.SystemRoot || process.env.windir) + "\\temp";
+        path53 = process.env.TEMP || process.env.TMP || (process.env.SystemRoot || process.env.windir) + "\\temp";
       } else {
-        path52 = process.env.TMPDIR || process.env.TMP || process.env.TEMP || "/tmp";
+        path53 = process.env.TMPDIR || process.env.TMP || process.env.TEMP || "/tmp";
       }
-      if (trailingSlashRe.test(path52)) {
-        path52 = path52.slice(0, -1);
+      if (trailingSlashRe.test(path53)) {
+        path53 = path53.slice(0, -1);
       }
-      return path52;
+      return path53;
     };
   }
 });
@@ -24302,9 +24302,9 @@ var require_os_tmpdir = __commonJS({
 // node_modules/tmp/lib/tmp.js
 var require_tmp = __commonJS({
   "node_modules/tmp/lib/tmp.js"(exports2, module2) {
-    var fs44 = require("fs");
-    var path52 = require("path");
-    var crypto4 = require("crypto");
+    var fs45 = require("fs");
+    var path53 = require("path");
+    var crypto6 = require("crypto");
     var osTmpDir = require_os_tmpdir();
     var _c2 = process.binding("constants");
     var tmpDir = osTmpDir();
@@ -24322,9 +24322,9 @@ var require_tmp = __commonJS({
     function _randomChars(howMany) {
       var value = [], rnd = null;
       try {
-        rnd = crypto4.randomBytes(howMany);
+        rnd = crypto6.randomBytes(howMany);
       } catch (e2) {
-        rnd = crypto4.pseudoRandomBytes(howMany);
+        rnd = crypto6.pseudoRandomBytes(howMany);
       }
       for (var i2 = 0; i2 < howMany; i2++) {
         value.push(RANDOM_CHARS[rnd[i2] % RANDOM_CHARS.length]);
@@ -24345,7 +24345,7 @@ var require_tmp = __commonJS({
     }
     function _generateTmpName(opts) {
       if (opts.name) {
-        return path52.join(opts.dir || tmpDir, opts.name);
+        return path53.join(opts.dir || tmpDir, opts.name);
       }
       if (opts.template) {
         return opts.template.replace(TEMPLATE_PATTERN, _randomChars(6));
@@ -24356,7 +24356,7 @@ var require_tmp = __commonJS({
         _randomChars(12),
         opts.postfix || ""
       ].join("");
-      return path52.join(opts.dir || tmpDir, name);
+      return path53.join(opts.dir || tmpDir, name);
     }
     function tmpName(options, callback) {
       var args = _parseArguments(options, callback), opts = args[0], cb = args[1], tries = opts.name ? 1 : opts.tries || DEFAULT_TRIES;
@@ -24366,7 +24366,7 @@ var require_tmp = __commonJS({
         return cb(new Error("Invalid template provided"));
       (function _getUniqueName() {
         const name = _generateTmpName(opts);
-        fs44.stat(name, function(err) {
+        fs45.stat(name, function(err) {
           if (!err) {
             if (tries-- > 0) return _getUniqueName();
             return cb(new Error("Could not get a unique tmp filename, max tries reached " + name));
@@ -24384,7 +24384,7 @@ var require_tmp = __commonJS({
       do {
         const name = _generateTmpName(opts);
         try {
-          fs44.statSync(name);
+          fs45.statSync(name);
         } catch (e2) {
           return name;
         }
@@ -24396,13 +24396,13 @@ var require_tmp = __commonJS({
       opts.postfix = _isUndefined(opts.postfix) ? ".tmp" : opts.postfix;
       tmpName(opts, function _tmpNameCreated(err, name) {
         if (err) return cb(err);
-        fs44.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
+        fs45.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
           if (err2) return cb(err2);
           if (opts.discardDescriptor) {
-            return fs44.close(fd, function _discardCallback(err3) {
+            return fs45.close(fd, function _discardCallback(err3) {
               if (err3) {
                 try {
-                  fs44.unlinkSync(name);
+                  fs45.unlinkSync(name);
                 } catch (e2) {
                   if (!isENOENT(e2)) {
                     err3 = e2;
@@ -24425,9 +24425,9 @@ var require_tmp = __commonJS({
       opts.postfix = opts.postfix || ".tmp";
       const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
       const name = tmpNameSync(opts);
-      var fd = fs44.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
+      var fd = fs45.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
       if (opts.discardDescriptor) {
-        fs44.closeSync(fd);
+        fs45.closeSync(fd);
         fd = void 0;
       }
       return {
@@ -24439,9 +24439,9 @@ var require_tmp = __commonJS({
     function _rmdirRecursiveSync(root) {
       const dirs = [root];
       do {
-        var dir2 = dirs.pop(), deferred = false, files = fs44.readdirSync(dir2);
+        var dir2 = dirs.pop(), deferred = false, files = fs45.readdirSync(dir2);
         for (var i2 = 0, length = files.length; i2 < length; i2++) {
-          var file2 = path52.join(dir2, files[i2]), stat = fs44.lstatSync(file2);
+          var file2 = path53.join(dir2, files[i2]), stat = fs45.lstatSync(file2);
           if (stat.isDirectory()) {
             if (!deferred) {
               deferred = true;
@@ -24449,11 +24449,11 @@ var require_tmp = __commonJS({
             }
             dirs.push(file2);
           } else {
-            fs44.unlinkSync(file2);
+            fs45.unlinkSync(file2);
           }
         }
         if (!deferred) {
-          fs44.rmdirSync(dir2);
+          fs45.rmdirSync(dir2);
         }
       } while (dirs.length !== 0);
     }
@@ -24461,7 +24461,7 @@ var require_tmp = __commonJS({
       var args = _parseArguments(options, callback), opts = args[0], cb = args[1];
       tmpName(opts, function _tmpNameCreated(err, name) {
         if (err) return cb(err);
-        fs44.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
+        fs45.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
           if (err2) return cb(err2);
           cb(null, name, _prepareTmpDirRemoveCallback(name, opts));
         });
@@ -24470,7 +24470,7 @@ var require_tmp = __commonJS({
     function dirSync(options) {
       var args = _parseArguments(options), opts = args[0];
       const name = tmpNameSync(opts);
-      fs44.mkdirSync(name, opts.mode || DIR_MODE);
+      fs45.mkdirSync(name, opts.mode || DIR_MODE);
       return {
         name,
         removeCallback: _prepareTmpDirRemoveCallback(name, opts)
@@ -24480,7 +24480,7 @@ var require_tmp = __commonJS({
       const removeCallback = _prepareRemoveCallback(function _removeCallback(fdPath) {
         try {
           if (0 <= fdPath[0]) {
-            fs44.closeSync(fdPath[0]);
+            fs45.closeSync(fdPath[0]);
           }
         } catch (e2) {
           if (!isEBADF(e2) && !isENOENT(e2)) {
@@ -24488,7 +24488,7 @@ var require_tmp = __commonJS({
           }
         }
         try {
-          fs44.unlinkSync(fdPath[1]);
+          fs45.unlinkSync(fdPath[1]);
         } catch (e2) {
           if (!isENOENT(e2)) {
             throw e2;
@@ -24501,7 +24501,7 @@ var require_tmp = __commonJS({
       return removeCallback;
     }
     function _prepareTmpDirRemoveCallback(name, opts) {
-      const removeFunction = opts.unsafeCleanup ? _rmdirRecursiveSync : fs44.rmdirSync.bind(fs44);
+      const removeFunction = opts.unsafeCleanup ? _rmdirRecursiveSync : fs45.rmdirSync.bind(fs45);
       const removeCallback = _prepareRemoveCallback(removeFunction, name);
       if (!opts.keep) {
         _removeObjects.unshift(removeCallback);
@@ -35714,11 +35714,11 @@ var parser = new YargsParser({
   resolve: import_path2.resolve,
   // TODO: figure  out a  way to combine ESM and CJS coverage, such  that
   // we can exercise all the lines below:
-  require: (path52) => {
+  require: (path53) => {
     if (typeof require !== "undefined") {
-      return require(path52);
-    } else if (path52.match(/\.json$/)) {
-      return JSON.parse((0, import_fs2.readFileSync)(path52, "utf8"));
+      return require(path53);
+    } else if (path53.match(/\.json$/)) {
+      return JSON.parse((0, import_fs2.readFileSync)(path53, "utf8"));
     } else {
       throw Error("only .json config files are supported in ESM");
     }
@@ -40399,8 +40399,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path52, errorMaps, issueData } = params;
-  const fullPath = [...path52, ...issueData.path || []];
+  const { data, path: path53, errorMaps, issueData } = params;
+  const fullPath = [...path53, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -40516,11 +40516,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path52, key) {
+  constructor(parent, value, path53, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path52;
+    this._path = path53;
     this._key = key;
   }
   get path() {
@@ -44117,6 +44117,51 @@ var StageKindSchema = HarnessStageKindSchema;
 var VerificationResultSchema = HarnessVerificationResultSchema;
 var StageResultSchema = HarnessStageRunResultSchema;
 var RunRecordTriggerSchema = external_exports.enum(["cli", "mcp", "script"]);
+var WorkUnitIdSchema = external_exports.string().min(1).max(128).regex(
+  /^[A-Za-z0-9][A-Za-z0-9._:/#@-]*$/,
+  "work unit id must start with an alphanumeric character and contain only stable identifier characters"
+);
+var WorkAttemptIdSchema = external_exports.string().uuid();
+var WorkUnitMetadataSchema = external_exports.object({
+  workUnitId: WorkUnitIdSchema,
+  source: external_exports.string().min(1).max(64).optional(),
+  sourceUrl: external_exports.string().url().optional(),
+  title: external_exports.string().min(1).max(256).optional(),
+  parentWorkUnitId: WorkUnitIdSchema.optional()
+});
+var WorkUnitOutcomeSchema = external_exports.object({
+  decision: external_exports.enum(["completed", "abandoned"]),
+  decidedAt: external_exports.string(),
+  attemptId: WorkAttemptIdSchema.optional(),
+  validationId: external_exports.string().uuid().optional(),
+  treeHash: external_exports.string().regex(/^[0-9a-f]{40,64}$/).optional(),
+  reason: external_exports.string().max(2e3).optional()
+}).superRefine((outcome, ctx) => {
+  if (outcome.decision === "completed" && (!outcome.attemptId || !outcome.validationId || !outcome.treeHash)) {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      message: "completed work must reference an attempt and exact-tree validation"
+    });
+  }
+});
+var WorkUnitRecordSchema = WorkUnitMetadataSchema.extend({
+  version: external_exports.number().int().default(1),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string(),
+  outcome: WorkUnitOutcomeSchema.optional()
+}).passthrough();
+var WorkAttemptRecordSchema = external_exports.object({
+  version: external_exports.number().int().default(1),
+  attemptId: WorkAttemptIdSchema,
+  workUnitId: WorkUnitIdSchema,
+  agentId: external_exports.number().int().min(HAR_AGENT_SLOT_MIN),
+  sessionKey: external_exports.string().min(1).optional(),
+  workDir: external_exports.string().optional(),
+  worktreePath: external_exports.string().optional(),
+  branch: external_exports.string().optional(),
+  baseCommit: external_exports.string().optional(),
+  createdAt: external_exports.string()
+}).passthrough();
 var RunRecordSchema = external_exports.object({
   runId: external_exports.string().uuid(),
   repoPath: external_exports.string(),
@@ -44132,7 +44177,9 @@ var RunRecordSchema = external_exports.object({
   relativePath: external_exports.string().optional(),
   command: external_exports.string().optional(),
   workDir: external_exports.string().optional(),
-  harnessRoot: external_exports.string().optional()
+  harnessRoot: external_exports.string().optional(),
+  workUnitId: WorkUnitIdSchema.optional(),
+  attemptId: WorkAttemptIdSchema.optional()
 }).passthrough();
 var SlotRegistryEntrySchema = external_exports.object({
   version: external_exports.number().int().default(1),
@@ -44154,6 +44201,8 @@ var SlotRegistryEntrySchema = external_exports.object({
   createdAt: external_exports.string(),
   ports: external_exports.record(external_exports.number()).optional(),
   previewUrls: external_exports.record(external_exports.string()).optional(),
+  workUnitId: WorkUnitIdSchema.optional(),
+  attemptId: WorkAttemptIdSchema.optional(),
   status: external_exports.enum(["starting", "active", "failed", "completed"]).default("active"),
   lastError: external_exports.string().optional()
 }).passthrough();
@@ -44199,6 +44248,8 @@ var AgentSlotStatusSchema = external_exports.object({
   sessionCreatedAt: external_exports.string().optional(),
   /** Derived from first captured user prompt (OTEL hooks); not set at launch. */
   purpose: external_exports.string().optional(),
+  workUnitId: WorkUnitIdSchema.optional(),
+  attemptId: WorkAttemptIdSchema.optional(),
   sessionStatus: external_exports.enum(["starting", "active", "failed", "completed"]).optional(),
   lastError: external_exports.string().optional(),
   /** Set when a failed/starting session can be resumed without --replace. */
@@ -44259,6 +44310,10 @@ var SyncSlotsInputSchema = external_exports.object({
   slots: external_exports.array(AgentSlotStatusSchema),
   generatedAt: external_exports.string()
 });
+var SyncWorkUnitsInputSchema = external_exports.object({
+  workUnits: external_exports.array(WorkUnitRecordSchema),
+  attempts: external_exports.array(WorkAttemptRecordSchema)
+});
 var ChangedFileStatusSchema = external_exports.enum(["A", "M", "D", "R", "C", "T", "U"]);
 var ChangedFileSchema = external_exports.object({
   path: external_exports.string(),
@@ -44285,6 +44340,17 @@ var ValidationRecordSchema = external_exports.object({
 var SyncValidationsInputSchema = external_exports.object({
   validations: external_exports.array(ValidationRecordSchema)
 });
+var ValidationBindingRecordSchema = external_exports.object({
+  bindingId: external_exports.string().uuid(),
+  workUnitId: WorkUnitIdSchema,
+  attemptId: WorkAttemptIdSchema,
+  validationId: external_exports.string().uuid(),
+  treeHash: external_exports.string().regex(/^[0-9a-f]{40,64}$/),
+  createdAt: external_exports.string()
+});
+var SyncValidationBindingsInputSchema = external_exports.object({
+  bindings: external_exports.array(ValidationBindingRecordSchema)
+});
 var AgentToolSchema = external_exports.enum(["claude_code", "codex", "cursor"]);
 var UsageSourceSchema = external_exports.enum(["otel", "harvest"]);
 var AgentSessionUsageSchema = external_exports.object({
@@ -44294,6 +44360,8 @@ var AgentSessionUsageSchema = external_exports.object({
   workDir: external_exports.string().optional(),
   branch: external_exports.string().optional(),
   suffix: external_exports.string().optional(),
+  workUnitId: WorkUnitIdSchema.optional(),
+  attemptId: WorkAttemptIdSchema.optional(),
   tokensInput: external_exports.number().nonnegative().default(0),
   tokensOutput: external_exports.number().nonnegative().default(0),
   tokensCacheRead: external_exports.number().nonnegative().default(0),
@@ -44315,6 +44383,8 @@ var AgentSessionEventSchema = external_exports.object({
   eventName: external_exports.string().min(1),
   sequence: external_exports.number().int().nonnegative().default(0),
   timestamp: external_exports.string(),
+  workUnitId: WorkUnitIdSchema.optional(),
+  attemptId: WorkAttemptIdSchema.optional(),
   attributes: external_exports.record(external_exports.unknown()).optional(),
   promptText: external_exports.string().nullable().optional(),
   responseText: external_exports.string().nullable().optional(),
@@ -44677,7 +44747,7 @@ function handleRemove(argv) {
 }
 
 // src/cli/commands/env.ts
-var path45 = __toESM(require("path"));
+var path46 = __toESM(require("path"));
 
 // src/core/harness.ts
 var fs20 = __toESM(require("fs"));
@@ -45456,13 +45526,13 @@ var MultipartBody = class {
 // node_modules/@anthropic-ai/sdk/_shims/node-runtime.mjs
 var import_web = require("node:stream/web");
 var fileFromPathWarned = false;
-async function fileFromPath3(path52, ...args) {
+async function fileFromPath3(path53, ...args) {
   const { fileFromPath: _fileFromPath } = await Promise.resolve().then(() => (init_fileFromPath(), fileFromPath_exports));
   if (!fileFromPathWarned) {
-    console.warn(`fileFromPath is deprecated; use fs.createReadStream(${JSON.stringify(path52)}) instead`);
+    console.warn(`fileFromPath is deprecated; use fs.createReadStream(${JSON.stringify(path53)}) instead`);
     fileFromPathWarned = true;
   }
-  return await _fileFromPath(path52, ...args);
+  return await _fileFromPath(path53, ...args);
 }
 var defaultHttpAgent = new import_agentkeepalive.default({ keepAlive: true, timeout: 5 * 60 * 1e3 });
 var defaultHttpsAgent = new import_agentkeepalive.default.HttpsAgent({ keepAlive: true, timeout: 5 * 60 * 1e3 });
@@ -46059,29 +46129,29 @@ var APIClient = class {
   defaultIdempotencyKey() {
     return `stainless-node-retry-${uuid4()}`;
   }
-  get(path52, opts) {
-    return this.methodRequest("get", path52, opts);
+  get(path53, opts) {
+    return this.methodRequest("get", path53, opts);
   }
-  post(path52, opts) {
-    return this.methodRequest("post", path52, opts);
+  post(path53, opts) {
+    return this.methodRequest("post", path53, opts);
   }
-  patch(path52, opts) {
-    return this.methodRequest("patch", path52, opts);
+  patch(path53, opts) {
+    return this.methodRequest("patch", path53, opts);
   }
-  put(path52, opts) {
-    return this.methodRequest("put", path52, opts);
+  put(path53, opts) {
+    return this.methodRequest("put", path53, opts);
   }
-  delete(path52, opts) {
-    return this.methodRequest("delete", path52, opts);
+  delete(path53, opts) {
+    return this.methodRequest("delete", path53, opts);
   }
-  methodRequest(method, path52, opts) {
+  methodRequest(method, path53, opts) {
     return this.request(Promise.resolve(opts).then(async (opts2) => {
       const body = opts2 && isBlobLike(opts2?.body) ? new DataView(await opts2.body.arrayBuffer()) : opts2?.body instanceof DataView ? opts2.body : opts2?.body instanceof ArrayBuffer ? new DataView(opts2.body) : opts2 && ArrayBuffer.isView(opts2?.body) ? new DataView(opts2.body.buffer) : opts2?.body;
-      return { method, path: path52, ...opts2, body };
+      return { method, path: path53, ...opts2, body };
     }));
   }
-  getAPIList(path52, Page, opts) {
-    return this.requestAPIList(Page, { method: "get", path: path52, ...opts });
+  getAPIList(path53, Page, opts) {
+    return this.requestAPIList(Page, { method: "get", path: path53, ...opts });
   }
   calculateContentLength(body) {
     if (typeof body === "string") {
@@ -46099,10 +46169,10 @@ var APIClient = class {
     return null;
   }
   buildRequest(options) {
-    const { method, path: path52, query, headers = {} } = options;
+    const { method, path: path53, query, headers = {} } = options;
     const body = ArrayBuffer.isView(options.body) || options.__binaryRequest && typeof options.body === "string" ? options.body : isMultipartBody(options.body) ? options.body.body : options.body ? JSON.stringify(options.body, null, 2) : null;
     const contentLength = this.calculateContentLength(body);
-    const url = this.buildURL(path52, query);
+    const url = this.buildURL(path53, query);
     if ("timeout" in options)
       validatePositiveInteger("timeout", options.timeout);
     const timeout = options.timeout ?? this.timeout;
@@ -46211,8 +46281,8 @@ var APIClient = class {
     const request = this.makeRequest(options, null);
     return new PagePromise(this, request, Page);
   }
-  buildURL(path52, query) {
-    const url = isAbsoluteURL(path52) ? new URL(path52) : new URL(this.baseURL + (this.baseURL.endsWith("/") && path52.startsWith("/") ? path52.slice(1) : path52));
+  buildURL(path53, query) {
+    const url = isAbsoluteURL(path53) ? new URL(path53) : new URL(this.baseURL + (this.baseURL.endsWith("/") && path53.startsWith("/") ? path53.slice(1) : path53));
     const defaultQuery = this.defaultQuery();
     if (!isEmptyObj(defaultQuery)) {
       query = { ...defaultQuery, ...query };
@@ -49802,6 +49872,9 @@ function buildStageResult(input) {
   });
 }
 
+// src/core/run-service.ts
+var crypto5 = __toESM(require("crypto"));
+
 // src/core/local-executor.ts
 var fs25 = __toESM(require("fs"));
 var path24 = __toESM(require("path"));
@@ -49854,6 +49927,8 @@ function buildLaunchFlagArgs(flags) {
   if (flags.confirmReplace) args.push("--replace");
   if (flags.force) args.push("--force");
   if (flags.resume) args.push("--resume");
+  if (flags.workUnitId) args.push(`--work-id=${flags.workUnitId}`);
+  if (flags.attemptId) args.push(`--attempt-id=${flags.attemptId}`);
   return args;
 }
 function resolveRepoPath(repoPath) {
@@ -50029,7 +50104,7 @@ var LocalScriptExecutor = class {
 var localScriptExecutor = new LocalScriptExecutor();
 
 // src/core/control-sync.ts
-var path39 = __toESM(require("path"));
+var path40 = __toESM(require("path"));
 init_control_config();
 
 // src/core/control-registry.ts
@@ -50288,7 +50363,9 @@ function createRun(ctx, meta) {
     status: "unknown",
     startedAt,
     relativePath,
-    trigger: ctx.trigger ?? "cli"
+    trigger: ctx.trigger ?? "cli",
+    workUnitId: ctx.workUnitId,
+    attemptId: ctx.attemptId
   });
   fs28.writeFileSync(runFilePath, JSON.stringify(run2, null, 2) + "\n");
   return run2;
@@ -51069,6 +51146,8 @@ function collectSlotStatus(harnessRoot, agentId, runs, pm2Procs) {
     baseBranch: session?.baseBranch,
     baseCommit: session?.baseCommit,
     sessionCreatedAt: session?.createdAt,
+    workUnitId: session?.workUnitId,
+    attemptId: session?.attemptId,
     sessionStatus: session?.status,
     lastError: session?.lastError,
     resumeHint,
@@ -51285,6 +51364,173 @@ function listValidations(harnessRoot) {
   return records.sort((a2, b2) => b2.updatedAt.localeCompare(a2.updatedAt));
 }
 
+// src/core/work-units.ts
+var crypto4 = __toESM(require("crypto"));
+var fs35 = __toESM(require("fs"));
+var path35 = __toESM(require("path"));
+var WORK_UNITS_DIR = "work-units";
+var WORK_ATTEMPTS_DIR = "work-attempts";
+var VALIDATION_BINDINGS_DIR = "validation-bindings";
+var EVIDENCE_DIRS = [WORK_UNITS_DIR, WORK_ATTEMPTS_DIR, VALIDATION_BINDINGS_DIR];
+function harEvidenceDir(harnessRoot, name) {
+  return path35.join(harnessRoot, ".har", name);
+}
+function hashedRecordPath(harnessRoot, dir, id) {
+  const digest = crypto4.createHash("sha256").update(id).digest("hex");
+  return path35.join(harEvidenceDir(harnessRoot, dir), `${digest}.json`);
+}
+function writeRecord2(file, value) {
+  fs35.mkdirSync(path35.dirname(file), { recursive: true });
+  const temp = `${file}.${process.pid}.tmp`;
+  fs35.writeFileSync(temp, `${JSON.stringify(value, null, 2)}
+`);
+  fs35.renameSync(temp, file);
+}
+function ensureWorkEvidenceIgnored(harnessRoot) {
+  const harDir = path35.join(harnessRoot, ".har");
+  if (!fs35.existsSync(harDir)) return;
+  const gitignorePath = path35.join(harDir, ".gitignore");
+  const content = fs35.existsSync(gitignorePath) ? fs35.readFileSync(gitignorePath, "utf8") : "";
+  const lines2 = new Set(content.split("\n").map((line) => line.trim()));
+  const missing = EVIDENCE_DIRS.map((dir) => `${dir}/`).filter((dir) => !lines2.has(dir));
+  if (missing.length === 0) return;
+  const separator = content.length === 0 || content.endsWith("\n") ? "" : "\n";
+  fs35.writeFileSync(gitignorePath, `${content}${separator}${missing.join("\n")}
+`);
+}
+function listRecords(harnessRoot, dir, parse4) {
+  const recordDir = harEvidenceDir(harnessRoot, dir);
+  if (!fs35.existsSync(recordDir)) return [];
+  const records = [];
+  for (const name of fs35.readdirSync(recordDir)) {
+    if (!name.endsWith(".json")) continue;
+    try {
+      records.push(parse4(JSON.parse(fs35.readFileSync(path35.join(recordDir, name), "utf8"))));
+    } catch {
+    }
+  }
+  return records;
+}
+function findWorkUnit(harnessRoot, workUnitId) {
+  const metadata = WorkUnitMetadataSchema.parse({ workUnitId });
+  const file = hashedRecordPath(harnessRoot, WORK_UNITS_DIR, metadata.workUnitId);
+  if (!fs35.existsSync(file)) return void 0;
+  try {
+    return WorkUnitRecordSchema.parse(JSON.parse(fs35.readFileSync(file, "utf8")));
+  } catch {
+    return void 0;
+  }
+}
+function upsertWorkUnit(harnessRoot, input) {
+  const metadata = WorkUnitMetadataSchema.parse(input);
+  ensureWorkEvidenceIgnored(harnessRoot);
+  const existing = findWorkUnit(harnessRoot, metadata.workUnitId);
+  if (existing) {
+    if (existing.outcome) {
+      throw new Error(
+        `Work unit ${metadata.workUnitId} is already ${existing.outcome.decision}; reopening is not supported`
+      );
+    }
+    for (const field of ["source", "sourceUrl", "title", "parentWorkUnitId"]) {
+      if (metadata[field] !== void 0 && existing[field] !== void 0 && metadata[field] !== existing[field]) {
+        throw new Error(
+          `Work unit ${metadata.workUnitId} has immutable ${field}=${existing[field]}`
+        );
+      }
+    }
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const record2 = WorkUnitRecordSchema.parse({
+    ...existing,
+    workUnitId: metadata.workUnitId,
+    source: existing?.source ?? metadata.source,
+    sourceUrl: existing?.sourceUrl ?? metadata.sourceUrl,
+    title: existing?.title ?? metadata.title,
+    parentWorkUnitId: existing?.parentWorkUnitId ?? metadata.parentWorkUnitId,
+    version: 1,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+    outcome: existing?.outcome
+  });
+  writeRecord2(
+    hashedRecordPath(harnessRoot, WORK_UNITS_DIR, metadata.workUnitId),
+    record2
+  );
+  return record2;
+}
+function listWorkUnits(harnessRoot) {
+  return listRecords(
+    harnessRoot,
+    WORK_UNITS_DIR,
+    (value) => WorkUnitRecordSchema.parse(value)
+  ).sort((a2, b2) => b2.updatedAt.localeCompare(a2.updatedAt));
+}
+function createWorkAttempt(harnessRoot, input) {
+  const attempt = WorkAttemptRecordSchema.parse({
+    ...input,
+    version: 1,
+    createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  });
+  ensureWorkEvidenceIgnored(harnessRoot);
+  writeRecord2(
+    hashedRecordPath(harnessRoot, WORK_ATTEMPTS_DIR, attempt.attemptId),
+    attempt
+  );
+  return attempt;
+}
+function listWorkAttempts(harnessRoot) {
+  return listRecords(
+    harnessRoot,
+    WORK_ATTEMPTS_DIR,
+    (value) => WorkAttemptRecordSchema.parse(value)
+  ).sort((a2, b2) => b2.createdAt.localeCompare(a2.createdAt));
+}
+function bindValidationToAttempt(harnessRoot, input) {
+  const stableKey = `${input.attemptId}:${input.validation.validationId}`;
+  ensureWorkEvidenceIgnored(harnessRoot);
+  const existingFile = hashedRecordPath(
+    harnessRoot,
+    VALIDATION_BINDINGS_DIR,
+    stableKey
+  );
+  if (fs35.existsSync(existingFile)) {
+    try {
+      return ValidationBindingRecordSchema.parse(
+        JSON.parse(fs35.readFileSync(existingFile, "utf8"))
+      );
+    } catch {
+    }
+  }
+  const binding = ValidationBindingRecordSchema.parse({
+    bindingId: crypto4.randomUUID(),
+    workUnitId: input.workUnitId,
+    attemptId: input.attemptId,
+    validationId: input.validation.validationId,
+    treeHash: input.validation.treeHash,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  writeRecord2(existingFile, binding);
+  return binding;
+}
+function listValidationBindings(harnessRoot) {
+  return listRecords(
+    harnessRoot,
+    VALIDATION_BINDINGS_DIR,
+    (value) => ValidationBindingRecordSchema.parse(value)
+  ).sort((a2, b2) => b2.createdAt.localeCompare(a2.createdAt));
+}
+function decideWorkUnitOutcome(harnessRoot, workUnitId, outcome) {
+  const existing = findWorkUnit(harnessRoot, workUnitId);
+  if (!existing) throw new Error(`Unknown work unit: ${workUnitId}`);
+  const record2 = WorkUnitRecordSchema.parse({
+    ...existing,
+    outcome,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  writeRecord2(hashedRecordPath(harnessRoot, WORK_UNITS_DIR, workUnitId), record2);
+  return record2;
+}
+
 // src/core/cloud-executor.ts
 var RemoteExecutor = class {
   constructor(apiUrl, apiKey) {
@@ -51311,14 +51557,14 @@ function createRemoteExecutor(apiUrl, apiKey) {
 init_telemetry_config();
 
 // src/core/usage-harvest/claude.ts
-var fs37 = __toESM(require("fs"));
+var fs38 = __toESM(require("fs"));
 var os10 = __toESM(require("os"));
-var path37 = __toESM(require("path"));
+var path38 = __toESM(require("path"));
 init_telemetry_config();
 
 // src/core/telemetry-env.ts
-var fs36 = __toESM(require("fs"));
-var path36 = __toESM(require("path"));
+var fs37 = __toESM(require("fs"));
+var path37 = __toESM(require("path"));
 init_control_config();
 function escapeAttrValue(value) {
   return value.replace(/[,=]/g, "_");
@@ -51332,6 +51578,10 @@ function buildOtelResourceAttributes(attrs) {
   ];
   if (attrs.branch) parts.push(`har.branch=${escapeAttrValue(attrs.branch)}`);
   if (attrs.suffix) parts.push(`har.suffix=${escapeAttrValue(attrs.suffix)}`);
+  if (attrs.workUnitId) {
+    parts.push(`har.work_unit_id=${escapeAttrValue(attrs.workUnitId)}`);
+  }
+  if (attrs.attemptId) parts.push(`har.attempt_id=${attrs.attemptId}`);
   return parts.join(",");
 }
 function buildSessionKey(input) {
@@ -51345,6 +51595,8 @@ function buildTelemetryEnvBlock(attrs) {
     "",
     "# HAR session attribution (generated)",
     `HAR_SESSION_KEY=${attrs.sessionKey}`,
+    ...attrs.workUnitId ? [`HAR_WORK_UNIT_ID=${attrs.workUnitId}`] : [],
+    ...attrs.attemptId ? [`HAR_ATTEMPT_ID=${attrs.attemptId}`] : [],
     `HAR_CONTROL_API_URL=${apiUrl}`,
     `OTEL_RESOURCE_ATTRIBUTES=${buildOtelResourceAttributes(attrs)}`,
     "# Agent telemetry: opentelemetry-hooks \u2192 Mission Control (har telemetry on|off)"
@@ -51358,8 +51610,8 @@ function appendTelemetryEnvToFile(envFilePath, attrs) {
 ${TELEMETRY_MARKER_END}
 `;
   let existing = "";
-  if (fs36.existsSync(envFilePath)) {
-    existing = fs36.readFileSync(envFilePath, "utf8");
+  if (fs37.existsSync(envFilePath)) {
+    existing = fs37.readFileSync(envFilePath, "utf8");
     const start = existing.indexOf(TELEMETRY_MARKER_START);
     if (start >= 0) {
       const end = existing.indexOf(TELEMETRY_MARKER_END, start);
@@ -51370,28 +51622,28 @@ ${TELEMETRY_MARKER_END}
       }
     }
   }
-  fs36.mkdirSync(path36.dirname(envFilePath), { recursive: true });
+  fs37.mkdirSync(path37.dirname(envFilePath), { recursive: true });
   const combined = (existing.replace(/\n+$/, "\n") + block).replace(/^\n+/, "");
-  fs36.writeFileSync(envFilePath, combined.endsWith("\n") ? combined : combined + "\n");
+  fs37.writeFileSync(envFilePath, combined.endsWith("\n") ? combined : combined + "\n");
 }
 
 // src/core/usage-harvest/claude.ts
 function pathsMatch(candidate, targets) {
-  const norm = path37.resolve(candidate);
+  const norm = path38.resolve(candidate);
   return targets.some((t2) => {
-    const target = path37.resolve(t2);
-    return norm === target || norm.startsWith(target + path37.sep) || target.startsWith(norm + path37.sep);
+    const target = path38.resolve(t2);
+    return norm === target || norm.startsWith(target + path38.sep) || target.startsWith(norm + path38.sep);
   });
 }
 function claudeProjectsRoot() {
-  return process.env.HAR_CLAUDE_PROJECTS_DIR ? path37.resolve(process.env.HAR_CLAUDE_PROJECTS_DIR) : path37.join(os10.homedir(), ".claude", "projects");
+  return process.env.HAR_CLAUDE_PROJECTS_DIR ? path38.resolve(process.env.HAR_CLAUDE_PROJECTS_DIR) : path38.join(os10.homedir(), ".claude", "projects");
 }
 function encodeClaudeProjectDir(cwd) {
   return cwd.replace(/[^a-zA-Z0-9]/g, "-");
 }
 function readJsonlRecords(filePath) {
-  if (!fs37.existsSync(filePath)) return [];
-  const lines2 = fs37.readFileSync(filePath, "utf8").split(/\r?\n/);
+  if (!fs38.existsSync(filePath)) return [];
+  const lines2 = fs38.readFileSync(filePath, "utf8").split(/\r?\n/);
   const out = [];
   for (const line of lines2) {
     const trimmed = line.trim();
@@ -51434,16 +51686,16 @@ function findMatchingClaudeTranscripts(slot) {
   const targets = [slot.workDir, slot.worktreePath].filter(Boolean);
   if (targets.length === 0) return [];
   const root = claudeProjectsRoot();
-  if (!fs37.existsSync(root)) return [];
+  if (!fs38.existsSync(root)) return [];
   const matches = [];
-  for (const entry of fs37.readdirSync(root, { withFileTypes: true })) {
+  for (const entry of fs38.readdirSync(root, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const projectDir = path37.join(root, entry.name);
+    const projectDir = path38.join(root, entry.name);
     const encodedHit = targets.some((t2) => entry.name.includes(encodeClaudeProjectDir(t2).slice(0, 40)));
-    for (const file of fs37.readdirSync(projectDir)) {
+    for (const file of fs38.readdirSync(projectDir)) {
       if (!file.endsWith(".jsonl")) continue;
-      const filePath = path37.join(projectDir, file);
-      const stat = fs37.statSync(filePath);
+      const filePath = path38.join(projectDir, file);
+      const stat = fs38.statSync(filePath);
       const records = readJsonlRecords(filePath);
       let cwdHit = encodedHit;
       for (const record2 of records) {
@@ -51554,30 +51806,30 @@ function harvestClaudeEvents(slot) {
 }
 
 // src/core/usage-harvest/codex.ts
-var fs38 = __toESM(require("fs"));
+var fs39 = __toESM(require("fs"));
 var os11 = __toESM(require("os"));
-var path38 = __toESM(require("path"));
+var path39 = __toESM(require("path"));
 function pathsMatch2(candidate, targets) {
-  const norm = path38.resolve(candidate);
+  const norm = path39.resolve(candidate);
   return targets.some((t2) => {
-    const target = path38.resolve(t2);
-    return norm === target || norm.startsWith(target + path38.sep) || target.startsWith(norm + path38.sep);
+    const target = path39.resolve(t2);
+    return norm === target || norm.startsWith(target + path39.sep) || target.startsWith(norm + path39.sep);
   });
 }
 function codexSessionsRoot() {
-  return process.env.HAR_CODEX_SESSIONS_DIR ? path38.resolve(process.env.HAR_CODEX_SESSIONS_DIR) : path38.join(os11.homedir(), ".codex", "sessions");
+  return process.env.HAR_CODEX_SESSIONS_DIR ? path39.resolve(process.env.HAR_CODEX_SESSIONS_DIR) : path39.join(os11.homedir(), ".codex", "sessions");
 }
 function walkJsonlFiles(dir, out = []) {
-  if (!fs38.existsSync(dir)) return out;
-  for (const entry of fs38.readdirSync(dir, { withFileTypes: true })) {
-    const full = path38.join(dir, entry.name);
+  if (!fs39.existsSync(dir)) return out;
+  for (const entry of fs39.readdirSync(dir, { withFileTypes: true })) {
+    const full = path39.join(dir, entry.name);
     if (entry.isDirectory()) walkJsonlFiles(full, out);
     else if (entry.isFile() && entry.name.endsWith(".jsonl")) out.push(full);
   }
   return out;
 }
 function readJsonl(filePath) {
-  const lines2 = fs38.readFileSync(filePath, "utf8").split(/\r?\n/);
+  const lines2 = fs39.readFileSync(filePath, "utf8").split(/\r?\n/);
   const out = [];
   for (const line of lines2) {
     const trimmed = line.trim();
@@ -51641,7 +51893,7 @@ function harvestCodexUsage(slot) {
     const extracted = extractCodexTokens(records);
     if (!extracted.cwd || !pathsMatch2(extracted.cwd, targets)) continue;
     if (extracted.tokensInput + extracted.tokensOutput + extracted.tokensCacheRead === 0) continue;
-    const mtime = fs38.statSync(file).mtimeMs;
+    const mtime = fs39.statSync(file).mtimeMs;
     if (mtime >= bestMtime) {
       bestMtime = mtime;
       best = extracted;
@@ -51787,13 +52039,22 @@ async function syncRepoWithControl(options) {
     }
     const runs = listRuns(repoPath);
     const status = collectEnvironmentStatus(repoPath);
+    const harnessRoot = resolveHarnessRoot(repoPath);
     const response = await fetch(`${process.env.HAR_CLOUD_API_URL}/api/sync`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${process.env.HAR_CLOUD_API_KEY}`
       },
-      body: JSON.stringify({ path: repoPath, runs, slots: status.slots })
+      body: JSON.stringify({
+        path: repoPath,
+        runs,
+        slots: status.slots,
+        workUnits: listWorkUnits(harnessRoot),
+        attempts: listWorkAttempts(harnessRoot),
+        validations: listValidations(harnessRoot),
+        validationBindings: listValidationBindings(harnessRoot)
+      })
     });
     if (!response.ok) {
       throw new Error(`Cloud sync failed: ${response.status}`);
@@ -51806,7 +52067,7 @@ async function syncRepoWithControl(options) {
     const listResponse = await fetch(`${apiUrl}/api/repos`);
     if (!listResponse.ok) throw new Error("Failed to list repos from Control API");
     const repos = await listResponse.json();
-    const existing = repos.find((r2) => path39.resolve(r2.path) === repoPath);
+    const existing = repos.find((r2) => path40.resolve(r2.path) === repoPath);
     if (!existing) {
       return;
     }
@@ -51827,6 +52088,13 @@ async function syncRepoRunsAndSlots(apiUrl, repoId, repoPath, dryRun) {
     generatedAt: status.generatedAt
   });
   await postJson(`${apiUrl}/api/repos/${repoId}/slots`, slotsBody, dryRun);
+  const workUnitsBody = SyncWorkUnitsInputSchema.parse({
+    workUnits: listWorkUnits(resolveHarnessRoot(repoPath)),
+    attempts: listWorkAttempts(resolveHarnessRoot(repoPath))
+  });
+  if (workUnitsBody.workUnits.length > 0 || workUnitsBody.attempts.length > 0) {
+    await postJson(`${apiUrl}/api/repos/${repoId}/work-units`, workUnitsBody, dryRun);
+  }
   if (isTelemetryEnabled() && process.env.NODE_ENV !== "test") {
     try {
       const usage2 = status.slots.flatMap(
@@ -51840,6 +52108,8 @@ async function syncRepoRunsAndSlots(apiUrl, repoId, repoPath, dryRun) {
           repoPath
         }).map((row) => ({
           ...row,
+          workUnitId: slot.workUnitId,
+          attemptId: slot.attemptId,
           sessionKey: row.sessionKey || buildSessionKey({
             branch: slot.branch,
             agentId: slot.agentId,
@@ -51861,7 +52131,11 @@ async function syncRepoRunsAndSlots(apiUrl, repoId, repoPath, dryRun) {
           suffix: slot.suffix,
           sessionCreatedAt: slot.sessionCreatedAt,
           repoPath
-        })
+        }).map((event) => ({
+          ...event,
+          workUnitId: slot.workUnitId,
+          attemptId: slot.attemptId
+        }))
       );
       if (events.length > 0) {
         const eventsBody = SyncSessionEventsInputSchema.parse({ events });
@@ -51878,6 +52152,16 @@ async function syncRepoRunsAndSlots(apiUrl, repoId, repoPath, dryRun) {
     const validationsBody = SyncValidationsInputSchema.parse({ validations });
     await postJson(`${apiUrl}/api/repos/${repoId}/validations`, validationsBody, dryRun);
   }
+  const bindingsBody = SyncValidationBindingsInputSchema.parse({
+    bindings: listValidationBindings(resolveHarnessRoot(repoPath))
+  });
+  if (bindingsBody.bindings.length > 0) {
+    await postJson(
+      `${apiUrl}/api/repos/${repoId}/validation-bindings`,
+      bindingsBody,
+      dryRun
+    );
+  }
 }
 var SYNC_TIMEOUT_MS = 15e3;
 function withTimeout(promise, ms, label) {
@@ -51935,7 +52219,7 @@ init_control_config();
 
 // src/core/control-lifecycle.ts
 var import_child_process8 = require("child_process");
-var path40 = __toESM(require("path"));
+var path41 = __toESM(require("path"));
 
 // src/core/control-image.ts
 var DEFAULT_CONTROL_IMAGE = "theosfactory/har-control";
@@ -51959,10 +52243,10 @@ var CONTROL_DATA_VOLUME = "har_control_data";
 var CONTROL_CONTAINER_PORT = 3847;
 var CONTROL_DATA_DB_URL = "file:/data/har_control.db";
 function resolveControlDir() {
-  return path40.resolve(__dirname, "..", "control");
+  return path41.resolve(__dirname, "..", "control");
 }
 function resolveControlBuildContext() {
-  return path40.resolve(resolveControlDir(), "..");
+  return path41.resolve(resolveControlDir(), "..");
 }
 function buildDockerRunArgs(options) {
   const name = options.containerName ?? CONTROL_CONTAINER_NAME;
@@ -52018,7 +52302,7 @@ async function startMissionControl(options) {
       "-t",
       imageRef,
       "-f",
-      path40.join(resolveControlDir(), "Dockerfile"),
+      path41.join(resolveControlDir(), "Dockerfile"),
       resolveControlBuildContext()
     ]);
     if (buildCode !== 0) {
@@ -52162,7 +52446,7 @@ async function ensureTelemetryInfrastructure(options) {
 
 // src/core/run-service.ts
 init_telemetry_config();
-var path42 = __toESM(require("path"));
+var path43 = __toESM(require("path"));
 function extractShellOutput(result) {
   const stdout = result.logs?.find((log) => log.stream === "stdout")?.content ?? result.logs?.find((log) => !log.stream)?.content ?? "";
   const stderr = result.logs?.find((log) => log.stream === "stderr")?.content ?? "";
@@ -52200,11 +52484,14 @@ var RunService = class {
     this.executor = executor;
   }
   async runStage(options) {
+    const activeSession = options.agentId !== void 0 && options.kind !== "launch" ? readSlotRegistry(resolveHarnessRoot(options.repoPath), options.agentId) : void 0;
     const ctx = {
       repoPath: options.repoPath,
       capture: options.capture,
       agentId: options.agentId,
-      trigger: options.trigger
+      trigger: options.trigger,
+      workUnitId: options.workUnitId ?? activeSession?.workUnitId,
+      attemptId: options.attemptId ?? activeSession?.attemptId
     };
     const stageLookup = options.stageId ? { id: options.stageId } : options.kind ? { kind: options.kind } : null;
     if (!stageLookup) {
@@ -52306,47 +52593,96 @@ Usage from Cursor / Claude / Codex (opentelemetry-hooks) will appear under Workt
 `;
       }
     }
+    const harnessRoot = resolveHarnessRoot(options.repoPath);
+    const resumableSession = options.resume ? readSlotRegistry(harnessRoot, options.agentId) : void 0;
+    const workUnitId = options.workUnitId ?? resumableSession?.workUnitId;
+    const attemptId = workUnitId ? resumableSession?.attemptId ?? crypto5.randomUUID() : void 0;
+    if (workUnitId && attemptId) {
+      const conflictingSession = listSlotRegistryEntries(harnessRoot).find(
+        (entry) => entry.workUnitId === workUnitId && !(entry.agentId === options.agentId && (options.resume || options.confirmReplace))
+      );
+      if (conflictingSession) {
+        return {
+          code: 2,
+          stdout: "",
+          stderr: `Work unit ${workUnitId} is already bound to slot ${conflictingSession.agentId} (attempt ${conflictingSession.attemptId ?? "unknown"}).`,
+          blocked: true
+        };
+      }
+      upsertWorkUnit(harnessRoot, {
+        workUnitId,
+        source: options.source,
+        sourceUrl: options.sourceUrl,
+        title: options.title,
+        parentWorkUnitId: options.parentWorkUnitId
+      });
+      createWorkAttempt(harnessRoot, {
+        attemptId,
+        workUnitId,
+        agentId: options.agentId
+      });
+    }
     const result = await this.runStage({
       repoPath: options.repoPath,
       kind: "launch",
       agentId: options.agentId,
+      workUnitId,
+      attemptId,
       capture: options.capture ?? false,
       launchFlags: {
         worktree: options.worktree,
         claude: options.claude,
         confirmReplace: options.confirmReplace,
         force: options.force,
-        resume: options.resume
+        resume: options.resume,
+        workUnitId,
+        attemptId
       },
       trigger: "cli"
     });
     const envResult = toEnvironmentRunResult(result);
     if (envResult.code === 0) {
-      const harnessRoot = resolveHarnessRoot(options.repoPath);
       const session = readSlotRegistry(harnessRoot, options.agentId);
       if (session) {
         envResult.workDir = session.workDir;
         envResult.worktreePath = session.worktreePath;
         envResult.branch = session.branch;
         envResult.previewUrls = envResult.previewUrls ?? session.previewUrls;
+        envResult.workUnitId = session.workUnitId;
+        envResult.attemptId = session.attemptId;
         const sessionKey = buildSessionKey({
           branch: session.branch,
           agentId: options.agentId,
           suffix: session.suffix,
           createdAt: session.createdAt
         });
-        const envFile = path42.join(session.workDir, `.env.agent.${options.agentId}`);
+        const envFile = path43.join(session.workDir, `.env.agent.${options.agentId}`);
         try {
           appendTelemetryEnvToFile(envFile, {
             sessionKey,
             agentId: options.agentId,
-            repoPath: path42.resolve(options.repoPath),
+            repoPath: path43.resolve(options.repoPath),
             workDir: session.workDir,
             branch: session.branch,
-            suffix: session.suffix
+            suffix: session.suffix,
+            workUnitId: session.workUnitId,
+            attemptId: session.attemptId
           });
         } catch {
         }
+        if (session.workUnitId && session.attemptId) {
+          createWorkAttempt(harnessRoot, {
+            attemptId: session.attemptId,
+            workUnitId: session.workUnitId,
+            agentId: options.agentId,
+            sessionKey,
+            workDir: session.workDir,
+            worktreePath: session.worktreePath,
+            branch: session.branch,
+            baseCommit: session.baseCommit,
+            createdAt: session.createdAt
+          });
+        }
       }
       if (telemetryBanner) {
         envResult.stderr = `${telemetryBanner}${envResult.stderr ?? ""}`;
@@ -52377,7 +52713,7 @@ Usage from Cursor / Claude / Codex (opentelemetry-hooks) will appear under Workt
         const harnessRoot = resolveHarnessRoot(options.repoPath);
         const checkoutDir = resolveAgentWorkDir(harnessRoot, options.agentId) ?? harnessRoot;
         const runId = typeof result.data === "object" && result.data !== null && !Array.isArray(result.data) ? result.data.runId : void 0;
-        recordValidation({
+        const validation2 = recordValidation({
           checkoutDir,
           harnessRoot,
           status: verification.status,
@@ -52385,7 +52721,22 @@ Usage from Cursor / Claude / Codex (opentelemetry-hooks) will appear under Workt
           runId,
           agentId: options.agentId
         });
+        const session = readSlotRegistry(harnessRoot, options.agentId);
+        if (session?.workUnitId && session.attemptId) {
+          bindValidationToAttempt(harnessRoot, {
+            workUnitId: session.workUnitId,
+            attemptId: session.attemptId,
+            validation: validation2
+          });
+        }
         await syncRepoWithControlAsync(options.repoPath);
+        return {
+          code: shell.code,
+          stdout: shell.stdout,
+          stderr: shell.stderr,
+          verification,
+          validation: validation2
+        };
       } catch {
       }
     }
@@ -52423,6 +52774,7 @@ Usage from Cursor / Claude / Codex (opentelemetry-hooks) will appear under Workt
       };
     }
     let verification;
+    let validation2;
     if (!options.skipVerify) {
       const verify = await this.runVerification({
         repoPath: options.repoPath,
@@ -52432,6 +52784,7 @@ Usage from Cursor / Claude / Codex (opentelemetry-hooks) will appear under Workt
         trigger: options.trigger
       });
       verification = verify.verification;
+      validation2 = verify.validation;
       if (verify.code !== 0 || verification?.status !== "pass") {
         return {
           ...verify,
@@ -52439,6 +52792,24 @@ Usage from Cursor / Claude / Codex (opentelemetry-hooks) will appear under Workt
         };
       }
     }
+    if (session.workUnitId && session.attemptId && !options.skipVerify && !validation2) {
+      return {
+        code: 1,
+        stdout: "",
+        stderr: "Full verification passed, but HAR could not record exact-tree validation proof. Session NOT completed.",
+        verification
+      };
+    }
+    if (session.workUnitId && session.attemptId && validation2) {
+      decideWorkUnitOutcome(harnessRoot, session.workUnitId, {
+        decision: "completed",
+        decidedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        attemptId: session.attemptId,
+        validationId: validation2.validationId,
+        treeHash: validation2.treeHash
+      });
+      await syncRepoWithControlAsync(options.repoPath);
+    }
     const teardown = await this.teardownEnvironment({
       repoPath: options.repoPath,
       agentId: options.agentId,
@@ -52522,9 +52893,9 @@ var getEnvironmentLogs = defaultRunService.getEnvironmentLogs.bind(defaultRunSer
 var readline5 = __toESM(require("readline"));
 
 // src/core/hooks.ts
-var fs40 = __toESM(require("fs"));
+var fs41 = __toESM(require("fs"));
 var os13 = __toESM(require("os"));
-var path43 = __toESM(require("path"));
+var path44 = __toESM(require("path"));
 var MARKER_START = "# >>> har commit gate (managed by `har hooks`) >>>";
 var MARKER_END = "# <<< har commit gate <<<";
 var PRE_COMMIT_BLOCK = [
@@ -52549,7 +52920,7 @@ function resolveCheckoutRoot(cwd) {
 function resolveHooksDir(checkoutDir) {
   const hooksPath = tryGit3(checkoutDir, "rev-parse --git-path hooks");
   if (!hooksPath) throw new Error(`Not a git checkout: ${checkoutDir}`);
-  return path43.resolve(checkoutDir, hooksPath);
+  return path44.resolve(checkoutDir, hooksPath);
 }
 function getConfiguredHooksPath(checkoutDir) {
   return tryGit3(checkoutDir, "config core.hooksPath") || void 0;
@@ -52557,9 +52928,9 @@ function getConfiguredHooksPath(checkoutDir) {
 function defaultHarInvocation() {
   const entry = process.argv[1];
   if (entry && entry.endsWith(".js")) {
-    return `"${process.execPath}" "${path43.resolve(entry)}"`;
+    return `"${process.execPath}" "${path44.resolve(entry)}"`;
   }
-  if (entry) return `"${path43.resolve(entry)}"`;
+  if (entry) return `"${path44.resolve(entry)}"`;
   return "har";
 }
 function buildHookScript(harInvocation, subcommand, failOpenNotice) {
@@ -52580,40 +52951,40 @@ exit 0
 `;
 }
 function upsertMarkedBlock(filePath, block) {
-  if (!fs40.existsSync(filePath)) {
-    fs40.writeFileSync(filePath, `#!/bin/sh
+  if (!fs41.existsSync(filePath)) {
+    fs41.writeFileSync(filePath, `#!/bin/sh
 ${block}
 `, { mode: 493 });
     return "created";
   }
-  const content = fs40.readFileSync(filePath, "utf8");
+  const content = fs41.readFileSync(filePath, "utf8");
   if (content.includes(MARKER_START)) {
     const pattern = new RegExp(
       `${escapeRegExp(MARKER_START)}[\\s\\S]*?${escapeRegExp(MARKER_END)}`
     );
-    fs40.writeFileSync(filePath, content.replace(pattern, block));
-    fs40.chmodSync(filePath, 493);
+    fs41.writeFileSync(filePath, content.replace(pattern, block));
+    fs41.chmodSync(filePath, 493);
     return "updated";
   }
   const suffix = content.endsWith("\n") ? "" : "\n";
-  fs40.writeFileSync(filePath, `${content}${suffix}
+  fs41.writeFileSync(filePath, `${content}${suffix}
 ${block}
 `);
-  fs40.chmodSync(filePath, 493);
+  fs41.chmodSync(filePath, 493);
   return "appended";
 }
 function removeMarkedBlock(filePath) {
-  if (!fs40.existsSync(filePath)) return false;
-  const content = fs40.readFileSync(filePath, "utf8");
+  if (!fs41.existsSync(filePath)) return false;
+  const content = fs41.readFileSync(filePath, "utf8");
   if (!content.includes(MARKER_START)) return false;
   const pattern = new RegExp(
     `\\n?${escapeRegExp(MARKER_START)}[\\s\\S]*?${escapeRegExp(MARKER_END)}\\n?`
   );
   const stripped = content.replace(pattern, "\n");
   if (stripped.replace(/^#!\/bin\/sh\n?/, "").trim() === "") {
-    fs40.rmSync(filePath);
+    fs41.rmSync(filePath);
   } else {
-    fs40.writeFileSync(filePath, stripped);
+    fs41.writeFileSync(filePath, stripped);
   }
   return true;
 }
@@ -52635,20 +53006,20 @@ Or re-run with --force to write into that directory anyway.`
     );
   }
   const hooksDir = resolveHooksDir(checkout);
-  fs40.mkdirSync(hooksDir, { recursive: true });
+  fs41.mkdirSync(hooksDir, { recursive: true });
   const invocation = options.harInvocation ?? defaultHarInvocation();
-  fs40.writeFileSync(
-    path43.join(hooksDir, "har-pre-commit"),
+  fs41.writeFileSync(
+    path44.join(hooksDir, "har-pre-commit"),
     buildHookScript(invocation, "check", "har: binary not found; skipping commit gate (reinstall with har hooks install)"),
     { mode: 493 }
   );
-  fs40.writeFileSync(
-    path43.join(hooksDir, "har-post-commit"),
+  fs41.writeFileSync(
+    path44.join(hooksDir, "har-post-commit"),
     buildHookScript(invocation, "record-commit", "har: binary not found; skipping commit association"),
     { mode: 493 }
   );
-  const preCommit = upsertMarkedBlock(path43.join(hooksDir, "pre-commit"), PRE_COMMIT_BLOCK);
-  const postCommit = upsertMarkedBlock(path43.join(hooksDir, "post-commit"), POST_COMMIT_BLOCK);
+  const preCommit = upsertMarkedBlock(path44.join(hooksDir, "pre-commit"), PRE_COMMIT_BLOCK);
+  const postCommit = upsertMarkedBlock(path44.join(hooksDir, "post-commit"), POST_COMMIT_BLOCK);
   ensureValidationsIgnored(checkout);
   return { hooksDir, preCommit, postCommit };
 }
@@ -52657,12 +53028,12 @@ function uninstallHooks(repoPath) {
   if (!checkout) throw new Error(`Not a git repository: ${repoPath}`);
   const hooksDir = resolveHooksDir(checkout);
   let removed = false;
-  removed = removeMarkedBlock(path43.join(hooksDir, "pre-commit")) || removed;
-  removed = removeMarkedBlock(path43.join(hooksDir, "post-commit")) || removed;
+  removed = removeMarkedBlock(path44.join(hooksDir, "pre-commit")) || removed;
+  removed = removeMarkedBlock(path44.join(hooksDir, "post-commit")) || removed;
   for (const file of ["har-pre-commit", "har-post-commit"]) {
-    const full = path43.join(hooksDir, file);
-    if (fs40.existsSync(full)) {
-      fs40.rmSync(full);
+    const full = path44.join(hooksDir, file);
+    if (fs41.existsSync(full)) {
+      fs41.rmSync(full);
       removed = true;
     }
   }
@@ -52681,10 +53052,10 @@ function isAgentWorktree(checkoutDir) {
   if (branch && (/^har-agent-\d+$/.test(branch) || /-har-agent-\d+-[a-z0-9]+$/.test(branch))) {
     return true;
   }
-  const worktreesRoot = path43.join(os13.homedir(), "worktrees");
-  const resolved = path43.resolve(checkoutDir);
-  const name = path43.basename(resolved);
-  return resolved.startsWith(`${worktreesRoot}${path43.sep}`) && (/-agent-\d+$/.test(name) || /-har-agent-\d+-[a-z0-9]+$/.test(name));
+  const worktreesRoot = path44.join(os13.homedir(), "worktrees");
+  const resolved = path44.resolve(checkoutDir);
+  const name = path44.basename(resolved);
+  return resolved.startsWith(`${worktreesRoot}${path44.sep}`) && (/-agent-\d+$/.test(name) || /-har-agent-\d+-[a-z0-9]+$/.test(name));
 }
 function resolveEffectiveMode(checkoutDir, gate) {
   if (!gate.enabled) return "off";
@@ -52697,15 +53068,15 @@ function getHooksStatus(repoPath) {
   const hooksDir = resolveHooksDir(checkout);
   const gate = getCommitGateConfig(checkout);
   const hasBlock = (name) => {
-    const file = path43.join(hooksDir, name);
-    return fs40.existsSync(file) && fs40.readFileSync(file, "utf8").includes(MARKER_START);
+    const file = path44.join(hooksDir, name);
+    return fs41.existsSync(file) && fs41.readFileSync(file, "utf8").includes(MARKER_START);
   };
   return {
     checkout,
     hooksDir,
     configuredHooksPath: getConfiguredHooksPath(checkout),
-    preCommitInstalled: hasBlock("pre-commit") && fs40.existsSync(path43.join(hooksDir, "har-pre-commit")),
-    postCommitInstalled: hasBlock("post-commit") && fs40.existsSync(path43.join(hooksDir, "har-post-commit")),
+    preCommitInstalled: hasBlock("pre-commit") && fs41.existsSync(path44.join(hooksDir, "har-pre-commit")),
+    postCommitInstalled: hasBlock("post-commit") && fs41.existsSync(path44.join(hooksDir, "har-post-commit")),
     gate,
     effectiveMode: resolveEffectiveMode(checkout, gate)
   };
@@ -52716,7 +53087,7 @@ function checkCommitGate(cwd) {
   }
   const checkout = resolveCheckoutRoot(cwd);
   if (!checkout) return { exitCode: 0, messages: [] };
-  if (!fs40.existsSync(path43.join(checkout, ".har", "stages.json"))) {
+  if (!fs41.existsSync(path44.join(checkout, ".har", "stages.json"))) {
     return { exitCode: 0, messages: [] };
   }
   const gate = getCommitGateConfig(checkout);
@@ -52836,20 +53207,20 @@ async function handleCommitGateOnboarding(options) {
 }
 
 // src/core/onboarding-preferences.ts
-var fs41 = __toESM(require("fs"));
+var fs42 = __toESM(require("fs"));
 var os14 = __toESM(require("os"));
-var path44 = __toESM(require("path"));
+var path45 = __toESM(require("path"));
 function getOnboardingPreferencesPath() {
   if (process.env.HAR_PREFERENCES_PATH) {
-    return path44.resolve(process.env.HAR_PREFERENCES_PATH);
+    return path45.resolve(process.env.HAR_PREFERENCES_PATH);
   }
-  return path44.join(os14.homedir(), ".har", "preferences.json");
+  return path45.join(os14.homedir(), ".har", "preferences.json");
 }
 function readOnboardingPreferences() {
   const preferencePath = getOnboardingPreferencesPath();
   try {
-    if (!fs41.existsSync(preferencePath)) return OnboardingPreferencesSchema.parse({});
-    return OnboardingPreferencesSchema.parse(JSON.parse(fs41.readFileSync(preferencePath, "utf8")));
+    if (!fs42.existsSync(preferencePath)) return OnboardingPreferencesSchema.parse({});
+    return OnboardingPreferencesSchema.parse(JSON.parse(fs42.readFileSync(preferencePath, "utf8")));
   } catch {
     return OnboardingPreferencesSchema.parse({});
   }
@@ -52874,8 +53245,8 @@ function writeOnboardingPreferences(overrides) {
   };
   const parsed = OnboardingPreferencesSchema.parse(preference);
   const preferencePath = getOnboardingPreferencesPath();
-  fs41.mkdirSync(path44.dirname(preferencePath), { recursive: true });
-  fs41.writeFileSync(preferencePath, `${JSON.stringify(parsed, null, 2)}
+  fs42.mkdirSync(path45.dirname(preferencePath), { recursive: true });
+  fs42.writeFileSync(preferencePath, `${JSON.stringify(parsed, null, 2)}
 `);
   return parsed;
 }
@@ -53070,6 +53441,15 @@ var envCommand = {
       type: "boolean",
       default: false,
       describe: LAUNCH_RESUME_DESCRIBE
+    }).option("work-id", {
+      type: "string",
+      describe: "Bind this session to a durable external work identifier"
+    }).option("work-source", {
+      type: "string",
+      describe: "Optional provider/source name (for example github or linear)"
+    }).option("work-url", { type: "string", describe: "Optional source URL for the work" }).option("work-title", { type: "string", describe: "Optional human-readable title" }).option("parent-work-id", {
+      type: "string",
+      describe: "Optional parent work unit identifier"
     }).epilog(LAUNCH_EPILOG),
     handleLaunch
   ).command(
@@ -53146,7 +53526,7 @@ var envCommand = {
   }
 };
 async function handleInit(argv) {
-  const repoPath = path45.resolve(argv.repo);
+  const repoPath = path46.resolve(argv.repo);
   const onboarding = resolveOnboardingOptions(argv);
   header("har env init");
   info(`Repository: ${repoPath}`);
@@ -53210,7 +53590,7 @@ async function handleInit(argv) {
   }
 }
 async function handleMaintain(argv) {
-  const repoPath = path45.resolve(argv.repo);
+  const repoPath = path46.resolve(argv.repo);
   const onboarding = resolveOnboardingOptions(argv);
   header("har env maintain");
   info(`Repository: ${repoPath}`);
@@ -53325,7 +53705,7 @@ async function handleAgentMdProposal(repoPath, autoYes) {
   if (autoYes) {
     const proposal = readAgentMdProposal(repoPath);
     if (proposal) {
-      writeFileSafe(path45.join(repoPath, "AGENT.md"), proposal.content);
+      writeFileSafe(path46.join(repoPath, "AGENT.md"), proposal.content);
       clearAgentMdProposal(repoPath);
       info("Applied AGENT.md proposal (--yes)");
     }
@@ -53334,7 +53714,7 @@ async function handleAgentMdProposal(repoPath, autoYes) {
   await promptApplyAgentMdProposal(repoPath);
 }
 async function handleAddStage(argv) {
-  const repoPath = path45.resolve(argv.repo);
+  const repoPath = path46.resolve(argv.repo);
   const available = listStageTemplateIds();
   if (argv.list) {
     for (const id of available) {
@@ -53411,7 +53791,7 @@ async function handleAddStage(argv) {
   }
 }
 async function handlePreflight(argv) {
-  const repo = path45.resolve(argv.repo);
+  const repo = path46.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await preflightEnvironment({
     repoPath: repo,
@@ -53429,7 +53809,7 @@ async function handlePreflight(argv) {
   process.exit(result.code);
 }
 async function handleLaunch(argv) {
-  const repo = path45.resolve(argv.repo);
+  const repo = path46.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   let confirmReplace = argv.replace;
   let force = argv.force;
@@ -53481,6 +53861,11 @@ async function handleLaunch(argv) {
     confirmReplace,
     force,
     resume: argv.resume,
+    workUnitId: argv.workId,
+    source: argv.workSource,
+    sourceUrl: argv.workUrl,
+    title: argv.workTitle,
+    parentWorkUnitId: argv.parentWorkId,
     capture: false
   });
   if (result.blocked) {
@@ -53509,11 +53894,16 @@ async function handleRecover(argv) {
     claude: false,
     replace: false,
     force: false,
-    resume: true
+    resume: true,
+    workId: void 0,
+    workSource: void 0,
+    workUrl: void 0,
+    workTitle: void 0,
+    parentWorkId: void 0
   });
 }
 async function handleVerify(argv) {
-  const repo = path45.resolve(argv.repo);
+  const repo = path46.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await runVerification({
     repoPath: repo,
@@ -53525,7 +53915,7 @@ async function handleVerify(argv) {
   process.exit(result.code);
 }
 async function handleTeardown(argv) {
-  const repo = path45.resolve(argv.repo);
+  const repo = path46.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await teardownEnvironment({
     repoPath: repo,
@@ -53536,7 +53926,7 @@ async function handleTeardown(argv) {
   process.exit(result.code);
 }
 async function handleComplete(argv) {
-  const repo = path45.resolve(argv.repo);
+  const repo = path46.resolve(argv.repo);
   const agentId = validateAgentId(argv.id, repo);
   const result = await completeEnvironment({
     repoPath: repo,
@@ -53557,7 +53947,7 @@ async function handleComplete(argv) {
   process.exit(result.code);
 }
 async function handleStatus(argv) {
-  const repoPath = path45.resolve(argv.repo);
+  const repoPath = path46.resolve(argv.repo);
   if (argv.json) {
     const status = collectEnvironmentStatus(repoPath);
     const output = EnvironmentStatusSchema.parse(status);
@@ -53570,7 +53960,7 @@ async function handleStatus(argv) {
   });
 }
 async function handleRunsList(argv) {
-  const repoPath = path45.resolve(argv.repo);
+  const repoPath = path46.resolve(argv.repo);
   const runs = listRuns(repoPath, { stageId: argv.stage, limit: argv.limit });
   if (argv.json) {
     process.stdout.write(JSON.stringify({ runs }, null, 2) + "\n");
@@ -53587,7 +53977,7 @@ async function handleRunsList(argv) {
   }
 }
 async function handleRunsGet(argv) {
-  const run2 = getRun(path45.resolve(argv.repo), argv.runId);
+  const run2 = getRun(path46.resolve(argv.repo), argv.runId);
   if (!run2) {
     error(`Run not found: ${argv.runId}`);
     process.exit(1);
@@ -53666,20 +54056,20 @@ function printNextSteps(auto2) {
 }
 
 // src/cli/commands/control.ts
-var path47 = __toESM(require("path"));
+var path48 = __toESM(require("path"));
 init_control_config();
 
 // src/core/control-unregister.ts
-var fs42 = __toESM(require("fs"));
-var path46 = __toESM(require("path"));
+var fs43 = __toESM(require("fs"));
+var path47 = __toESM(require("path"));
 init_control_config();
 function listUnregisterWorktreeCandidates(repoPath) {
   const harnessRoot = canonicalizeControlRepoPath(repoPath);
   const byPath = /* @__PURE__ */ new Map();
   const add = (partial2) => {
-    const resolved = path46.resolve(partial2.worktreePath);
+    const resolved = path47.resolve(partial2.worktreePath);
     if (!resolved || resolved === harnessRoot) return;
-    const exists = partial2.exists ?? fs42.existsSync(resolved);
+    const exists = partial2.exists ?? fs43.existsSync(resolved);
     const prev = byPath.get(resolved);
     if (prev) {
       byPath.set(resolved, {
@@ -53793,28 +54183,28 @@ async function teardownWorktrees(repoPath, candidates, dryRun) {
         trigger: "cli"
       });
       if (result.code !== 0) {
-        if (fs42.existsSync(candidate.worktreePath)) {
-          fs42.rmSync(candidate.worktreePath, { recursive: true, force: true });
+        if (fs43.existsSync(candidate.worktreePath)) {
+          fs43.rmSync(candidate.worktreePath, { recursive: true, force: true });
         }
       }
       outcomes.push({
         path: candidate.worktreePath,
         agentId: candidate.agentId,
-        deleted: !fs42.existsSync(candidate.worktreePath),
-        error: result.code !== 0 && fs42.existsSync(candidate.worktreePath) ? result.stderr : void 0
+        deleted: !fs43.existsSync(candidate.worktreePath),
+        error: result.code !== 0 && fs43.existsSync(candidate.worktreePath) ? result.stderr : void 0
       });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       try {
-        if (fs42.existsSync(candidate.worktreePath)) {
-          fs42.rmSync(candidate.worktreePath, { recursive: true, force: true });
+        if (fs43.existsSync(candidate.worktreePath)) {
+          fs43.rmSync(candidate.worktreePath, { recursive: true, force: true });
         }
       } catch {
       }
       outcomes.push({
         path: candidate.worktreePath,
         agentId: candidate.agentId,
-        deleted: !fs42.existsSync(candidate.worktreePath),
+        deleted: !fs43.existsSync(candidate.worktreePath),
         error: message
       });
     }
@@ -53996,7 +54386,7 @@ async function handleDown() {
   process.exit(code);
 }
 async function handleRegister(argv) {
-  const repoPath = path47.resolve(argv.repo);
+  const repoPath = path48.resolve(argv.repo);
   header("har control register");
   info(`Repository: ${repoPath}`);
   try {
@@ -54020,7 +54410,7 @@ async function handleRegister(argv) {
   }
 }
 async function handleUnregister(argv) {
-  const repoPath = path47.resolve(argv.repo);
+  const repoPath = path48.resolve(argv.repo);
   const worktrees = listUnregisterWorktreeCandidates(repoPath);
   try {
     let deleteWorktrees = argv.deleteWorktrees;
@@ -54089,7 +54479,7 @@ async function handleUnregister(argv) {
   }
 }
 async function handleSync(argv) {
-  const repoPath = path47.resolve(argv.repo);
+  const repoPath = path48.resolve(argv.repo);
   try {
     await syncRepoWithControl({
       repoPath,
@@ -54128,7 +54518,7 @@ async function handleWatch(argv) {
   };
   const tick = async () => {
     if (argv.repo) {
-      await syncOne(path47.resolve(argv.repo));
+      await syncOne(path48.resolve(argv.repo));
       return;
     }
     try {
@@ -54159,11 +54549,11 @@ async function handleLogin(argv) {
 }
 
 // src/cli/commands/hooks.ts
-var path49 = __toESM(require("path"));
+var path50 = __toESM(require("path"));
 
 // src/core/claude-hooks.ts
-var fs43 = __toESM(require("fs"));
-var path48 = __toESM(require("path"));
+var fs44 = __toESM(require("fs"));
+var path49 = __toESM(require("path"));
 var CLAUDE_GUARD_RELATIVE_PATH = ".har/hooks/claude-worktree-guard.sh";
 var CLAUDE_SETTINGS_RELATIVE_PATH = ".claude/settings.json";
 var GUARD_MATCHER = "Edit|Write|MultiEdit|NotebookEdit";
@@ -54174,8 +54564,8 @@ function isHarGuardEntry(entry) {
   );
 }
 function readSettings(settingsPath) {
-  if (!fs43.existsSync(settingsPath)) return {};
-  const raw = fs43.readFileSync(settingsPath, "utf8").trim();
+  if (!fs44.existsSync(settingsPath)) return {};
+  const raw = fs44.readFileSync(settingsPath, "utf8").trim();
   if (raw === "") return {};
   const parsed = JSON.parse(raw);
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -54184,19 +54574,19 @@ function readSettings(settingsPath) {
   return parsed;
 }
 function writeSettings(settingsPath, settings) {
-  fs43.mkdirSync(path48.dirname(settingsPath), { recursive: true });
-  fs43.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  fs44.mkdirSync(path49.dirname(settingsPath), { recursive: true });
+  fs44.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function installClaudeGuard(repoPath) {
   const templatePath = resolveTemplateFile("claude-worktree-guard.sh.template");
   if (!templatePath) {
     throw new Error("Guard template not found (claude-worktree-guard.sh.template). Run npm run build.");
   }
-  const guardScript = path48.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
-  fs43.mkdirSync(path48.dirname(guardScript), { recursive: true });
-  fs43.copyFileSync(templatePath, guardScript);
-  fs43.chmodSync(guardScript, 493);
-  const settingsPath = path48.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
+  const guardScript = path49.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
+  fs44.mkdirSync(path49.dirname(guardScript), { recursive: true });
+  fs44.copyFileSync(templatePath, guardScript);
+  fs44.chmodSync(guardScript, 493);
+  const settingsPath = path49.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
   const settings = readSettings(settingsPath);
   const hooks = settings.hooks ?? {};
   const preToolUse = (hooks.PreToolUse ?? []).filter((entry) => !isHarGuardEntry(entry));
@@ -54210,15 +54600,15 @@ function installClaudeGuard(repoPath) {
 }
 function uninstallClaudeGuard(repoPath) {
   let removed = false;
-  const guardScript = path48.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
-  if (fs43.existsSync(guardScript)) {
-    fs43.rmSync(guardScript);
+  const guardScript = path49.join(repoPath, CLAUDE_GUARD_RELATIVE_PATH);
+  if (fs44.existsSync(guardScript)) {
+    fs44.rmSync(guardScript);
     removed = true;
-    const parent = path48.dirname(guardScript);
-    if (fs43.existsSync(parent) && fs43.readdirSync(parent).length === 0) fs43.rmdirSync(parent);
+    const parent = path49.dirname(guardScript);
+    if (fs44.existsSync(parent) && fs44.readdirSync(parent).length === 0) fs44.rmdirSync(parent);
   }
-  const settingsPath = path48.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
-  if (fs43.existsSync(settingsPath)) {
+  const settingsPath = path49.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
+  if (fs44.existsSync(settingsPath)) {
     const settings = readSettings(settingsPath);
     const preToolUse = settings.hooks?.PreToolUse;
     if (preToolUse) {
@@ -54243,8 +54633,8 @@ function uninstallClaudeGuard(repoPath) {
   return { removed };
 }
 function claudeGuardInstalled(repoPath) {
-  const settingsPath = path48.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
-  if (!fs43.existsSync(settingsPath)) return false;
+  const settingsPath = path49.join(repoPath, CLAUDE_SETTINGS_RELATIVE_PATH);
+  if (!fs44.existsSync(settingsPath)) return false;
   try {
     const settings = readSettings(settingsPath);
     return (settings.hooks?.PreToolUse ?? []).some(isHarGuardEntry);
@@ -54260,7 +54650,7 @@ function repoOption(y2) {
 function handleInstall2(argv) {
   try {
     if (argv.claude) {
-      const result2 = installClaudeGuard(path49.resolve(argv.repo));
+      const result2 = installClaudeGuard(path50.resolve(argv.repo));
       success("Claude Code worktree guard installed.");
       info(`Guard script:  ${result2.guardScript}`);
       info(`Settings:      ${result2.settingsPath} (PreToolUse: Edit|Write|MultiEdit|NotebookEdit)`);
@@ -54268,7 +54658,7 @@ function handleInstall2(argv) {
       info("Commit both files so the guard travels with the repo.");
       return;
     }
-    const result = installHooks({ repoPath: path49.resolve(argv.repo), force: argv.force });
+    const result = installHooks({ repoPath: path50.resolve(argv.repo), force: argv.force });
     success(`Commit gate installed in ${result.hooksDir}`);
     info(`pre-commit: ${result.preCommit}, post-commit: ${result.postCommit}`);
     info("Commits of unverified change batches will be blocked in agent worktrees.");
@@ -54281,7 +54671,7 @@ function handleInstall2(argv) {
 function handleUninstall(argv) {
   try {
     if (argv.claude) {
-      const result2 = uninstallClaudeGuard(path49.resolve(argv.repo));
+      const result2 = uninstallClaudeGuard(path50.resolve(argv.repo));
       if (result2.removed) {
         success("Claude Code worktree guard removed.");
       } else {
@@ -54289,7 +54679,7 @@ function handleUninstall(argv) {
       }
       return;
     }
-    const result = uninstallHooks(path49.resolve(argv.repo));
+    const result = uninstallHooks(path50.resolve(argv.repo));
     if (result.removed) {
       success(`Commit gate removed from ${result.hooksDir}`);
     } else {
@@ -54302,7 +54692,7 @@ function handleUninstall(argv) {
 }
 function handleStatus2(argv) {
   try {
-    const status = getHooksStatus(path49.resolve(argv.repo));
+    const status = getHooksStatus(path50.resolve(argv.repo));
     if (argv.json) {
       process.stdout.write(`${JSON.stringify(status, null, 2)}
 `);
@@ -54320,7 +54710,7 @@ function handleStatus2(argv) {
     );
     info(`Effective:     ${status.effectiveMode} (in this checkout)`);
     info(
-      `Claude guard:  ${claudeGuardInstalled(path49.resolve(argv.repo)) ? `installed (${CLAUDE_GUARD_RELATIVE_PATH})` : "not installed"}`
+      `Claude guard:  ${claudeGuardInstalled(path50.resolve(argv.repo)) ? `installed (${CLAUDE_GUARD_RELATIVE_PATH})` : "not installed"}`
     );
   } catch (err) {
     error(err instanceof Error ? err.message : String(err));
@@ -54581,10 +54971,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path52) {
-  if (!path52)
+function getElementAtPath(obj, path53) {
+  if (!path53)
     return obj;
-  return path52.reduce((acc, key) => acc?.[key], obj);
+  return path53.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -54904,11 +55294,11 @@ function aborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path52, issues) {
+function prefixIssues(path53, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path52);
+    iss.path.unshift(path53);
     return iss;
   });
 }
@@ -61382,7 +61772,7 @@ var Server = class extends Protocol {
 };
 
 // src/mcp/server.ts
-var path50 = __toESM(require("path"));
+var path51 = __toESM(require("path"));
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 var import_node_process2 = __toESM(require("node:process"), 1);
@@ -61553,13 +61943,20 @@ var LaunchEnvironmentInputSchema = external_exports.object({
   force: external_exports.boolean().default(false).describe(
     "Discard uncommitted changes in a dirty occupied worktree. Requires confirmReplace=true and explicit user approval \u2014 never set autonomously."
   ),
-  resume: external_exports.boolean().default(false).describe("Resume a failed or partial launch without creating a new worktree.")
+  resume: external_exports.boolean().default(false).describe("Resume a failed or partial launch without creating a new worktree."),
+  workUnitId: external_exports.string().min(1).max(128).optional(),
+  source: external_exports.string().min(1).max(64).optional(),
+  sourceUrl: external_exports.string().url().optional(),
+  title: external_exports.string().min(1).max(256).optional(),
+  parentWorkUnitId: external_exports.string().min(1).max(128).optional()
 });
 var LaunchEnvironmentOutputSchema = ShellRunOutputSchema.extend({
   previewUrls: external_exports.record(external_exports.string()).optional(),
   workDir: external_exports.string().optional().describe("Where the session code lives \u2014 ALL file edits must go under this path"),
   worktreePath: external_exports.string().optional(),
   branch: external_exports.string().optional(),
+  workUnitId: external_exports.string().optional(),
+  attemptId: external_exports.string().uuid().optional(),
   blocked: external_exports.boolean().optional(),
   occupiedSlot: external_exports.object({
     agentId: external_exports.number().int(),
@@ -61692,6 +62089,17 @@ var HAR_MCP_TOOLS = [
         resume: {
           type: "boolean",
           description: "Resume a failed or partial launch (status failed/starting) without confirmReplace. Preserves worktree and env."
+        },
+        workUnitId: {
+          type: "string",
+          description: "Durable external work identifier to bind to this session."
+        },
+        source: { type: "string", description: "Optional provider/source name." },
+        sourceUrl: { type: "string", description: "Optional source URL." },
+        title: { type: "string", description: "Optional human-readable work title." },
+        parentWorkUnitId: {
+          type: "string",
+          description: "Optional parent work unit identifier."
         }
       },
       ["agentId"]
@@ -61875,6 +62283,11 @@ async function handleMcpToolCall(toolName, args, defaultRepo = ".") {
         confirmReplace: input.confirmReplace,
         force: input.force,
         resume: input.resume,
+        workUnitId: input.workUnitId,
+        source: input.source,
+        sourceUrl: input.sourceUrl,
+        title: input.title,
+        parentWorkUnitId: input.parentWorkUnitId,
         capture: true
       });
       const parsed = LaunchEnvironmentOutputSchema.parse(result);
@@ -61894,6 +62307,11 @@ async function handleMcpToolCall(toolName, args, defaultRepo = ".") {
         confirmReplace: false,
         force: false,
         resume: true,
+        workUnitId: input.workUnitId,
+        source: input.source,
+        sourceUrl: input.sourceUrl,
+        title: input.title,
+        parentWorkUnitId: input.parentWorkUnitId,
         capture: true
       });
       const parsed = LaunchEnvironmentOutputSchema.parse(result);
@@ -62014,7 +62432,7 @@ async function handleMcpToolCall(toolName, args, defaultRepo = ".") {
       const input = ControlUpInputSchema.parse({ ...args, repo });
       const result = await startControlAndSync({
         detach: input.detach,
-        cwd: path50.resolve(input.repo)
+        cwd: path51.resolve(input.repo)
       });
       if (result.code !== 0) {
         return {
@@ -64128,9 +64546,9 @@ var import_run_async = __toESM(require_run_async(), 1);
 var import_mute_stream2 = __toESM(require_lib3(), 1);
 var import_ansi_escapes5 = __toESM(require_ansi_escapes(), 1);
 var _2 = {
-  set: (obj, path52 = "", value) => {
+  set: (obj, path53 = "", value) => {
     let pointer = obj;
-    path52.split(".").forEach((key, index, arr) => {
+    path53.split(".").forEach((key, index, arr) => {
       if (key === "__proto__" || key === "constructor")
         return;
       if (index === arr.length - 1) {
@@ -64141,8 +64559,8 @@ var _2 = {
       pointer = pointer[key];
     });
   },
-  get: (obj, path52 = "", defaultValue) => {
-    const travel = (regexp) => String.prototype.split.call(path52, regexp).filter(Boolean).reduce(
+  get: (obj, path53 = "", defaultValue) => {
+    const travel = (regexp) => String.prototype.split.call(path53, regexp).filter(Boolean).reduce(
       // @ts-expect-error implicit any on res[key]
       (res, key) => res !== null && res !== void 0 ? res[key] : res,
       obj
@@ -64506,7 +64924,7 @@ var preferencesCommand = {
 };
 
 // src/cli/commands/telemetry.ts
-var path51 = __toESM(require("path"));
+var path52 = __toESM(require("path"));
 init_control_config();
 init_otel_hooks();
 init_telemetry_config();
@@ -64591,7 +65009,7 @@ async function handleOff() {
   info("Mission Control will not auto-start. Existing usage rows are kept.");
 }
 async function handleWriteEnv(argv) {
-  const repoPath = path51.resolve(argv.repo);
+  const repoPath = path52.resolve(argv.repo);
   const harnessRoot = resolveHarnessRoot(repoPath);
   const session = readSlotRegistry(harnessRoot, argv.agentId);
   const workDir = argv.workDir ?? session?.workDir ?? repoPath;
@@ -64603,7 +65021,7 @@ async function handleWriteEnv(argv) {
     suffix,
     createdAt: session?.createdAt
   });
-  const envFile = argv.envFile ?? path51.join(workDir, `.env.agent.${argv.agentId}`);
+  const envFile = argv.envFile ?? path52.join(workDir, `.env.agent.${argv.agentId}`);
   const attrs = {
     sessionKey,
     agentId: argv.agentId,
@@ -64622,7 +65040,7 @@ async function handleWriteEnv(argv) {
   success(`Wrote session attribution to ${envFile}`);
 }
 function handlePrintEnv(argv) {
-  const repoPath = path51.resolve(argv.repo);
+  const repoPath = path52.resolve(argv.repo);
   const workDir = argv.workDir ?? repoPath;
   const sessionKey = buildSessionKey({
     branch: argv.branch,