urma-mcp 0.1.0-rc.2 → 0.1.0

package/README.md

@@ -4,8 +4,6 @@
   <img src="https://raw.githubusercontent.com/sajidurdev/urma/main/assets/urma-banner.png" alt="Urma" width="100%" />
   <br /><br />
   <strong>Retrieve video captions and frames through MCP.</strong>
-  <br />
-  A stdio MCP server for bounded caption and visual evidence.
   <br /><br />
   <a href="#try-urma">Try Urma</a>
   ·
@@ -17,111 +15,88 @@
   ·
   <a href="#documentation">Documentation</a>
   <br /><br />
-  <sub><code>urma-mcp</code> · MCP stdio · Node.js 24 LTS</sub>
+  <sub><code>urma-mcp</code> · MCP stdio · Node.js 22.16+ (22.x), 24.x, 26.x</sub>
 </div>
 
 <br />
 
-> **Release candidate:** Use the `rc` npm tag for RC testing.
+Urma gives MCP clients access to captions and frames from public video URLs
+and local video files. Search captions for a topic, browse a visual overview,
+or retrieve frames at specific timestamps.
 
-Urma retrieves captions and sampled frames from videos with a known end time.
-Each result identifies its source snapshot and requested timestamps or range.
-The MCP host chooses what to retrieve and interprets the results.
-
-Urma runs locally and stores its cache on your filesystem. Remote videos still
-require network access. The host receives the requested evidence and controls
-how it is processed or sent to a model.
-
-The server uses MCP stdio. A host starts one Urma process for a session and
-owns its lifecycle. Urma does not run a daemon or expose an HTTP API.
+Urma runs locally and keeps its cache on your filesystem. Your MCP client
+starts the server over stdio and receives the requested text and images.
+Remote videos require network access.
 
 ## Try Urma
 
