skill-family-harness-node 0.19.0 → 0.19.2

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+<!-- release-skill:changelog:start version=0.19.2 locale=en baseline=sha256:ac3f4b15f249649e6bbae8c6a21e48f28fa206346108b21958a8daa22d85f243 -->
+## [0.19.2] - 2026-09-08
+
+Harness 0.19.2 aligns its package version with the Foundation Adoption Review distribution patch. Existing mechanisms and runtime behavior are unchanged.
+
+### Changed
+
+- Aligns the package version and release documentation with Foundation 0.19.2 without changing Harness implementation or driver behavior.
+
+### Upgrade Notes
+
+Pin all three Foundation packages to exactly 0.19.2. This patch adds no Harness capability and does not change host descriptors, drivers, since values, or maturity.
+<!-- release-skill:changelog:end version=0.19.2 locale=en -->
+
+
+<!-- release-skill:changelog:start version=0.19.1 locale=en baseline=sha256:76ded57ddca31105929a12a1b198bd6da407090e353dbf90096c17da5532a3ea -->
+## [0.19.1] - 2026-09-08
+
+Harness 0.19.1 makes the candidate mechanism-batch entry point settle on the current transfer's actual completion or failure while preserving caller ownership of programmatic streams.
+
+### Fixed
+
+- Waits for the current write callback, handles premature input and output closure, and removes only listeners installed by the batch helper.
+- Stops the library helper's own reading and releases its buffer after input overflow without destroying a caller-owned stream.
+- Releases CLI-owned standard input after an oversized request is reported, allowing the process to exit 2 while the upstream pipe remains open.
+
+### Upgrade Notes
+
+Pin all three Foundation packages to exactly 0.19.1. The batch operation, capacity policy, per-item order, and single-request CLI remain unchanged. This entry is candidate and requires re-verification after an upgrade.
+<!-- release-skill:changelog:end version=0.19.1 locale=en -->
+
+
 <!-- release-skill:changelog:start version=0.19.0 locale=en baseline=sha256:c3b3a06b509cc53719c2de75d1edacd22c1711c99c5f7687ad91f350976262e3 -->
 ## [0.19.0] - 2026-09-07
 

package/CHANGELOG.zh-CN.md

@@ -1,5 +1,37 @@
 # 变更日志
 
+<!-- release-skill:changelog:start version=0.19.2 locale=zh-CN baseline=sha256:aef79e7341fbe6581d798fd5d7371315c023b4a0c1733b094b13ce4166bfbcf3 -->
+## [0.19.2] - 2026-09-08
+
+Harness 0.19.2 将包版本与 Foundation Adoption Review 分发补丁对齐。既有机制和运行时行为保持不变。
+
+### 变更
+
+- 包版本和发布说明与 Foundation 0.19.2 数值对齐；Harness 实现和 driver 行为不变。
+
+### 升级说明
+
+三个 Foundation 包须一起精确锁定到 0.19.2。本补丁不增加 Harness 能力，不改变宿主 descriptor、driver、since 字段或成熟度。
+<!-- release-skill:changelog:end version=0.19.2 locale=zh-CN -->
+
+
+<!-- release-skill:changelog:start version=0.19.1 locale=zh-CN baseline=sha256:398aacf147e429237ff5b72fa1d22652afb76eb49da388eeb333d073bbd0a032 -->
+## [0.19.1] - 2026-09-08
+
+Harness 0.19.1 让候选机制批量入口等待本次传输真正完成或失败，同时保留程序化入口中调用方对流的所有权。
+
+### 修复
+
+- 等待本次写入回调，处理输入与输出提前关闭，并且只移除批量辅助函数自己安装的监听器。
+- 输入超限后停止库辅助函数自己的读取并释放缓存，不销毁调用方拥有的流。
+- 超限错误写出后释放 CLI 自己拥有的标准输入，使上游管道保持打开时进程仍能自行退出 2。
+
+### 升级说明
+
+三个 Foundation 包须一起精确锁定到 0.19.1。批量操作、容量政策、逐项顺序和旧单请求 CLI 保持不变。该入口仍是候选能力，升级后须重新验证。
+<!-- release-skill:changelog:end version=0.19.1 locale=zh-CN -->
+
+
 <!-- release-skill:changelog:start version=0.19.0 locale=zh-CN baseline=sha256:e0a716c69bbc9033af79ab9b1d1b607ba997b5324bb8301dfc8e0b7f4072dab2 -->
 ## [0.19.0] - 2026-09-07
 

