@wrongstack/requirement-intake-mcp 0.299.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,56 @@
+# @wrongstack/requirement-intake-mcp
+
+WrongStack Requirements Intake as a project-scoped MCP server. Agents (Claude
+Code, Codex, Cursor, custom MCP clients) can list intake records and file +
+submit new requirement intakes directly into the project's intake store.
+
+Mirrors the `@wrongstack/kanban-mcp` pattern: a standalone server with a
+read-only default and an explicit `--writable` tier.
+
+## Tools
+
+| Tool | Tier | Purpose |
+|---|---|---|
+| `requirement_intake_list` | read (always) | List intake records for the project, newest first, optional `statuses` filter |
+| `requirement_intake_submit` | writable (`--writable`) | File + submit an intake record from the `request` text (preserved verbatim) |
+
+`requirement_intake_submit` arguments: `request` (required), `title`,
+`requestType` (feature/bug_fix/refactor/… — unknown values normalize to
+`other`/`unspecified`), `priority`, `idempotencyKey` (safe retries).
+
+Records are stored under the project state dir
+(`~/.wrongstack/projects/<slug>/requirement-intakes`) and are the same records
+served by the WebUI REST API and the CLI `/intake` command. The MCP transport
+is the authorization boundary; the service runs with an allow-all authorizer
+inside it.
+
+## Usage
+
+```bash
+# stdio (default) — read-only
+wstack-requirement-intake-mcp --project-root /path/to/project
+
+# expose intake filing
+wstack-requirement-intake-mcp --project-root /path/to/project --writable
+
+# HTTP transport with token auth
+WRONGSTACK_MCP_TOKEN=secret wstack-requirement-intake-mcp \
+  --project-root /path/to/project --http --writable
+```
+
+Project identity comes from `.wrongstack/project.json`
+(`readProjectIdentity`). `requirement_intake_submit` creates it when missing;
+`requirement_intake_list` requires it (run `wstack init` first).
+
+## Development
+
+```bash
+pnpm exec vitest run packages/requirement-intake-mcp/tests
+pnpm --filter @wrongstack/requirement-intake-mcp build
+```
+
+## Code references
+
+- `src/adapter.ts` — `createRequirementIntakeMcpToolHost` / `...Server`
+- `src/policy.ts` — read/writable capability tiers
+- `src/cli.ts` — `wstack-requirement-intake-mcp` entry

package/dist/adapter.d.ts

