@nema-project/nema 0.0.0-stage → 0.1.3

package/dist/chunks/chunk-HEIQINX3.js

@@ -0,0 +1,825 @@
+// ../../../packages/shared/dist/report.js
+import { z } from "zod";
+var HookSignal = z.object({
+  agent: z.string().min(1).max(40),
+  cwd: z.string(),
+  gitCommonDir: z.string(),
+  branch: z.string().nullable(),
+  head: z.string().regex(/^[0-9a-f]{40}$/),
+  at: z.iso.datetime({ offset: true }),
+  sessionId: z.string().max(200).nullable()
+});
+var ReportInput = z.object({
+  agent: z.string().min(1).max(40),
+  gitCommonDir: z.string(),
+  summary: z.string().min(1).max(2e3),
+  entries: z.array(z.string().regex(/^[RDTQSGW]-[1-9]\d*$/)).max(50).default([]),
+  commits: z.array(z.string().regex(/^[0-9a-f]{7,40}$/)).min(1).max(50),
+  files: z.array(z.string().min(1).max(500)).max(500).default([]),
+  task: z.number().int().min(1).max(15).optional()
+});
+var IMPLEMENTATION_STATUSES = ["reported", "verified", "mismatch"];
+var Implementation = z.object({
+  status: z.enum(IMPLEMENTATION_STATUSES),
+  evidence: z.object({
+    reportMessageId: z.string().nullable(),
+    commits: z.array(z.string()),
+    /** True when the work was inferred from code on main with no report. */
+    inferred: z.boolean(),
+    note: z.string().nullable(),
+    confirmedBy: z.literal("user").nullable()
+  })
+});
+
+// ../../../packages/shared/dist/entry.js
+import { z as z2 } from "zod";
+var ENTRY_KINDS = ["requirement", "decision", "tradeoff", "question", "source", "diagram", "workpackage"];
+var EntryKindSchema = z2.enum(ENTRY_KINDS);
+var BASIS_VALUES = ["stated", "decided", "inferred"];
+var BasisSchema = z2.enum(BASIS_VALUES);
+var Quote = z2.object({ messageId: z2.string().min(1), text: z2.string().min(1).max(500) });
+var DIAGRAM_TYPES = [
+  "architecture",
+  "workflow",
+  "sequence",
+  "dataflow",
+  "lifecycle",
+  "erd",
+  "class",
+  "tree",
+  "timeline",
+  "waterfall"
+];
+var DiagramMeta = z2.object({
+  repoId: z2.string().min(1),
+  type: z2.enum(DIAGRAM_TYPES),
+  /** repo id -> main sha the diagram was drawn at. */
+  sourceCommits: z2.record(z2.string(), z2.string()),
+  /** archify node id -> repo-relative paths that node stands for. */
+  nodePaths: z2.record(z2.string(), z2.array(z2.string()))
+});
+var MAX_WP_TASKS = 15;
+var WpTask = z2.object({
+  n: z2.number().int().min(1).max(MAX_WP_TASKS),
+  title: z2.string(),
+  satisfies: z2.array(z2.string()),
+  files: z2.array(z2.object({ op: z2.enum(["modify", "create"]), repo: z2.string(), path: z2.string() })),
+  status: z2.enum(["pending", "reported", "verified", "mismatch"]),
+  inferred: z2.boolean(),
+  reportMessageId: z2.string().nullable(),
+  confirmedBy: z2.literal("user").nullable()
+});
+var WorkPackageMeta = z2.object({
+  requirements: z2.array(z2.string()),
+  repos: z2.array(z2.string()),
+  approvedAt: z2.string().nullable(),
+  approvedCommit: z2.string().nullable(),
+  blockedOn: z2.string().nullable(),
+  tasks: z2.array(WpTask)
+});
+var IsoDateTime = z2.iso.datetime({ offset: true }).nullable();
+var PREFIX_KIND = {
+  R: "requirement",
+  D: "decision",
+  T: "tradeoff",
+  Q: "question",
+  S: "source",
+  G: "diagram",
+  W: "workpackage"
+};
+var ID_RE = /^(R|D|T|Q|S|G|W)-[1-9]\d*$/;
+function kindFromId(id) {
+  if (!ID_RE.test(id))
+    return null;
+  return PREFIX_KIND[id[0]] ?? null;
+}
+var KIND_STATUSES = {
+  requirement: ["active", "superseded", "dropped"],
+  decision: ["active", "superseded", "dropped"],
+  tradeoff: ["active", "dropped"],
+  question: ["open", "resolved", "dropped"],
+  source: ["active", "dropped"],
+  diagram: ["active", "superseded", "dropped"],
+  workpackage: ["draft", "approved", "in_progress", "done", "dropped"]
+};
+var ALL_STATUSES = ["active", "superseded", "dropped", "open", "resolved", "draft", "approved", "in_progress", "done"];
+var StatusSchema = z2.enum(ALL_STATUSES);
+var BusinessDate = z2.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable();
+var HttpUrl = z2.string().refine((s) => {
+  try {
+    const p = new URL(s).protocol;
+    return p === "http:" || p === "https:";
+  } catch {
+    return false;
+  }
+}, "url must be http or https");
+var Priority = z2.union([z2.literal(1), z2.literal(2), z2.literal(3)]);
+function refineKind(v, ctx) {
+  if (v.status !== void 0 && !KIND_STATUSES[v.kind].includes(v.status)) {
+    ctx.addIssue({ code: "custom", path: ["status"], message: `invalid status "${v.status}" for ${v.kind}` });
+  }
+  if (v.kind === "source") {
+    if (v.url === void 0)
+      ctx.addIssue({ code: "custom", path: ["url"], message: "url is required for source" });
+  } else if (v.url !== void 0) {
+    ctx.addIssue({ code: "custom", path: ["url"], message: "url is only allowed for source" });
+  }
+  if (v.kind === "diagram") {
+    if (v.diagram === void 0)
+      ctx.addIssue({ code: "custom", path: ["diagram"], message: "diagram is required for diagram" });
+  } else if (v.diagram !== void 0) {
+    ctx.addIssue({ code: "custom", path: ["diagram"], message: "diagram is only allowed for diagram" });
+  }
+  if (v.kind === "workpackage") {
+    if (v.workpackage === void 0)
+      ctx.addIssue({ code: "custom", path: ["workpackage"], message: "workpackage is required for workpackage" });
+  } else if (v.workpackage !== void 0) {
+    ctx.addIssue({ code: "custom", path: ["workpackage"], message: "workpackage is only allowed for workpackage" });
+  }
+  if (v.kind !== "requirement" && v.implementation !== void 0) {
+    ctx.addIssue({ code: "custom", path: ["implementation"], message: "implementation is only allowed for requirement" });
+  }
+  if (v.kind === "question") {
+    if (v.priority === void 0)
+      ctx.addIssue({ code: "custom", path: ["priority"], message: "priority is required for question" });
+  } else if (v.priority !== void 0) {
+    ctx.addIssue({ code: "custom", path: ["priority"], message: "priority is only allowed for question" });
+  }
+}
+var EntryFrontmatter = z2.object({
+  id: z2.string().regex(ID_RE),
+  kind: EntryKindSchema,
+  title: z2.string().min(1).max(200),
+  status: StatusSchema,
+  businessDate: BusinessDate,
+  related: z2.array(z2.string()),
+  sourceMessages: z2.array(z2.string()),
+  url: HttpUrl.optional(),
+  priority: Priority.optional(),
+  diagram: DiagramMeta.optional(),
+  implementation: Implementation.optional(),
+  workpackage: WorkPackageMeta.optional(),
+  basis: BasisSchema.nullable(),
+  ingestedAt: IsoDateTime,
+  confirmedAt: IsoDateTime,
+  quotes: z2.array(Quote)
+}).superRefine((v, ctx) => {
+  refineKind(v, ctx);
+  if (kindFromId(v.id) !== v.kind) {
+    ctx.addIssue({ code: "custom", path: ["id"], message: "id prefix does not match kind" });
+  }
+});
+var UpsertEntryInput = z2.object({
+  id: z2.string().regex(ID_RE).optional(),
+  kind: EntryKindSchema,
+  title: z2.string().min(1).max(200),
+  body: z2.string(),
+  status: StatusSchema.optional(),
+  businessDate: BusinessDate.optional(),
+  related: z2.array(z2.string()).optional(),
+  sourceMessages: z2.array(z2.string()).default([]),
+  url: HttpUrl.optional(),
+  priority: Priority.optional(),
+  /** Requirements only. The Room API checks it against reports; omitted keeps the stored one. */
+  implementation: Implementation.optional(),
+  basis: BasisSchema.optional(),
+  quotes: z2.array(Quote).max(10).optional(),
+  confirmed: z2.boolean().optional(),
+  reason: z2.string().min(1).max(500)
+}).superRefine((v, ctx) => {
+  refineKind(v, ctx);
+  if (v.id !== void 0 && kindFromId(v.id) !== v.kind) {
+    ctx.addIssue({ code: "custom", path: ["id"], message: "id prefix does not match kind" });
+  }
+});
+
+// ../../../packages/shared/dist/workspace.js
+import { z as z3 } from "zod";
+var MessageQuote = z3.object({
+  messageId: z3.string(),
+  role: z3.enum(["user", "agent", "system", "report"]),
+  excerpt: z3.string()
+});
+var UserMessageMeta = z3.object({
+  quote: MessageQuote.optional()
+});
+var AgentMessageMeta = z3.object({
+  changes: z3.array(z3.object({
+    entryId: z3.string(),
+    kind: EntryKindSchema,
+    title: z3.string(),
+    op: z3.enum(["add", "update"])
+  })),
+  askedQuestion: z3.object({ id: z3.string(), title: z3.string(), body: z3.string() }).nullable(),
+  quote: MessageQuote.optional()
+});
+function isBranchName(name) {
+  if (name === "" || name === "HEAD" || name === "@")
+    return false;
+  if (/^[-+]/.test(name))
+    return false;
+  if (/[\u0000-\u0020\u007f~^:?*[\\]/.test(name))
+    return false;
+  if (name.includes("..") || name.includes("@{"))
+    return false;
+  if (name.endsWith("/") || name.endsWith(".") || name.endsWith(".lock"))
+    return false;
+  return name.split("/").every((segment) => segment !== "" && !segment.startsWith(".") && !segment.endsWith(".lock"));
+}
+
+// ../../../packages/shared/dist/plugins.js
+var PAGE = { type: "number", minimum: 1, description: "Page number for pagination." };
+var PER_PAGE = { type: "number", minimum: 1, maximum: 100, description: "Results per page, at most 100." };
+var OWNER = { type: "string", description: "Repository owner." };
+var REPO_NAME = { type: "string", description: "Repository name." };
+function ghArgsSchema(description) {
+  return {
+    type: "object",
+    properties: { args: { type: "array", items: { type: "string" }, minItems: 2, maxItems: 80, description } },
+    required: ["args"],
+    additionalProperties: false
+  };
+}
+var GITHUB_FUNCTIONS = [
+  {
+    name: "github__pull_request_read",
+    description: "Read one pull request of a bound repository on GitHub: details, diff, files, commits, reviews or comments.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        owner: OWNER,
+        repo: REPO_NAME,
+        pullNumber: { type: "number", minimum: 1, description: "Pull request number." },
+        method: {
+          type: "string",
+          enum: ["get", "get_diff", "get_status", "get_files", "get_commits", "get_review_comments", "get_reviews", "get_comments", "get_check_runs"]
+        },
+        page: PAGE,
+        perPage: PER_PAGE,
+        after: { type: "string", description: "Cursor for get_review_comments pagination." }
+      },
+      required: ["owner", "repo", "pullNumber", "method"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "github__list_pull_requests",
+    description: "List pull requests of a bound repository on GitHub.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        owner: OWNER,
+        repo: REPO_NAME,
+        state: { type: "string", enum: ["open", "closed", "all"] },
+        base: { type: "string", description: "Filter by base branch." },
+        head: { type: "string", description: "Filter by head user or org and branch." },
+        sort: { type: "string" },
+        direction: { type: "string" },
+        page: PAGE,
+        perPage: PER_PAGE
+      },
+      required: ["owner", "repo"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "github__search_pull_requests",
+    description: "Search pull requests on GitHub with a query that names exactly one bound repository as repo:owner/name.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "GitHub search syntax, with exactly one repo:owner/name qualifier." },
+        sort: { type: "string" },
+        order: { type: "string" },
+        page: PAGE,
+        perPage: PER_PAGE
+      },
+      required: ["query"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "github__issue_read",
+    description: "Read one issue of a bound repository on GitHub: details, comments, sub-issues, parent or labels.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        owner: OWNER,
+        repo: REPO_NAME,
+        issue_number: { type: "number", minimum: 1, description: "Issue number." },
+        method: { type: "string", enum: ["get", "get_comments", "get_sub_issues", "get_parent", "get_labels"] },
+        page: PAGE,
+        perPage: PER_PAGE
+      },
+      required: ["owner", "repo", "issue_number", "method"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "github__list_issues",
+    description: "List issues of a bound repository on GitHub.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        owner: OWNER,
+        repo: REPO_NAME,
+        state: { type: "string" },
+        labels: { type: "array", items: { type: "string" } },
+        orderBy: { type: "string" },
+        direction: { type: "string" },
+        since: { type: "string", description: "ISO 8601 timestamp." },
+        after: { type: "string", description: "Cursor from the previous page." },
+        perPage: PER_PAGE
+      },
+      required: ["owner", "repo"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "github__search_issues",
+    description: "Search issues on GitHub with a query that names exactly one bound repository as repo:owner/name.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "GitHub search syntax, with exactly one repo:owner/name qualifier." },
+        sort: { type: "string" },
+        order: { type: "string" },
+        page: PAGE,
+        perPage: PER_PAGE
+      },
+      required: ["query"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "github__gh_read",
+    description: "Run a read-only gh command on a bound repository or on a Project of a bound owner, such as issue list, pr view, label list, run list or project item-list.",
+    readOnly: true,
+    parameters: ghArgsSchema("Arguments after gh, one array item each. Read commands: issue list|view|status, pr list|view|diff|checks|status, label list, run list|view, project list|view|field-list|item-list. Repository commands need --repo owner/name; project commands need --owner. Use long flags (--state, --limit, --json fields, --jq expr).")
+  },
+  {
+    name: "github__gh_write",
+    description: "Run a gh command that changes GitHub on a bound repository or on a Project of a bound owner, such as issue create, issue comment, issue edit, pr comment or project item-add.",
+    readOnly: false,
+    parameters: ghArgsSchema("Arguments after gh, one array item each. Write commands: issue create|comment|edit|close|reopen, pr comment|edit, label create|edit, project item-add|item-create|item-edit|item-archive. Repository commands need --repo owner/name; project commands need --owner. Pass text with --title and --body; files, editors and merging are not available.")
+  }
+];
+var PLUGINS = [
+  {
+    id: "code",
+    displayName: "graphify",
+    dataFlow: "local",
+    runsOn: "daemon",
+    scope: "repo",
+    functions: [
+      {
+        name: "code__search",
+        description: "Search the repository for code matching a query.",
+        readOnly: true,
+        parameters: {
+          type: "object",
+          properties: {
+            repo: { type: "string" },
+            query: { type: "string" }
+          },
+          required: ["repo", "query"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "code__explain",
+        description: "Explain what a named symbol does in the repository.",
+        readOnly: true,
+        parameters: {
+          type: "object",
+          properties: {
+            repo: { type: "string" },
+            symbol: { type: "string" }
+          },
+          required: ["repo", "symbol"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "code__path",
+        description: "Show the path from one symbol to another in the repository.",
+        readOnly: true,
+        parameters: {
+          type: "object",
+          properties: {
+            repo: { type: "string" },
+            from: { type: "string" },
+            to: { type: "string" }
+          },
+          required: ["repo", "from", "to"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "code__read",
+        description: "Read a file from the repository, optionally limited to a line range.",
+        readOnly: true,
+        parameters: {
+          type: "object",
+          properties: {
+            repo: { type: "string" },
+            path: { type: "string" },
+            startLine: { type: "integer", minimum: 1 },
+            endLine: { type: "integer", minimum: 1 }
+          },
+          required: ["repo", "path"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "code__changes",
+        description: "List changes in the repository between two refs.",
+        readOnly: true,
+        parameters: {
+          type: "object",
+          properties: {
+            repo: { type: "string" },
+            from: { type: "string" },
+            to: { type: "string", description: "Defaults to the current main ref when omitted." }
+          },
+          required: ["repo", "from"],
+          additionalProperties: false
+        }
+      }
+    ]
+  },
+  {
+    id: "diagram",
+    displayName: "archify",
+    dataFlow: "local",
+    runsOn: "hub",
+    scope: "repo",
+    functions: [
+      {
+        name: "diagram__save",
+        description: "Save an archify diagram of a bound repository as a knowledge entry; pass id to update that diagram in place, and fix the spec and retry when the result is ok:false with diagnostics.",
+        readOnly: true,
+        parameters: {
+          type: "object",
+          properties: {
+            repo: { type: "string" },
+            type: { type: "string", enum: [...DIAGRAM_TYPES] },
+            title: { type: "string", minLength: 1, maxLength: 200 },
+            summary: { type: "string", description: "Markdown shown above the diagram." },
+            spec: { type: "object", description: "The archify JSON spec for this diagram type." },
+            nodePaths: {
+              type: "object",
+              description: "archify node id -> repo-relative paths that node stands for.",
+              additionalProperties: { type: "array", items: { type: "string" } }
+            },
+            id: { type: "string", pattern: "^G-[1-9][0-9]*$", description: "An existing diagram to update; omit to create one." }
+          },
+          required: ["repo", "type", "title", "summary", "spec", "nodePaths"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "diagram__read",
+        description: "Read a saved diagram entry and its archify JSON spec.",
+        readOnly: true,
+        parameters: {
+          type: "object",
+          properties: {
+            id: { type: "string", pattern: "^G-[1-9][0-9]*$" }
+          },
+          required: ["id"],
+          additionalProperties: false
+        }
+      }
+    ]
+  },
+  {
+    id: "superpowers",
+    displayName: "superpowers",
+    dataFlow: "local",
+    runsOn: "hub",
+    scope: "none",
+    functions: [
+      {
+        name: "workpackage__read",
+        description: "Read a work package: its entry, spec, plan and the writing rules for spec and plan.",
+        readOnly: true,
+        parameters: {
+          type: "object",
+          properties: { id: { type: "string", pattern: "^W-[1-9][0-9]*$" } },
+          required: ["id"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "workpackage__save_spec",
+        description: "Save the spec of a work package, and fix it and retry when the result is ok:false with an error.",
+        readOnly: true,
+        parameters: {
+          type: "object",
+          properties: { id: { type: "string", pattern: "^W-[1-9][0-9]*$" }, markdown: { type: "string" } },
+          required: ["id", "markdown"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "workpackage__save_plan",
+        description: "Save the plan of a work package, and fix it and retry when the result is ok:false with an error.",
+        readOnly: true,
+        parameters: {
+          type: "object",
+          properties: { id: { type: "string", pattern: "^W-[1-9][0-9]*$" }, markdown: { type: "string" } },
+          required: ["id", "markdown"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "workpackage__block",
+        description: "Mark a work package as blocked on an open question entry of this workspace.",
+        readOnly: true,
+        parameters: {
+          type: "object",
+          properties: { id: { type: "string", pattern: "^W-[1-9][0-9]*$" }, questionId: { type: "string", pattern: "^Q-[1-9][0-9]*$" } },
+          required: ["id", "questionId"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "workpackage__request",
+        description: "Ask for a work package to be written from the given requirement entries.",
+        readOnly: true,
+        parameters: {
+          type: "object",
+          properties: {
+            requirements: { type: "array", items: { type: "string", pattern: "^R-[1-9][0-9]*$" }, minItems: 1 },
+            title: { type: "string", minLength: 1, maxLength: 200 }
+          },
+          required: ["requirements"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "workpackage__mark_task_inferred",
+        description: "Mark a pending task of a work package as reported from the given main commits, inferred from the code.",
+        readOnly: true,
+        parameters: {
+          type: "object",
+          properties: {
+            id: { type: "string", pattern: "^W-[1-9][0-9]*$" },
+            task: { type: "integer", minimum: 1 },
+            commits: { type: "array", items: { type: "string" }, minItems: 1 }
+          },
+          required: ["id", "task", "commits"],
+          additionalProperties: false
+        }
+      }
+    ]
+  },
+  {
+    id: "grill",
+    displayName: "grill-me",
+    dataFlow: "local",
+    runsOn: "hub",
+    scope: "none",
+    functions: []
+  },
+  {
+    id: "github",
+    displayName: "GitHub",
+    dataFlow: "external",
+    runsOn: "daemon",
+    scope: "github",
+    functions: GITHUB_FUNCTIONS
+  }
+];
+
+// ../../../packages/shared/dist/extensions.js
+function bundled(id, name, availability, error) {
+  return {
+    id,
+    kind: "plugin",
+    name,
+    summary: "",
+    source: "bundled",
+    revision: "bundled",
+    provision: "bundled",
+    installState: "installed",
+    useState: "enabled",
+    availability,
+    externalPath: null,
+    error
+  };
+}
+function bundledExtensions() {
+  return [
+    bundled("code", "graphify", "missing-dependency", "bundled-runtime-missing"),
+    bundled("diagram", "archify", "ready", null),
+    bundled("superpowers", "superpowers", "ready", null),
+    bundled("grill", "grill-me", "ready", null),
+    bundled("github", "GitHub", "ready", null)
+  ];
+}
+
+// ../../../packages/shared/dist/protocol.js
+import { z as z4 } from "zod";
+var DaemonToHubSchema = z4.union([
+  z4.object({
+    type: z4.literal("hello"),
+    token: z4.string(),
+    version: z4.string(),
+    adapters: z4.array(z4.string()),
+    /** sha256 hex of ~/.nema/report-token, sent when that file exists. */
+    reportTokenHash: z4.string().regex(/^[0-9a-f]{64}$/).optional()
+  }),
+  z4.object({
+    type: z4.literal("task.event"),
+    taskId: z4.string(),
+    event: z4.object({ type: z4.enum(["progress", "agent_message", "tool_call"]), text: z4.string() })
+  }),
+  z4.object({ type: z4.literal("task.finished"), taskId: z4.string(), ok: z4.literal(true), reply: z4.string() }),
+  z4.object({ type: z4.literal("task.finished"), taskId: z4.string(), ok: z4.literal(false), error: z4.string() }),
+  z4.object({ type: z4.literal("rpc.response"), id: z4.string(), ok: z4.literal(true), result: z4.unknown() }),
+  z4.object({ type: z4.literal("rpc.response"), id: z4.string(), ok: z4.literal(false), error: z4.string() }),
+  z4.object({ type: z4.literal("repo.moved"), repoId: z4.string(), mainRef: z4.string(), from: z4.string().nullable(), to: z4.string() }),
+  z4.object({ type: z4.literal("repo.fetched"), repoId: z4.string(), ok: z4.boolean(), error: z4.string().optional(), at: z4.string() })
+]);
+var HubToDaemonSchema = z4.discriminatedUnion("type", [
+  // workspaceIds: every workspace that still exists, so the daemon can remove the isolation dirs
+  // (`~/.nema/ws/<id>`) of workspaces deleted while it was offline. Optional for older hubs.
+  z4.object({ type: z4.literal("welcome"), workspaceIds: z4.array(z4.string()).optional() }),
+  // Sent to a connected daemon when a workspace is deleted, so it removes that workspace's isolation dir.
+  z4.object({ type: z4.literal("workspace.deleted"), workspaceId: z4.string() }),
+  z4.object({
+    type: z4.literal("task.assign"),
+    taskId: z4.string(),
+    workspaceId: z4.string(),
+    adapter: z4.string().min(1),
+    confidential: z4.boolean(),
+    prompt: z4.string(),
+    runToken: z4.string(),
+    hubUrl: z4.string(),
+    pluginTools: z4.array(z4.object({ name: z4.string(), description: z4.string(), parameters: z4.record(z4.string(), z4.unknown()) })),
+    limits: z4.object({ maxModelCalls: z4.number().int().min(1), maxToolCalls: z4.number().int().min(1), timeoutMs: z4.number().int().min(1) }).optional()
+  }),
+  z4.object({ type: z4.literal("rpc.request"), id: z4.string(), method: z4.string(), params: z4.unknown() }),
+  z4.object({ type: z4.literal("error"), message: z4.string() })
+]);
+function parseHubToDaemon(raw) {
+  return HubToDaemonSchema.parse(raw);
+}
+
+// ../../../packages/shared/dist/ghCommand.js
+var OUT = { json: "json", jq: "str" };
+var rep = (kind) => ({ kind, repeat: true });
+var STATE = { enum: ["open", "closed", "all"] };
+var SPECS = {
+  "issue list": { mode: "read", scope: "repo", positional: "none", flags: { ...OUT, state: STATE, limit: "int", label: rep("str"), assignee: "str", author: "str", milestone: "str", mention: "str" } },
+  "issue view": { mode: "read", scope: "repo", positional: "number", flags: { ...OUT, comments: "bool" } },
+  "issue status": { mode: "read", scope: "repo", positional: "none", flags: { ...OUT } },
+  "issue create": { mode: "write", scope: "repo", positional: "none", flags: { title: "str", body: "str", label: rep("str"), assignee: rep("str"), milestone: "str", project: rep("str") }, required: ["title", "body"] },
+  "issue comment": { mode: "write", scope: "repo", positional: "number", flags: { body: "str" }, required: ["body"] },
+  "issue edit": { mode: "write", scope: "repo", positional: "number", flags: { title: "str", body: "str", "add-label": rep("str"), "remove-label": rep("str"), "add-assignee": rep("str"), "remove-assignee": rep("str"), milestone: "str", "remove-milestone": "bool", "add-project": rep("str"), "remove-project": rep("str") } },
+  "issue close": { mode: "write", scope: "repo", positional: "number", flags: { comment: "str", reason: { enum: ["completed", "not planned", "duplicate"] } } },
+  "issue reopen": { mode: "write", scope: "repo", positional: "number", flags: { comment: "str" } },
+  "pr list": { mode: "read", scope: "repo", positional: "none", flags: { ...OUT, state: { enum: ["open", "closed", "merged", "all"] }, limit: "int", label: rep("str"), assignee: "str", author: "str", base: "str", head: "str" } },
+  "pr view": { mode: "read", scope: "repo", positional: "number", flags: { ...OUT, comments: "bool" } },
+  "pr diff": { mode: "read", scope: "repo", positional: "number", flags: { "name-only": "bool", patch: "bool" } },
+  "pr checks": { mode: "read", scope: "repo", positional: "number", flags: { ...OUT, required: "bool" } },
+  "pr status": { mode: "read", scope: "repo", positional: "none", flags: { ...OUT } },
+  "pr comment": { mode: "write", scope: "repo", positional: "number", flags: { body: "str" }, required: ["body"] },
+  "pr edit": { mode: "write", scope: "repo", positional: "number", flags: { title: "str", body: "str", base: "str", milestone: "str", "add-label": rep("str"), "remove-label": rep("str"), "add-assignee": rep("str"), "remove-assignee": rep("str"), "add-reviewer": rep("str"), "remove-reviewer": rep("str") } },
+  "label list": { mode: "read", scope: "repo", positional: "none", flags: { ...OUT, limit: "int" } },
+  "label create": { mode: "write", scope: "repo", positional: "name", flags: { color: "str", description: "str", force: "bool" } },
+  "label edit": { mode: "write", scope: "repo", positional: "name", flags: { color: "str", description: "str", name: "str" } },
+  "run list": { mode: "read", scope: "repo", positional: "none", flags: { ...OUT, limit: "int", workflow: "str", branch: "str", status: "str" } },
+  "run view": { mode: "read", scope: "repo", positional: "number", flags: { ...OUT, log: "bool", "log-failed": "bool" } },
+  "project list": { mode: "read", scope: "owner", positional: "none", flags: { owner: "str", limit: "int", format: { enum: ["json"] }, jq: "str", closed: "bool" } },
+  "project view": { mode: "read", scope: "owner", positional: "number", flags: { owner: "str", format: { enum: ["json"] }, jq: "str" } },
+  "project field-list": { mode: "read", scope: "owner", positional: "number", flags: { owner: "str", limit: "int", format: { enum: ["json"] }, jq: "str" } },
+  "project item-list": { mode: "read", scope: "owner", positional: "number", flags: { owner: "str", limit: "int", format: { enum: ["json"] }, jq: "str" } },
+  "project item-add": { mode: "write", scope: "owner", positional: "number", flags: { owner: "str", url: "str" }, required: ["url"] },
+  "project item-create": { mode: "write", scope: "owner", positional: "number", flags: { owner: "str", title: "str", body: "str" }, required: ["title"] },
+  "project item-archive": { mode: "write", scope: "owner", positional: "number", flags: { owner: "str", id: "str", undo: "bool" }, required: ["id"] },
+  // Node ids cannot be tied to an owner; the Agent only gets them by reading a bound owner's Project.
+  "project item-edit": { mode: "write", scope: "none", positional: "none", flags: { id: "str", "project-id": "str", "field-id": "str", text: "str", number: "str", date: "str", "single-select-option-id": "str", "iteration-id": "str", clear: "bool" }, required: ["id"] }
+};
+var MAX_ITEMS = 80;
+var MAX_VALUE = 65536;
+var MAX_TOTAL = 2e5;
+var NAME = /^[A-Za-z0-9._-]+$/;
+var ISSUE_URL = /^https:\/\/github\.com\/([A-Za-z0-9._-]+)\/([A-Za-z0-9._-]+)\/(?:issues|pull)\/\d{1,9}$/;
+var fail = (error) => ({ ok: false, error });
+function boundRepo(value, bound) {
+  const [owner, repo, extra] = value.split("/");
+  if (extra !== void 0 || !owner || !repo || !NAME.test(owner) || !NAME.test(repo))
+    return false;
+  return bound.some((target) => target.owner.toLowerCase() === owner.toLowerCase() && target.repo.toLowerCase() === repo.toLowerCase());
+}
+function parseGhCommand(input, bound) {
+  if (!Array.isArray(input) || input.length === 0 || input.length > MAX_ITEMS || input.some((item) => typeof item !== "string"))
+    return fail("args must be a non-empty array of strings");
+  const args = input;
+  if (args.reduce((sum, item) => sum + item.length, 0) > MAX_TOTAL || args.some((item) => item.length > MAX_VALUE || item.includes("\0")))
+    return fail("argument too long or contains a NUL");
+  const spec = SPECS[`${args[0]} ${args[1]}`];
+  if (!spec)
+    return fail(`unsupported gh command: ${args.slice(0, 2).join(" ")}`);
+  const positionals = [];
+  const flags = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 2; i < args.length; i++) {
+    const token = args[i];
+    let name;
+    let inline;
+    if (token === "-R")
+      name = "repo";
+    else if (token.startsWith("--")) {
+      const eq = token.indexOf("=");
+      name = eq < 0 ? token.slice(2) : token.slice(2, eq);
+      inline = eq < 0 ? void 0 : token.slice(eq + 1);
+    } else if (token.startsWith("-"))
+      return fail(`unsupported flag: ${token.slice(0, 40)}`);
+    else {
+      positionals.push(token);
+      continue;
+    }
+    const raw = name === "repo" ? spec.scope === "repo" ? "str" : void 0 : spec.flags[name];
+    if (raw === void 0)
+      return fail(`unsupported flag for gh ${args[0]} ${args[1]}: --${name.slice(0, 40)}`);
+    const flag = typeof raw === "object" && "kind" in raw ? raw.kind : raw;
+    const repeat = typeof raw === "object" && "kind" in raw;
+    if (!repeat && seen.has(name))
+      return fail(`repeated flag: --${name}`);
+    seen.add(name);
+    if (flag === "bool") {
+      if (inline !== void 0)
+        return fail(`--${name} takes no value`);
+      flags.push([name, true]);
+      continue;
+    }
+    const value2 = inline ?? args[++i];
+    if (value2 === void 0)
+      return fail(`--${name} needs a value`);
+    if (flag === "int" && !(/^\d{1,4}$/.test(value2) && +value2 >= 1 && +value2 <= 1e3))
+      return fail(`--${name} must be 1-1000`);
+    if (flag === "json" && !/^[A-Za-z0-9,]+$/.test(value2))
+      return fail("--json takes a comma-separated field list");
+    if (typeof flag === "object" && "enum" in flag && !flag.enum.includes(value2))
+      return fail(`--${name} must be one of: ${flag.enum.join(", ")}`);
+    flags.push([name, value2]);
+  }
+  for (const name of spec.required ?? [])
+    if (!seen.has(name))
+      return fail(`--${name} is required`);
+  if (spec.positional === "none" && positionals.length > 0)
+    return fail("unexpected argument");
+  if (spec.positional !== "none" && positionals.length !== 1)
+    return fail("exactly one target argument is required");
+  const target = positionals[0];
+  if (spec.positional === "number" && !/^\d{1,9}$/.test(target))
+    return fail("the target must be an issue, pull request, project or run number");
+  if (spec.positional === "name" && (target.startsWith("-") || target.length > 50 || /[\r\n]/.test(target)))
+    return fail("invalid name");
+  const value = (name) => flags.find(([key]) => key === name)?.[1];
+  if (spec.scope === "repo") {
+    const repo = value("repo");
+    if (repo === void 0)
+      return fail("--repo owner/name is required");
+    if (!boundRepo(repo, bound))
+      return fail(`only repositories bound to this workspace may be used: ${repo.slice(0, 100)}`);
+  }
+  if (spec.scope === "owner") {
+    const owner = value("owner");
+    if (owner === void 0)
+      return fail("--owner is required");
+    if (!NAME.test(owner) || !bound.some((item) => item.owner.toLowerCase() === owner.toLowerCase()))
+      return fail(`only owners of repositories bound to this workspace may be used: ${owner.slice(0, 100)}`);
+  }
+  const url = value("url");
+  if (args[0] === "project" && url !== void 0) {
+    const match = ISSUE_URL.exec(url);
+    if (!match || !boundRepo(`${match[1]}/${match[2]}`, bound))
+      return fail("--url must be an issue or pull request of a bound repository");
+  }
+  const argv = [args[0], args[1], ...positionals, ...flags.map(([name, v]) => v === true ? `--${name}` : `--${name}=${v}`)];
+  return { ok: true, mode: spec.mode, argv };
+}
+var GH_COMMAND_TOOLS = ["gh_read", "gh_write"];
+
+export {
+  HookSignal,
+  ReportInput,
+  UpsertEntryInput,
+  isBranchName,
+  PLUGINS,
+  bundledExtensions,
+  parseHubToDaemon,
+  parseGhCommand,
+  GH_COMMAND_TOOLS
+};