package/README.md

@@ -4,28 +4,22 @@
 
 # skill-family-harness-node
 
-<!-- release-skill:release-version: 0.19.0 -->
+<!-- release-skill:release-version: 0.19.2 -->
 
 The **single default Node implementation** of the Contracts mechanism protocol. This is a thin runtime: it only implements the mechanism protocol, introduces no business semantics, and does not provide a second-language implementation.
 
 <!-- release-skill:managed:start id=latest-release -->
-**0.19.0** (2026-09-07)
+**0.19.2** (2026-09-08)
 
-Harness 0.19.0 adds runMechanismCliBatch and the explicit --batch CLI mode for bounded, ordered, same-operation batch transport, with canonical-json as the first operation.
-
-**Added**
-
-- Adds runMechanismCliBatch({input, output, error}) on the existing fixed mechanism CLI, reading one batch request and returning per-item results with inputIndex, exitCode, and the original single-request response.
-- Adds the explicit --batch mode to the official Bundle-projected mechanisms-cli.mjs. Without --batch the old single-request path is unchanged.
+Harness 0.19.2 aligns its package version with the Foundation Adoption Review distribution patch. Existing mechanisms and runtime behavior are unchanged.
 
 **Changed**
 
-- Batch structure and capacity refusals use TypeError with error.details.kind from the closed set batch-structure-invalid, batch-item-limit, batch-input-limit, and batch-output-limit.
-- A single item's mechanism failure is recorded in its result position and sibling items continue; the whole batch exits 2 when any item failed.
+- Aligns the package version and release documentation with Foundation 0.19.2 without changing Harness implementation or driver behavior.
 
 **Upgrade Notes**
 
-Pin all three Foundation packages to exactly 0.19.0. The fixed capacity policy is 256 items, 16 MiB input bytes, and 32 MiB output bytes; consumers own grouping independent requests and splitting oversized batches. This entry is candidate: re-verify after upgrading. The old single-request CLI keeps its previous contract.
+Pin all three Foundation packages to exactly 0.19.2. This patch adds no Harness capability and does not change host descriptors, drivers, since values, or maturity.
 <!-- release-skill:managed:end id=latest-release -->
 
 ## Problem It Solves
@@ -38,7 +32,7 @@ The Harness consumes `skill-family-contracts` (a workspace dependency), reusing
 
 ## Installation and Minimal Example
 
-Version 0.18.0 is a local candidate. Build all three tarballs into one temporary directory and install those exact files for a candidate check:
+Version 0.19.2 is the local source candidate. Build all three tarballs into one temporary directory and install those exact files for a candidate check:
 
 ```sh
 pack_dir="$(mktemp -d)"
@@ -46,13 +40,13 @@ pack_dir="$(mktemp -d)"
 (cd packages/skill-family-harness-node && pnpm pack --pack-destination "$pack_dir")
 (cd packages/skill-family-engineering-kit && pnpm pack --pack-destination "$pack_dir")
 mkdir "$pack_dir/consumer" && (cd "$pack_dir/consumer" && npm init -y)
-(cd "$pack_dir/consumer" && npm install "$pack_dir/skill-family-contracts-0.18.0.tgz" "$pack_dir/skill-family-harness-node-0.18.0.tgz" "$pack_dir/skill-family-engineering-kit-0.18.0.tgz")
+(cd "$pack_dir/consumer" && npm install "$pack_dir/skill-family-contracts-0.19.2.tgz" "$pack_dir/skill-family-harness-node-0.19.2.tgz" "$pack_dir/skill-family-engineering-kit-0.19.2.tgz")
 ```
 
 After publication, use the registry coordinate:
 
 ```sh
-npm install skill-family-harness-node@0.19.0
+npm install skill-family-harness-node@0.19.2
 npm info skill-family-harness-node --help
 ```
 
