@maximtop/opencode-debug-mode 0.1.0

package/ATTRIBUTION.md

@@ -0,0 +1,5 @@
+# Attribution
+
+OpenCode documentation, Node.js documentation, npm documentation, Vitest documentation, and community debugging projects were studied as references for public APIs and general design ideas.
+
+No third-party source code was copied into this repository. If code is selectively ported later, the same change must add its exact source file, license, copyright notice, and required attribution here before merge.

package/CONTRIBUTING.md

@@ -0,0 +1,48 @@
+# Contributing
+
+Use Node.js 20 or newer and npm. Install reproducibly with `npm ci`.
+
+Before submitting a change, run:
+
+```sh
+npm run lint
+npm run typecheck
+npm test
+npm run test:integration
+npm run test:e2e
+npm run coverage
+npm run build
+npm pack --dry-run
+```
+
+Behavior changes should begin with a failing focused test. Preserve the stable public tool names, machine-readable envelopes, strict schemas, bounded data flow, trusted-session isolation, and exact ownership cleanup. Do not add a new evidence transport or probe language without cross-platform syntax, end-to-end capture, verification, cleanup, security, and stress coverage.
+
+## Releases
+
+Pushing a supported version tag runs one automated pipeline: prepare and test the package, create the GitHub Release, then publish the exact prepared tarball to npm with provenance. The tag and `package.json` version must match exactly:
+
+- `vX.Y.Z` publishes with npm dist-tag `latest`.
+- `vX.Y.Z-beta.N` creates a prerelease and publishes with npm dist-tag `beta`.
+- `vX.Y.Z-rc.N` creates a prerelease and publishes with npm dist-tag `next`.
+
+Only tag commits that belong to `master`. For a normal patch release:
+
+```sh
+npm version patch --no-git-tag-version
+git add package.json package-lock.json
+git commit -m "Bump version to X.Y.Z"
+git push origin master
+# Wait for the CI workflow on master to pass.
+git tag -a vX.Y.Z -m "vX.Y.Z"
+git push origin vX.Y.Z
+```
+
+Use the same sequence with an exact `X.Y.Z-beta.N` or `X.Y.Z-rc.N` version for a prerelease. Do not move or reuse a published tag or version.
+
+The release workflow is safe to rerun. It accepts an existing GitHub Release only when the tag, prerelease state, tarball, and checksum match. If the npm version already exists, its registry integrity must match the prepared manifest; any mismatch is reported as a collision. A failed npm publish leaves the GitHub Release in place, so rerun only the failed job.
+
+### First npm publication
+
+Before pushing the first tag, make the repository public and create the GitHub Environment `npm` without manual approval, restricted to protected tag pattern `v*`. Create a short-lived npm granular token with read/write access to the `@maximtop` scope and bypass 2FA, then save it only as the environment secret `NPM_TOKEN`. The bootstrap token is necessary because the npm package does not exist yet.
+
+After the first successful publication, configure an npm Trusted Publisher with user `maximtop`, repository `opencode-debug-mode`, workflow `release.yml`, environment `npm`, and permission `npm publish`. Then remove the `NODE_AUTH_TOKEN` binding from the workflow, delete the `NPM_TOKEN` GitHub secret, revoke the granular token, and enable npm's "2FA and disallow tokens" mode. Later releases authenticate only through GitHub OIDC and continue to receive provenance automatically.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 opencode-debug-mode contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,76 @@
+# opencode-debug-mode
+
+`@maximtop/opencode-debug-mode` is an explicit, hypothesis-driven runtime debugging agent for OpenCode. It registers a selectable `debug` primary agent, the `/debug` command, and a bounded structured tool surface for CLI, web, and browser-extension investigations.
+
+## Requirements
+
+- OpenCode 1.17 or any compatible 1.x release
+- Node.js 20 or newer
+- An npm-compatible OpenCode plugin installation
+
+## Install
+
+Install the package from the public npm registry in the environment where OpenCode resolves plugins:
+
+```sh
+npm install @maximtop/opencode-debug-mode
+```
+
+Then add its npm name to the normal OpenCode configuration:
+
+```json
+{
+  "plugin": ["@maximtop/opencode-debug-mode"]
+}
+```
+
+Restart OpenCode, select the `debug` agent or run `/debug describe the runtime failure`. No agent or command files need to be copied.
+
+## Workflow
+
+The agent records scope and two to four falsifiable hypotheses, captures a failing `pre-fix` baseline, adds the smallest owned probe, analyzes correlated evidence, applies only the confirmed fix, creates a distinct `post-fix` run, and cleans every owned resource. Durable revisioned state allows the workflow to resume after compaction or restart without repeating conclusive checks.
+
+CLI targets run below a watchdog supervisor. Web targets use an authenticated server bound only to loopback. Extension content scripts relay through the existing messaging style; only the background helper can reach loopback.
+
+See the runnable patterns in:
+
+- `examples/cli`
+- `examples/web`
+- `examples/chrome-extension`
+- `examples/firefox-extension`
+
+## Privacy, retention, and cleanup
+
+The default is `keepArtifacts=false`. Evidence, state, credentials, manifests, helpers, probes, permissions, listeners, and owned processes are removed on completion or abandonment. Nothing is uploaded and the package emits no telemetry.
+
+Explicit retention requires a destination. The exported bundle contains sanitized NDJSON evidence, a sanitized checkpoint, a report, and public hashes. It never includes the bearer credential, internal cleanup manifest, raw environment, or ephemeral path inventory.
+
+Cleanup removes only byte-for-byte owned marker blocks, exact-hash helper files, and extension permissions added by the active session. Ambiguous user-edited content is preserved and reported as partial cleanup.
+
+## Limits
+
+- 64 KiB per collector request and 100 events per batch
+- 8 KiB control/scalar values
+- 25,000 events and 25 MiB evidence per session
+- 256 KiB durable checkpoint
+- 30-minute idle expiry, suppressed only by a process or explicit reproduction-wait lease
+- Three no-signal investigation iterations
+
+## v1 boundaries
+
+Generated probes target JavaScript and TypeScript only. The two transports are supervised process capture and authenticated loopback HTTP ingestion. There is no evidence-reading HTTP endpoint, remote collector, debugger-protocol backend, or automatic activation.
+
+## Troubleshooting
+
+- If startup reports a bind error, verify local software is not denying both IPv4 and IPv6 loopback sockets.
+- If a probe cannot register, reapply the exact marker returned by the preparation tool and retry the project parse/type/build check.
+- If cleanup is partial, preserve the reported marker or permission and review it manually; unrelated edits are intentionally never overwritten.
+- If a checkpoint is invalid or incompatible, follow the explicit recovery result rather than restarting the investigation silently.
+
+## Uninstall
+
+Finish or abandon active investigations so cleanup can run, remove `@maximtop/opencode-debug-mode` from the OpenCode `plugin` list, uninstall the npm package, and restart OpenCode.
+
+## License
+
+MIT. See `LICENSE`.

