npm - @theaileverage/marionette - Versions diffs - 0.2.1 → 0.2.2 - Mend

@theaileverage/marionette 0.2.1 → 0.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (24) hide show

package/CHANGELOG.md +7 -0
package/DESIGN.md +3 -3
package/ORCHESTRATION.md +2 -2
package/README.md +19 -4
package/THIRD_PARTY_NOTICES.md +208 -0
package/VERIFICATION.md +8 -0
package/dist/cli.js +789 -121
package/dist/herdr-protocol.d.ts +1916 -0
package/dist/herdr-protocol.js +108 -0
package/dist/herdr-sdk.d.ts +105 -0
package/dist/herdr-sdk.js +105 -0
package/dist/herdr-streams.d.ts +49 -0
package/dist/herdr-streams.js +156 -0
package/dist/herdr-transport.d.ts +50 -0
package/dist/herdr-transport.js +232 -0
package/dist/mcp.js +1 -1
package/package.json +22 -5
package/public/assets/{index-BCi4LMak.js → index-CCfdv-uF.js} +1 -1
package/public/index.html +1 -1
package/skills/marionette/SKILL.md +70 -0
package/skills/marionette/references/coordination.md +63 -0
package/skills/marionette/references/herdr-sdk.md +147 -0
package/vendor/herdr-0.9.0/LICENSE +201 -0
package/vendor/herdr-0.9.0/README.md +5 -0

package/public/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="theme-color" content="#182a29" />
     <title>Marionette · Project control</title>
-    <script type="module" crossorigin src="/assets/index-BCi4LMak.js"></script>
+    <script type="module" crossorigin src="/assets/index-CCfdv-uF.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Dfuji944.css">
   </head>
   <body>

package/skills/marionette/SKILL.md ADDED Viewed