@@ -261,4 +255,4 @@ When the actual threat includes malicious concurrency, return a minimal upstream
 
 The separate candidate `observeExecutableIdentity({ boundRoots, lookup, interpreterPolicy? })` provides a read-only point-in-time observation of only the caller-explicit roots and lookup paths, for an immediate re-observation before launch. When an `/usr/bin/env` shebang resolves an interpreter through explicit `pathEntries`, the observation preserves the interpreter candidate's complete symlink chain rather than collapsing it to the final file. It is not part of `host-adapter` and does not prove wrapper control flow, ambient `PATH`, fd-exec/kernel image, signature trust, cross-call caching, host support/lifecycle, or domain acceptance; the caller owns those semantics. The candidate entry alone does not qualify a host.
 
-Version 0.18.0 is a local source candidate and is not published. Consume the three locally verified tarballs; a version marker, unit test or successful install is not complete contract integration, migration completion, or real-host qualification.
+Version 0.19.2 is the local source candidate. Remote availability must be established by the corresponding release-skill post-release evidence. Consume the three locally verified tarballs for candidate checks; a version marker, unit test, or successful install is not complete contract integration, migration completion, or real-host qualification.

package/README.zh-CN.md

@@ -5,28 +5,22 @@
 
 # skill-family-harness-node
 
-<!-- release-skill:release-version: 0.19.0 -->
+<!-- release-skill:release-version: 0.19.2 -->
 
 Contracts 机制协议的**唯一默认 Node 实现**。这是一个薄运行时（thin runtime）：只实现机制协议，不引入业务语义，不做第二语言实现。
 
 <!-- release-skill:managed:start id=latest-release -->
-**0.19.0** (2026-09-07)
+**0.19.2** (2026-09-08)
 
-Harness 0.19.0 在既有固定机制 CLI 上新增 runMechanismCliBatch 与显式 --batch 模式，提供有界、有序、同操作批量传输，首批操作 canonical-json。
-
-**新增**
-
-- 新增 runMechanismCliBatch({input, output, error})：读入一个批量请求，逐项返回 inputIndex、exitCode 与原单请求响应。
-- 官方 Bundle 投影的 mechanisms-cli.mjs 新增显式 --batch 模式。不带 --batch 时旧单请求路径不变。
+Harness 0.19.2 将包版本与 Foundation Adoption Review 分发补丁对齐。既有机制和运行时行为保持不变。
 
 **变更**
 
-- 批量结构与容量拒绝使用 TypeError，error.details.kind 封闭为 batch-structure-invalid、batch-item-limit、batch-input-limit、batch-output-limit。
-- 单项机制失败写入该项结果位置，其余项继续执行；任一机制项失败时整批退出码为 2。
+- 包版本和发布说明与 Foundation 0.19.2 数值对齐；Harness 实现和 driver 行为不变。
 
 **升级说明**
 
-三个 Foundation 包须一起精确锁定到 0.19.0。固定容量政策为 256 项、16 MiB 输入字节、32 MiB 输出字节；相互独立请求的分组与超限切分由消费者负责。该入口为候选能力，升级后须重新验证。旧单请求 CLI 合同保持不变。
+三个 Foundation 包须一起精确锁定到 0.19.2。本补丁不增加 Harness 能力，不改变宿主 descriptor、driver、since 字段或成熟度。
 <!-- release-skill:managed:end id=latest-release -->
 
 ## 解决的问题
@@ -39,7 +33,7 @@ Harness 消费 `skill-family-contracts`（工作区依赖），复用其方言
 
 ## 安装和最小示例
 