@@ -0,0 +1,19 @@
+import { MCPServer, type MCPServerToolHost } from '@wrongstack/mcp';
+import { RequirementIntakeService } from '@wrongstack/requirement-intake';
+import { type RequirementIntakeMcpPolicyOptions } from './policy.js';
+export interface RequirementIntakeMcpDependencies {
+    /** Pre-built intake service (tests/embeds). Defaults to a fresh per-project service. */
+    service?: RequirementIntakeService | undefined;
+    /**
+     * Resolve the canonical project id. Defaults to reading `.wrongstack/project.json`
+     * (`readProjectIdentity`); when missing, `createIfMissing` (submit) creates it.
+     */
+    resolveProjectId?: ((createIfMissing: boolean) => Promise<string>) | undefined;
+}
+export interface RequirementIntakeMcpToolHostOptions extends RequirementIntakeMcpPolicyOptions {
+    actor?: string | undefined;
+    dependencies?: RequirementIntakeMcpDependencies | undefined;
+}
+export declare function createRequirementIntakeMcpToolHost(projectRoot: string, opts?: RequirementIntakeMcpToolHostOptions): MCPServerToolHost;
+export declare function createRequirementIntakeMcpServer(projectRoot: string, opts?: RequirementIntakeMcpToolHostOptions): MCPServer;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/cli.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+export interface ParsedArgs {
+    projectRoot: string;
+    transport: 'stdio' | 'http';
+    httpPort: number;
+    httpHost: string;
+    httpToken?: string | undefined;
+    writable: boolean;
+    actor?: string | undefined;
+    help: boolean;
+}
+export declare function printHelp(stdout: NodeJS.WriteStream): void;
+export declare function parseArgs(argv: readonly string[], env?: NodeJS.ProcessEnv): ParsedArgs;
+export declare function main(argv?: string[]): Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,409 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { realpathSync } from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { canonicalProjectRoot } from "@wrongstack/core/utils";
+import { serveHttp, serveStdio } from "@wrongstack/mcp";
+
+// src/adapter.ts
+import {
+  ensureProjectIdentity,
+  readProjectIdentity,
+  resolveWstackPaths
+} from "@wrongstack/core/utils";
+import {
+  MCPServer
+} from "@wrongstack/mcp";
+import {
+  AllowAllIntakeAuthorizer,
+  INTAKE_PRIORITIES,
+  INTAKE_STATUSES,
+  RequirementIntakeService,
+  RequirementIntakeStore
+} from "@wrongstack/requirement-intake";
+
+// src/policy.ts
+function selectRequirementIntakeTools(opts = {}) {
+  const tools = [{ name: "requirement_intake_list" }];
+  if (opts.writable === true) {
+    tools.push({ name: "requirement_intake_submit" });
+  }
+  return tools;
+}
+
+// src/version.ts
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var here = dirname(fileURLToPath(import.meta.url));
+var packagePath = resolve(here, "..", "package.json");
+var cached;
+function readServerInfo() {
+  if (cached) return cached;
+  try {
+    const pkg = JSON.parse(readFileSync(packagePath, "utf8"));
+    cached = {
+      name: pkg.name ?? "@wrongstack/requirement-intake-mcp",
+      version: pkg.version ?? "0.0.0"
+    };
+  } catch {
+    cached = { name: "@wrongstack/requirement-intake-mcp", version: "0.0.0" };
+  }
+  return cached;
+}
+var SERVER_INFO = readServerInfo();
+
+// src/adapter.ts
+var SUBMIT_SCHEMA = {
+  type: "object",
+  properties: {
+    request: {
+      type: "string",
+      description: "The exact software development request to record \u2014 a feature, bug fix, refactor, UI/API/infra change, migration, documentation, etc. Preserved verbatim."
+    },
+    title: {
+      type: "string",
+      description: "Optional short title. Defaults to a deterministic title from the request."
+    },
+    requestType: {
+      type: "string",
+      enum: [
+        "feature",
+        "bug_fix",
+        "refactor",
+        "performance",
+        "security",
+        "ui_change",
+        "api_change",
+        "infrastructure",
+        "migration",
+        "testing",
+        "documentation",
+        "maintenance",
+        "other",
+        "unspecified"
+      ],
+      description: "Request type hint. Unknown values normalize to other/unspecified."
+    },
+    priority: {
+      type: "string",
+      enum: [...INTAKE_PRIORITIES],
+      description: "Desired priority."
+    },
+    idempotencyKey: {
+      type: "string",
+      description: "Optional key making create idempotent \u2014 retries return the existing record."
+    }
+  },
+  required: ["request"],
+  additionalProperties: false
+};
+var LIST_SCHEMA = {
+  type: "object",
+  properties: {
+    statuses: {
+      type: "array",
+      items: { type: "string", enum: [...INTAKE_STATUSES] },
+      description: "Optional status filter (draft, collecting_information, submitted, cancelled, archived)."
+    }
+  },
+  additionalProperties: false
+};
+var TOOL_DESCRIPTIONS = {
+  requirement_intake_list: "List requirement intake records for the project, newest first, optionally filtered by status.",
+  requirement_intake_submit: "File and submit a requirement intake record from the given request text. Requires server --writable."
+};
+function toolDescriptor(name) {
+  return {
+    name,
+    description: TOOL_DESCRIPTIONS[name],
+    inputSchema: name === "requirement_intake_submit" ? SUBMIT_SCHEMA : LIST_SCHEMA
+  };
+}
+function intakeContext(projectId, actor) {
+  return { id: actor, type: "automation", projectId };
+}
+async function defaultResolveProjectId(projectRoot, createIfMissing) {
+  const existing = await readProjectIdentity(projectRoot);
+  if (existing) return existing.projectId;
+  if (!createIfMissing) {
+    throw new Error(
+      "No WrongStack project identity found \u2014 run `wstack init` (or file an intake first) to create it"
+    );
+  }
+  return (await ensureProjectIdentity(projectRoot)).identity.projectId;
+}
+function createRequirementIntakeMcpToolHost(projectRoot, opts = {}) {
+  const policy = selectRequirementIntakeTools(opts);
+  const allowed = new Set(policy.map((entry) => entry.name));
+  const actor = opts.actor?.trim() || "external-intake-mcp";
+  const service = opts.dependencies?.service ?? new RequirementIntakeService({
+    store: new RequirementIntakeStore({
+      baseDir: resolveWstackPaths({ projectRoot }).projectRequirementIntakes
+    }),
+    authorizer: new AllowAllIntakeAuthorizer()
+  });
+  const resolveProjectId = opts.dependencies?.resolveProjectId ?? ((createIfMissing) => defaultResolveProjectId(projectRoot, createIfMissing));
+  return {
+    listTools() {
+      return policy.map((entry) => toolDescriptor(entry.name));
+    },
+    async callTool(name, args) {
+      if (!allowed.has(name)) {
+        return {
+          content: `Tool "${name}" is not exposed by this Requirements Intake MCP server`,
+          isError: true
+        };
+      }
+      try {
+        if (name === "requirement_intake_submit") {
+          return await submitIntake(args);
+        }
+        return await listIntakes(args);
+      } catch (error) {
+        return {
+          content: error instanceof Error ? error.message : String(error),
+          isError: true
+        };
+      }
+    }
+  };
+  async function submitIntake(args) {
+    const request = args["request"];
+    if (typeof request !== "string" || request.trim().length === 0) {
+      return {
+        content: 'requirement_intake_submit requires a non-blank "request" string',
+        isError: true
+      };
+    }
+    const projectId = await resolveProjectId(true);
+    const ctx = intakeContext(projectId, actor);
+    const result = await service.createIntake(
+      {
+        projectId,
+        originalRequest: request,
+        requestedBy: actor,
+        ...typeof args["title"] === "string" ? { title: args["title"] } : {},
+        ...typeof args["requestType"] === "string" ? { requestType: args["requestType"] } : {},
+        ...typeof args["priority"] === "string" ? { priority: args["priority"] } : {},
+        ...typeof args["idempotencyKey"] === "string" ? { idempotencyKey: args["idempotencyKey"] } : {}
+      },
+      ctx
+    );
+    const submitted = await service.submitIntake(result.record.id, ctx);
+    return {
+      content: {
+        intakeId: submitted.record.id,
+        title: submitted.record.title,
+        requestType: submitted.record.requestType,
+        status: submitted.record.status,
+        projectId,
+        created: result.created,
+        idempotent: submitted.idempotent
+      },
+      isError: false
+    };
+  }
+  async function listIntakes(args) {
+    const projectId = await resolveProjectId(false);
+    const ctx = intakeContext(projectId, actor);
+    const statuses = filterStatuses(args["statuses"]);
+    const records = await service.listIntakes(projectId, ctx, statuses ? { statuses } : void 0);
+    return {
+      content: {
+        projectId,
+        count: records.length,
+        intakes: records.map((record) => ({
+          id: record.id,
+          title: record.title,
+          requestType: record.requestType,
+          status: record.status,
+          priority: record.priority,
+          updatedAt: record.updatedAt,
+          createdAt: record.createdAt
+        }))
+      },
+      isError: false
+    };
+  }
+}
+function filterStatuses(value) {
+  if (!Array.isArray(value)) return void 0;
+  const known = value.filter(
+    (item) => INTAKE_STATUSES.includes(String(item))
+  );
+  return known.length > 0 ? known : void 0;
+}
+function createRequirementIntakeMcpServer(projectRoot, opts = {}) {
+  return new MCPServer({
+    host: createRequirementIntakeMcpToolHost(projectRoot, opts),
+    serverInfo: { name: "wrongstack-requirement-intake-mcp", version: SERVER_INFO.version },
+    prompts: [
+      {
+        name: "file-requirement-intake",
+        title: "File a WrongStack requirement intake",
+        description: "Record and submit an unstructured software development request as a structured intake record.",
+        arguments: [{ name: "request", description: "The exact request text", required: true }],
+        template: "Use requirement_intake_submit to record and submit the request {{request}} verbatim. If a matching intake record may already exist, list records first and reuse the idempotency key pattern."
+      }
+    ]
+  });
+}
+
+// src/cli.ts
+function printHelp(stdout) {
+  stdout.write(
+    [
+      `${SERVER_INFO.name} v${SERVER_INFO.version} \u2014 WrongStack Requirements Intake MCP server`,
+      "",
+      "Usage:",
+      `  ${SERVER_INFO.name} --project-root <path> [options]`,
+      "",
+      "Options:",
+      "  --project-root <path>   Project whose requirement intakes should be served (required).",
+      "  --stdio                 Use stdio transport (default).",
+      "  --http                  Use HTTP transport.",
+      "  --port <n>              HTTP port (default 0 = ephemeral).",
+      "  --host <h>              HTTP bind host (default 127.0.0.1).",
+      "  --token <t>             Bearer token. Required for a non-loopback HTTP bind.",
+      "                          Prefer WRONGSTACK_MCP_TOKEN \u2014 a command line is readable",
+      "                          by other local processes (WS-064).",
+      "  --actor <id>            Actor id recorded as the intake requester.",
+      "  --writable              Expose requirement_intake_submit (filing records).",
+      "  -h, --help              Show this message."
+    ].join("\n") + "\n"
+  );
+}
+var HTTP_TOKEN_ENV = "WRONGSTACK_MCP_TOKEN";
+function parseArgs(argv, env = process.env) {
+  const parsed = {
+    projectRoot: "",
+    transport: "stdio",
+    httpPort: 0,
+    httpHost: "127.0.0.1",
+    writable: false,
+    help: false
+  };
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index];
+    switch (arg) {
+      case "--project-root":
+        parsed.projectRoot = path.resolve(argv[++index] ?? "");
+        break;
+      case "--stdio":
+        parsed.transport = "stdio";
+        break;
+      case "--http":
+        parsed.transport = "http";
+        break;
+      case "--port":
+        parsed.httpPort = Number(argv[++index] ?? "") || 0;
+        break;
+      case "--host":
+        parsed.httpHost = argv[++index] ?? "127.0.0.1";
+        break;
+      case "--token":
+        parsed.httpToken = argv[++index];
+        break;
+      case "--actor":
+        parsed.actor = argv[++index];
+        break;
+      case "--writable":
+        parsed.writable = true;
+        break;
+      case "-h":
+      case "--help":
+        parsed.help = true;
+        break;
+      default:
+        break;
+    }
+  }
+  if (parsed.httpToken === void 0) {
+    const fromEnv = env[HTTP_TOKEN_ENV]?.trim();
+    if (fromEnv) parsed.httpToken = fromEnv;
+  } else if (parsed.httpToken.length > 0) {
+    console.warn(
+      `[mcp] --token puts the auth token in this process's command line, which other local processes can read. Prefer ${HTTP_TOKEN_ENV}.`
+    );
+  }
+  return parsed;
+}
+async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  if (args.help) {
+    printHelp(process.stdout);
+    return 0;
+  }
+  if (!args.projectRoot) {
+    process.stderr.write(`${SERVER_INFO.name}: --project-root is required
+`);
+    printHelp(process.stderr);
+    return 2;
+  }
+  const projectRoot = canonicalProjectRoot(args.projectRoot);
+  const server = createRequirementIntakeMcpServer(projectRoot, {
+    writable: args.writable,
+    ...args.actor ? { actor: args.actor } : {}
+  });
+  const policyText = `writable=${String(args.writable)}`;
+  if (args.transport === "http") {
+    const handle2 = await serveHttp(server, {
+      port: args.httpPort,
+      host: args.httpHost,
+      ...args.httpToken ? { token: args.httpToken } : {},
+      logger: { warn: (message) => process.stderr.write(`[requirement-intake-mcp] ${message}
+`) }
+    });
+    process.stderr.write(
+      `${SERVER_INFO.name}: ready at ${handle2.url} \u2014 projectRoot=${projectRoot} transport=http ${policyText}${args.httpToken ? " [token auth]" : ""}
+`
+    );
+    await new Promise((resolve3) => {
+      process.once("SIGINT", resolve3);
+      process.once("SIGTERM", resolve3);
+    });
+    await handle2.close();
+    return 0;
+  }
+  const handle = serveStdio(server);
+  process.stderr.write(
+    `${SERVER_INFO.name}: ready on stdio \u2014 projectRoot=${projectRoot} transport=stdio ${policyText}
+`
+  );
+  await handle.done;
+  return 0;
+}
+function isMainModule() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  const self = fileURLToPath2(import.meta.url);
+  if (path.resolve(entry) === self) return true;
+  try {
+    return realpathSync(entry) === realpathSync(self);
+  } catch {
+    return false;
+  }
+}
+if (isMainModule()) {
+  main().then(
+    (code) => {
+      process.exitCode = code;
+    },
+    (error) => {
+      process.stderr.write(`${SERVER_INFO.name}: unexpected error
+`);
+      process.stderr.write(error instanceof Error ? error.stack ?? error.message : String(error));
+      process.stderr.write("\n");
+      process.exitCode = 1;
+    }
+  );
+}
+export {
+  main,
+  parseArgs,
+  printHelp
+};
+//# sourceMappingURL=cli.js.map

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { createRequirementIntakeMcpServer, createRequirementIntakeMcpToolHost, type RequirementIntakeMcpDependencies, type RequirementIntakeMcpToolHostOptions, } from './adapter.js';
+export { REQUIREMENT_INTAKE_READ_TOOLS, REQUIREMENT_INTAKE_WRITE_TOOLS, type RequirementIntakeMcpPolicyOptions, type RequirementIntakeMcpToolName, type RequirementIntakeMcpToolPolicy, selectRequirementIntakeTools, } from './policy.js';
+export { SERVER_INFO } from './version.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,255 @@
+// src/adapter.ts
+import {
+  ensureProjectIdentity,
+  readProjectIdentity,
+  resolveWstackPaths
+} from "@wrongstack/core/utils";
+import {
+  MCPServer
+} from "@wrongstack/mcp";
+import {
+  AllowAllIntakeAuthorizer,
+  INTAKE_PRIORITIES,
+  INTAKE_STATUSES,
+  RequirementIntakeService,
+  RequirementIntakeStore
+} from "@wrongstack/requirement-intake";
+
+// src/policy.ts
+var REQUIREMENT_INTAKE_READ_TOOLS = ["requirement_intake_list"];
+var REQUIREMENT_INTAKE_WRITE_TOOLS = ["requirement_intake_submit"];
+function selectRequirementIntakeTools(opts = {}) {
+  const tools = [{ name: "requirement_intake_list" }];
+  if (opts.writable === true) {
+    tools.push({ name: "requirement_intake_submit" });
+  }
+  return tools;
+}
+
+// src/version.ts
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var here = dirname(fileURLToPath(import.meta.url));
+var packagePath = resolve(here, "..", "package.json");
+var cached;
+function readServerInfo() {
+  if (cached) return cached;
+  try {
+    const pkg = JSON.parse(readFileSync(packagePath, "utf8"));
+    cached = {
+      name: pkg.name ?? "@wrongstack/requirement-intake-mcp",
+      version: pkg.version ?? "0.0.0"
+    };
+  } catch {
+    cached = { name: "@wrongstack/requirement-intake-mcp", version: "0.0.0" };
+  }
+  return cached;
+}
+var SERVER_INFO = readServerInfo();
+
+// src/adapter.ts
+var SUBMIT_SCHEMA = {
+  type: "object",
+  properties: {
+    request: {
+      type: "string",
+      description: "The exact software development request to record \u2014 a feature, bug fix, refactor, UI/API/infra change, migration, documentation, etc. Preserved verbatim."
+    },
+    title: {
+      type: "string",
+      description: "Optional short title. Defaults to a deterministic title from the request."
+    },
+    requestType: {
+      type: "string",
+      enum: [
+        "feature",
+        "bug_fix",
+        "refactor",
+        "performance",
+        "security",
+        "ui_change",
+        "api_change",
+        "infrastructure",
+        "migration",
+        "testing",
+        "documentation",
+        "maintenance",
+        "other",
+        "unspecified"
+      ],
+      description: "Request type hint. Unknown values normalize to other/unspecified."
+    },
+    priority: {
+      type: "string",
+      enum: [...INTAKE_PRIORITIES],
+      description: "Desired priority."
+    },
+    idempotencyKey: {
+      type: "string",
+      description: "Optional key making create idempotent \u2014 retries return the existing record."
+    }
+  },
+  required: ["request"],
+  additionalProperties: false
+};
+var LIST_SCHEMA = {
+  type: "object",
+  properties: {
+    statuses: {
+      type: "array",
+      items: { type: "string", enum: [...INTAKE_STATUSES] },
+      description: "Optional status filter (draft, collecting_information, submitted, cancelled, archived)."
+    }
+  },
+  additionalProperties: false
+};
+var TOOL_DESCRIPTIONS = {
+  requirement_intake_list: "List requirement intake records for the project, newest first, optionally filtered by status.",
+  requirement_intake_submit: "File and submit a requirement intake record from the given request text. Requires server --writable."
+};
+function toolDescriptor(name) {
+  return {
+    name,
+    description: TOOL_DESCRIPTIONS[name],
+    inputSchema: name === "requirement_intake_submit" ? SUBMIT_SCHEMA : LIST_SCHEMA
+  };
+}
+function intakeContext(projectId, actor) {
+  return { id: actor, type: "automation", projectId };
+}
+async function defaultResolveProjectId(projectRoot, createIfMissing) {
+  const existing = await readProjectIdentity(projectRoot);
+  if (existing) return existing.projectId;
+  if (!createIfMissing) {
+    throw new Error(
+      "No WrongStack project identity found \u2014 run `wstack init` (or file an intake first) to create it"
+    );
+  }
+  return (await ensureProjectIdentity(projectRoot)).identity.projectId;
+}
+function createRequirementIntakeMcpToolHost(projectRoot, opts = {}) {
+  const policy = selectRequirementIntakeTools(opts);
+  const allowed = new Set(policy.map((entry) => entry.name));
+  const actor = opts.actor?.trim() || "external-intake-mcp";
+  const service = opts.dependencies?.service ?? new RequirementIntakeService({
+    store: new RequirementIntakeStore({
+      baseDir: resolveWstackPaths({ projectRoot }).projectRequirementIntakes
+    }),
+    authorizer: new AllowAllIntakeAuthorizer()
+  });
+  const resolveProjectId = opts.dependencies?.resolveProjectId ?? ((createIfMissing) => defaultResolveProjectId(projectRoot, createIfMissing));
+  return {
+    listTools() {
+      return policy.map((entry) => toolDescriptor(entry.name));
+    },
+    async callTool(name, args) {
+      if (!allowed.has(name)) {
+        return {
+          content: `Tool "${name}" is not exposed by this Requirements Intake MCP server`,
+          isError: true
+        };
+      }
+      try {
+        if (name === "requirement_intake_submit") {
+          return await submitIntake(args);
+        }
+        return await listIntakes(args);
+      } catch (error) {
+        return {
+          content: error instanceof Error ? error.message : String(error),
+          isError: true
+        };
+      }
+    }
+  };
+  async function submitIntake(args) {
+    const request = args["request"];
+    if (typeof request !== "string" || request.trim().length === 0) {
+      return {
+        content: 'requirement_intake_submit requires a non-blank "request" string',
+        isError: true
+      };
+    }
+    const projectId = await resolveProjectId(true);
+    const ctx = intakeContext(projectId, actor);
+    const result = await service.createIntake(
+      {
+        projectId,
+        originalRequest: request,
+        requestedBy: actor,
+        ...typeof args["title"] === "string" ? { title: args["title"] } : {},
+        ...typeof args["requestType"] === "string" ? { requestType: args["requestType"] } : {},
+        ...typeof args["priority"] === "string" ? { priority: args["priority"] } : {},
+        ...typeof args["idempotencyKey"] === "string" ? { idempotencyKey: args["idempotencyKey"] } : {}
+      },
+      ctx
+    );
+    const submitted = await service.submitIntake(result.record.id, ctx);
+    return {
+      content: {
+        intakeId: submitted.record.id,
+        title: submitted.record.title,
+        requestType: submitted.record.requestType,
+        status: submitted.record.status,
+        projectId,
+        created: result.created,
+        idempotent: submitted.idempotent
+      },
+      isError: false
+    };
+  }
+  async function listIntakes(args) {
+    const projectId = await resolveProjectId(false);
+    const ctx = intakeContext(projectId, actor);
+    const statuses = filterStatuses(args["statuses"]);
+    const records = await service.listIntakes(projectId, ctx, statuses ? { statuses } : void 0);
+    return {
+      content: {
+        projectId,
+        count: records.length,
+        intakes: records.map((record) => ({
+          id: record.id,
+          title: record.title,
+          requestType: record.requestType,
+          status: record.status,
+          priority: record.priority,
+          updatedAt: record.updatedAt,
+          createdAt: record.createdAt
+        }))
+      },
+      isError: false
+    };
+  }
+}
+function filterStatuses(value) {
+  if (!Array.isArray(value)) return void 0;
+  const known = value.filter(
+    (item) => INTAKE_STATUSES.includes(String(item))
+  );
+  return known.length > 0 ? known : void 0;
+}
+function createRequirementIntakeMcpServer(projectRoot, opts = {}) {
+  return new MCPServer({
+    host: createRequirementIntakeMcpToolHost(projectRoot, opts),
+    serverInfo: { name: "wrongstack-requirement-intake-mcp", version: SERVER_INFO.version },
+    prompts: [
+      {
+        name: "file-requirement-intake",
+        title: "File a WrongStack requirement intake",
+        description: "Record and submit an unstructured software development request as a structured intake record.",
+        arguments: [{ name: "request", description: "The exact request text", required: true }],
+        template: "Use requirement_intake_submit to record and submit the request {{request}} verbatim. If a matching intake record may already exist, list records first and reuse the idempotency key pattern."
+      }
+    ]
+  });
+}
+export {
+  REQUIREMENT_INTAKE_READ_TOOLS,
+  REQUIREMENT_INTAKE_WRITE_TOOLS,
+  SERVER_INFO,
+  createRequirementIntakeMcpServer,
+  createRequirementIntakeMcpToolHost,
+  selectRequirementIntakeTools
+};
+//# sourceMappingURL=index.js.map