@@ -0,0 +1,70 @@
+---
+name: marionette
+description: Coordinate persistent coding, research, and review workers through Marionette using its MCP tools or CLI. Use when asked to use Marionette, act as its lead, or complete an assignment in a Marionette worker pane.
+---
+# Marionette
+Marionette is a persistent supervisor for agent CLIs in Herdr. Leads use a fenced lease; workers use an attempt-scoped environment credential. Read the role you are performing below. Use Marionette for managed task dispatch and lifecycle; direct Herdr operations do not create Marionette assignments or satisfy acceptance checks.
+## Connect and establish context
+Prefer connected Marionette MCP tools. MCP names use underscores (`project_briefing`); CLI action names use dots (`project.briefing`). Read the tool's input schema before constructing a call.
+For CLI access, use the installed `marionette`, or `node /absolute/package/dist/cli.js` for a source build. Commands discover the project binding from the working directory; pass `--home /absolute/state/directory` for a selected instance. Start with:
+```sh
+marionette projects
+marionette briefing PROJECT_ID
+marionette inbox PROJECT_ID --consumer stable-lead-name
+```
+Read the selected project's briefing, decisions, outstanding questions, and inbox before dispatch. Keep IDs from responses; do not infer workspace, task, revision, or lead identity from names or UI focus. Use `task_get` / `task.get` for targeted detail.
+If setup is needed, `marionette setup --schema` and `setup --help` describe the installed options. `setup --json --project /absolute/project --lead codex-desktop --lead-name NAME` creates/reuses the named session, supervisor and project binding and configures the selected lead. Setup's `--dry-run` previews its effects. Preserve an existing installation and saved lead. `doctor` diagnoses connections; deleting state is not a recovery step.
+## Lead workflow
+Read a supplied bootstrap prompt and private lease file locally. Keep the token out of prose, artifacts, and logs. A CLI mutation accepts `--lease /private/path/lead.json`; an MCP mutation accepts the equivalent `lease` object. Acquire control only for initial establishment or an authorized takeover. `lead_handover` / `lead.handover` transfers the lease and invalidates the old one. Do not take over merely because another lead is quiet.
+Submit an assignment with a stable idempotency `key`, an objective, `kind` (`codex`, `claude`, or `agy`), bounded `ownership`, and meaningful `checks`. See [assignment and outcome examples](references/coordination.md) when constructing inputs.
+- Ownership paths are literal files or directory prefixes relative to the task's working directory, not globs. Workers share files unless explicitly placed in a worktree. Preserve concurrent edits.
+- Assess file conflicts before choosing execution. Use shared mode for disjoint work or deliberate access to uncommitted changes. Recommend worktree mode for overlapping work and obtain a choice when the workflow has not already been authorized. Worktrees start from committed HEAD or `baseRef`; source edits and dependency branches are not automatically copied or merged.
+- Submission returns before startup. A queued assignment may be waiting for dependencies, ownership, provider/model limits, or project capacity. Read its wait reason before retrying.
+- After a lost submission response, reuse the same key and identical input. A changed objective needs a redirect/revision with its own key, not a duplicated assignment.
+- Use `task_control` / `task.control` for reply, pause, cancel, redirect, or explicit keys. Cancellation retains the worker terminal. A worker's native permission UI requires inspecting the actual screen and resolving the specific request.
+For durable multi-step outcomes, create criteria with `outcome_create`, attach assignments to the outcome and current tree revision, and use `plan_revise` with current revisions and reasons for changes. Review evidence independently. Finish with criterion assessments, integrated review, and `outcome_complete`; worker prose and terminal idle status are insufficient. Required failed, cancelled, stale, or unverified work prevents completion.
+When no independent work remains, register `lead_wait` with an observable condition and yield. A Herdr adapter must pin the actual lead pane, terminal, agent name/kind, and native session obtained through `project_inspect`. Desktop leads use the `next-message` adapter: MCP alone does not wake an idle conversation. Read and acknowledge inbox events on later turns; do not hold a model turn open polling. Save checkpoints before handover or consequential context changes.
+Completion retains Git worktrees and branches. Follow existing authorization for review, merging, publishing, and cleanup; task completion itself does not authorize publication. Use `cleanup_preview` before explicit release/delivery/archive/collection. Pane-aware workers can share a tab, so never close a worker's entire tab manually to release one worker.
+## Worker workflow
+Your launch prompt is the task contract: preserve its ID, current revision, working directory, owned paths, and checks. Use its exact durable worker CLI path. Credentials are already in `MARIONETTE_WORKER_TOKEN`, `MARIONETTE_TASK_ID`, and `MARIONETTE_URL`; do not print them or acquire a lead lease.
+Write request/report JSON under `.marionette-reports/TASK_ID/` in the task working directory. Run the supplied `worker-report --file /absolute/report.json` command with, for example:
+```json
+{
+  "revision": 1,
+  "type": "complete",
+  "summary": "Implemented the assigned behavior and verified it",
+  "artifacts": ["src/owned-file.ts"],
+  "evidence": ["Actual command and result"]
+}
+```
+Use the actual revision and artifacts. Other report types are `progress`, `blocked`, and `failure`. For a question, report `blocked` with the precise question in `summary`, then yield. Request normal sandbox permission if the report command cannot reach the local supervisor. Finish your native turn after the report so Marionette can observe settlement and verify checks.
+Only workers explicitly granted `canDelegate` may create children, through `worker-call` action `delegate`. Children stay within the parent's ownership and inherited budget. Read current state through `worker-call` action `inspect`; mutations include the current parent revision. After delegation, report `yield` at the returned `parentRevision`, end the turn, and stop editing delegated paths until resumed. Integrate child evidence and pass your own checks before completing.
+## Recover uncertainty
+An `uncertain` run means delivery or creation lost confirmation. Inspect the recorded pane and output, then use `task_reconcile` with evidence and `delivered` or `not-delivered`. Do not replay automatically. A creation interruption cannot be marked delivered because no task prompt was attempted. Ambiguous split membership or an occupied orphan pane requires manual inspection; recovery preserves it. Explicit retries consume the task's bounded attempts and preserve its worktree.
+## Programmatic Herdr control
+For explicitly requested terminal control or integration code, read [the thin SDK guide](references/herdr-sdk.md). The SDK controls terminals; it does not enforce Marionette leases, task ownership, or verification. Use task controls for Marionette-managed workers.

package/skills/marionette/references/coordination.md ADDED Viewed