-0.18.0 是本地候选版本。候选验证先把三个包分别打入同一个临时目录，再安装这三个精确 tarball：
+0.19.2 是本地源码候选。候选验证先把三个包分别打入同一个临时目录，再安装这三个精确 tarball：
 
 ```sh
 pack_dir="$(mktemp -d)"
@@ -47,13 +41,13 @@ pack_dir="$(mktemp -d)"
 (cd packages/skill-family-harness-node && pnpm pack --pack-destination "$pack_dir")
 (cd packages/skill-family-engineering-kit && pnpm pack --pack-destination "$pack_dir")
 mkdir "$pack_dir/consumer" && (cd "$pack_dir/consumer" && npm init -y)
-(cd "$pack_dir/consumer" && npm install "$pack_dir/skill-family-contracts-0.18.0.tgz" "$pack_dir/skill-family-harness-node-0.18.0.tgz" "$pack_dir/skill-family-engineering-kit-0.18.0.tgz")
+(cd "$pack_dir/consumer" && npm install "$pack_dir/skill-family-contracts-0.19.2.tgz" "$pack_dir/skill-family-harness-node-0.19.2.tgz" "$pack_dir/skill-family-engineering-kit-0.19.2.tgz")
 ```
 
 发布后再使用 registry 坐标：
 
 ```sh
-npm install skill-family-harness-node@0.19.0
+npm install skill-family-harness-node@0.19.2
 npm info skill-family-harness-node --help
 ```
 
@@ -261,4 +255,4 @@ v2 机制会重算每个 path-backed output 和 evidence Resource 的真实字
 
 另一个独立候选 `observeExecutableIdentity({ boundRoots, lookup, interpreterPolicy? })` 只对调用方显式提供的根和查找路径做逐次只读观察，供正式启动前紧邻重观察。`/usr/bin/env` shebang 通过显式 `pathEntries` 找到解释器时，结果保留解释器候选的完整 symlink chain，不折叠成最终文件。它不属于 `host-adapter`，也不证明 wrapper 控制流、ambient `PATH`、fd-exec/内核映像、签名信任、跨调用缓存、宿主支持/生命周期或领域接受；这些语义仍由调用方负责。候选入口存在不等于宿主已获资格。
 
-0.18.0 为本地源码候选，尚未发布。消费本地已验证的三包 tarball；版本标记、单元测试或安装成功都不等于契约接入完成、迁移完成或真实宿主资格。
+0.19.2 是本地源码候选，远端可用性须由对应的 release-skill 发布后证据证明。候选检查使用本地已验证的三包 tarball；版本标记、单元测试或安装成功都不等于契约接入完成、迁移完成或真实宿主资格。

package/candidate/mechanisms-cli.mjs