package/SECURITY.md

@@ -0,0 +1,17 @@
+# Security policy
+
+## Threat model
+
+Runtime evidence and target processes are untrusted. Loopback is a network boundary, not authentication: every data/health request requires a random 256-bit bearer credential. Only a minimal unauthenticated CORS preflight is allowed. The collector never exposes evidence reading or deletion over HTTP.
+
+Credentials live only in mode-0600 ephemeral storage, collector memory, and an exact-hash-owned background/web helper. They are excluded from manifests, checkpoints, tool results, logs, reports, and retained bundles. Authentication compares fixed-length digests.
+
+Input bodies, headers, schemas, IDs, paths, strings, collections, event counts, files, and queues are bounded. Evidence is recursively sanitized with deterministic secret-key redaction before persistence. Runtime IDs never become path components.
+
+Commands use executable/argument arrays with no shell. The watchdog terminates descendant trees if the parent disappears. Commands involving credentials, devices, external state, materially different actions, or external directories require OpenCode permission approval.
+
+Cleanup owns exact marker bytes, helper hashes, and individual permission entries; it never restores a whole source file. Ambiguous changes are preserved and reported. Explicitly retained evidence remains sensitive even after sanitization and should receive the same access controls as source code.
+
+## Reporting a vulnerability
+
+Use the repository's GitHub private vulnerability reporting feature. Do not open a public issue containing a credential, exploit, or captured evidence. Include affected versions, reproduction conditions, impact, and a minimal proof without real user data.

package/assets/debug-agent.md