@@ -0,0 +1,63 @@
+# Assignment and outcome inputs
+CLI calls accept JSON files; MCP calls accept the same fields with the lease supplied in the object. Replace IDs, paths and checks with observed project values.
+```json
+{
+  "assignment": {
+    "projectId": "PROJECT_ID",
+    "key": "parser-v1",
+    "title": "Implement invoice parser",
+    "kind": "codex",
+    "prompt": "Implement the parser and its behavior tests. Preserve concurrent edits.",
+    "ownership": ["src/parser.ts", "tests/parser.test.ts"],
+    "execution": { "mode": "shared" },
+    "dependencies": [],
+    "checks": [
+      {
+        "type": "command",
+        "command": "npm",
+        "args": ["test", "--", "tests/parser.test.ts"],
+        "timeoutMs": 30000
+      }
+    ],
+    "maxAttempts": 2
+  }
+}
+```
+```sh
+marionette call task.submit --file assignment.json --lease /private/path/lead.json
+marionette call task.get --json '{"taskId":"RETURNED_TASK_ID"}'
+```
+Command checks execute without a shell. Use a real executable and argument array; shell syntax is not interpreted. File checks support `path`, optional `contains` and `sha256`, and `allowUnchanged` (false by default). A file normally must change from its dispatch digest. Worker-reported artifacts must be owned by the assignment.
+For an isolated checkout use `"execution": { "mode": "worktree", "baseRef": "main" }` only when that branch and workflow are appropriate. `baseRef` is optional. Inspect returned `task.worktree` and `task.cwd`; don't invent the checkout path.
+A persistent outcome starts with:
+```json
+{
+  "outcome": {
+    "projectId": "PROJECT_ID",
+    "key": "parser-outcome-v1",
+    "objective": "Deliver correct invoice parsing",
+    "scope": ["src/parser.ts", "tests/parser.test.ts", "review"],
+    "category": "software",
+    "criteria": [
+      {
+        "id": "correct",
+        "description": "Valid invoices parse and invalid inputs fail clearly",
+        "requiredEvidence": "Independent tests and review"
+      }
+    ],
+    "maxTurns": 30,
+    "maxDepth": 2
+  }
+}
+```
+Call `outcome.create`, then add the returned `outcomeId` and current `expectedTreeRevision` to assignments. `maxTurns` bounds supervisor-triggered execution turns, not tokens or cost. Each required addition changes the tree revision; fetch fresh state before the next revision-sensitive call.
+For each criterion call `outcome.assess` with `outcomeId`, `expectedRevision`, `criterionId`, `rationale`, and `references` (file path strings). Call `outcome.integrate` with the current revision, `summary`, and `references`; then `outcome.complete`. All require the lease. References into managed checkouts use `task:TASK_ID:relative/owned/file`. Never weaken the completion contract merely to pass it.

package/skills/marionette/references/herdr-sdk.md ADDED Viewed

