@gitdocket/core 0.0.0 → 0.1.1

package/src/init.ts

@@ -0,0 +1,338 @@
+// docket init — pure text transforms for adopt-in-place. Adoption is
+// additive, never a migration: every function here takes what already
+// exists and returns a composed result, so callers can guarantee "never
+// clobbers". Filesystem and git orchestration live in the CLI; this module
+// stays runtime-portable.
+
+import { INDEX_MARKER } from "./indexmd";
+import { findFreshnessWatermark } from "./lint";
+import { DOCKET_VERSION } from "./version";
+
+export type InitAction = "create" | "update" | "skip";
+
+export interface InitResult {
+  action: InitAction;
+  content: string;
+  /** Present when action is "skip" for a reason worth surfacing. */
+  reason?: string;
+}
+
+/** docket.yaml template — mirrors this repo's reference copy. */
+export function defaultConfigYaml(project: string, bundle: string): string {
+  return `# Docket configuration — consumed by the docket CLI and by agents.
+
+bundle: ${bundle}
+
+project: ${project}          # ID key for work items: ${project}-1, ${project}-2, … (epics + tasks share one sequence)
+
+ids:
+  scheme: sequential     # next = max existing + 1
+  decision_prefix: DEC   # decisions number independently: DEC-1, DEC-2, …
+
+workflow:
+  states: [todo, in-progress, blocked, in-review, done, closed]
+  # \`ready\` is never written to a file — it is derived:
+  # status == todo AND every task in depends_on has status == done.
+
+git:
+  trailer: "Task"        # commit trailer key linking commits to tasks
+  branch_prefix: "task/" # branch naming: task/${project}-12-short-slug
+`;
+}
+
+/** Project key from a directory name: letters/digits, uppercased, max 3. */
+export function deriveProjectKey(dirname: string): string {
+  const key = dirname
+    .replace(/[^a-zA-Z0-9]/g, "")
+    .toUpperCase()
+    .slice(0, 3);
+  return key || "DKT";
+}
+
+/** Bundle files scaffolded when missing. Paths are bundle-relative. */
+export function scaffoldFiles(
+  project: string,
+  today: string,
+): { path: string; content: string }[] {
+  return [
+    {
+      path: "index.md",
+      content: `# ${project} — docs & work\n\n<!-- Replace the heading above with the project's full name and add one concise sentence explaining its purpose. Docket preserves this preamble when regenerating the index. -->\n\n${INDEX_MARKER}\n`,
+    },
+    {
+      path: "log.md",
+      content: `# Log\n\n## ${today}\n\n- **Create** — Adopted Docket (\`docket init\`).\n`,
+    },
+  ];
+}
+
+/**
+ * Stamp the freshness baseline watermark into log.md. Adoption is
+ * the baseline: a fresh bundle has nothing to retrospect, so init seeds the
+ * watermark the docket-freshness workflow advances from — instead of lint
+ * nagging for a ritual with nothing to sweep. The entry lands under today's
+ * section (log.md is newest-first). "create" refers to the entry — the file
+ * itself always pre-exists (scaffolded or brownfield).
+ */
+export function composeFreshnessBaseline(
+  log: string,
+  sha: string | undefined,
+  today: string,
+): InitResult {
+  if (findFreshnessWatermark(log))
+    return { action: "skip", content: log, reason: "already stamped" };
+  if (!sha) return { action: "skip", content: log, reason: "no commits yet" };
+  const entry = `- **Freshness** — baseline at adoption; reviewed through \`${sha}\` (nothing to review before Docket).`;
+  const heading = `## ${today}`;
+  const lines = log.split("\n");
+  const at = lines.indexOf(heading);
+  if (at >= 0) {
+    lines.splice(at + 1, 0, "", entry);
+    return { action: "create", content: lines.join("\n") };
+  }
+  // No section for today — open one. The log is newest-first, so it goes
+  // right after the title (or at the very top of a title-less log).
+  const title = lines.findIndex((line) => line.startsWith("# "));
+  lines.splice(title + 1, 0, "", heading, "", entry);
+  return { action: "create", content: lines.join("\n") };
+}
+
+const HOOK_BEGIN = `# >>> docket prepare-commit-msg@${DOCKET_VERSION} >>>`;
+const HOOK_END = "# <<< docket prepare-commit-msg <<<";
+// Matches the begin marker at any version, and the legacy unversioned form.
+const HOOK_MARKER_PREFIX = "# >>> docket prepare-commit-msg";
+
+// Self-contained sh block; variable names are prefixed so appending into an
+// existing hook can't collide, and every failure path exits 0 so a broken
+// docket state never blocks a commit.
+const HOOK_BLOCK = `${HOOK_BEGIN}
+# Inject the active task's trailer into the commit message. Active task is
+# per-checkout state in .docket/active-task (untracked), so git worktrees
+# each carry their own active task.
+docket_msg_file="$1"
+docket_top="$(git rev-parse --show-toplevel 2>/dev/null)" || docket_top=""
+if [ -n "$docket_top" ] && [ -f "$docket_top/.docket/active-task" ]; then
+  docket_task_id="$(head -n1 "$docket_top/.docket/active-task" | tr -d '[:space:]')"
+  if [ -n "$docket_task_id" ] && ! grep -qi "^Task:" "$docket_msg_file"; then
+    git interpret-trailers --in-place --trailer "Task: $docket_task_id" "$docket_msg_file"
+  fi
+fi
+${HOOK_END}
+`;
+
+/**
+ * Compose the trailer-injecting block into a prepare-commit-msg hook.
+ * Missing hook → create; existing without our block → append; already
+ * installed → skip. Never rewrites what's there.
+ */
+export function composeHook(existing: string | undefined): InitResult {
+  if (existing === undefined) {
+    return { action: "create", content: `#!/bin/sh\n${HOOK_BLOCK}` };
+  }
+  // Our marker (any version), or any hand-rolled hook already reading the
+  // active-task file (this repo's Phase 0 hook predates the marker).
+  if (
+    existing.includes(HOOK_MARKER_PREFIX) ||
+    existing.includes(".docket/active-task")
+  ) {
+    return { action: "skip", content: existing, reason: "already installed" };
+  }
+  const base = existing.endsWith("\n") ? existing : `${existing}\n`;
+  return { action: "update", content: `${base}\n${HOOK_BLOCK}` };
+}
+
+// Full block span, any marker version — for upgrade's regenerate-in-place.
+const HOOK_BLOCK_RE =
+  /# >>> docket prepare-commit-msg(@\S+)? >>>[\s\S]*?# <<< docket prepare-commit-msg <<<\n?/;
+
+/**
+ * Upgrade the hook block in place: the marked span (any version) is replaced
+ * with the current block. Hand-rolled hooks — active-task readers without our
+ * marker — are never touched (same rule as composeHook, inverted: compose
+ * skips what upgrade regenerates).
+ */
+export function upgradeHookBlock(existing: string): InitResult {
+  if (!HOOK_BLOCK_RE.test(existing)) {
+    return {
+      action: "skip",
+      content: existing,
+      reason: existing.includes(".docket/active-task")
+        ? "hand-rolled hook — never touched"
+        : "no docket block",
+    };
+  }
+  // Replacer fn: the block contains a literal `$1`, which a string
+  // replacement would eat as a capture-group reference.
+  const content = existing.replace(HOOK_BLOCK_RE, () => HOOK_BLOCK);
+  return content === existing
+    ? { action: "skip", content: existing, reason: "up to date" }
+    : { action: "update", content };
+}
+
+const MCP_SERVER = { command: "docket-mcp" };
+
+const CODEX_MCP_BEGIN = `# >>> docket mcp@${DOCKET_VERSION} >>>`;
+const CODEX_MCP_END = "# <<< docket mcp <<<";
+const CODEX_MCP_BEGIN_RE = /# >>> docket mcp(@\S+)? >>>/;
+const CODEX_MCP_BLOCK = `${CODEX_MCP_BEGIN}
+[mcp_servers.docket]
+command = "docket-mcp"
+${CODEX_MCP_END}
+`;
+const CODEX_MCP_BLOCK_RE =
+  /# >>> docket mcp(@\S+)? >>>[\s\S]*?# <<< docket mcp <<<\n?/;
+
+/** Register the docket MCP server in .mcp.json without touching other entries. */
+export function mergeMcpJson(existing: string | undefined): InitResult {
+  if (existing === undefined) {
+    return {
+      action: "create",
+      content: `${JSON.stringify({ mcpServers: { docket: MCP_SERVER } }, null, 2)}\n`,
+    };
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(existing);
+  } catch {
+    return { action: "skip", content: existing, reason: "not valid JSON" };
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return { action: "skip", content: existing, reason: "not a JSON object" };
+  }
+  const root = parsed as Record<string, unknown>;
+  const servers =
+    typeof root.mcpServers === "object" && root.mcpServers !== null
+      ? (root.mcpServers as Record<string, unknown>)
+      : {};
+  if (servers.docket) {
+    return { action: "skip", content: existing, reason: "already registered" };
+  }
+  root.mcpServers = { ...servers, docket: MCP_SERVER };
+  return { action: "update", content: `${JSON.stringify(root, null, 2)}\n` };
+}
+
+/**
+ * Add Docket's marker-managed MCP table to a valid Codex project config.
+ * TOML validation belongs to the runtime caller; this pure transform only
+ * composes text and refuses to replace an existing docket registration.
+ */
+export function mergeCodexConfig(existing: string | undefined): InitResult {
+  if (existing === undefined)
+    return { action: "create", content: CODEX_MCP_BLOCK };
+  if (
+    CODEX_MCP_BEGIN_RE.test(existing) ||
+    /^\s*\[\s*mcp_servers(?:\.|\s*\.\s*)["']?docket["']?\s*\]\s*$/m.test(
+      existing,
+    )
+  ) {
+    return { action: "skip", content: existing, reason: "already registered" };
+  }
+  const base = existing.endsWith("\n") ? existing : `${existing}\n`;
+  return { action: "update", content: `${base}\n${CODEX_MCP_BLOCK}` };
+}
+
+/** Regenerate only Docket's marked Codex MCP block; never add one. */
+export function upgradeCodexConfig(existing: string): InitResult {
+  if (!CODEX_MCP_BLOCK_RE.test(existing)) {
+    return {
+      action: "skip",
+      content: existing,
+      reason: "no docket block",
+    };
+  }
+  const content = existing.replace(CODEX_MCP_BLOCK_RE, () => CODEX_MCP_BLOCK);
+  return content === existing
+    ? { action: "skip", content: existing, reason: "up to date" }
+    : { action: "update", content };
+}
+
+export const ALLOW_RULES = ["mcp__docket", "Bash(docket:*)"] as const;
+
+/**
+ * Ensure .claude/settings.json pre-approves the docket surface:
+ * enableAllProjectMcpServers plus the allow rules. Preserves everything else.
+ */
+export function mergeClaudeSettings(existing: string | undefined): InitResult {
+  let root: Record<string, unknown> = {};
+  if (existing !== undefined) {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(existing);
+    } catch {
+      return { action: "skip", content: existing, reason: "not valid JSON" };
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+      return { action: "skip", content: existing, reason: "not a JSON object" };
+    }
+    root = parsed as Record<string, unknown>;
+  }
+
+  const permissions =
+    typeof root.permissions === "object" && root.permissions !== null
+      ? (root.permissions as Record<string, unknown>)
+      : {};
+  const allow = Array.isArray(permissions.allow)
+    ? permissions.allow.filter((r): r is string => typeof r === "string")
+    : [];
+  const missing = ALLOW_RULES.filter((rule) => !allow.includes(rule));
+
+  if (
+    existing !== undefined &&
+    missing.length === 0 &&
+    root.enableAllProjectMcpServers === true
+  ) {
+    return { action: "skip", content: existing, reason: "already configured" };
+  }
+
+  root.enableAllProjectMcpServers = true;
+  root.permissions = { ...permissions, allow: [...allow, ...missing] };
+  return {
+    action: existing === undefined ? "create" : "update",
+    content: `${JSON.stringify(root, null, 2)}\n`,
+  };
+}
+
+const GITIGNORE_BLOCK = `# docket per-checkout state (active task, cache)
+.docket/
+`;
+
+/**
+ * Ensure `.docket/` is ignored. Additive: appends a commented rule unless some
+ * line already covers the directory; never reorders or rewrites existing rules.
+ */
+export function ensureGitignore(existing: string | undefined): InitResult {
+  if (existing === undefined)
+    return { action: "create", content: GITIGNORE_BLOCK };
+  const covered = existing
+    .split("\n")
+    .map((line) => line.trim())
+    .some(
+      (line) =>
+        line === ".docket" ||
+        line === ".docket/" ||
+        line === "/.docket" ||
+        line === "/.docket/",
+    );
+  if (covered)
+    return { action: "skip", content: existing, reason: "already ignored" };
+  const base = existing.endsWith("\n") ? existing : `${existing}\n`;
+  return { action: "update", content: `${base}\n${GITIGNORE_BLOCK}` };
+}
+
+/** True when a markdown source lacks a frontmatter block with a `type` key. */
+export function needsFrontmatter(source: string): boolean {
+  const match = source.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return true;
+  return !/^type:/m.test(match[1] ?? "");
+}
+
+/** Mechanical type proposal from a bundle-relative path — the agent refines it. */
+export function proposeType(path: string): string {
+  if (path.startsWith("work/epics/")) return "Epic";
+  if (path.startsWith("work/tasks/")) return "Task";
+  if (path.startsWith("decisions/")) return "Decision";
+  if (path.startsWith("specs/")) return "Spec";
+  if (path.startsWith("reference/")) return "Reference";
+  if (path.startsWith("workflows/")) return "Workflow";
+  return "Doc";
+}