@@ -0,0 +1,71 @@
+# Hypothesis-driven runtime debugging
+
+You are the explicit debug agent. Use runtime evidence to confirm or eliminate falsifiable explanations, preserve the investigation independently of conversation context, apply only an evidence-backed fix, verify it against a baseline, and deterministically remove every owned resource.
+
+## Entry and suitability
+
+Activate this workflow only when the developer selects the `debug` agent or invokes `/debug`. Do not auto-activate for generic errors. Call `debug_state_read` before the first action of every resumed turn, after compaction, and after an OpenCode restart. Reconcile the stored revision, phase, checks, evidence references, and next action before doing anything else.
+
+If a trivial error is already directly proven and needs no runtime evidence, explain that and offer ordinary debugging before starting a debug session. Never claim runtime confirmation from static analysis alone.
+
+## Scope checkpoint
+
+Call `debug_session_start`. Record the problem summary, expected and actual behavior, runtime target, reproduction method, whether a person must reproduce it, and measurable success criteria. Persist the complete state with `debug_state_checkpoint` before waiting or editing behavioral code. Checkpoint after every meaningful transition: hypotheses, completed checks and interpretations, instrumentation changes, reproduction confirmation, evidence decisions, fix decisions, verification, and cleanup.
+
+## Hypotheses
+
+Before a behavioral fix, record two to four ranked falsifiable hypotheses. Give each explicit confirmation and elimination signals. The only exception is one existing runtime trace that directly proves a single cause; record its evidence ID as the single-cause reference. Static analysis may rank hypotheses but cannot confirm them.
+
+## Baseline
+
+Create a `pre-fix` run with `debug_run_start`. Capture the failing baseline before changing behavior. Use `debug_process_capture` for a CLI target, or start the collector and prepare the relevant runtime transport for a human-reproduced target. Record whether the failure actually reproduced.
+
+## Instrumentation
+
+Add the minimum probe needed to distinguish the ranked hypotheses. Use the exact marker block returned by `debug_probe_prepare`; do not synthesize IDs, markers, endpoints, credentials, or expressions. Captures must be identifier/property paths. Register the exact edit with `debug_probe_register`, then run the most relevant parse, type, or build check with `debug_process_capture` using `instrumentation-check` before reproduction. Use sampling or aggregation for hot paths; never instrument every item in an unbounded loop.
+
+Only JavaScript and TypeScript probes are supported. Extension content code must relay through its selected message adapter; background code owns loopback transport.
+
+## Human reproduction
+
+Immediately before requesting user action, checkpoint phase `waiting_for_reproduction`, the waiting run, and the precise next action. Ask only for actions inside the target application. Do not ask the developer to inspect the collector. Do not ask for ports, health checks, local files, console output, or copied logs. After the reply, call `debug_state_read`, then `debug_evidence_read`, and record whether reproduction occurred before classifying evidence.
+
+## Evidence decisions
+
+For every hypothesis, record `open`, `confirmed`, or `eliminated` with stable evidence IDs. Keep raw payloads and complete output in the bounded evidence store, not the checkpoint. If an iteration yields no deciding signal, checkpoint the interpretation, increment `loopIteration`, and change the probe or reproduction deliberately. Stop after three no-signal iterations. Offer a materially different approach, escalation, or abandonment; do not repeat the same inconclusive check.
+
+## Fix
+
+Change only the cause supported by deciding evidence. Identify masking, feature-disabling, or bypass changes as workarounds and request explicit approval before applying them. Checkpoint the selected fix, evidence, and changed files before editing.
+
+## Verification
+
+Create a distinct `post-fix` run. Repeat the same reproduction and relevant regression, build, type, and lint checks. Compare pre-fix and post-fix evidence, not only exit status. Ensure instrumentation did not mask the failure. Record verification results and deciding evidence in the checkpoint.
+
+## Cleanup and report
+
+Checkpoint phase `cleaning`. Always call `debug_cleanup` on success, unresolved outcome, abandonment, escalation, or the next safe action after cancellation. Supply the structured outcome, root cause and evidence, final hypothesis statuses, fix and files, verification, and an optional bounded clean-target check. Report the retained artifact location only when explicit retention succeeded. Report every failed or ambiguous cleanup resource. Never say the target is clean when cleanup is partial.
+
+## Resume and invalidation
+
+Do not repeat a completed conclusive check unless its checkpoint entry records `invalidatedBy` with a changed condition or newer conflicting evidence. A missing, invalid, or unsupported checkpoint is a recovery condition: report it explicitly and reconstruct only verifiable runtime facts. Never invent lost conclusions or silently restart.
+
+## Secret and scope rules
+
+Never request, display, log, checkpoint, or report a bearer token or an ephemeral session path. Never use runtime IDs as filesystem paths. Never access another trusted session. Never add telemetry or send evidence off the local machine. Never enable an unadvertised adapter or language. Use executable and argument arrays, and request approval for credentials, devices, external state, external directories, or materially different actions.
+
+## Phase-to-tool guide
+
+| Phase | Tool |
+| --- | --- |
+| Start | `debug_session_start` |
+| Public lifecycle check | `debug_session_status` |
+| Resume/reconcile | `debug_state_read` |
+| Persist transition | `debug_state_checkpoint` |
+| Baseline or verification run | `debug_run_start` |
+| CLI/check execution | `debug_process_capture` |
+| Web/background transport | `debug_collector_start` |
+| Prepare exact instrumentation | `debug_probe_prepare` |
+| Verify marker ownership | `debug_probe_register` |
+| Analyze bounded evidence | `debug_evidence_read` |
+| Teardown and report | `debug_cleanup` |

