@ycheung5/pi-computer-use 0.1.0 → 0.1.1

package/dist/pointer.d.ts

@@ -34,6 +34,16 @@ export declare const pointerTools: {
                 minItems: number;
                 maxItems: number;
             };
+            holdMs?: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            } | undefined;
+            timeoutMs?: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            } | undefined;
             windowRef: {
                 type: string;
                 minLength: number;
@@ -82,6 +92,16 @@ export declare const pointerTools: {
                 type: string;
                 default: boolean;
             };
+            holdMs?: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            } | undefined;
+            timeoutMs?: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            } | undefined;
             windowRef: {
                 type: string;
                 minLength: number;

package/dist/pointer.js

@@ -1,3 +1,4 @@
+import { pressTiming, timingMilliseconds } from "./input-timing.js";
 import { confirmInputCleanup, nativeDesktop, retainInput } from "./native.js";
 const integer = { type: "integer" };
 const target = {
@@ -20,6 +21,9 @@ export const pointerTools = ["click", "double_click", "move", "drag"].map((actio
         additionalProperties: false,
         properties: {
             ...target,
+            ...(action === "click"
+                ? { holdMs: timingMilliseconds, timeoutMs: timingMilliseconds }
+                : {}),
             ...(action === "drag"
                 ? {
                     path: {
@@ -84,6 +88,7 @@ export function validatePointer(action, args) {
                 "includeOffscreen",
                 ...(action === "move" ? [] : ["button", "dispatch"]),
             ]),
+        ...(action === "click" ? ["holdMs", "timeoutMs"] : []),
         ...(action === "scroll" ? ["deltaX", "deltaY", "browserTab"] : []),
     ]);
     if (args.windowRef !== undefined &&
@@ -115,6 +120,25 @@ export function validatePointer(action, args) {
     if (args.dispatch !== undefined &&
         !["auto", "background", "foreground"].includes(String(args.dispatch)))
         return bad("unsupported dispatch");
+    if (action === "click") {
+        try {
+            pressTiming(args, 90_000);
+        }
+        catch (cause) {
+            return {
+                ok: false,
+                action,
+                error: cause instanceof Error ? cause.message : String(cause),
+            };
+        }
+        if ((args.holdMs !== undefined || args.timeoutMs !== undefined) &&
+            (args.dispatch === "background" || args.activate === false))
+            return {
+                ok: false,
+                action,
+                error: "TIMING_UNSUPPORTED: click timing requires native foreground dispatch without explicit activate: false",
+            };
+    }
     if (action === "drag") {
         if (!Array.isArray(args.path) ||
             args.path.length < 2 ||

package/dist/text.d.ts

@@ -24,6 +24,16 @@ export declare const textTools: ({
                 type: string;
                 default: boolean;
             };
+            inputDelayMs: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            };
+            timeoutMs: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            };
             windowRef: {
                 type: string;
                 minLength: number;
@@ -55,6 +65,16 @@ export declare const textTools: ({
         type: string;
         additionalProperties: boolean;
         properties: {
+            holdMs: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            };
+            timeoutMs: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            };
             keys: {
                 type: string;
                 items: {

package/dist/text.js

@@ -1,3 +1,4 @@
+import { pressTiming, textTiming, timingMilliseconds } from "./input-timing.js";
 import { compileNative } from "./native.js";
 import { executePointer } from "./pointer.js";
 const target = {
@@ -28,6 +29,8 @@ export const textTools = [
                     default: "preserve",
                 },
                 restoreClipboard: { type: "boolean", default: true },
+                inputDelayMs: timingMilliseconds,
+                timeoutMs: timingMilliseconds,
             },
             required: ["text"],
         },
@@ -39,6 +42,8 @@ export const textTools = [
             additionalProperties: false,
             properties: {
                 ...target,
+                holdMs: timingMilliseconds,
+                timeoutMs: timingMilliseconds,
                 keys: {
                     type: "array",
                     items: { type: "string", minLength: 1 },
@@ -94,8 +99,15 @@ export function validateText(action, args) {
     const allowed = new Set([
         ...Object.keys(target),
         ...(action === "type_text"
-            ? ["text", "method", "focusMode", "restoreClipboard"]
-            : ["keys", "dispatch"]),
+            ? [
+                "text",
+                "method",
+                "focusMode",
+                "restoreClipboard",
+                "inputDelayMs",
+                "timeoutMs",
+            ]
+            : ["keys", "dispatch", "holdMs", "timeoutMs"]),
     ]);
     if (args.windowRef !== undefined &&
         (typeof args.windowRef !== "string" || !args.windowRef.trim()))
@@ -118,6 +130,12 @@ export function validateText(action, args) {
             args.text.length > 1000000 ||
             args.text.includes("\0"))
             return bad("text must be nonempty, without NUL, at most 1000000 UTF-16 units");
+        try {
+            textTiming(args, 90_000);
+        }
+        catch (cause) {
+            return error(String(cause instanceof Error ? cause.message : cause));
+        }
         if (args.method !== undefined &&
             !["auto", "clipboard", "sendinput", "background"].includes(String(args.method)))
             return bad("unsupported method");
@@ -129,6 +147,15 @@ export function validateText(action, args) {
             return bad("restoreClipboard must be boolean");
     }
     else {
+        try {
+            pressTiming(args, 90_000);
+        }
+        catch (cause) {
+            return error(String(cause instanceof Error ? cause.message : cause));
+        }
+        if ((args.holdMs !== undefined || args.timeoutMs !== undefined) &&
+            (args.dispatch === "background" || args.browserTab !== undefined))
+            return error("TIMING_UNSUPPORTED: keypress timing requires native foreground dispatch");
         if (!Array.isArray(args.keys) ||
             args.keys.length < 1 ||
             args.keys.length > 4 ||
@@ -155,8 +182,10 @@ export function validateText(action, args) {
                     return bad("unsupported key");
             }
         }
-        if (main !== 1)
-            return bad("exactly one non-modifier key is required");
+        if (main !== 1 && !(main === 0 && args.keys.length === 1))
+            return bad("one main key or one standalone generic modifier is required");
+        if (main === 0 && args.browserTab !== undefined)
+            return error("TIMING_UNSUPPORTED: standalone modifiers require native foreground dispatch");
         if (args.dispatch !== undefined &&
             !["foreground", "background"].includes(String(args.dispatch)))
             return bad("unsupported dispatch");

package/dist/worker.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { createInterface } from "node:readline";
 import { controlTools, executeAccessibility, observationTools, } from "./accessibility.js";
 import { browse, browserListing, clearBrowserIndicators, configureBrowser, disposeBrowser, isBrowserRequest, } from "./browser.js";
-import { browserActionTools } from "./browser-actions.js";
+import { browserActionRefusal, browserActionTools } from "./browser-actions.js";
 import { screenshot, screenshotParameters } from "./capture.js";
 import { disposeDesktop, listWindows, listWindowsParameters, retireDesktop, } from "./desktop.js";
 import { runNativeOperation } from "./native.js";
@@ -249,6 +249,13 @@ async function dispatch(request, signal) {
         process.stdout.write(`${JSON.stringify({ id: request.id, result: { ok: false, action: request.action, error: "INVALID_ARGUMENTS: windowRef requires a nonempty native-window reference and cannot target desktop/browser channel" } })}\n`);
         return;
     }
+    const browserRefusal = isBrowserRequest(request.args)
+        ? browserActionRefusal(request.action, request.args)
+        : undefined;
+    if (browserRefusal) {
+        process.stdout.write(`${JSON.stringify({ id: request.id, result: { ok: false, action: request.action, error: browserRefusal } })}\n`);
+        return;
+    }
     const denial = await settings.authorize(request.action);
     if (denial) {
         process.stdout.write(`${JSON.stringify({ id: request.id, result: { ok: false, action: request.action, error: denial } })}\n`);
@@ -343,6 +350,8 @@ async function dispatch(request, signal) {
             // stale/disabled/covered-point error can trigger replay.
             if ((request.args.dispatch === "background" ||
                 (request.action === "click" &&
+                    request.args.holdMs === undefined &&
+                    request.args.timeoutMs === undefined &&
                     request.args.elementId &&
                     (request.args.button ?? "left") === "left" &&
                     !request.args.activate &&
@@ -520,6 +529,10 @@ input.on("line", (line) => {
 });
 input.on("close", () => {
     clearInterval(presentationPoll);
+    // EOF is shutdown, including when a call deliberately disabled its deadline.
+    for (const request of requests.values())
+        if (request.action !== "operation_end")
+            void stopOperation(request.operationId).catch((error) => process.stderr.write(`${String(error)}\n`));
     process.stdout.write(`${JSON.stringify({ event: "shutdown_state", phase: "started" })}\n`);
     void queue
         .then(async () => {

package/docs/README.md

@@ -5,11 +5,12 @@ Read the row matching the task; follow section links before reading whole docume
 | Task | Read |
 | --- | --- |
 | Requirements and scope | [Spec: solution](spec.md#solution), [user stories](spec.md#user-stories), [out of scope](spec.md#out-of-scope) |
+| Modifier taps, holds and timing controls | [Input timing spec](spec.md#input-timing-and-modifier-taps), [delivery](implementation-plan.md#input-timing-delivery), [scoped acceptance](validation.md#input-timing-and-modifier-tap-acceptance) |
 | Implementation contracts | [Spec: implementation decisions](spec.md#implementation-decisions) |
 | Delivery, design review and feasibility | [Design revision](implementation-plan.md#design-revision), [plan: detailed milestones](implementation-plan.md#detailed-milestones), [feasibility gates](implementation-plan.md#feasibility-gates) |
 | Test design and release validation | [Spec: testing decisions](spec.md#testing-decisions), [plan: coverage matrix](implementation-plan.md#coverage-matrix) |
 | Pi acceptance, phased testing and agent recovery | [Current phases](implementation-plan.md#detailed-milestones), [baseline audit](validation.md#baseline-identity-and-schema-evidence), [guidance inventory](validation.md#model-visible-guidance-inventory), [scenario catalog](validation.md#alignment-scenario-catalog) |
-| Release checks, capability coverage and pending acceptance | [0.1.0 release preparation](validation.md#first-release-preparation), [current release audit](validation.md#final-release-audit), [capability coverage](validation.md#capability-coverage), [validation history](validation.md) |
+| Release checks, capability coverage and pending acceptance | [0.1.1 preparation and release notes](validation.md#011-release-preparation), [verified 0.1.0 npm release](validation.md#npm-publication-receipt), [0.1.0 release preparation](validation.md#first-release-preparation), [current release audit](validation.md#final-release-audit), [capability coverage](validation.md#capability-coverage), [validation history](validation.md) |
 | Pi interfaces and sources | [Pi extension research](pi-extension-research.md) (research context; current spec takes precedence over earlier proposals) |
 | Domain terminology | [Glossary](../GLOSSARY.md) |
 | Current Pi-first acceptance scope | [ADR 0004](adr/0004-pi-first-acceptance.md) |
@@ -27,8 +28,8 @@ Read the row matching the task; follow section links before reading whole docume
 | Scoped native document and visual agent acceptance | [Document workflow](validation.md#native-document-workflow), [handback continuation](validation.md#native-cancellation-and-handback-continuation), [opt-in visual runner](windows.md#scoped-visual-agent-check), [A04 evidence](validation.md#visual-ocr-association-preflight) |
 | Lifetime-bound native targeting and stale-reference behavior | [Window references](windows.md#window-lifetime-references), [accepted design](implementation-plan.md#window-lifetime-design) |
 | Native interop alternatives and tradeoffs | [Native interop research](native-interop-research.md) |
-| Guarded desktop pointer and dedicated input validation | [Pointer actions](pointer.md), [popup/menu/cross-process drop and restoration acceptance](validation.md#scoped-pointer-and-restoration-acceptance) |
-| Text, chords, clipboard preservation and validation | [Text entry](text.md), [chord/editor-focus acceptance](validation.md#pi-chords-and-editor-focus-acceptance), [clipboard acceptance](validation.md#pi-clipboard-contention-and-privacy-acceptance) |
+| Guarded desktop pointer and dedicated input validation | [Pointer actions](pointer.md), [single-click holds/deadlines](pointer.md#single-click-holds-and-deadlines), [popup/menu/cross-process drop and restoration acceptance](validation.md#scoped-pointer-and-restoration-acceptance) |
+| Text, chords, keypress timing, clipboard preservation and validation | [Text entry](text.md), [keypress timing](text.md#keypress-holds-and-deadlines), [text pacing](text.md#sendinput-pacing-and-deadlines), [chord/editor-focus acceptance](validation.md#pi-chords-and-editor-focus-acceptance), [clipboard acceptance](validation.md#pi-clipboard-contention-and-privacy-acceptance) |
 | Personal settings, commands and tool loading | [Settings](settings.md) |
 | Browser reads/actions, dedicated profiles, idle cleanup and fixtures | [Browser](browser.md) |
 | Domain-document consumer rules | [Domain docs](agents/domain.md) |

package/docs/implementation-plan.md

@@ -1,9 +1,23 @@
 # Pi computer-use implementation plan
 
-Status: Pi-first completion under [ADR 0004](adr/0004-pi-first-acceptance.md), agreed 2026-11-02. All 25 tools have implementations; remaining Pi acceptance is owned by the [current queue](tickets.md#execution-queue). DSH installation, manual comparisons, host/model runs and parity benchmarks are not release prerequisites. No release is declared.
+Status: 0.1.0 is published with its recorded acceptance limits. Post-release delivery is owned by the [current queue](tickets.md#execution-queue), including the agreed input-timing change below. [ADR 0004](adr/0004-pi-first-acceptance.md) remains binding; DSH/manual parity runs are not prerequisites.
 
 Requirements and behavioral contracts are authoritative in the [specification](spec.md). Use the [documentation index](README.md) to load only relevant context.
 
+## Input timing delivery
+
+The [input timing/modifier-tap spec](spec.md#input-timing-and-modifier-taps) is the only requirement authority for this first post-release change. It extends existing tools. All three slices are implemented and accepted at the agreed seams, merged into main through PR #44 and prepared for 0.1.1. The [composed receipt](validation.md#input-timing-and-modifier-tap-acceptance) owns the source scope, final checks, live results and fixture-failure dispositions. Published npm 0.1.0 remains unchanged.
+
+1. Extend existing action schemas/normalizers and public tool/worker tests for standalone generic modifiers, timing values, route capability refusal and unchanged defaults.
+2. Keep per-call duration/deadline calculation in reusable request handling rather than duplicate it in host adapters. Thread effective policy through Pi/worker/native execution so omitted, explicit positive and disabled execution deadlines remain consistent. Reuse controlled request peers for long-duration/overflow/cancellation checks without real long sleeps; do not add a general scheduler or test-only production API.
+3. Extend native text/pointer execution with cancellable, representable pacing/hold waits and release acknowledgments using current input ownership. Keep each hold within one call and retain target/focus/protection checks. Reject unsupported explicit backend combinations before dispatch.
+4. Run affected configured regressions and package checks; extend the current owned text/pointer fixtures for one grouped live acceptance of actual down/up effects, exact text and newly affected cleanup. Exercise both host request paths only where changed forwarding requires it. Reuse accepted stop/display/profile evidence and retain any observed failures.
+5. Reconcile the existing topic docs/tool descriptions with the implemented fields and record validation. The second input-coverage change and any release/version bump need their own delivery work; do not expand this slice or mark it complete from portable mocks alone.
+
+The delivery is complete for #41 keyboard, #42 text and #43 mouse. Reuse the linked acceptance; do not rerun historical release checks. Future broader input coverage and any merge/version/publication remain separate work.
+
+Existing code locations for implementation navigation: `src/text.ts`, `src/pointer.ts` and `src/browser-actions.ts` own routed argument contracts; `src/extension.ts`, `src/client.ts`, `src/native.ts` and `src/worker.ts` own forwarding, deadlines and lifecycle; `assets/text.cs` and `assets/pointer.cs` own native effects/release. Prefer existing `tests/text.test.ts`, `tests/pointer.test.ts`, `tests/worker.test.ts`, input-preparation/extension tests and native text/pointer fixtures. These are delivery pointers, not a new shared-module hierarchy.
+
 ## Structure
 
 Keep flat, responsibility-named TypeScript modules in `src/`, tests in `tests/`, and packaged assets in `assets/`. Keep host-specific launcher and Windows interop logic separate from reusable orchestration through modules, without pre-creating nested directories. The [repository layout](README.md#repository-layout) is the navigation guide.

package/docs/pointer.md

@@ -14,6 +14,18 @@ A missing cleanup acknowledgment retains desktop ownership and blocks replacemen
 
 Confirmed activation and successful input/background operations remember the exact target HWND/PID for this operation. Later targetless observations and input use that identity after foreground is returned. Explicit targets, browser requests, element references and explicit desktop scope take precedence. Settlement clears the remembered target; a stale identity fails rather than guessing the user's current foreground. Screenshots retain their existing full-desktop versus window-capture semantics.
 
+## Single-click holds and deadlines
+
+The source candidate adds optional `holdMs` and `timeoutMs` to single `click` for existing left/right/middle buttons. Omitted or zero hold releases immediately. Explicit timing uses native foreground dispatch, including auto element clicks; explicit `dispatch: background`, `activate: false` and browser targets refuse before input. With both fields omitted, existing routing and activation rules above apply. Double-click and drag do not accept timing fields.
+
+Both request layers reuse the [keypress timing policy](text.md#keypress-holds-and-deadlines): positive timeout is authoritative, zero disables only the execution deadline, and omission adds an explicit hold to the ordinary budget. Safe whole nonnegative milliseconds have no product cap; invalid values and derived overflow refuse before input. Native waits use bounded interruptible intervals and check target, foreground, point, protection and pointer interference throughout a positive hold. Zero/omitted holds retain immediate release without a new post-down target check that could reject a dialog opened by the click.
+
+Results report effective `timing` (`holdMs`, `timeoutMs`, `deadlinePolicy`), `inputDispatched`, interruption and `cleanupConfirmed`. Dispatch remains distinct from an observed application effect. Release runs before pointer/foreground restoration. Unconfirmed release retains ownership and blocks dependent work; timeout, cancellation and partial input never trigger replay.
+
+The existing owned fixture prepares scoped acceptance with `npm run test:native:pointer:physical -- --list --case=timing` (safe planning only). The Pi-only `--case=timing` run requires a build, Windows Node and `PI_CU_DEDICATED_INPUT_DESKTOP=1` on the authorized idle test desktop. It observes actual button messages/timestamps and OS state for default click/restoration, zero hold, timed left/right/middle, a covering-target error, shorter deadline and cancellation of a representable very long hold with deadline disabled. Failure or unconfirmed cleanup retains the owner and fixture. This case does not rerun the old physical baseline or physical Esc demonstration.
+
+Portable worker/peer checks verify schema, route refusals, two-layer timing forwarding, default/positive/disabled deadlines, long values, overflow, shutdown and ownership retention without sleeping for long requested durations. Native compilation and the scoped actual fixture effects passed; see the [composed receipt](validation.md#input-timing-and-modifier-tap-acceptance). Portable results alone do not establish physical input timing.
+
 ## Validation
 
 - `npm test`: worker argument validation and the public worker lifecycle contract that prevents retirement while cleanup is unconfirmed. These portable tests do not prove Windows input delivery.

package/docs/runtime.md

@@ -12,7 +12,7 @@ A checksum mismatch fails explicitly; remove only the indicated runtime cache an
 
 From WSL2, a bounded fixed-variable `cmd.exe /u /d` query discovers the Windows data directory and architecture. UTF-16LE decoding preserves Unicode, and environment values are never interpolated into commands. Discovery is shared with personal settings and cached for subsequent launcher calls. `wslpath` translates the mounted runtime cache and the compiled worker location, including WSL UNC paths. The launcher executes that same private Windows Node directly with argument arrays, keeping protocol stdout separate from bootstrap diagnostics; it never sends a Linux PID to a Windows process API. Windows executable interop and `cmd.exe`/`wslpath` must be available; browser discovery and some native fixtures also use Windows PowerShell. A failed bootstrap reports `WSL_BOOTSTRAP_FAILED` with its cause.
 
-The runtime and worker start on first tool execution, not extension registration. Restoring tool exposure reads personal settings at session startup; in WSL2 this performs the small shared environment lookup but does not provision or start the worker. The cross-host settings fixture measured 39 ms for this first lookup on the tested host (a prior PowerShell query took about 1.2 seconds); this is measured overhead, not a zero-cost startup claim. The worker stays available until session shutdown/reload. Startup provisioning is cancelled on shutdown, even if a provider fails to observe the abort signal. Worker timeouts reject pending work and retire the worker; a later call can start a replacement. Input is never automatically replayed.
+The runtime and worker start on first tool execution, not extension registration. Restoring tool exposure reads personal settings at session startup; in WSL2 this performs the small shared environment lookup but does not provision or start the worker. The cross-host settings fixture measured 39 ms for this first lookup on the tested host (a prior PowerShell query took about 1.2 seconds); this is measured overhead, not a zero-cost startup claim. The worker stays available until session shutdown/reload. Startup provisioning is cancelled on shutdown, even if a provider fails to observe the abort signal. Worker timeouts reject pending work and retire the worker when ownership permits; a later call can start a replacement. Keypress, single-click and explicit SendInput text execution deadlines first request cooperative cancellation and retain the cleanup reply during an independent five-second grace. Optional hold/pacing and positive/disabled deadline policies cross both request layers; see [keypress timing](text.md#keypress-holds-and-deadlines), [text pacing](text.md#sendinput-pacing-and-deadlines) and [single-click timing](pointer.md#single-click-holds-and-deadlines). Worker shutdown also signals active operations when an execution deadline is disabled. Input is never automatically replayed.
 
 ## Interfaces for implementation
 

package/docs/spec.md

@@ -1,6 +1,6 @@
 # Pi Windows Computer Use
 
-Status: agreed scope. Original product specification: [GitHub issue #1](https://github.com/ycheung5/pi-computer-use/issues/1). Current Pi-first acceptance is tracked by the existing product issues and release gate [#21](https://github.com/ycheung5/pi-computer-use/issues/21). [ADR 0004](adr/0004-pi-first-acceptance.md) supersedes mandatory DSH parity; historical alignment records are not current release gates.
+Status: agreed scope. Original product specification: [GitHub issue #1](https://github.com/ycheung5/pi-computer-use/issues/1). Version 0.1.0 is published and its product/release owners are completed. The post-release [input timing and modifier-tap specification](#input-timing-and-modifier-taps) is merged into main for 0.1.1; it is not part of published 0.1.0. [ADR 0004](adr/0004-pi-first-acceptance.md) supersedes mandatory DSH parity; historical alignment records are not current release gates.
 
 ## Problem Statement
 
@@ -156,6 +156,75 @@ Accepted product decision, 2026-11-01; scoped control (#31) and presentation/dis
 
 ## Further Notes
 
-The initial implementation exists; acceptance remains incomplete. Follow the [current outcome map and queue](tickets.md#delivery-outcomes-and-ownership), [implementation plan](implementation-plan.md#detailed-milestones) and [validation catalog](validation.md#alignment-scenario-catalog). Each runnable scenario proceeds through baseline, diagnosis, targeted repair and affected regressions; final reconciliation and optimization follow the required outcomes. Pi functional and preservation requirements remain binding; removed DSH comparison gates must not be reintroduced through historical notes.
+Version 0.1.0 is published with its scoped acceptance and documented limitations. The input-timing change below is merged into main for 0.1.1 with scoped acceptance recorded. Follow the [current outcome map and queue](tickets.md#delivery-outcomes-and-ownership), [input-timing delivery plan](implementation-plan.md#input-timing-delivery) and [validation receipts](validation.md#npm-publication-receipt). Each runnable scenario proceeds through baseline, diagnosis, targeted repair and affected regressions; final reconciliation and optimization follow the required outcomes. Pi functional and preservation requirements remain binding; removed DSH comparison gates must not be reintroduced through historical notes.
 
 Issue tracker: [ycheung5/pi-computer-use](https://github.com/ycheung5/pi-computer-use). See [tracker configuration](agents/issue-tracker.md) for operations and [triage labels](agents/triage-labels.md) for status vocabulary.
+
+## Input timing and modifier taps
+
+Status: implemented, accepted and merged through PR #44 for 0.1.1, 2026-11-10; [GitHub specification #40](https://github.com/ycheung5/pi-computer-use/issues/40). The following template is the canonical first-change requirement set. See the [composed receipt](validation.md#input-timing-and-modifier-tap-acceptance). These new parameters are not in the unchanged published npm 0.1.0.
+
+### Problem Statement
+
+Pi users cannot tap Ctrl, Alt or Shift alone, request a timed key/button press, or adjust the fixed SendInput typing delay. Long requested input durations also conflict with execution deadlines inside the Windows worker and at the Pi boundary. Agents need explicit per-call controls that preserve existing behavior when omitted and retain stopping, cleanup and non-replay guarantees. This addresses input flexibility; the cause of the user's whole-task slowness has not been measured.
+
+### Solution
+
+Extend the existing keypress, click and text-entry tools with standalone generic modifier taps and opt-in per-call timing. Every press/hold completes and releases inside one tool call. Agents can choose a typing interval, hold duration and execution timeout, including disabling that execution timeout. Keep the existing Pi extension and Windows worker; add no new tool family, MCP server or persistent held-input state.
+
+### User Stories
+
+1. As an agent, I want to tap Ctrl alone, so that applications can respond to a standalone modifier.
+2. As an agent, I want to tap Alt or Shift alone, so that modifier-only interactions are available.
+3. As a user, I want existing shortcuts unchanged, so that upgrading preserves current workflows.
+4. As an agent, I want to hold a supported key or chord for a requested duration, so that I can perform a long press.
+5. As an agent, I want to hold a supported mouse button at the selected target, so that I can perform a long mouse press.
+6. As a user, I want each held input released before its call completes, so that the model cannot leave a key down while thinking.
+7. As an agent, I want an explicit SendInput typing interval, so that I can adapt pacing to an application's behavior.
+8. As a user, I want the existing 50 ms typing interval when omitted, so that the compatibility baseline remains available.
+9. As an agent, I want zero typing delay where appropriate, so that I can request unpaced dispatch explicitly.
+10. As a user, I want no arbitrary duration ceiling, so that the extension does not guess how long my task should take.
+11. As an agent, I want a per-call execution timeout, so that I can choose how long to wait for that operation.
+12. As an agent, I want zero timeout to disable the execution deadline, so that an intentional long operation is not cut short by that deadline.
+13. As an agent, I want default deadlines to accommodate explicit timing, so that accepted long-duration requests can finish.
+14. As a user, I want Esc and cancellation to interrupt waits, so that increasing durations does not prevent stopping.
+15. As a user, I want input released after errors, shutdown or cancellation, so that failures do not leave controls held.
+16. As a user, I want uncertain cleanup to retain ownership and block dependent work, so that subsequent input does not compound uncertainty.
+17. As an agent, I want unsupported method/parameter combinations rejected before input, so that my requested method is not silently changed.
+18. As an agent, I want actual timing settings and dispatch status reported, so that I can distinguish configuration from observed task success.
+19. As a user, I want partial or stopped input never automatically replayed, so that changing timing cannot duplicate actions.
+20. As a maintainer, I want native Windows and WSL2 callers to share the same contract, so that host routing does not change timing semantics.
+21. As a maintainer, I want focused regression and owned-fixture checks, so that this update does not reopen accepted release tests.
+22. As a user, I want broader keyboard/mouse coverage delivered separately, so that the first change stays small and reviewable.
+
+### Implementation Decisions
+
+- Extend existing input schemas, route validation, Pi integration, request/deadline handling and native input execution. Preserve the current module responsibilities and independent emergency-stop helper. No new dependencies, public test API, general scheduler or persistent down/up API.
+- Accept one standalone generic Ctrl/Control, Alt/Option or Shift modifier in keypress. Existing supported ordinary keys/chords remain supported. Multiple modifiers without a main key are not newly promised. Existing aliases and malformed/duplicate-key validation remain applicable.
+- Add optional holdMs to keypress and single click only. Omission preserves current immediate release; zero explicitly requests immediate release. For a chord, hold its pressed main key and modifiers together, then release all held inputs. For a click, press the selected supported button at the resolved target, wait, and release. Existing targeting, foreground intent and restoration rules continue to apply. No new auto-repeat guarantee is implied by a held key.
+- Add optional inputDelayMs to type_text only with explicitly selected sendinput. Omission preserves the existing 50 ms pacing. Zero requests no intentional inter-unit delay. Keep current Unicode/newline/tab handling; the unit is the actual dispatched UTF-16 input unit, with the existing newline normalization. This is not a promise of exact application processing time or universal correctness at lower intervals.
+- Add optional timeoutMs to type_text, keypress and single click only. A positive value supplies the requested execution deadline; zero disables that call's execution deadline through all relevant input execution layers. An explicit shorter timeout is honored, not silently extended, and may end partial input with the existing cleanup/non-replay result.
+- With timeoutMs omitted, ordinary calls retain current deadline behavior. When holdMs or inputDelayMs is explicitly supplied, derive sufficient default execution budgets from the requested hold/pacing duration plus existing execution overhead allowances. Both the native-helper request and outer Pi-worker request must accommodate it; an inner 40-second or outer 90-second timer must not silently override the accepted contract.
+- Timing arguments are non-negative safe whole milliseconds, without arbitrary product ceilings. Reject negative, fractional, non-finite, unsafe or otherwise unrepresentable values and unrepresentable derived durations before input. Long waits must not wrap, clamp to a short timer, or accidentally mean infinity because of an underlying API integer limit. Zero has the parameter-specific meanings above.
+- Disabling the execution deadline does not disable explicit cancellation, shutdown handling, emergency stopping, target/protection checks or cleanup acknowledgments. Existing startup, target-resolution and cleanup safeguards remain independent. Timing is best effort, not a hard real-time guarantee.
+- Validate backend/method capability before sending input. The first slice requires native foreground timed holds and explicit native SendInput pacing. A selected browser/background/quiet route must either honor the requested semantics or return a clear unsupported-combination error before input. Do not silently ignore a parameter, switch an explicit method, or escalate an explicit background request. Existing auto routing remains unchanged when new parameters are omitted; its resolution with new parameters must honor them or refuse before dispatch. This slice does not promise universal browser/background long-press support.
+- Preserve exclusive control, visible local border, target identity/focus/occlusion checks, protection during tool gaps, clipboard preservation and human handback. Cancellation/error/shutdown must release agent-held input, or explicitly report unconfirmed cleanup and block dependent work. No automatic replay or forced termination of an uncertain input owner.
+- Report the effective requested timing/deadline policy, whether input was dispatched or interrupted, and existing cleanup confirmation. A successful dispatch does not establish an observed application effect. Existing result fields retain their meaning.
+- Keep the current Pi package and tool names. The published 0.1.0 remains unchanged; implementation and any later publication are separate work.
+
+### Testing Decisions
+
+- Reuse the confirmed public Pi-tool and worker request/cancellation interfaces as the highest practical seams. Extend existing schema, input-preparation, text, pointer and worker/transport tests; do not add a new framework or public timing-test interface.
+- Test externally visible validation, routing, effects and cleanup results rather than private state. Cover modifier taps, existing chords, omitted/zero/positive timing, representable large values and derived overflow, invalid values, unsupported routes and no input before refusal.
+- Use existing controllable worker peers and owned fixtures to test omitted/positive/disabled execution deadlines at both request layers, a deliberately shorter timeout, cancellation during a long requested interval and release/ownership uncertainty. Use short deterministic simulations for very long values and timer-overflow cases; tests must not sleep for the full requested durations.
+- Extend the existing native text and pointer fixtures for one grouped scoped Windows acceptance: standalone modifier down/up events, a timed key/chord and mouse press/release, explicit typing intervals with exact Unicode readback, default pacing regression, and stop/error cleanup of newly held inputs. Observe events/effects independently of returned dispatch success. Reuse existing stop/control evidence; repeat a physical Esc demonstration only if the changed mechanism or a failure specifically requires it.
+- Check relevant Pi/WSL2-to-Windows and native request forwarding so no layer drops a field or restores a hidden default deadline. Keep these checks scoped to changed behavior; no new paid-model reset series, DSH comparison or unrelated display/browser/profile acceptance.
+- Run configured portable checks and actual package/documentation validation for implementation. Record unrun live prerequisites and limitations honestly. Passing mocks do not establish real Windows input effects; exact-text verification is required before claiming lower pacing correct.
+
+### Out of Scope
+
+Broader named-key coverage, Windows keys, left/right modifiers, numpad/media keys, mouse side buttons and modifier-click/drag are deferred to the second change. Also excluded: raw virtual-key/scan-code input, holds across calls, separate key-down/up tools, double-click/drag timing controls, privileged or device-specific integrations, secure-desktop bypass, changing default typing pace, global timeout removal, a new MCP adapter, universal device/application coverage and diagnosing or claiming a fix for unmeasured whole-task latency.
+
+### Further Notes
+
+The user confirmed this first-change scope after choosing a two-change delivery. Existing 0.1.0 acceptance remains closed and reusable. This spec describes the implementation merged into main for 0.1.1; the unchanged npm 0.1.0 does not accept the new timing parameters. Readable key names remain the agent-facing interface. Required input release and uncertain-cleanup safeguards qualify every duration/timeout option. Future broader input coverage must be specified and accepted separately rather than silently added here.

package/docs/text.md

@@ -2,15 +2,35 @@
 
 The candidate acquires [exclusive control](spec.md#exclusive-control) before physical text entry. Suppressed physical events do not invalidate typing; foreign injected or unconsumed events still do. Pi chord/focus has [scoped acceptance](validation.md#pi-chords-and-editor-focus-acceptance); #31 control/handback and #27 clipboard outcomes retain their accepted receipts.
 
-`type_text` accepts `text`, `method: auto | clipboard | sendinput | background`, `focusMode: preserve | main`, `restoreClipboard` (default true), and native target options. Browser options retain browser-first routing. `keypress` accepts a `keys` array with exactly one non-modifier key and optional Ctrl/Alt/Shift modifiers. Windows/Cmd/Meta keys are blocked; unsupported names/layout mappings fail without input. Explicit background keypress supports one printable character only.
+`type_text` accepts `text`, `method: auto | clipboard | sendinput | background`, `focusMode: preserve | main`, `restoreClipboard` (default true), and native target options. Browser options retain browser-first routing. `keypress` accepts a `keys` array with one main key and optional Ctrl/Alt/Shift modifiers, or a single standalone generic Ctrl/Control, Alt/Option or Shift. Windows/Cmd/Meta keys are blocked; unsupported names/layout mappings fail without input. Explicit background keypress supports one printable character only.
 
 Auto text first tries the focused native Edit/RichEdit control using bounded `EM_REPLACESEL`, preserving its selection. This quiet path handles Unicode without clipboard or physical keys; multiline text, main-focus selection and unsupported controls require physical entry. An uncertain edit-message result is never retried as clipboard input. Background WM_CHAR delivery is explicitly unverified. Read-only/disabled controls refuse mutation.
 
 The operation's last target is reused after foreground restoration. Fresh Win32 focus takes precedence over remembered native focus. Only an agent-established focus is remembered; subsequent click/focus/target changes invalidate it. Remembered controls must retain their HWND/PID/root and unchanged input-history stamp. An intervening user input with unavailable fresh focus returns `TARGET_FOCUS_CHANGED`; it does not guess the old field. Main focus explicitly chooses the largest enabled, keyboard-focusable, on-screen writable Edit/Document control. After an explicit or remembered focus request, physical text entry waits up to one second for foreground and the requested field to agree. The wait observes without repeating focus or text, checks cancellation and identity, and refuses with `TARGET_FOCUS_CHANGED` if focus cannot be confirmed. An explicit field request cannot be replaced by remembered focus. Successful confirmation reports `focusConfirmed` and `inputFocusHandle`. Optional native edit `verifyValue` is capped at 200 characters and excludes password edits. Physical entry does not read password values.
 
+## Keypress holds and deadlines
+
+On integration/input-timing-40 (not published npm 0.1.0), the #41 keyboard slice adds `holdMs` and `timeoutMs` to `keypress`. Omitted or zero `holdMs` releases immediately. A positive hold keeps the main key and its modifiers down together, then releases every agent-held key within the call. Immediate presses release without post-dispatch focus checks, preserving shortcuts that move focus or open menus. Positive holds retain the existing keypress identity, foreground, protection and interference checks while permitting focus changes between controls in the same window. Held keys do not promise auto-repeat. Timing and standalone modifiers require native foreground input; browser and explicit background timing requests return `TIMING_UNSUPPORTED` before input. Existing background printable-character behavior remains available with timing omitted.
+
+A positive `timeoutMs` requests that call's execution deadline; an explicit shorter deadline can interrupt a hold. Zero disables only the execution deadline. Cancellation, emergency stopping, shutdown, target/focus checks, physical protection and cleanup still apply. Omitted timing keeps the ordinary native-helper 40-second and Pi-worker 90-second budgets. An explicit hold with timeout omitted adds its duration to those existing overhead allowances at each layer. Values must be finite, non-negative safe whole milliseconds; derived overflow is refused before dispatch. Long timers and native waits use bounded chunks without wrapping.
+
+Results report `timing: { holdMs, timeoutMs, deadlinePolicy }` with `default`, `derived`, `explicit` or `disabled` policy, `inputDispatched`, `interrupted` and existing `cleanupConfirmed`. The native result describes its effective helper budget; a transport deadline result describes the expiring request layer. Execution expiry requests cooperative cancellation and gives cleanup acknowledgment an independent five-second grace. A missing acknowledgment retains ownership and blocks dependent input; it never authorizes killing an uncertain input owner. Dispatch and requested timings do not establish an application effect. There is no automatic replay.
+
+Portable tests cover schema/route refusals, aliases, invalid/large/overflow values, both request layers, explicit short deadlines, cancellation races, shutdown and ownership uncertainty using controlled peers. These tests establish forwarding and lifecycle behavior, not Windows input effects. Scoped Windows acceptance is recorded in the [composed receipt](validation.md#input-timing-and-modifier-tap-acceptance). Prepare its safe plan with `npm run test:native:text -- --timing --plan`. The grouped owned-fixture run is `npm run test:native:text -- --timing` on an authorized Windows desktop with `PI_CU_DEDICATED_INPUT_DESKTOP=1` after building. It observes down/up messages and durations independently for aliases, immediate release, a key/chord hold, default/zero/timed Tab focus changes, foreground-loss release, short deadlines and cancellation with a disabled deadline; it checks OS key state and released control. It neither accesses the clipboard nor repeats the old chord suite. Follow the [WSL runtime prerequisites](runtime.md#verification) before running from a WSL worktree. Timing is best effort. The final keyboard-only run used `--timing --phase=keyboard`; `--phase=text` selects text cases and omission selects all. The two fixture failures/corrections are retained in the receipt.
+
+## SendInput pacing and deadlines
+
+Explicit native `method: sendinput` accepts `inputDelayMs` and `timeoutMs`. Omitted pacing remains 50 ms; zero requests no intentional delay. Each delay follows one dispatched UTF-16 unit (CRLF is one Enter); a surrogate pair remains two UTF-16 units. Values are non-negative safe whole milliseconds. Timing fields on auto, clipboard, background or browser routes return `TIMING_UNSUPPORTED` before input, including explicit zero. Omitted fields preserve those routes.
+
+Text reuses the [keypress execution deadline and cleanup contract](#keypress-holds-and-deadlines): positive timeout is honored unchanged, zero disables only execution expiry, and omitted timeout adds explicit pacing multiplied by the normalized unit count to each layer's ordinary overhead. Both the product and derived budgets must be representable, even when execution expiry is disabled. Long pacing waits check cancellation, target identity, focus and protection at least every 25 ms. They never wrap to a short wait. A stopped or partial entry is never replayed.
+
+Results expose effective `inputDelayMs`, `timing: { inputDelayMs, timeoutMs, deadlinePolicy }`, `inputDispatched`, `interrupted`, `inputUnitsDispatched` and cleanup confirmation. The unit count records complete dispatched down/up pairs, not observed text. Exact text still requires independent observation.
+
+The existing `--timing` plan includes exact Unicode/CRLF/tab readback at omitted (50 ms), zero and 25 ms pacing, a shorter text deadline, focus-change interruption, and cancellation during a `MAX_SAFE_INTEGER` delay with the execution deadline disabled. The owned fixture enables tab insertion only during text cases, then restores ordinary Tab focus behavior for keypress cases. Portable tests verify safe values, routing, budgets at both request layers, host forwarding, shutdown and uncertain cleanup with controlled peers. Windows compilation, exact-text and interruption acceptance passed in the named owned fixture; see the [composed receipt](validation.md#input-timing-and-modifier-tap-acceptance). No lower interval is claimed universally correct.
+
 ## Physical entry and cleanup
 
-Explicit `sendinput` text uses KEYEVENTF_UNICODE down/up pairs for ordinary text, Enter key pairs for LF or CR (CRLF becomes one Enter), and Tab key pairs for tabs. Whitespace-only strings are valid text. These keys retain the target application's normal Enter/Tab behavior. A cancellable 50 ms gap follows each dispatched unit: both unpaced delivery and a 10 ms gap were observed to corrupt appended text in modern Notepad despite successful dispatch. The pinned DSH reference instead batches Unicode events without this per-character delay. Pacing and control-character handling changed together in Pi, so the successful regression does not establish that 50 ms is necessary or isolate the cause. See the [Pi text validation scope](validation.md#unicode-mechanism-investigation). Minimum-delay discovery and DSH batching experiments are not release gates. This provisional compatibility workaround adds approximately 50 ms per unit plus platform scheduling overhead; it is not a universal guarantee about application processing. Dispatch remains unverified until a subsequent observation confirms the intended text. Successful results expose `inputDelayMs` so callers can identify the pacing actually used by the running helper. Default `auto` entry retains its existing quiet-edit/clipboard routing. Chords are mapped using the target thread's keyboard layout and use SendInput rather than an uninterruptible SendKeys call. The shared activity observer spans the whole call and distinguishes our tagged key events from intervening physical/foreign injected input; a later synthetic key cannot erase earlier intervention evidence. The helper rechecks target HWND/PID, foreground and cancellation before each character/key; text also checks focused control and user-held modifiers/buttons. Every held key/modifier is released in `finally`, even when its key-down result was uncertain. Partial text, timeout and cancellation never authorize automatic replay.
+Explicit `sendinput` text uses KEYEVENTF_UNICODE down/up pairs for ordinary text, Enter key pairs for LF or CR (CRLF becomes one Enter), and Tab key pairs for tabs. Whitespace-only strings are valid text. These keys retain the target application's normal Enter/Tab behavior. A cancellable gap follows each dispatched unit (50 ms when omitted): both unpaced delivery and a 10 ms gap were observed to corrupt appended text in modern Notepad despite successful dispatch. The pinned DSH reference instead batches Unicode events without this per-character delay. Pacing and control-character handling changed together in Pi, so the successful regression does not establish that 50 ms is necessary or isolate the cause. See the [Pi text validation scope](validation.md#unicode-mechanism-investigation). Minimum-delay discovery and DSH batching experiments are not release gates. The default compatibility workaround adds approximately 50 ms per unit plus platform scheduling overhead; it is not a universal guarantee about application processing. Dispatch remains unverified until a subsequent observation confirms the intended text. Successful results expose `inputDelayMs` so callers can identify the pacing actually used by the running helper. Default `auto` entry retains its existing quiet-edit/clipboard routing. Chords are mapped using the target thread's keyboard layout and use SendInput rather than an uninterruptible SendKeys call. The shared activity observer spans the whole call and distinguishes our tagged key events from intervening physical/foreign injected input; a later synthetic key cannot erase earlier intervention evidence. The helper rechecks target HWND/PID, foreground and cancellation before each character/key; text also checks focused control and user-held modifiers/buttons. Every held key/modifier is released in `finally`, even when its key-down result was uncertain. Partial text, timeout and cancellation never authorize automatic replay.
 
 The independent stop event and retained-input acknowledgment from [pointer stopping](pointer.md) cover keyboard actions too. A timeout signals the operation to stop; missing release/clipboard acknowledgment retains ownership and blocks worker termination/replacement. `set_value` may escalate only an explicit background `WCU_NEEDS_INPUT`, after re-resolving the observed control, checking enabled/read-only state and focusing it; select-all and typing use the same guarded cleanup.
 

package/docs/tickets.md

@@ -1,6 +1,6 @@
 # Implementation tickets
 
-Requirements live in [spec](spec.md), delivery/coverage in [implementation-plan](implementation-plan.md), results in [validation](validation.md). This is the current Pi-first queue, reconciled on 2026-11-09 under [ADR 0004](adr/0004-pi-first-acceptance.md). DSH manual/host/model comparisons, credentials and parity benchmarks are discarded.
+Requirements live in [spec](spec.md), delivery/coverage in [implementation-plan](implementation-plan.md), results in [validation](validation.md). This is the current Pi-first queue, reconciled on 2026-11-10 under [ADR 0004](adr/0004-pi-first-acceptance.md). DSH manual/host/model comparisons, credentials and parity benchmarks are discarded.
 
 ## Current investigation and acceptance work
 
@@ -9,13 +9,13 @@ Requirements live in [spec](spec.md), delivery/coverage in [implementation-plan]
 | Measure | Status after scope reconciliation |
 | --- | --- |
 | Tool implementation | All 25 target tools have implementations. Release acceptance concerns Pi correctness, preservation and usability. |
-| Completed issues | 24: #2, #3, #6, #7, #8, #14, #16, #17, #18, #19, #20, #24, #25, #26, #27, #28, #29, #30, #31, #32, #33, #34, #35, #36. Historical comparison completions retain their original evidence scope. |
+| Completed issues | 30: #1, #2, #3, #6, #7, #8, #14, #16, #17, #18, #19, #20, #21, #24, #25, #26, #27, #28, #29, #30, #31, #32, #33, #34, #35, #36, #40, #41, #42, #43. Historical comparison completions retain their original evidence scope. |
 | Superseded issues | 10: #4, #5, #9, #10, #11, #12, #13, #15, #23, #37. Superseded is not a completed product delivery. |
-| Open issues | 2: release #21 and product parent #1. Installation #2 is complete with explicitly accepted first-release test limitations. |
+| Open issues | None in the first-release and accepted input-timing delivery queues. #40/#41/#42/#43 are complete with scoped evidence and merged through PR #44; 0.1.1 is being prepared, with npm publication pending. |
 | Accepted Pi outcomes | Windows/WSL2 packaged launch, ownership, waits, settings/tool selection, Chromium and experimental Firefox workflows; six browser/mixed agent scenarios each passed three reset runs. Native creation/preservation, replacement/partial recovery and composed continuation (#35), #31 control interruption/cleanup and human-confirmed GitHub sign-in persistence/removal also passed. |
-| Latest recorded checks | Final release-audit checks: 187 passed, one historical-reference skip; 91-entry 0.1.0 archive, MIT/notices/version/development-file exclusion and documentation links passed. [Audit](validation.md#final-release-audit). Existing Windows/model/physical receipts retain their source scope; no release declared. |
+| Latest recorded checks | Input-timing integration: **214 passed, one historical-reference skip**, scoped Windows keyboard/text/mouse acceptance and reviews passed; [receipt](validation.md#input-timing-and-modifier-tap-acceptance). First-release audit: 187 passed, one historical-reference skip; 91-entry 0.1.0 archive, MIT/notices/version/development-file exclusion and documentation links passed. [Audit](validation.md#final-release-audit). The final scoped/banner package check passed 92 entries. Public npm 0.1.0/latest and downloaded archive hash are verified; earlier Windows/model/physical receipts retain their scope. |
 
-The package is implemented; remaining work is targeted Pi acceptance and repair. An open issue does not reopen its accepted cases. No overall completion percentage is asserted, and no release is declared. The earlier development baseline and historical comparison receipts remain available through commits/archive tags.
+The first release is published as [@ycheung5/pi-computer-use@0.1.0](https://www.npmjs.com/package/@ycheung5/pi-computer-use). Its public archive matches the user-submitted build from 73616b5. An open issue does not reopen its accepted cases. Completion is scoped to the accepted first-release requirements and recorded test limitations. The earlier development baseline and historical comparison receipts remain available through commits/archive tags.
 
 ### Delivery outcomes and ownership
 
@@ -33,7 +33,7 @@ The package is implemented; remaining work is targeted Pi acceptance and repair.
 | #31 — stop/control | Native Pi Esc, worker shortcut/suppression, native/WSL command stop, rejection/recovery and no-input host-exit cleanup passed; queued-settlement bug fixed. Four known-held Ctrl/button cancellation/target-error cases and actual WSL Pi Ctrl+Alt+F9 and human handback/resume also passed. | Completed: native availability-loss response and existing worker/held-input/host/handback results satisfy the narrowed scope; [acceptance](validation.md#control-interruption-acceptance). |
 | #35 — native agent goals | Three preopened append/save tasks, three creation/preservation/save resets and three replacement/partial-observation recovery workflows have accepted independent evidence. [Creation](validation.md#native-document-workflow); [recovery and collector-failure disposition](validation.md#native-replacement-and-partial-observation-recovery-preparation). | Completed: three real-Pi continuation resets preserved the labelled stand-in edit after cancelled/retired setup. [Composed handback acceptance](validation.md#native-cancellation-and-handback-continuation) reuses #31 actual human/control proof; no new physical-control claim. |
 | #36 — browser/mixed agent goals | Six named Pi scenarios passed three resets: form/delay; navigation/dialog/transfer; stale recovery; quiet mixed task; partial-observation recovery; held-navigation cancellation. | Completed for this scope. Shared physical control stays #31/#20; native creation/recovery stays #35. No DSH leg remains. |
-| #21 under #1 — release | Capability mapping, existing checks and accepted scopes retained. | Reconcile the Pi owners above, known failures/limits, useful responsiveness, package/docs/version and final user acceptance; then publish. |
+| #21 under #1 — release | Capability mapping, existing checks and accepted scopes retained. | Completed: user-approved 0.1.0 publication, public version/latest and registry archive identity verified. [Release receipt](validation.md#npm-publication-receipt). |
 
 ### Execution queue
 
@@ -41,7 +41,8 @@ Work on one bounded missing outcome at a time. Reuse accepted evidence across is
 
 | Order / owner | Next action | User involvement |
 | --- | --- | --- |
-| 1 — #21 under #1 | Agent-owned [release audit](validation.md#final-release-audit) is complete: package/license repair, coherent version/install docs, capability/failure/limit reconciliation and final checks/reviews. The user confirmed [interactive settings/editor/reload](validation.md#interactive-settings-and-reload-acceptance) on 2026-11-09. #2 is complete with accepted limitations. [0.1.0 release notes and scope](validation.md#first-release-preparation) are prepared; final aggregate approval and publication remain. | Final approval of the prepared release scope/notes; no more display-scaling/stop-key tests for closed issues, and no repeated guest request. |
+| Input timing complete — #40/#41/#42/#43 | [Modifier taps, holds, pacing and timeout control](spec.md#input-timing-and-modifier-taps) merged into main through PR #44 for 0.1.1. [Composed acceptance](validation.md#input-timing-and-modifier-tap-acceptance) records portable, owned Windows and review results plus both fixture failures/corrections. | No further repeated tests needed for this accepted scope. Main merge is complete; see [0.1.1 release preparation](validation.md#011-release-preparation). npm publication remains pending; broader inputs remain deferred. |
+| First release complete | 0.1.0 is public on npm; maintainer/latest and the downloaded archive checksum match. #21 and #1 are complete. | None required for this release. Do not reopen accepted cases or repeat tests without a demonstrated new issue. |
 
 Standing scoped idle-test authorization remains. Preserve unrelated applications, documents, clipboard and profiles, serialize desktop activity and request human participation only for genuine physical/private/visual steps. Unknown input cleanup retains actual owners and blocks dependent activity. No DSH/OpenRouter credentials, DSH installation or side-by-side tests are needed.