@@ -0,0 +1,147 @@
+# Thin Herdr SDK
+## Coverage and compatibility
+The SDK targets the installed Herdr **0.9.0, protocol 22** schema. It exposes all **102 schema-defined methods**, plus the documented `pane.graphics.stream` transport omitted by upstream's exported schema. This includes workspace, worktree, tab, pane, layout, agent, event, integration, plugin, notification, client, and server APIs. The full surface uses `api[method](params, options?)`; the short helpers below remain conveniences for common operations.
+The vendored schema and generated types are reproducible with `npm run sdk:generate` in the Marionette source checkout. Coverage tests exercise every method through an isolated Unix-socket peer, plus streaming success/failure cases. A separate live 0.9.0 server/client check verified emitted RGB/RGBA/BGRA/PNG payloads, file-frame acknowledgements, placement, replacement, and layer removal using a simulated Kitty-capable terminal. See `VERIFICATION.md` in the package for evidence and limits; this does not validate every server-side operation or the native terminal display. Herdr still enforces semantic constraints, installed plugins, and client/graphics capabilities. Existing Marionette pane and agent methods also remain schema-compatible with 0.8.2/protocol 20.
+The [Socket API documentation](https://herdr.dev/docs/socket-api/) describes the server contract. In 0.9.0, multiple clients can size tabs independently, so read current pane geometry before splitting.
+After installing a build of Marionette containing the SDK, import its ESM subpath in Node.js 22.13+:
+```js
+import { HerdrClient, HerdrError } from '@theaileverage/marionette/herdr-sdk';
+// Inside a real Herdr pane: reads HERDR_ENV and HERDR_SOCKET_PATH.
+const herdr = HerdrClient.fromEnv();
+const caller = process.env.HERDR_PANE_ID;
+if (!caller) throw new Error('Missing caller pane');
+const { layout } = await herdr.pane.layout(caller);
+const rect = layout.panes.find((pane) => pane.pane_id === caller)?.rect;
+if (!rect) throw new Error('Caller pane is missing from layout');
+const { pane } = await herdr.pane.split(caller, {
+  direction: rect.width >= rect.height * 3 ? 'right' : 'down',
+  cwd: process.cwd(),
+});
+await herdr.agent.start(pane.pane_id, 'reviewer', 'codex');
+const { agent } = await herdr.agent.get(pane.pane_id);
+if (
+  agent.name !== 'reviewer' ||
+  agent.agent !== 'codex' ||
+  !['idle', 'done'].includes(agent.agent_status) ||
+  agent.launch_pending ||
+  agent.interactive_ready === false
+) {
+  throw new Error('Inspect startup readiness before sending work');
+}
+await herdr.agent.prompt('reviewer', 'Review the assigned code and report actionable findings.', {
+  timeout_ms: 120000,
+});
+const { read } = await herdr.pane.read(pane.pane_id, 120);
+console.log(read.text);
+```
+This example creates and runs an independent agent only when that work is authorized. Do not use it to bypass a Marionette worker's delegation restriction.
+For service integration, `new HerdrClient('/absolute/explicitly-selected/herdr.sock')` selects a named connection without fabricating caller environment or relying on UI focus. The constructor does not discover or start sessions. Keep the selected socket private to the local user.
+Typed helpers preserve Herdr's result envelopes and opaque IDs:
+- `workspace.list()`, `workspace.create({ cwd, label, env?, focus? })`
+- `tab.list(workspaceId)`, `tab.create(workspaceId, { cwd, label?, env?, focus? })`, `tab.close(tabId)`
+- `pane.list(workspaceId)`, `pane.layout(paneId)`, `pane.split(paneId, { direction, cwd, ratio?, env?, focus? })`
+- `pane.read(paneId, lines?)`, `pane.sendText(paneId, text)`, `pane.sendKeys(paneId, keys)`, `pane.close(paneId)`
+- `agent.start(paneId, name, kind, args?, timeoutMs?)`, `agent.get(target)`, `agent.prompt(target, text, wait?)`, `agent.wait(target, { timeout_ms, until? })`, `agent.sendKeys(target, keys)`
+Creation defaults to `focus: false`. `pane.split` maps its target to the protocol's `target_pane_id`. Read uses `recent_unwrapped` text. `sendText` does not submit Enter; use `agent.prompt` for atomic agent prompt submission. Start requires an available shell pane. `agent.start` only acknowledges the protocol launch; check `agent.get` for matching identity and interactive readiness before prompting. The CLI can provide additional startup polling that the raw socket does not.
+## Full typed wire API
+```ts
+import { HerdrClient, HERDR_METHODS } from '@theaileverage/marionette/herdr-sdk';
+const herdr = HerdrClient.fromEnv();
+const info = await herdr.request('ping');
+if (info.type === 'pong') console.log(info.version, info.protocol);
+// Same exact method and parameter names as Herdr's schema:
+const layout = await herdr.api['pane.layout']({ pane_id: process.env.HERDR_PANE_ID });
+if (layout.type === 'pane_layout') console.log(layout.layout.panes);
+const plugins = await herdr.api['plugin.list']();
+if (plugins.type === 'plugin_list') console.log(plugins.plugins);
+console.log(HERDR_METHODS); // 102 schema-defined names
+console.log(Object.keys(herdr.api)); // Includes pane.graphics.stream as well
+```
+`request(method, params?, options?)` supports all one-shot methods with generated parameter types. It returns the schema's discriminated `HerdrResult` union; narrow on `result.type` to read a particular response shape. Parameters are required when the schema requires fields. Runtime semantic and range validation belongs to Herdr. Values are ordinary JSON/JavaScript values; use safe integer values for counters that need exact arithmetic.
+`api[method]` exposes those same calls and routes `events.subscribe` and `pane.graphics.stream` to persistent connections. `HerdrParams`, `HerdrMethod`, `HerdrResult`, `HerdrEvent`, and the request/response type namespaces are exported for typed agent code. The wire API passes parameters as supplied: unlike convenience creation helpers, it does not add `focus: false` or fill missing targets. Pass explicit IDs to avoid server-focused defaults.
+Options accept `signal: AbortSignal`, `timeoutMs`, and `maxResponseBytes` (default 32 MiB per message). Ordinary requests default to 10 seconds. Agent startup and server waits allow their requested server timeout plus five seconds; a wait with no server deadline remains open until completion, disconnect or cancellation. `timeoutMs: null` explicitly disables the transport deadline. Aborting a mutation cannot undo input already delivered.
+`call<Result>(method, params?, timeoutMs?)` remains an untyped escape hatch for future one-shot extensions, with a 10-second default. JavaScript omits `<Result>`. It refuses the two streaming methods, since closing at their first acknowledgement would discard the stream.
+## Event subscriptions
+```js
+const controller = new AbortController();
+const events = await herdr.subscribe([{ type: 'pane.created' }, { type: 'layout.updated' }], {
+  signal: controller.signal,
+  maxQueuedEvents: 1024,
+});
+try {
+  // Subscribe first: 0.9.0 does not replay lifecycle history.
+  const snapshot = await herdr.request('session.snapshot');
+  console.log(snapshot);
+  for await (const event of events) {
+    console.log(event.event, event.data);
+    // Apply events to the snapshot in order; break when this monitoring job finishes.
+  }
+} finally {
+  events.close();
+}
+```
+Subscription creation resolves only after Herdr's acknowledgement. It then buffers events while the initial snapshot is loading. All lifecycle, output-match, agent-status, and scroll subscriptions are available through generated `RequestTypes.Subscription`. A `for await` break or `events.close()` releases the socket. The supplied signal cancels the stream's entire lifetime. The open timeout applies only to acknowledgement.
+Buffers default to 1,024 pending messages and 32 MiB total; `maxQueuedEvents` and `maxQueuedBytes` customize these bounds. Overflow fails with `herdr_stream_overflow` and closes the socket instead of silently losing events. Errors and unexpected disconnects reject iteration and `events.closed`. The SDK never reconnects or replays automatically; after an intentional reconnect, subscribe first and take a fresh snapshot.
+## Graphics streams
+```js
+const stream = await herdr.graphicsStream({ pane_id: 'OBSERVED_PANE_ID', layer_id: 'preview' });
+try {
+  // One pixel of owned RGBA bytes; the SDK computes data_length.
+  await stream.frame(
+    { format: 'rgba', image_width: 1, image_height: 1 },
+    new Uint8Array([255, 128, 0, 255]),
+  );
+  // Keep the stream open for the desired display lifetime.
+} finally {
+  stream.close(); // Herdr removes the layer when its owning stream closes.
+}
+```
+Await each frame before sending another. Concurrent frames are rejected with `herdr_stream_busy` to prevent interleaved headers/bodies. Inline PNG/RGB/RGBA/BGRA frames send a JSON header followed by exactly the raw payload bytes, up to Herdr's 16 MiB inline limit. `frame()` resolves after the local socket write; Herdr does not send successful inline-frame acknowledgements. Observe `stream.closed` for later server errors.
+For negotiated direct-file transport, first inspect `api['pane.graphics.info']`. Only use it when the server advertises support for the intended format, layer, size and attached terminal. Send an immutable absolute local `rgba` or `bgra` file with:
+```js
+const ack = await stream.fileFrame({
+  format: 'rgba',
+  image_width: 800,
+  image_height: 600,
+  file: { path: '/absolute/private/frame.rgba' },
+  sequence: 1,
+  revision: 1,
+});
+```
+The returned ACK must match both sequence and revision before the source file may be reused. A failed or timed-out call grants no source-reuse acknowledgement. The SDK does not read, write or remove the source file. Frame calls have a 30-second default transport deadline. Graphics-stream request/frame types are maintained against Herdr's tagged stream implementation because the exported schema omits that method.
+## Errors and scope
+Errors expose `code` and `message`. Server codes are preserved; transport failures include `herdr_timeout`, `herdr_unavailable`, `herdr_disconnected`, `herdr_aborted`, `herdr_response_too_large`, and `herdr_stream_overflow`. A timeout or disconnect can occur after a mutation succeeded. Inspect the intended target before deciding to retry.
+The SDK is dependency-free at runtime and accepts explicitly selected Unix socket paths or Windows named-pipe paths. It does not start sessions, manage permissions, install plugins, or dispatch workers except through the API calls the caller chooses. Closing a tab closes every pane inside it; preserve sibling workers and close only resources within the authorized scope.

package/vendor/herdr-0.9.0/LICENSE ADDED Viewed

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+   1. Definitions.
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+   END OF TERMS AND CONDITIONS
+   APPENDIX: How to apply the Apache License to your work.
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+   Copyright [yyyy] [name of copyright owner]
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/vendor/herdr-0.9.0/README.md ADDED Viewed

@@ -0,0 +1,5 @@
+# Herdr 0.9.0 socket schema
+`api.schema.json` is the unmodified output of `herdr api schema --json` from the installed Herdr 0.9.0 binary (protocol 22). The corresponding upstream release is https://github.com/herdrdev/herdr/tree/v0.9.0. The upstream Apache-2.0 license is retained in `LICENSE`.
+Marionette generates TypeScript declarations and its method registry with `npm run sdk:generate`. The generated types describe wire structure; Herdr enforces numeric ranges, feature availability, and other semantic constraints. The documented `pane.graphics.stream` transport is handled separately because upstream omits it from this JSON schema; its contract comes from `src/api/schema/panes.rs` and `src/api/server/pane_graphics_stream.rs` at the same tag.