package/dist/chunk-2PCBVVWX.js

@@ -0,0 +1,20 @@
+// src/core/errors.ts
+var DebugModeError = class extends Error {
+  code;
+  retryable;
+  action;
+  details;
+  constructor(code, message, retryable = false, options = {}) {
+    super(message.slice(0, 8192));
+    this.name = "DebugModeError";
+    this.code = code;
+    this.retryable = retryable;
+    if (options.action !== void 0) this.action = options.action.slice(0, 8192);
+    if (options.details !== void 0) this.details = options.details;
+  }
+};
+
+export {
+  DebugModeError
+};
+//# sourceMappingURL=chunk-2PCBVVWX.js.map

package/dist/chunk-2PCBVVWX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/errors.ts"],"sourcesContent":["export type DebugErrorCode =\n  | \"SESSION_EXISTS\"\n  | \"DESTINATION_REQUIRED\"\n  | \"NODE_UNSUPPORTED\"\n  | \"STORAGE_UNAVAILABLE\"\n  | \"NO_ACTIVE_SESSION\"\n  | \"SESSION_OWNERSHIP_MISMATCH\"\n  | \"STATE_MISSING\"\n  | \"STATE_INVALID\"\n  | \"STATE_VERSION_UNSUPPORTED\"\n  | \"STALE_REVISION\"\n  | \"STATE_TOO_LARGE\"\n  | \"INVALID_PHASE\"\n  | \"RUN_LIMIT\"\n  | \"RUN_NOT_FOUND\"\n  | \"PROBE_NOT_VALIDATED\"\n  | \"COMMAND_REQUIRES_APPROVAL\"\n  | \"PROCESS_START_FAILED\"\n  | \"PROCESS_TIMEOUT\"\n  | \"LOOPBACK_BIND_FAILED\"\n  | \"COLLECTOR_EXISTS\"\n  | \"HELPER_PATH_UNSAFE\"\n  | \"UNSAFE_CAPTURE\"\n  | \"UNSUPPORTED_LANGUAGE\"\n  | \"COLLECTOR_REQUIRED\"\n  | \"MARKER_MISSING\"\n  | \"MARKER_MISMATCH\"\n  | \"PERMISSION_MISMATCH\"\n  | \"FILTER_INVALID\"\n  | \"EVIDENCE_UNAVAILABLE\"\n  | \"CLEANUP_PARTIAL\"\n  | \"EXPORT_FAILED\"\n  | \"INTERNAL_ERROR\"\n\nexport type SafeErrorDetail = string | number | boolean\n\nexport class DebugModeError extends Error {\n  readonly code: DebugErrorCode\n  readonly retryable: boolean\n  readonly action?: string\n  readonly details?: Record<string, SafeErrorDetail>\n\n  constructor(\n    code: DebugErrorCode,\n    message: string,\n    retryable = false,\n    options: { action?: string; details?: Record<string, SafeErrorDetail> } = {},\n  ) {\n    super(message.slice(0, 8_192))\n    this.name = \"DebugModeError\"\n    this.code = code\n    this.retryable = retryable\n    if (options.action !== undefined) this.action = options.action.slice(0, 8_192)\n    if (options.details !== undefined) this.details = options.details\n  }\n}\n"],"mappings":";AAoCO,IAAM,iBAAN,cAA6B,MAAM;AAAA,EAC/B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YACE,MACA,SACA,YAAY,OACZ,UAA0E,CAAC,GAC3E;AACA,UAAM,QAAQ,MAAM,GAAG,IAAK,CAAC;AAC7B,SAAK,OAAO;AACZ,SAAK,OAAO;AACZ,SAAK,YAAY;AACjB,QAAI,QAAQ,WAAW,OAAW,MAAK,SAAS,QAAQ,OAAO,MAAM,GAAG,IAAK;AAC7E,QAAI,QAAQ,YAAY,OAAW,MAAK,UAAU,QAAQ;AAAA,EAC5D;AACF;","names":[]}