package/dist/policy.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Requirements Intake MCP — capability tiers.
+ *
+ * Mirrors the Kanban MCP policy shape: read-only tooling is always exposed;
+ * mutation (filing + submitting intake records) requires the writable tier.
+ */
+export declare const REQUIREMENT_INTAKE_READ_TOOLS: readonly ['requirement_intake_list'];
+export declare const REQUIREMENT_INTAKE_WRITE_TOOLS: readonly ['requirement_intake_submit'];
+export type RequirementIntakeMcpToolName = (typeof REQUIREMENT_INTAKE_READ_TOOLS)[number] | (typeof REQUIREMENT_INTAKE_WRITE_TOOLS)[number];
+export interface RequirementIntakeMcpPolicyOptions {
+    /** Expose the writable `requirement_intake_submit` tool. Default: read-only. */
+    writable?: boolean;
+}
+export interface RequirementIntakeMcpToolPolicy {
+    name: RequirementIntakeMcpToolName;
+}
+export declare function selectRequirementIntakeTools(opts?: RequirementIntakeMcpPolicyOptions): RequirementIntakeMcpToolPolicy[];
+//# sourceMappingURL=policy.d.ts.map

package/dist/version.d.ts

@@ -0,0 +1,5 @@
+export declare const SERVER_INFO: {
+    name: string;
+    version: string;
+};
+//# sourceMappingURL=version.d.ts.map

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@wrongstack/requirement-intake-mcp",
+  "version": "0.299.0",
+  "license": "MIT",
+  "description": "WrongStack Requirements Intake as a project-scoped MCP server: list intake records (read tier) and file+submit intake records (writable tier).",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/WrongStack/WrongStack.git",
+    "directory": "packages/requirement-intake-mcp"
+  },
+  "homepage": "https://github.com/WrongStack/WrongStack#readme",
+  "bugs": {
+    "url": "https://github.com/WrongStack/WrongStack/issues"
+  },
+  "author": "ECOSTACK TECHNOLOGY OÜ",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "wstack-requirement-intake-mcp": "./dist/cli.js"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "README.md"
+  ],
+  "dependencies": {
+    "@wrongstack/mcp": "0.299.0",
+    "@wrongstack/core": "0.299.0",
+    "@wrongstack/requirement-intake": "0.299.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.2",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node ../../scripts/build-package.mjs",
+    "typecheck": "tsc --noEmit -p tsconfig.test.json",
+    "test": "echo \"Run @wrongstack/requirement-intake-mcp tests from the workspace root: pnpm exec vitest run packages/requirement-intake-mcp/tests\"",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
+  }
+}