package/src/intents.ts

@@ -0,0 +1,262 @@
+/**
+ * Canonical agent authority and intent contract.
+ *
+ * These examples are product/evaluation fixtures, not substring-matching
+ * rules. Agent surfaces may derive discovery text from this registry or
+ * validate their own text against it, but routing remains harness-owned.
+ */
+
+export const DOCKET_INTENT_IDS = [
+  "orientation",
+  "backlog-hygiene",
+  "pickup",
+  "epic-supervision",
+  "task-management",
+  "project-maintenance",
+] as const;
+
+export type DocketIntentId = (typeof DOCKET_INTENT_IDS)[number];
+
+export const DIRECT_WORK_INTENT_ID = "direct-work" as const;
+
+export const AGENT_INTENT_IDS = [
+  DIRECT_WORK_INTENT_ID,
+  ...DOCKET_INTENT_IDS,
+] as const;
+
+export type AgentIntentId = (typeof AGENT_INTENT_IDS)[number];
+
+export type IntentMode =
+  | "pass-through"
+  | "read-only"
+  | "proposal-first"
+  | "state-changing"
+  | "operation-scoped";
+
+export type IntentEntrypoint =
+  | { kind: "direct"; value: string }
+  | { kind: "command"; value: string }
+  | { kind: "workflow"; value: string }
+  | { kind: "named-operation"; value: string };
+
+export interface AgentIntentContract {
+  id: AgentIntentId;
+  title: string;
+  /** Mutually exclusive discovery summary for generated agent surfaces. */
+  discovery: string;
+  defaultEntrypoint: IntentEntrypoint;
+  mode: IntentMode;
+  authority: string;
+  inspectionScope: string;
+  positiveExamples: readonly string[];
+  exclusions: readonly string[];
+}
+
+export type DocketIntentContract = AgentIntentContract & {
+  id: DocketIntentId;
+};
+
+export const PICKUP_AUTHORITY_EVIDENCE = [
+  "a Docket ID",
+  "an unambiguous reference to an existing tracked item",
+  "an explicit request for Docket or backlog selection",
+] as const;
+
+export const DIRECT_WORK_INTENT = {
+  id: DIRECT_WORK_INTENT_ID,
+  title: "Carry out direct user work",
+  discovery:
+    "Direct user work — execute a concrete product or repository request in the user's stated scope without Docket coordination.",
+  defaultEntrypoint: {
+    kind: "direct",
+    value: "the user's concrete requested work",
+  },
+  mode: "pass-through",
+  authority:
+    "The concrete request authorizes only its stated product or repository scope; generic implementation language such as work, task, fix, or implement does not authorize Docket pickup or any tracker mutation.",
+  inspectionScope:
+    "Inspect and change only the product or repository surfaces needed for the user's concrete request, subject to the ordinary safety and approval policy of the harness.",
+  positiveExamples: [
+    "fix the mobile navigation overflow",
+    "implement validation for this form",
+    "update this documentation example",
+  ],
+  exclusions: [
+    "a Docket ID or an unambiguous reference to an existing tracked item",
+    "an explicit request for Docket or backlog selection",
+    "a named Docket operation such as create, move, or close",
+  ],
+} as const satisfies AgentIntentContract;
+
+export const DOCKET_INTENTS = {
+  orientation: {
+    id: "orientation",
+    title: "Orient and review",
+    discovery:
+      "Read-only orientation — answer what is happening or what comes next from the shared Docket overview.",
+    defaultEntrypoint: { kind: "command", value: "docket overview --json" },
+    mode: "read-only",
+    authority:
+      "No confirmation is needed because the path may not mutate task, bundle, cache, index, or Git state.",
+    inspectionScope:
+      "Start with the structured overview; follow bundle links only when the requested explanation needs more evidence.",
+    positiveExamples: [
+      "what's next?",
+      "where are we?",
+      "let's review",
+      "give me a status update",
+    ],
+    exclusions: [
+      "an explicit request to groom or audit backlog hygiene",
+      "an explicit request to start or continue implementation",
+      "a named task mutation such as create, move, or close",
+    ],
+  },
+  "backlog-hygiene": {
+    id: "backlog-hygiene",
+    title: "Audit backlog hygiene",
+    discovery:
+      "Full backlog hygiene audit — inspect stale or inconsistent work state and propose fixes before applying any mutation.",
+    defaultEntrypoint: { kind: "workflow", value: "docket-groom" },
+    mode: "proposal-first",
+    authority:
+      "The audit is read-only until the user confirms proposed fixes or has explicitly granted autonomous mechanical cleanup authority.",
+    inspectionScope:
+      "Inspect the Docket bundle and task-linked Git evidence required by the groom workflow, not unrelated product implementation files.",
+    positiveExamples: [
+      "groom the backlog",
+      "audit our task hygiene",
+      "find stale or inconsistent tickets",
+    ],
+    exclusions: [
+      "ordinary review or what-is-next questions",
+      "starting the highest-priority ready task",
+      "a single named task operation",
+    ],
+  },
+  pickup: {
+    id: "pickup",
+    title: "Pick up or continue work",
+    discovery:
+      "Start or resume explicitly tracked Docket work only — use a Docket ID, an unambiguous existing item, or explicit next/backlog selection; direct work bypasses Docket and ambiguous references require resolution before active-task state changes.",
+    defaultEntrypoint: { kind: "workflow", value: "docket-pickup" },
+    mode: "state-changing",
+    authority:
+      "Pickup requires positive tracked-work evidence: a Docket ID, an unambiguous reference to an existing tracked item, or an explicit request for Docket or backlog selection. Generic action language alone does not authorize pickup.",
+    inspectionScope:
+      "Use the engine-returned task, epic, dependencies, linked concepts, and commits before inspecting implementation files needed for the task.",
+    positiveExamples: [
+      "start DKT-12",
+      "pick up the next Docket task",
+      "continue work on DKT-12",
+    ],
+    exclusions: [
+      "what-is-next questions without action language",
+      "requests that explicitly say not to start or change anything",
+      "generic implementation requests with no tracked-work evidence",
+      "an unresolved or ambiguous tracked-item reference",
+      "creating or closing a task as tracker administration",
+    ],
+  },
+  "epic-supervision": {
+    id: "epic-supervision",
+    title: "Supervise an epic",
+    discovery:
+      "Run a named epic to completion — supervise ready child work through isolated workers or the mandatory serial fallback, verify integration, and return one completion or blocker receipt.",
+    defaultEntrypoint: { kind: "workflow", value: "docket-epic" },
+    mode: "state-changing",
+    authority:
+      "Explicit run, start, or supervise language applied to a named epic authorizes its ready child work and final epic review, but no unrelated task or speculative scheduler work.",
+    inspectionScope:
+      "Inspect the named epic, its child dependency graph, likely write overlap, task-linked Git evidence, and verification surfaces required to integrate and review that epic.",
+    positiveExamples: [
+      "run epic DKT-42 and come back when it is done",
+      "start the DKT-42 epic",
+      "supervise all ready work under DKT-42",
+    ],
+    exclusions: [
+      "starting one named task",
+      "ordinary epic status or review without action language",
+      "building an orchestration service or changing unrelated work",
+    ],
+  },
+  "task-management": {
+    id: "task-management",
+    title: "Manage a named work item",
+    discovery:
+      "Perform an explicit task operation — create, inspect, edit, move, log, stop, or close only the work item and derived surfaces in scope.",
+    defaultEntrypoint: {
+      kind: "named-operation",
+      value: "the corresponding docket task command or workflow",
+    },
+    mode: "operation-scoped",
+    authority:
+      "The named operation supplies authority only for its documented mutations; read operations remain read-only and close follows its reconciliation workflow.",
+    inspectionScope:
+      "Inspect the named item and the linked concepts or derived surfaces required by that operation; do not broaden into backlog grooming.",
+    positiveExamples: [
+      "create an epic with these tickets",
+      "move DKT-12 to blocked",
+      "close DKT-12",
+      "show me DKT-12",
+    ],
+    exclusions: [
+      "general status or what-is-next questions",
+      "a full backlog hygiene audit",
+      "starting implementation unless pickup is also explicit",
+    ],
+  },
+  "project-maintenance": {
+    id: "project-maintenance",
+    title: "Run named Docket maintenance",
+    discovery:
+      "Run an explicitly named Docket maintenance procedure such as freshness review or product-context refresh, using that workflow's own mutation contract.",
+    defaultEntrypoint: {
+      kind: "named-operation",
+      value: "the explicitly requested maintenance workflow",
+    },
+    mode: "operation-scoped",
+    authority:
+      "Maintenance never acts as a fallback for orientation; the user must request the procedure or its concrete maintenance outcome.",
+    inspectionScope:
+      "Use only the evidence and repository writes named by the selected maintenance workflow.",
+    positiveExamples: [
+      "run a freshness review",
+      "refresh the product context",
+      "prepare the weekly standup report",
+    ],
+    exclusions: [
+      "ordinary status or review requests",
+      "backlog hygiene unless grooming is explicit",
+      "task implementation or tracker mutation outside the named procedure",
+    ],
+  },
+} as const satisfies Record<DocketIntentId, DocketIntentContract>;
+
+export const AGENT_INTENTS = {
+  [DIRECT_WORK_INTENT_ID]: DIRECT_WORK_INTENT,
+  ...DOCKET_INTENTS,
+} as const satisfies Record<AgentIntentId, AgentIntentContract>;
+
+export const AGENT_INTENT_DISAMBIGUATION = [
+  "A concrete product or repository request is direct work unless positive tracked-work evidence is present. Generic words such as work, task, fix, implement, or UX never supply pickup authority.",
+  "Pickup is authorized only by a Docket ID, an unambiguous reference to an existing tracked item, or an explicit request for Docket or backlog selection.",
+  "If a tracked-item reference cannot be resolved unambiguously, resolve or clarify that reference; never degrade to bare pickup or top-ready selection.",
+  "Direct work does not create, start, stop, adopt, clear, or otherwise mutate .docket/active-task or any tracked item. Existing active or ready work does not change the direct request's scope.",
+  "Ordinary review, status, and what-is-next language defaults to read-only orientation.",
+  "Specific Docket action language beats a generic word such as review: groom or audit selects backlog hygiene; tracked start, pick up, resume, or continue selects pickup; run, start, or supervise a named epic selects epic supervision; a named tracker operation selects task management.",
+  "A negative constraint such as do not start narrows permitted actions but never selects a broader workflow by itself.",
+  "Combined operations retain separate authority: creating a task does not start it unless pickup is also explicit, while track this and start it authorizes both bounded operations in sequence.",
+  "No intent may mutate outside its declared authority, and every Docket workflow is opt-in rather than a fallback for direct work.",
+] as const;
+
+/** @deprecated Use AGENT_INTENT_DISAMBIGUATION for the complete boundary. */
+export const DOCKET_INTENT_DISAMBIGUATION = AGENT_INTENT_DISAMBIGUATION;
+
+export function agentIntent(id: AgentIntentId): AgentIntentContract {
+  return AGENT_INTENTS[id];
+}
+
+export function docketIntent(id: DocketIntentId): DocketIntentContract {
+  return DOCKET_INTENTS[id];
+}