package/dist/cleanup/export.d.ts

@@ -0,0 +1,23 @@
+import { type CleanupResult, type FinalReportInput } from "./types.js";
+export type RetainedBundleInput = Readonly<{
+    keepArtifacts: boolean;
+    destination?: string;
+    sessionDir: string;
+    evidenceFile: string;
+    stateFile: string;
+    token: string;
+    securityValues?: string[];
+    finalReport: FinalReportInput;
+}>;
+export type StagedBundle = Readonly<{
+    partialPath: string;
+    finalPath: string;
+    token: string;
+    securityValues: string[];
+    report: FinalReportInput;
+    eventCount: number;
+}>;
+export declare function stageRetainedBundle(input: RetainedBundleInput): Promise<StagedBundle>;
+export declare function finalizeRetainedBundle(staged: StagedBundle, cleanupInput: CleanupResult): Promise<{
+    path: string;
+}>;

package/dist/cleanup/service.d.ts

@@ -0,0 +1,33 @@
+import type { z } from "zod";
+import type { CollectorServer } from "../collector/server.js";
+import type { DebugSession } from "../session/registry.js";
+import type { ProcessManifestSchema } from "../session/types.js";
+import { type CleanupResult, type FinalReportInput } from "./types.js";
+type OwnedProcess = z.infer<typeof ProcessManifestSchema>;
+type ResourceResult = CleanupResult["resources"]["collector"];
+export declare class CleanupService {
+    private readonly session;
+    private readonly dependencies;
+    private running;
+    private completed;
+    constructor(session: DebugSession, dependencies?: {
+        collector?: Pick<CollectorServer, "close">;
+        terminateProcess?: (process: OwnedProcess) => Promise<ResourceResult>;
+        removeSecret?: () => Promise<"success" | "already-clean">;
+        securityValues?: string[];
+    });
+    run(input: {
+        reason: string;
+        finalReport: FinalReportInput;
+        cleanCheck?: {
+            executable: string;
+            args: string[];
+            cwd: string;
+            timeoutMs: number;
+        };
+    }): Promise<CleanupResult>;
+    private execute;
+    private removeOwnedFile;
+    private runCleanCheck;
+}
+export {};

package/dist/cleanup/types.d.ts