-1. Install the current RC with `npx -y urma-mcp@rc setup`.
-2. [Register your MCP host](#register-a-generic-json-host), then restart it.
-3. Give the host a video URL or allowed local path and ask it to locate a moment
-   using captions or an overview.
-4. Request exact frames around that moment to verify the visual claim.
+1. Install with `npx -y urma-mcp@latest setup`.
+2. [Connect your MCP client](#register-a-generic-json-host) and restart it.
+3. Give the client a video URL and a question about the video.
 
-Example prompt (replace `<video URL>` with your source):
+For example, replace `<video URL>` in this prompt with a public product demo:
 
-> Inspect this product-demo video: `<video URL>`. Use captions to find where the presenter
-> mentions dark mode, use the overview to locate the settings screen, then
-> request exact frames around that timestamp to verify whether the dark-mode
-> toggle is enabled. If the returned frames do not show the toggle clearly,
-> say that the evidence is insufficient.
+> In this demo, where does the presenter discuss dark mode, and is the toggle
+> enabled on screen? `<video URL>`
 
-## RC testing
-
-External testers can report installation, MCP-host, or source/provider problems
-through the [RC bug-report template](https://github.com/sajidurdev/urma/issues/new?template=bug-report.md).
-Include reproduction steps, your OS/architecture, Node.js and host versions,
-the installed Urma version, and expected versus actual behavior. For a
-source-specific issue, include a public URL or a description of a reproducible
-local video. Add relevant [doctor output](#cli-and-maintenance) if setup
-completed; otherwise include the setup error. Remove credentials, private
-URLs, and personal paths before posting logs.
+For a local file, [allow its directory](#local-videos) first. See
+[supported sources](docs/PRODUCT_SCOPE.md#source-admission) for provider and
+format limitations.
 
 ## Install and connect a host
 
 ### Requirements
 
-- Native Node.js 24 LTS (`>=24 <25`).
-- A user-owned local filesystem for Urma's data root.
-- One of these runtime targets: Windows x64 or arm64, macOS x64 or arm64, or
-  Linux x64 or arm64 with glibc.
+- Native Node.js `>=22.16.0 <23`, `>=24.0.0 <25`, or `>=26.0.0 <27`.
+- Windows x64/arm64, macOS x64/arm64, or Linux x64/arm64 with glibc.
+- A user-owned local directory with at least 1 GiB free for the installation.
 
-Urma installs the pinned FFmpeg, ffprobe, and yt-dlp artifacts it needs. Do
-not install those tools separately for the packaged runtime. Urma does not
-install or manage Node.js.
+Setup installs the required versions of FFmpeg, ffprobe, and yt-dlp. You only
+need to install Node.js yourself.
 
 ### Install the runtime
 
-Run the npm bootstrap with Node.js 24:
-
 ```sh
-npx -y urma-mcp@rc setup
+npx -y urma-mcp@latest setup
 ```
 
-The `rc` tag can move between candidates. To find its exact version without
-installing it:
+Setup downloads and verifies the native tools, tests the installed server, and
+prints the paths needed by your MCP client. Updates are installed separately
+from the current runtime; a failed update leaves the current installation
+selected.
+
+For a repeatable installation, pin the package version:
 
 ```sh
-npm view urma-mcp dist-tags.rc
+npx -y urma-mcp@0.1.0 setup
 ```
 
-For a repeatable install, replace `rc` in the setup command with the exact
-version returned above.
-
-Setup downloads and verifies the pinned native tools, checks that the installed
-runtime can serve MCP requests, and selects the new installation for future
-launches. Each installation is stored in a separate directory called a
-generation. If setup fails during an update, the previously active generation
-remains selected.
-
-The default data roots are:
+Urma uses these default data directories:
 
-| Platform | Root |
+| Platform | Directory |
 | --- | --- |
 | Windows | `%LOCALAPPDATA%\Urma` |
 | macOS | `~/Library/Application Support/Urma` |
 | Linux | `${XDG_DATA_HOME:-~/.local/share}/urma` |
 
-Use `--data-dir PATH` with `setup`, or set `URMA_DATA_DIR`, to select another
-user-owned local directory. Network and UNC paths are outside the supported
-installation boundary.
+To choose another directory, pass `--data-dir PATH` to setup or set
+`URMA_DATA_DIR`. The data directory must be on a user-owned local filesystem;
+network and UNC locations are unsupported.
 
 ### Register a generic JSON host
 
-If the host uses the usual `mcpServers` JSON shape, setup can add the `urma`
-entry and preserve the other entries in the file:
+For clients that use an `mcpServers` JSON configuration, setup can write the
+entry for you:
 
 ```sh
-npx -y urma-mcp@rc setup --client generic --config "/absolute/path/to/mcp.json"
+npx -y urma-mcp@latest setup --client generic --config "/absolute/path/to/mcp.json"
 ```
 
-The configuration file path must be absolute. The resulting entry has this
-shape; use the absolute paths printed by setup:
+The configuration path must be absolute. Setup preserves unrelated entries.
+If an `urma` entry already exists, setup updates `command`, `args`, and
+`env.URMA_DATA_DIR`, leaving its other settings in place.
+
+To configure a client manually, use the absolute paths printed by setup:
 
 ```json
 {
@@ -137,302 +112,195 @@ shape; use the absolute paths printed by setup:
 }
 ```
 
-On Windows, use the path escaping required by JSON. The `command` and the
-launcher path must be absolute. The launcher selects the installed generation
-and starts the local Urma runtime; use the npm package only for setup and
-version checks.
-
-Host registration and runtime installation are reported separately. A healthy
-runtime can be left installed when the configuration file cannot be written.
-After registration, restart the host and check that it lists the [five tools](#tools).
+On Windows, escape backslashes in JSON, for example `C:\\Users\\you\\AppData\\Local\\Urma`.
+For clients with a different configuration format, use the same Node
+executable, launcher, and environment settings in a stdio server entry.
 
-For a host with a different configuration format, create the equivalent
-stdio entry with the same absolute Node executable, launcher path, and
-`URMA_DATA_DIR` value.
+Restart the client after saving the configuration. It should list the five
+tools below. If registration fails, setup reports that separately from the
+runtime installation; you can still configure the installed server manually.
 
 ## Tools
 
-| Tool | Returns |
-| --- | --- |
-| `inspect_video` | A source snapshot and a new investigation reference. |
-| `search_transcript` | Literal matches in one selected caption track. |
-| `read_transcript` | Timestamped caption segments in a bounded interval. |
-| `get_overview` | A visual overview with up to 12 sampled cells. |
-| `get_frames` | Exact JPEG points, ordered sparse points, or a fixed-cadence schedule. |
-
-Call `inspect_video` first for a new source. It accepts an HTTP(S) URL, an
-allowed local path, or a previously returned `sourceRef`. It rejects sources
-that do not define one finite video timeline. The default `freshness: "reuse"`
-reuses a stored snapshot for a known remote URL or `sourceRef`. A local path
-is read again to check the video and sidecar content. Set `freshness: "refresh"`
-to resolve the source again. Every evidence request then uses the returned
-`investigationRef`.
-
-Use captions to locate likely time ranges, `get_overview` to locate visual
-moments, and `get_frames` to verify selected moments. These tools expose
-different observations:
-
-- Caption search and reads are limited to the selected source-provided track.
-- An overview is a sparse locator with up to 12 returned cells.
-- A frame burst is an ordered set of requested points.
-- A cadence request is a finite list of exact point requests. It reports each
-  page slot as `success`, `error`, or `unfinished`.
-
-A source cache can be reused across investigations, but evidence presentation
-is recorded per investigation.
-
-### Source and caption inputs
-
-Urma accepts:
-
-- A generic HTTP(S) video URL admitted by the remote source policy.
-- A supported single-video YouTube URL.
-- A local video path under a root listed in `URMA_LOCAL_ROOTS`.
-
-Local caption sidecars are optional. Urma checks the video basename with `.vtt`
-first and `.srt` second. Local paths remain disabled when
-`URMA_LOCAL_ROOTS` is empty.
-
-`search_transcript` accepts either one `query` or a `queries` array. Its
-default mode is `phrase`; `terms` requires every normalized term to occur in a
-cue. Search is literal and case-insensitive after NFKC normalization. A
-matching caption is a lead for visual verification, not visual proof.
-
-`read_transcript` requires a source-global half-open interval,
-`[startMs,endMs)`. It returns at most 200 segments or 16,000 caption
-characters per page. To continue, pass `nextCursor` as `cursor` with the same
-investigation, interval, and selected track.
-
-### Visual inputs
-
-`get_overview` accepts an optional source-global interval. It requests 12
-temporally distributed cells. The returned timestamps are the samples that
-were observed; they do not describe continuous coverage.
-
-`get_frames` accepts one of these requests:
-
-| Request | Contract |
+| Tool | Use it to |
 | --- | --- |
-| `points` | 1–12 unique timestamps, each before the source duration. |
-| `burst` | A half-open interval and 2–12 ordered samples. |
-| `cadence` | A half-open interval and a positive integer `cadenceMs`. |
-
-Times are nonnegative integer milliseconds from the start of the source.
-Intervals require `startMs < endMs` and must fit within its duration. An exact
-frame request asks for the first decodable frame at or after the target; it
-does not guarantee a frame with precisely that presentation timestamp.
+| `inspect_video` | Open a video and list its duration, metadata, and caption tracks. |
+| `search_transcript` | Find literal phrases or terms in a caption track. |
+| `read_transcript` | Read timestamped captions for a time range. |
+| `get_overview` | Browse up to 12 visual samples from a video or time range. |
+| `get_frames` | Retrieve JPEG frames at chosen times, in a burst, or at a fixed interval. |
 
-For `points` and `burst`, the default presentation is `individual`. Set
-`presentation: "panel"` to receive one derived JPEG panel plus links to the
-canonical frame artifacts. A panel contains at most 12 cells and preserves
-request order.
+Start with `inspect_video`. For an allowed local file, its arguments are:
 
-Cadence requests are paged. The default page maximum is 12 targets and the
-default schedule maximum is 120 targets. Continue with the returned opaque
-`nextCursor`; do not construct a cursor yourself. A cadence schedule is
-discrete evidence and does not cover the time between its targets.
-
-### Example tool arguments
+```json
+{ "source": "/absolute/path/to/demo.mp4" }
+```
 
-For a local video, first add its parent directory to `URMA_LOCAL_ROOTS` in the
-host's Urma environment and restart the host. Call `inspect_video` with the
-absolute path to your file:
+Use the returned `investigationRef` for subsequent calls. For example, these
+`search_transcript` arguments find mentions of dark mode:
 
 ```json
-{ "source": "/absolute/path/to/video.mp4" }
+{
+  "investigationRef": "urma:investigation:0123456789abcdef0123456789abcdef",
+  "query": "dark mode"
+}
 ```
 
-Use the returned `investigationRef` in subsequent calls. For example, these
-`get_frames` arguments request a panel at 1 and 5 seconds from a video longer
-than 5 seconds. Replace the example reference with the value from inspection:
+Replace the example reference with the one from inspection. If a match occurs
+near 10 seconds, these `get_frames` arguments request a panel at 10 and 11
+seconds from a video longer than 11 seconds:
 
 ```json
 {
   "investigationRef": "urma:investigation:0123456789abcdef0123456789abcdef",
-  "request": { "kind": "points", "timesMs": [1000, 5000] },
+  "request": { "kind": "points", "timesMs": [10000, 11000] },
   "presentation": "panel"
 }
 ```
 
-To continue a cadence page, pass `investigationRef` and the returned
-`nextCursor` as `cursor`, without a new `request`.
-
-## Resources and errors
+All times are integer milliseconds from the start of the video. Caption
+search uses source-provided captions; Urma does not transcribe audio. Overviews
+and frame requests show selected moments, so brief events between samples can
+be missed.
 
-Successful evidence results include investigation-scoped resource links. An
-artifact can be reopened through
-`urma://investigation/{investigationId}/artifact/{artifactHash}` only after
-that investigation has received it in a tool result. Reopening an artifact
-does not add temporal coverage.
+The [tool reference](docs/EVIDENCE_MODEL.md) covers all arguments, pagination,
+result fields, and timing guarantees.
 
-The state resource is
-`urma://investigation/{investigationId}/state`. It contains persisted
-acquisition, cache, and presentation state for that investigation.
+## Configuration
 
-Top-level MCP failures return `isError: true` with a JSON text object containing
-`code`, `retryable`, and `detail`. A cadence page can instead return an error
-in an individual slot and continue with other targets.
+Set environment variables in the client's Urma `env` entry and restart the
+client after changing them.
 
-## Evidence rules
+### Local videos
 
-For caption search, `partial: false` means all matches under the selected
-track's matching rules were returned. It says nothing about uncaptioned
-speech or visual events. Sampled frames describe only the returned points,
-and reopening cached artifacts adds no coverage.
+Local file access is disabled by default. Set `URMA_LOCAL_ROOTS` to the
+directories that Urma may read. Use absolute paths, separated by `;` on
+Windows or `:` on macOS/Linux. For example:
 
-See [Evidence Model](docs/EVIDENCE_MODEL.md) for the full contract.
+```json
+{
+  "URMA_LOCAL_ROOTS": "/home/you/Videos:/home/you/Demos"
+}
+```
 
-## Limits
+This example is an `env` fragment for macOS/Linux. On Windows, a single root
+might be `"URMA_LOCAL_ROOTS": "C:\\Users\\you\\Videos"`.
 
-Runtime defaults are:
+Urma looks for captions beside the video: `demo.vtt` first, then `demo.srt` for
+`demo.mp4`. Sidecars must also be inside an allowed root. Symlinks and junctions
+are checked against their resolved locations.
 
-| Limit | Default |
-| --- | ---: |
-| Single caption search result limit | 5, maximum 20 |
-| Caption query length | 256 characters |
-| Batched caption queries | 20 queries, 20 merged hits, 16,000 returned characters |
-| Caption read page | 200 segments or 16,000 characters |
-| Overview request | 12 requested cells |
-| Explicit frame request | 12 points or burst samples |
-| Cadence page | 12 targets |
-| Cadence schedule | 120 targets |
-| Inline image response | 8 MiB |
-| Resource read | 32 MiB |
-| Targeted media acquisition | 64 MiB |
-| Navigation media acquisition | 256 MiB |
-| Reusable evidence media | 512 MiB |
-| Remote acquisition wall time | 180,000 ms |
-
-The environment variables below override the tunable limits. Values for byte
-limits are bytes; the remote wall limit is milliseconds. Each value must be a
-positive integer. `URMA_MAX_FRAME_SCHEDULE_PAGE_TARGETS` cannot exceed 12.
-
-| Variable | Overrides |
+| Variable | Purpose |
 | --- | --- |
-| `URMA_MAX_TARGETED_MEDIA_BYTES` | Targeted media limit. |
-| `URMA_MAX_NAVIGATION_COPY_BYTES` | Navigation media and timeline-validation limit. |
-| `URMA_MAX_REUSABLE_EVIDENCE_MEDIA_BYTES` | Reusable evidence media limit. |
-| `URMA_MAX_REMOTE_ACQUISITION_WALL_MS` | Remote acquisition wall-time limit. |
-| `URMA_MAX_FRAME_SCHEDULE_PAGE_TARGETS` | Cadence page limit. |
-| `URMA_MAX_FRAME_SCHEDULE_TARGETS` | Cadence schedule limit. |
+| `URMA_DATA_DIR` | Installation, database, and cache directory. |
+| `URMA_LOCAL_ROOTS` | Directories allowed for local videos and caption sidecars. |
+| `URMA_ALLOW_UNC` | Set to `1` or `true` to allow UNC video inputs under an allowed root. This does not allow a UNC data directory. |
+| `URMA_DEBUG` | Set to `1` or `true` to write diagnostic logs to stderr. |
+| `URMA_DEBUG_FILE` | Append diagnostic logs to a JSONL file when debugging is enabled. |
 
-## Configuration
+### Acquisition limits
 
-| Variable | Purpose |
-| --- | --- |
-| `URMA_DATA_DIR` | Selects the persistent Urma data root. |
-| `URMA_LOCAL_ROOTS` | Platform-delimited list of roots allowed for local videos and sidecars. |
-| `URMA_ALLOW_UNC` | Allows UNC paths when set to `1` or `true`; the path must still be under an allowed root. |
-| `URMA_DEBUG` | Writes opt-in acquisition and subprocess diagnostics to stderr when set to `1` or `true`. |
-| `URMA_DEBUG_FILE` | Appends diagnostics to a JSONL file when `URMA_DEBUG` is enabled. |
+These limits bound downloads and frame schedules. Override them with positive
+integer values; byte limits use bytes and the timeout uses milliseconds.
 
-Set these variables in the host's Urma `env` entry, then restart the host.
-Separate local roots with `;` on Windows and `:` on macOS/Linux. Use absolute
-paths so root selection does not depend on the host's working directory.
+| Variable | Default |
+| --- | ---: |
+| `URMA_MAX_TARGETED_MEDIA_BYTES` | 67,108,864 (64 MiB) |
+| `URMA_MAX_NAVIGATION_COPY_BYTES` | 268,435,456 (256 MiB); also used for timeline validation |
+| `URMA_MAX_REUSABLE_EVIDENCE_MEDIA_BYTES` | 536,870,912 (512 MiB) |
+| `URMA_MAX_REMOTE_ACQUISITION_WALL_MS` | 180,000 (3 minutes) |
+| `URMA_MAX_FRAME_SCHEDULE_PAGE_TARGETS` | 12; cannot be increased above 12 |
+| `URMA_MAX_FRAME_SCHEDULE_TARGETS` | 120 |
 
-The packaged launcher uses the selected generation's absolute native-tool
-paths. It does not look up FFmpeg, ffprobe, or yt-dlp through `PATH`.
+Inline image responses have a fixed 8 MiB ceiling, and resource reads have a
+fixed 32 MiB ceiling. Tool-specific caption and sampling limits are listed in
+the [tool reference](docs/EVIDENCE_MODEL.md).
 
 ## CLI and maintenance
 
-The npm entry point exposes setup and version checks:
-
-```sh
-npx -y urma-mcp@rc --version
-npx -y urma-mcp@rc setup
-```
+Run setup again to update Urma. Restart the MCP client to use the new
+installation; an already running server keeps its current version.
 
-The `npx` version command reports the npm candidate's version. To check the
-installed generation, use the Node and launcher paths printed by setup:
+The npm version command reports the package selected by the tag:
 
 ```sh
-"/absolute/path/to/node" "/absolute/path/to/Urma/launcher-v1.mjs" --version
+npx -y urma-mcp@latest --version
 ```
 
-After setup, run the read-only doctor through the persistent launcher:
+To check the installed version or diagnose a problem, use the Node and launcher
+paths printed by setup. If setup used a custom data directory, set
+`URMA_DATA_DIR` to that directory before running launcher commands:
 
 ```sh
+"/absolute/path/to/node" "/absolute/path/to/Urma/launcher-v1.mjs" --version
 "/absolute/path/to/node" "/absolute/path/to/Urma/launcher-v1.mjs" doctor
 ```
 
-In PowerShell, prefix the quoted executable path with `&`:
+In PowerShell, prefix a quoted executable path with `&`:
 
 ```powershell
 & "C:\path\to\node.exe" "C:\path\to\Urma\launcher-v1.mjs" doctor
 ```
 
-Doctor checks the selected runtime, Node version, SQLite/FTS5, native-tool
-versions, storage, blob access, local roots, and frame-schedule limits. It
-prints its report to stderr and exits with status 0 when no check fails
-(warnings are allowed), or 1 when a check fails.
-
-For both version checks and doctor, set `URMA_DATA_DIR` if setup used a custom
-data root. To diagnose host behavior, also use the host's `URMA_LOCAL_ROOTS`
-and other Urma settings. If setup did not complete, report its error instead.
+Doctor checks the runtime, native tools, storage, local roots, and configured
+limits without changing the installation. Its report goes to stderr. Exit
+status `0` means no check failed, although warnings may remain; `1` means at
+least one check failed. Use the same `URMA_DATA_DIR`, `URMA_LOCAL_ROOTS`, and
+other Urma settings as your MCP client.
 
-The launcher also provides local generation recovery:
+If an update causes problems, the launcher provides two recovery commands:
 
 ```sh
 "/absolute/path/to/node" "/absolute/path/to/Urma/launcher-v1.mjs" rollback
 "/absolute/path/to/node" "/absolute/path/to/Urma/launcher-v1.mjs" recover
 ```
 
-`rollback` selects the retained previous generation after integrity and state
-compatibility checks. `recover` restores the selection recorded in
-`ACTIVE.backup.json`. Set `URMA_DATA_DIR` for a non-default data root.
+`rollback` selects the retained previous installation after integrity and
+state-compatibility checks. `recover` restores the installation selection
+saved in `ACTIVE.backup.json`. Restart the MCP client afterward.
 
-Normal MCP startup selects one generation for the process. It does not invoke
-npm, make a network request, check for updates, modify `PATH`, or download
-dependencies. A later setup affects new processes only.
+## Reporting problems
 
-## Boundaries
+Use the [bug-report template](https://github.com/sajidurdev/urma/issues/new?template=bug-report.md).
+Include reproduction steps, your OS and architecture, Node.js and MCP client
+versions, and the installed Urma version. For source-specific problems,
+include a public URL or describe a local file that reproduces the failure.
 
-Urma v0.1 does not transcribe audio, recognize objects or actions, or call a
-model. It supports finite videos without authentication or DRM. See
-[Product scope](docs/PRODUCT_SCOPE.md) for supported sources and exclusions.
+Include doctor output if setup completed, or the setup error if it did not.
+Remove credentials, private URLs, and personal paths before posting logs.
 
 ## Security
 
-Local paths require explicit allowed roots. Remote HTTP(S) work uses a
-process-local Safe Proxy that validates destinations and DNS results before
-connecting. Installed native tools are receipt-bound and hash-checked before
-first use. Subprocesses use argument arrays, `shell: false`, an allowlisted
-environment, bounded output, deadlines, cancellation, and process-tree
-cleanup.
-
-These controls protect the local application boundary under the trusted
-Node/FFmpeg/ffprobe/yt-dlp runtime model. They are not an operating-system
-sandbox against a compromised trusted executable.
-
-See [Security](docs/SECURITY.md) for the full boundary and failure behavior.
+Urma restricts local files to configured roots, validates remote destinations,
+and verifies its managed native tools. It is intended for one trusted local
+user. See [Security](docs/SECURITY.md) for the controls, assumptions, and MCP
+integration considerations.
 
 ## Development
 
-Use Node.js 24 and the pnpm version declared in `package.json`. See the
-[development prerequisites](docs/CONTRIBUTING.md#development-setup) for native
-tools used by the tests. From the repository root:
+From the repository root, using Node.js 24 and the pnpm version in
+`package.json`:
 
 ```sh
 pnpm install --frozen-lockfile
 pnpm check
 ```
 
-Contributions are welcome. Follow the [contribution guide](docs/CONTRIBUTING.md)
-for code structure, documentation standards, and pull request expectations.
+See [Contributing](docs/CONTRIBUTING.md) for native-tool prerequisites, code
+structure, and validation commands.
 
-## License
+## Documentation
 
-Urma is licensed under [Apache License 2.0](LICENSE). Third-party dependencies
-and downloaded native tools retain their own licenses. The installed
-generation's `licenses/` directory records native component licenses and
-upstream references; preserve the accompanying upstream notices when
-redistributing those tools. Urma's license does not grant rights to videos or
-captions retrieved from other sources.
+- [Product scope](docs/PRODUCT_SCOPE.md): supported sources and limitations.
+- [Tool reference](docs/EVIDENCE_MODEL.md): arguments, results, and examples.
+- [Architecture](docs/ARCHITECTURE.md): source snapshots, acquisition, caching, and installation design.
+- [Security](docs/SECURITY.md): filesystem, network, subprocess, and resource boundaries.
+- [Contributing](docs/CONTRIBUTING.md): development setup and contribution guidelines.
 
-## Documentation
+## License
 
-- [Product scope](docs/PRODUCT_SCOPE.md) — current v0.1 behavior and exclusions.
-- [Architecture](docs/ARCHITECTURE.md) — runtime layers, persistence, caching, and acquisition decisions.
-- [Evidence Model](docs/EVIDENCE_MODEL.md) — what each result means and what it cannot establish.
-- [Security](docs/SECURITY.md) — path, network, subprocess, installation, and cache controls.
-- [Contributing](docs/CONTRIBUTING.md) — local setup, validation commands, and change expectations.
+Urma is licensed under [Apache License 2.0](LICENSE). Dependencies and downloaded
+native tools retain their own licenses. The installed runtime's `licenses/`
+directory contains native component licenses and upstream references; preserve
+their notices when redistributing those tools. Urma's license does not grant
+rights to retrieved videos or captions.

package/dist/src/acquisition/frames.d.ts

@@ -4,7 +4,7 @@ import type { ResolvedSource } from "../sources/types.js";
 import { BlobStore } from "../store/blob-store.js";
 import type { StoredArtifact, UrmaStore } from "../store/store.js";
 import { MediaAcquirer } from "./media.js";
-import type { RemoteOperationContext } from "../remote/worker.js";
+import type { RemoteOperationContext } from "../remote/operation-context.js";
 export declare function exactFrameRequestKey(source: Pick<ResolvedSource, "sourceRef" | "revision">, atMs: number): string;
 export type FrameTargetOutcome = Readonly<{
     status: "success";