@@ -176,21 +176,45 @@ function batchRefusal(kind, message) {
  * path releases this function's listeners; refusal never terminates the
  * caller process.
  */
-function readBoundedBatchInput(input, byteLimit) {
+function readBoundedBatchInput(input, byteLimit, outputWatch) {
   return new Promise((resolve, reject) => {
     const chunks = [];
     let received = 0;
+    let settled = false;
+    let preexistingErrorFallback;
+    let deferredFailure;
+    let stopWatchingOutput = () => {};
+    const startedFlowing = input.readableFlowing !== true && input.listenerCount("data") === 0;
     const cleanup = () => {
       input.removeListener("data", onData);
       input.removeListener("end", onEnd);
       input.removeListener("error", onError);
+      input.removeListener("close", onClose);
+      stopWatchingOutput();
+      if (preexistingErrorFallback !== undefined) {
+        clearImmediate(preexistingErrorFallback);
+        preexistingErrorFallback = undefined;
+      }
+    };
+    const rejectRead = (cause) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      chunks.length = 0;
+      if (
+        startedFlowing &&
+        input.readableFlowing === true &&
+        input.listenerCount("data") === 0
+      ) {
+        input.pause();
+      }
+      reject(cause);
     };
     const onData = (chunk) => {
       const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
       const next = received + bytes.length;
       if (next > byteLimit) {
-        cleanup();
-        reject(
+        rejectRead(
           batchRefusal(
             "batch-input-limit",
             `mechanism batch input exceeds ${byteLimit} raw UTF-8 bytes`,
@@ -202,16 +226,45 @@ function readBoundedBatchInput(input, byteLimit) {
       chunks.push(bytes);
     };
     const onEnd = () => {
+      if (settled) return;
+      settled = true;
       cleanup();
-      resolve(Buffer.concat(chunks));
+      const bytes = Buffer.concat(chunks, received);
+      chunks.length = 0;
+      resolve(bytes);
     };
     const onError = (cause) => {
-      cleanup();
-      reject(cause);
+      rejectRead(deferredFailure ?? cause);
+    };
+    const onClose = () => {
+      rejectRead(
+        deferredFailure ?? input.errored ?? new Error("mechanism batch input closed before the request ended"),
+      );
+    };
+    const onOutputFailure = (cause) => {
+      if (input.errored) {
+        deferredFailure ??= cause;
+        if (preexistingErrorFallback === undefined) {
+          preexistingErrorFallback = setImmediate(() => rejectRead(deferredFailure));
+        }
+        return;
+      }
+      rejectRead(cause);
     };
     input.on("data", onData);
     input.on("end", onEnd);
     input.on("error", onError);
+    input.on("close", onClose);
+    // A destroy(error) may have set `closed` while its public error event is
+    // still queued. Keep our listener through that event; the immediate also
+    // handles a stream whose error event had already been observed by callers.
+    if (input.errored) {
+      preexistingErrorFallback = setImmediate(() => rejectRead(deferredFailure ?? input.errored));
+    } else if (input.closed || input.readableEnded || input.destroyed) {
+      onClose();
+    }
+    stopWatchingOutput = outputWatch.onFailure(onOutputFailure);
+    if (settled) stopWatchingOutput();
   });
 }
 
@@ -250,31 +303,121 @@ function assertMechanismBatchShape(request) {
   }
 }
 
+// Keeps only the batch call's short-lived listeners active before the actual
+// write begins. This closes the gap where an already-destroyed Writable still
+// owes its public error event, without ending or otherwise managing the stream.
+function watchBatchWritable(stream, channelName) {
+  let failure = stream.errored;
+  let failureListener;
+  let pendingErrorFallback;
+  let resolvePendingError;
+  const pendingError = failure
+    ? new Promise((resolve) => {
+      resolvePendingError = resolve;
+      pendingErrorFallback = setImmediate(resolve);
+    })
+    : undefined;
+  const onError = (cause) => {
+    failure ??= cause;
+    failureListener?.(failure);
+    if (resolvePendingError) {
+      clearImmediate(pendingErrorFallback);
+      pendingErrorFallback = undefined;
+      const resolve = resolvePendingError;
+      resolvePendingError = undefined;
+      resolve();
+    }
+  };
+  const onClose = () => {
+    failure ??= stream.errored ?? new Error(
+      `mechanism batch ${channelName} closed before its write completed`,
+    );
+    failureListener?.(failure);
+  };
+  stream.on("error", onError);
+  stream.on("close", onClose);
+  if (!failure && (stream.closed || stream.writableEnded || stream.destroyed)) onClose();
+  return {
+    pendingError,
+    failure: () => failure,
+    onFailure(listener) {
+      failureListener = listener;
+      if (failure) listener(failure);
+      return () => {
+        if (failureListener === listener) failureListener = undefined;
+      };
+    },
+    release() {
+      failureListener = undefined;
+      stream.removeListener("error", onError);
+      stream.removeListener("close", onClose);
+      if (pendingErrorFallback !== undefined) clearImmediate(pendingErrorFallback);
+    },
+  };
+}
+
 /**
- * Waits until the writable accepted the whole payload, propagating both
- * synchronous write throws and asynchronous stream errors.
+ * Waits for this write's callback rather than treating the writable's buffer
+ * signal as delivery completion. The caller retains ownership of the stream,
+ * so completion neither ends it nor waits for the whole stream to finish.
  */
-function writeAll(stream, text) {
+function writeAll(stream, text, channelName) {
   return new Promise((resolve, reject) => {
-    const onError = (cause) => {
-      stream.removeListener("drain", onDrain);
+    let settled = false;
+    let callbackFailureFallback;
+    const cleanup = () => {
+      stream.removeListener("error", onError);
+      stream.removeListener("close", onClose);
+      if (callbackFailureFallback !== undefined) {
+        clearImmediate(callbackFailureFallback);
+        callbackFailureFallback = undefined;
+      }
+    };
+    const rejectWrite = (cause) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
       reject(cause);
     };
-    const onDrain = () => {
-      stream.removeListener("error", onError);
+    const onError = (cause) => {
+      rejectWrite(cause);
+    };
+    const onClose = () => {
+      rejectWrite(
+        stream.errored ?? new Error(`mechanism batch ${channelName} closed before its write completed`),
+      );
+    };
+    const onWrite = (cause) => {
+      if (settled) return;
+      if (cause) {
+        // A standard Writable emits its matching error just after invoking the
+        // write callback. Keep our listener through that event so the failure
+        // cannot become an unhandled error; the immediate is a fallback for a
+        // writable-like caller that reports only through the callback.
+        callbackFailureFallback = setImmediate(() => rejectWrite(cause));
+        return;
+      }
+      settled = true;
+      cleanup();
       resolve();
     };
     stream.on("error", onError);
+    stream.on("close", onClose);
+    // As with input, an errored destroy may still owe its public error event.
+    // Waiting for that event preserves the cause and prevents it from becoming
+    // unhandled after an eager preflight rejection.
+    if (stream.errored) {
+      callbackFailureFallback = setImmediate(() => rejectWrite(stream.errored));
+      return;
+    }
+    if (stream.closed || stream.writableEnded || stream.destroyed) {
+      onClose();
+      return;
+    }
     try {
-      if (stream.write(text)) {
-        stream.removeListener("error", onError);
-        resolve();
-        return;
-      }
-      stream.once("drain", onDrain);
+      stream.write(text, onWrite);
     } catch (cause) {
-      stream.removeListener("error", onError);
-      reject(cause);
+      rejectWrite(cause);
     }
   });
 }
@@ -298,8 +441,16 @@ export async function runMechanismCliBatch({
   error = stderr,
   invoke = invokeFoundationMechanism,
 } = {}) {
+  const outputWatch = watchBatchWritable(output, "output");
+  const errorWatch = watchBatchWritable(error, "error output");
   try {
-    const bytes = await readBoundedBatchInput(input, MECHANISM_BATCH_POLICY.inputByteLimit);
+    // Start the input read synchronously so a queued input error is covered
+    // before any output preflight can await or fail this batch.
+    const bytes = await readBoundedBatchInput(
+      input,
+      MECHANISM_BATCH_POLICY.inputByteLimit,
+      outputWatch,
+    );
     const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
     const request = JSON.parse(text);
     assertMechanismBatchShape(request);
@@ -337,18 +488,34 @@ export async function runMechanismCliBatch({
       fragments.push(fragment);
       if (exitCode === 2) anyItemFailure = true;
     }
+    const outputFailure = outputWatch.failure();
+    outputWatch.release();
+    if (outputFailure) throw outputFailure;
     await writeAll(
       output,
       `${BATCH_OUTPUT_PREFIX}${fragments.join(",")}${BATCH_OUTPUT_SUFFIX}`,
+      "output",
     );
+    if (errorWatch.pendingError) await errorWatch.pendingError;
+    errorWatch.release();
     return anyItemFailure ? 2 : 0;
   } catch (cause) {
-    try {
-      await writeAll(error, `${JSON.stringify(errorResponse(cause))}\n`);
-    } catch {
-      // The error channel itself failed; the batch still exits failed.
+    const pendingErrors = [outputWatch.pendingError, errorWatch.pendingError].filter(Boolean);
+    if (pendingErrors.length > 0) await Promise.all(pendingErrors);
+    outputWatch.release();
+    const errorFailure = errorWatch.failure();
+    errorWatch.release();
+    if (!errorFailure) {
+      try {
+        await writeAll(error, `${JSON.stringify(errorResponse(cause))}\n`, "error output");
+      } catch {
+        // The error channel itself failed; the batch still exits failed.
+      }
     }
     return 2;
+  } finally {
+    outputWatch.release();
+    errorWatch.release();
   }
 }
 
@@ -363,7 +530,9 @@ if (process.argv[1] && realpathSync(fileURLToPath(import.meta.url)) === realpath
       );
       process.exitCode = 2;
     } else {
-      process.exitCode = await runMechanismCliBatch();
+      const exitCode = await runMechanismCliBatch();
+      if (exitCode === 2 && !stdin.destroyed) stdin.destroy();
+      process.exitCode = exitCode;
     }
   } else {
     process.exitCode = await runMechanismCli();

package/package.json

@@ -10,7 +10,7 @@
   "dependencies": {
     "@pnpm/lockfile.fs": "1001.1.35",
     "ipaddr.js": "2.5.0",
-    "skill-family-contracts": "0.19.0",
+    "skill-family-contracts": "0.19.2",
     "yaml": "2.9.0"
   },
   "description": "Thin Node.js mechanism runtime for Skill Family engineering contracts.",
@@ -49,7 +49,7 @@
     "url": "https://github.com/ifoohoo/skill-family-harness-node.git"
   },
   "type": "module",
-  "version": "0.19.0",
+  "version": "0.19.2",
   "scripts": {
     "check": "node --test",
     "test": "node --test"

package/release-notes/0.19.1.yaml

@@ -0,0 +1,19 @@
+version: 0.19.1
+date: 2026-09-08
+locales:
+  en:
+    summary: Harness 0.19.1 makes the candidate mechanism-batch entry point settle on the current transfer's actual completion or failure while preserving caller ownership of programmatic streams.
+    changes:
+      fixed:
+        - Waits for the current write callback, handles premature input and output closure, and removes only listeners installed by the batch helper.
+        - Stops the library helper's own reading and releases its buffer after input overflow without destroying a caller-owned stream.
+        - Releases CLI-owned standard input after an oversized request is reported, allowing the process to exit 2 while the upstream pipe remains open.
+    upgradeNotes: Pin all three Foundation packages to exactly 0.19.1. The batch operation, capacity policy, per-item order, and single-request CLI remain unchanged. This entry is candidate and requires re-verification after an upgrade.
+  zh-CN:
+    summary: Harness 0.19.1 让候选机制批量入口等待本次传输真正完成或失败，同时保留程序化入口中调用方对流的所有权。
+    changes:
+      fixed:
+        - 等待本次写入回调，处理输入与输出提前关闭，并且只移除批量辅助函数自己安装的监听器。
+        - 输入超限后停止库辅助函数自己的读取并释放缓存，不销毁调用方拥有的流。
+        - 超限错误写出后释放 CLI 自己拥有的标准输入，使上游管道保持打开时进程仍能自行退出 2。
+    upgradeNotes: 三个 Foundation 包须一起精确锁定到 0.19.1。批量操作、容量政策、逐项顺序和旧单请求 CLI 保持不变。该入口仍是候选能力，升级后须重新验证。

package/release-notes/0.19.2.yaml

@@ -0,0 +1,15 @@
+version: 0.19.2
+date: 2026-09-08
+locales:
+  en:
+    summary: Harness 0.19.2 aligns its package version with the Foundation Adoption Review distribution patch. Existing mechanisms and runtime behavior are unchanged.
+    changes:
+      changed:
+        - Aligns the package version and release documentation with Foundation 0.19.2 without changing Harness implementation or driver behavior.
+    upgradeNotes: Pin all three Foundation packages to exactly 0.19.2. This patch adds no Harness capability and does not change host descriptors, drivers, since values, or maturity.
+  zh-CN:
+    summary: Harness 0.19.2 将包版本与 Foundation Adoption Review 分发补丁对齐。既有机制和运行时行为保持不变。
+    changes:
+      changed:
+        - 包版本和发布说明与 Foundation 0.19.2 数值对齐；Harness 实现和 driver 行为不变。
+    upgradeNotes: 三个 Foundation 包须一起精确锁定到 0.19.2。本补丁不增加 Harness 能力，不改变宿主 descriptor、driver、since 字段或成熟度。

package/src/version.mjs

@@ -1,2 +1,2 @@
 /** Exact Foundation release coordinate shared by the public Harness exports. */
-export const FOUNDATION_PACKAGE_VERSION = "0.19.0";
+export const FOUNDATION_PACKAGE_VERSION = "0.19.2";