@@ -0,0 +1,235 @@
+import { z } from "zod";
+export declare const ResourceCleanupResultSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        "already-clean": "already-clean";
+        failed: "failed";
+        skipped: "skipped";
+        success: "success";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const CleanupResultSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+    }>;
+    reason: z.ZodString;
+    resources: z.ZodObject<{
+        collector: z.ZodObject<{
+            status: z.ZodEnum<{
+                "already-clean": "already-clean";
+                failed: "failed";
+                skipped: "skipped";
+                success: "success";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+            location: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        processes: z.ZodArray<z.ZodObject<{
+            status: z.ZodEnum<{
+                "already-clean": "already-clean";
+                failed: "failed";
+                skipped: "skipped";
+                success: "success";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+            location: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        probes: z.ZodArray<z.ZodObject<{
+            status: z.ZodEnum<{
+                "already-clean": "already-clean";
+                failed: "failed";
+                skipped: "skipped";
+                success: "success";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+            location: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        permissions: z.ZodArray<z.ZodObject<{
+            status: z.ZodEnum<{
+                "already-clean": "already-clean";
+                failed: "failed";
+                skipped: "skipped";
+                success: "success";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+            location: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        files: z.ZodArray<z.ZodObject<{
+            status: z.ZodEnum<{
+                "already-clean": "already-clean";
+                failed: "failed";
+                skipped: "skipped";
+                success: "success";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+            location: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        secret: z.ZodObject<{
+            status: z.ZodEnum<{
+                "already-clean": "already-clean";
+                failed: "failed";
+                skipped: "skipped";
+                success: "success";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+            location: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        sessionDirectory: z.ZodObject<{
+            status: z.ZodEnum<{
+                "already-clean": "already-clean";
+                failed: "failed";
+                skipped: "skipped";
+                success: "success";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+            location: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    remainingArtifacts: z.ZodArray<z.ZodString>;
+    durationMs: z.ZodNumber;
+    cleanCheck: z.ZodOptional<z.ZodObject<{
+        command: z.ZodString;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        timedOut: z.ZodBoolean;
+        durationMs: z.ZodNumber;
+    }, z.core.$strict>>;
+    retainedArtifactLocation: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const FinalReportInputSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        abandoned: "abandoned";
+        completed: "completed";
+        escalated: "escalated";
+        unresolved: "unresolved";
+    }>;
+    rootCause: z.ZodString;
+    decidingEvidence: z.ZodArray<z.ZodString>;
+    hypotheses: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            confirmed: "confirmed";
+            eliminated: "eliminated";
+            open: "open";
+        }>;
+        statement: z.ZodString;
+    }, z.core.$strict>>;
+    fix: z.ZodString;
+    changedFiles: z.ZodArray<z.ZodString>;
+    verification: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const FinalReportSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        abandoned: "abandoned";
+        completed: "completed";
+        escalated: "escalated";
+        unresolved: "unresolved";
+    }>;
+    rootCause: z.ZodString;
+    decidingEvidence: z.ZodArray<z.ZodString>;
+    hypotheses: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            confirmed: "confirmed";
+            eliminated: "eliminated";
+            open: "open";
+        }>;
+        statement: z.ZodString;
+    }, z.core.$strict>>;
+    fix: z.ZodString;
+    changedFiles: z.ZodArray<z.ZodString>;
+    verification: z.ZodArray<z.ZodString>;
+    cleanup: z.ZodObject<{
+        status: z.ZodEnum<{
+            complete: "complete";
+            partial: "partial";
+        }>;
+        reason: z.ZodString;
+        resources: z.ZodObject<{
+            collector: z.ZodObject<{
+                status: z.ZodEnum<{
+                    "already-clean": "already-clean";
+                    failed: "failed";
+                    skipped: "skipped";
+                    success: "success";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+                location: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            processes: z.ZodArray<z.ZodObject<{
+                status: z.ZodEnum<{
+                    "already-clean": "already-clean";
+                    failed: "failed";
+                    skipped: "skipped";
+                    success: "success";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+                location: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            probes: z.ZodArray<z.ZodObject<{
+                status: z.ZodEnum<{
+                    "already-clean": "already-clean";
+                    failed: "failed";
+                    skipped: "skipped";
+                    success: "success";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+                location: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            permissions: z.ZodArray<z.ZodObject<{
+                status: z.ZodEnum<{
+                    "already-clean": "already-clean";
+                    failed: "failed";
+                    skipped: "skipped";
+                    success: "success";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+                location: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            files: z.ZodArray<z.ZodObject<{
+                status: z.ZodEnum<{
+                    "already-clean": "already-clean";
+                    failed: "failed";
+                    skipped: "skipped";
+                    success: "success";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+                location: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            secret: z.ZodObject<{
+                status: z.ZodEnum<{
+                    "already-clean": "already-clean";
+                    failed: "failed";
+                    skipped: "skipped";
+                    success: "success";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+                location: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            sessionDirectory: z.ZodObject<{
+                status: z.ZodEnum<{
+                    "already-clean": "already-clean";
+                    failed: "failed";
+                    skipped: "skipped";
+                    success: "success";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+                location: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        remainingArtifacts: z.ZodArray<z.ZodString>;
+        durationMs: z.ZodNumber;
+        cleanCheck: z.ZodOptional<z.ZodObject<{
+            command: z.ZodString;
+            exitCode: z.ZodNullable<z.ZodNumber>;
+            timedOut: z.ZodBoolean;
+            durationMs: z.ZodNumber;
+        }, z.core.$strict>>;
+        retainedArtifactLocation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    retainedArtifactLocation: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CleanupResult = z.infer<typeof CleanupResultSchema>;
+export type FinalReportInput = z.infer<typeof FinalReportInputSchema>;
+export type FinalReport = z.infer<typeof FinalReportSchema>;

package/dist/collector/auth.d.ts

@@ -0,0 +1,3 @@
+import type { SecretStore } from "../session/secret-store.js";
+export declare function authenticateBearer(header: string | undefined, expectedToken: string): boolean;
+export declare function createCollectorCredential(store: SecretStore): Promise<string>;

package/dist/collector/body.d.ts

@@ -0,0 +1,7 @@
+import type { IncomingMessage } from "node:http";
+export declare class CollectorBodyError extends Error {
+    readonly status: 400 | 413 | 415;
+    readonly code: "INVALID_REQUEST" | "LIMIT_EXCEEDED" | "UNSUPPORTED_MEDIA_TYPE";
+    constructor(status: 400 | 413 | 415, code: "INVALID_REQUEST" | "LIMIT_EXCEEDED" | "UNSUPPORTED_MEDIA_TYPE");
+}
+export declare function readBoundedJsonBody(request: IncomingMessage): Promise<unknown>;

package/dist/collector/ingest.d.ts

@@ -0,0 +1,8 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { EvidenceStore } from "../evidence/store.js";
+import { type EventInput } from "../evidence/types.js";
+export declare function createIngestHandler(options: {
+    evidence: EvidenceStore;
+    validateEvent: (event: EventInput) => Promise<EventInput>;
+    sample?: (event: EventInput) => boolean | Promise<boolean>;
+}): (request: IncomingMessage, response: ServerResponse, origin?: string) => Promise<void>;

package/dist/collector/router.d.ts

@@ -0,0 +1,8 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export type IngestHandler = (request: IncomingMessage, response: ServerResponse, origin?: string) => Promise<void>;
+export declare function createCollectorRouter(options: {
+    token: string;
+    ingest?: IngestHandler;
+    onAuthenticated?: () => void | Promise<void>;
+}): (request: IncomingMessage, response: ServerResponse, status: () => "ready" | "draining") => Promise<void>;
+export declare function writeCollectorJson(response: ServerResponse, status: number, value: unknown, origin?: string): void;

package/dist/collector/server.d.ts

@@ -0,0 +1,25 @@
+import { type IncomingMessage, type ServerResponse } from "node:http";
+export type CollectorStatus = "stopped" | "starting" | "ready" | "draining" | "failed";
+export type CollectorRequestHandler = (request: IncomingMessage, response: ServerResponse, status: () => "ready" | "draining") => void | Promise<void>;
+export type CollectorHandle = Readonly<{
+    id: string;
+    host: "127.0.0.1" | "::1";
+    port: number;
+    status: "ready";
+    close(): Promise<void>;
+}>;
+export declare class CollectorServer {
+    private readonly handler;
+    private readonly onFailure?;
+    private server;
+    private readonly sockets;
+    private state;
+    private handle;
+    private failureReported;
+    constructor(handler?: CollectorRequestHandler, onFailure?: ((reason: string) => void | Promise<void>) | undefined);
+    start(): Promise<CollectorHandle>;
+    get status(): CollectorStatus;
+    close(): Promise<void>;
+    private bind;
+    private reportFailure;
+}

package/dist/core/clock.d.ts

@@ -0,0 +1,5 @@
+export interface Clock {
+    now(): Date;
+    monotonicMs(): number;
+}
+export declare const systemClock: Clock;

package/dist/core/constants.d.ts

@@ -0,0 +1,20 @@
+export declare const PACKAGE_ID: "opencode-debug-mode";
+export declare const MANIFEST_SCHEMA_VERSION: 1;
+export declare const STATE_SCHEMA_VERSION: 1;
+export declare const EVENT_SCHEMA_VERSION: 1;
+export declare const TEMP_BASE_NAME: "opencode-debug-mode-v1";
+export declare const PROCESS_EVENT_PREFIX: "__OPENCODE_DEBUG_EVENT_V1__";
+export declare const LIMITS: Readonly<{
+    requestBytes: number;
+    scalarBytes: number;
+    events: 25000;
+    evidenceBytes: number;
+    checkpointBytes: number;
+    eventsPerBatch: 100;
+    idleMs: number;
+    collectorReadyMs: 2000;
+    cleanupMs: 5000;
+    gracefulKillMs: 750;
+    forcedKillMs: 1500;
+    noSignalIterations: 3;
+}>;