granttap-mcp 0.8.105 → 0.8.107

package/apps/bridge/src/engine/README.md

@@ -29,7 +29,8 @@ Explicit Graph builds also invoke the Engine's `graph.analyze_project` for two
 to eight admitted local repositories. The projection labels these shared static
 contracts and keeps their runtime destination unverified. They do not become
 verified Backbone dependencies or merge Project grants. The Apple Silicon
-artifact pins Engine 0.1.3 with Weavatrix 2.17.5; unsupported Engine operations
+artifact pins Engine 0.1.5 with Weavatrix 2.17.5, injective package import identities
+and per-file function extent reuse during metrics analysis; unsupported Engine operations
 leave this analysis unavailable. See `runtime/project-relationships/README.md`.
 
 Claude, Codex, and Cursor hooks can evaluate the engine's local Project
@@ -62,7 +63,7 @@ on macOS, Linux and Windows rather than relying on a LaunchAgent environment.
 Explicit disablement and a complete explicit executable/checksum pair win over
 the saved declaration. Partial environment overrides are never mixed with a
 different file's checksum. The supervisor still verifies the executable's bytes
-before launch. Windows clients derive a local named pipe from the normalized
+before launch. Its child process receives a minimum 32 MiB Rust worker stack: the default stack aborts the native parser on long, valid Rust syntax trees. Larger explicit reserves are retained. The parent process environment, Engine enablement and project policy settings are unchanged. This is a worker stack reserve, not a scan timeout or a guarantee that arbitrary inputs cannot exhaust resources. Windows clients derive a local named pipe from the normalized
 configuration path; remote shares never become Engine endpoints.
 The paired monitor installs the pinned managed Engine in the background when
 needed. Catalog delivery does not await that download. Failed preparation retries

package/apps/bridge/src/engine/distribution/artifacts.ts

@@ -8,8 +8,8 @@ export type EngineArtifact = {
 
 /** Release hashes are part of the reviewed MCP, never supplied by a remote manifest. */
 export const ENGINE_ARTIFACTS: readonly EngineArtifact[] = [
-  { version: "0.1.3", platform: "darwin", arch: "arm64",
-    sha256: "d948b6cfc572fa062af602c72d7b0e14bedcc5b48ecb8fb8d7af5b6fc33e9920", bytes: 12185568 },
+  { version: "0.1.5", platform: "darwin", arch: "arm64",
+    sha256: "bd16babf11fd3d7e65b9713797b977deba1670ba41230a0e6607ce938b847455", bytes: 12202080 },
   { version: "0.1.2", platform: "darwin", arch: "x64",
     sha256: "b3235a15936a77ec323d5ecbc54a0bc19994fe6e5a36044da964b68524b4c1dd", bytes: 13944984 },
   { version: "0.1.2", platform: "linux", arch: "x64",

package/apps/bridge/src/engine/runtime/engine-supervisor.ts

@@ -8,7 +8,7 @@ import { configDir } from "../../config/runtime/paths";
 import { EngineClient } from "./engine-client";
 import { engineHealth, type EngineHealth } from "./engine-health";
 import { EngineProtocolError } from "../protocol/engine-protocol";
-import { engineSocketEndpoint } from "../startup";
+import { engineLaunchEnvironment } from "./launch";
 
 export type VerifiedEngineBinary = { path: string; sha256: string };
 
@@ -133,8 +133,7 @@ function configuredBinary(env: NodeJS.ProcessEnv): VerifiedEngineBinary | undefi
 
 function launchEngine(path: string, socketPath: string, env: NodeJS.ProcessEnv): ChildProcess {
   const child = spawn(path, [], {
-    env: { ...env, GRANTTAP_ENGINE_SOCKET: engineSocketEndpoint(socketPath),
-      ...(process.platform === "win32" ? { GRANTTAP_ENGINE_STATE_DIR: join(configDir(), "engine", "state") } : {}) },
+    env: engineLaunchEnvironment(env, socketPath),
     stdio: "ignore",
     shell: false,
   });

package/apps/bridge/src/engine/runtime/launch/README.md

@@ -0,0 +1,18 @@
+# Engine process launch
+
+`index.ts` prepares the verified Engine child's environment. Rust parser workers
+receive a minimum 32 MiB stack reserve; larger explicit reserves remain intact.
+This prevents the reproduced daemon abort on long Rust expression trees. It does
+not change the parent environment, enablement, policy, or provider settings.
+Windows keeps its private Engine state directory and local endpoint mapping.
+
+The native regression analyzes a real synthetic Rust checkout through
+`EngineSupervisor` and confirms Graph data plus a subsequent control ping.
+Environment tests cover disablement, invalid and larger reserves, parent
+immutability and Windows state placement. Set `GRANTTAP_ENGINE_TEST_BINARY` to
+an exact verified native binary to run the native case.
+
+This is a fixed worker reserve, not a guarantee against arbitrary resource
+exhaustion. [Engine bridge](../../README.md) owns the public runtime boundary.
+
+License: GrantTap Commercial Source License; see the repository-root `LICENSE`.

package/apps/bridge/src/engine/runtime/launch/index.ts

@@ -0,0 +1,21 @@
+import { join } from "node:path";
+import { configDir } from "../../../config/runtime/paths";
+import { engineSocketEndpoint } from "../../startup";
+
+const MINIMUM_PARSER_STACK_BYTES = 32 * 1_024 * 1_024;
+
+/** Native syntax parsing runs on Rust worker threads, outside the JS stack. */
+export function engineLaunchEnvironment(
+  env: NodeJS.ProcessEnv, socketPath: string, platform: NodeJS.Platform = process.platform,
+): NodeJS.ProcessEnv {
+  const requestedStack = Number(env.RUST_MIN_STACK);
+  return {
+    ...env,
+    GRANTTAP_ENGINE_SOCKET: engineSocketEndpoint(socketPath),
+    // Rust's default worker stack aborts the daemon on ordinary long ASTs.
+    // Scope this reserve to the verified Engine child; keep larger explicit reserves.
+    RUST_MIN_STACK: String(Number.isSafeInteger(requestedStack)
+      ? Math.max(MINIMUM_PARSER_STACK_BYTES, requestedStack) : MINIMUM_PARSER_STACK_BYTES),
+    ...(platform === "win32" ? { GRANTTAP_ENGINE_STATE_DIR: join(configDir(), "engine", "state") } : {}),
+  };
+}

package/apps/bridge/src/mesh/restrictions/check.ts

@@ -1,6 +1,7 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { join, relative, sep } from "node:path";
 import type { ProjectRestrictionSet } from "../../../../../packages/protocol/schema";
+import { hasGuidance } from "./guidance";
 import { evaluateContent, type RestrictionViolation } from "./evaluate";
 
 const SKIP_DIR = new Set([
@@ -62,12 +63,12 @@ function isTextish(name: string): boolean {
 }
 
 export function restrictionSummary(restrictions: ProjectRestrictionSet | undefined): string {
-  if (!restrictions || restrictions.rules.length === 0) return "No restrictions";
+  if (!restrictions || (restrictions.rules.length === 0 && !hasGuidance(restrictions.guidance))) return "No restrictions";
   const count = restrictions.rules.length;
   const scope = restrictions.scope === "sync_from_repo"
     ? "from the repository"
     : restrictions.scope === "project_and_repo"
       ? "Project and repository"
       : "this Project";
-  return `${count} rule${count === 1 ? "" : "s"} · ${scope}`;
+  return `${count} rule${count === 1 ? "" : "s"}${hasGuidance(restrictions.guidance) ? " + agent guidance" : ""} · ${scope}`;
 }

package/apps/bridge/src/mesh/restrictions/cli.ts

@@ -1,3 +1,4 @@
+import { hasGuidance } from "./guidance";
 import { inspectRepository } from "../catalog";
 import { computerId } from "../identity/computer";
 import { localMeshStore } from "../local-remote/local";
@@ -19,7 +20,10 @@ export function runRestrictionsCheck(root: string): RestrictionsCheckResult {
   const restrictions = readRepoRestrictions(root, projectId ?? "ci")
     ?? (projectId ? loadRestrictions(projectId) : undefined);
 
+  const advisory = hasGuidance(restrictions?.guidance)
+    ? "Agent guidance is advisory and not machine-checked by this command.\n" : "";
   if (!restrictions || restrictions.rules.length === 0) {
+    if (advisory) return { exitCode: 0, stdout: advisory, stderr: "" };
     return { exitCode: 0, stdout: "GrantTap restrictions: none configured.\n", stderr: "" };
   }
 
@@ -27,7 +31,7 @@ export function runRestrictionsCheck(root: string): RestrictionsCheckResult {
   if (violations.length === 0) {
     return {
       exitCode: 0,
-      stdout: `GrantTap restrictions: ${restrictions.rules.length} rule(s) clean.\n`,
+      stdout: `GrantTap restrictions: ${restrictions.rules.length} rule(s) clean.\n${advisory}`,
       stderr: "",
     };
   }
@@ -36,5 +40,5 @@ export function runRestrictionsCheck(root: string): RestrictionsCheckResult {
     .map((item) => `${item.effect.toUpperCase()} ${item.reason}\n`)
     .join("");
   const denied = violations.some((item) => item.effect === "deny");
-  return { exitCode: denied ? 1 : 0, stdout: "", stderr };
+  return { exitCode: denied ? 1 : 0, stdout: advisory, stderr };
 }

package/apps/bridge/src/mesh/restrictions/evaluate.ts

@@ -38,7 +38,7 @@ export function functionLineCounts(source: string): number[] {
 
 function unparsedFunctionForm(filePath: string, content: string): boolean {
   const extension = filePath.split(".").at(-1)?.toLowerCase();
-  if (extension === "py") return /^\s*(?:async\s+)?def\s+\w+/m.test(content);
+  if (["py", "rb"].includes(extension ?? "")) return /^\s*(?:async\s+)?def\s+\w+/m.test(content);
   if (!["ts", "tsx", "js", "jsx", "mjs", "cjs"].includes(extension ?? "")) return false;
   if (/=>/.test(content)) return true;
   return /^\s*(?:async\s+)?(?!(?:if|while|for|switch|catch)\b)[A-Za-z_$][\w$]*\s*\([^;\n]*\)\s*\{/m

package/apps/bridge/src/mesh/restrictions/guidance/README.md

@@ -0,0 +1,27 @@
+# Project coding guidance
+
+`projectGuidancePrompt(projectId, text)` is the public prompt boundary. It loads
+only the accepted local restriction set for the named Project, adds its
+advisory principles, architecture preference, design targets and exact Markdown,
+then preserves the original request. Empty guidance is a no-op. It never edits
+provider configuration or raises tool permissions.
+
+Continuation delivery calls this through the existing routing prompt for all
+supported providers. New phone Tasks use the Project returned by validated
+workspace admission. Transfer starts use the existing Task's Project scope.
+A loose cwd or unvalidated message Project ID does not supply instruction scope.
+Original delivery identities, origin records and run journals retain the person's
+original request; attached guidance is not a separately delivered prompt.
+
+The optional protocol field is backward compatible for reading old sets. A Mac
+that predates this contract must be upgraded before a phone sends guidance;
+strict old protocol receivers cannot honestly acknowledge a field they reject.
+The canonical policy receipt proves local acceptance, not semantic compliance.
+
+The private store and `.granttap/restrictions.json` export preserve all guidance.
+The explicit repository check reports guidance as advisory and never claims to
+machine-check Clean Code, architecture, class or parameter targets. Existing
+write checks own numeric enforcement; Ruby/Python function forms outside the
+brace scanner request parser review.
+
+License: GrantTap Commercial Source License, in the repository-root `LICENSE`.

package/apps/bridge/src/mesh/restrictions/guidance/index.ts

@@ -0,0 +1,45 @@
+import { loadRestrictions } from '../store';
+import type { ProjectRestrictionGuidance } from '../../../../../../packages/protocol/messages/restrictions';
+
+const principles: Record<string, string> = {
+  single_responsibility: 'Keep each module focused on one responsibility and reason to change.',
+  small_interfaces: 'Expose small explicit public interfaces; hide implementation details.',
+  composition: 'Prefer composition to inheritance when it reduces coupling.',
+  dependency_inversion: 'Keep domain logic independent of infrastructure through explicit boundaries.',
+  behavior_tests: 'Test observable behavior and durable state, including failure paths.',
+  clear_names: 'Use clear domain names; keep control flow readable and nesting shallow.',
+  explicit_errors: 'Handle failures explicitly; do not silently swallow errors.',
+  no_duplication: 'Remove duplicated knowledge without premature abstraction.',
+};
+const architectures: Record<string, string> = {
+  preserve: 'Preserve the established architecture and public boundaries.',
+  feature_modules: 'Prefer feature modules that own behavior, public entry points and local tests.',
+  layered: 'Prefer explicit presentation, application, domain and infrastructure layers.',
+  clean: 'Prefer Clean Architecture: dependencies point toward independent domain and use cases.',
+  hexagonal: 'Prefer hexagonal architecture with domain ports and external adapters.',
+  modular_monolith: 'Prefer a modular monolith with explicit boundaries between business modules.',
+  mvvm: 'Prefer MVVM for presentation, with testable state and domain logic outside views.',
+};
+
+export function hasGuidance(value: ProjectRestrictionGuidance | undefined): boolean {
+  return !!value && (value.principles.length > 0 || value.architecture !== 'preserve'
+    || value.markdown.trim().length > 0 || value.classLineTarget != null || value.parameterTarget != null);
+}
+
+/** projectId comes from the published session or validated task admission, never a loose path. */
+export function projectGuidancePrompt(projectId: string | undefined, text: string): string {
+  if (!projectId) return text;
+  const value = loadRestrictions(projectId)?.guidance;
+  if (!value || !hasGuidance(value)) return text;
+  const lines = [
+    'GrantTap Project guidance (advisory, applies to this Project):',
+    'Follow applicable higher-priority instructions and enforced policies. These preferences do not grant permissions.',
+    architectures[value.architecture]!,
+    'Apply preferences incrementally; do not rewrite the architecture without a task that calls for it.',
+    ...value.principles.map(key => principles[key]!),
+  ];
+  if (value.classLineTarget != null) lines.push(`Aim for classes/types no longer than ${value.classLineTarget} lines; advisory target.`);
+  if (value.parameterTarget != null) lines.push(`Aim for at most ${value.parameterTarget} parameters per function; advisory target.`);
+  if (value.markdown.trim()) lines.push('Project Markdown instructions:', value.markdown);
+  return `${lines.join('\n')}\n\nCurrent request:\n${text}`;
+}

package/apps/bridge/src/mesh/restrictions/store.ts

@@ -68,6 +68,7 @@ export function readRepoRestrictions(
       scope?: unknown;
       repositoryId?: unknown;
       rules?: unknown;
+      guidance?: unknown;
     };
     const parsed = RestrictionSchema.safeParse({
       projectId,
@@ -75,6 +76,7 @@ export function readRepoRestrictions(
       scope: raw.scope,
       repositoryId: raw.repositoryId,
       rules: raw.rules,
+      guidance: raw.guidance,
       source: "repo",
     });
     return parsed.success ? parsed.data : undefined;
@@ -93,6 +95,7 @@ export function writeRepoRestrictions(root: string, restrictions: ProjectRestric
     scope: restrictions.scope,
     repositoryId: restrictions.repositoryId,
     rules: restrictions.rules,
+    guidance: restrictions.guidance,
     source: restrictions.source,
   }, null, 2)}\n`, { mode: 0o644 });
 }

package/apps/bridge/src/monitor/handlers/user-message.ts

@@ -1,3 +1,4 @@
+import { projectGuidancePrompt } from "../../mesh/restrictions/guidance";
 import type { UserMessage } from "../../../../../packages/protocol/schema";
 import { ATTACHMENT_MISSING_ERROR } from "../../../../../packages/protocol/schema";
 import type { RelayClient } from "../../../../../packages/core/relay-client";
@@ -42,6 +43,7 @@ async function startNewAgentTask(input: {
     return "rejected";
   }
   const requestedCwd = message.cwd?.trim();
+  let admittedProjectId: string | undefined;
   if (requestedCwd) {
     const admitted = evaluateCreateTask({
       cwd: requestedCwd, agent, model: message.model,
@@ -52,6 +54,7 @@ async function startNewAgentTask(input: {
       await say(admitted.detail, undefined, true);
       return "rejected";
     }
+    admittedProjectId = admitted.projectId;
     if ("queued" in admitted && admitted.queued) {
       // The phone's durable outbox retries after reconnect. This monitor has
       // no worker for its separate pinned-task queue, so do not launch here.
@@ -87,7 +90,7 @@ async function startNewAgentTask(input: {
   }[agent];
   let run: Promise<ReplyResult>;
   try {
-    run = create(message.text, requestedCwd, PHONE_RUN_LIMIT_MS, resolved.attachments,
+    run = create(projectGuidancePrompt(admittedProjectId, message.text), requestedCwd, PHONE_RUN_LIMIT_MS, resolved.attachments,
       message.model, undefined, message.effort).catch(() => {
       input.origin?.registry.complete(input.origin.scope, { ok: true });
       return { ok: false, error: 'The provider task stopped unexpectedly.' } as ReplyResult;

package/apps/bridge/src/reply/index.ts

@@ -1,3 +1,4 @@
+import { projectGuidancePrompt } from "../mesh/restrictions/guidance";
 /** Deliver phone messages into existing sessions or start a new Codex task. */
 import { localTaskTransfers, localTransferContinuations } from "../task-transfer";
 import { localRoutingRequests } from '../task-routing/requests';
@@ -66,13 +67,13 @@ export function deliverToSession(
     return queued(session.sessionId, async () => (await localTaskTransfers().deliver(
       session.sessionId, text, attachments, options, {
         start: request => request.provider === "grok"
-          ? createGrokSession(request.text, request.cwd, timeoutMs, request.attachments,
+          ? createGrokSession(projectGuidancePrompt(session.projectId, request.text), request.cwd, timeoutMs, request.attachments,
             request.model, request.operationKey, request.effort, nativeId => {
               request.onNativeSession(nativeId);
               options.onAgentActivity?.(nativeId);
             })
           : ({ claude: createClaudeSession, codex: createCodexSession,
-            cursor: createCursorSession }[request.provider])(request.text, request.cwd,
+            cursor: createCursorSession }[request.provider])(projectGuidancePrompt(session.projectId, request.text), request.cwd,
             timeoutMs, request.attachments, request.model, request.operationKey, request.effort),
         resume: (native, body, images, settings) => withAttachments(images, body, prepared => runDelivery(native,
           native.agent === "codex" ? prepared.prompt : prepared.claudePrompt, timeoutMs, prepared.images, settings)),

package/apps/bridge/src/reply/payload/routing.ts

@@ -1,3 +1,4 @@
+import { projectGuidancePrompt } from "../../mesh/restrictions/guidance";
 import type { SessionInfo } from "../../../../../packages/protocol/schema";
 import type { DeliveryOptions } from "./types";
 
@@ -14,5 +15,6 @@ export function routingPrompt(
     const invocation = session.agent === "claude" ? `/${options.skill}` : `$${options.skill}`;
     instructions.push(`Use the project skill ${invocation} for this request.`);
   }
-  return instructions.length === 0 ? text : `${instructions.join("\n")}\n\n${text}`;
+  const routed = instructions.length === 0 ? text : `${instructions.join("\n")}\n\n${text}`;
+  return projectGuidancePrompt(session.projectId, routed);
 }

package/cursor-plugin/README.md

@@ -10,7 +10,7 @@ keeps each phone response tied to the exact originating chat and prompt.
 Install the supported CLI on this computer, then run:
 
 ```bash
-npm install -g granttap-mcp@0.8.105
+npm install -g granttap-mcp@0.8.107
 granttap setup
 granttap status
 ```

package/cursor-plugin/mcp.json

@@ -4,7 +4,7 @@
       "command": "node",
       "args": [
         "-e",
-        "\"use strict\";\n\n// Cursor may start this MCP from any cwd. Execute JavaScript entry points with\n// Node itself: Windows batch shims require shell quoting that differs by host.\nconst { spawn } = require(\"node:child_process\");\nconst { existsSync } = require(\"node:fs\");\nconst { delimiter, dirname, join } = require(\"node:path\");\n\nconst PACKAGE = \"granttap-mcp@0.8.105\";\nconst dryRun = process.env.GRANTTAP_BOOTSTRAP_DRY_RUN === \"1\";\nconst platform = dryRun && process.env.GRANTTAP_BOOTSTRAP_PLATFORM\n  ? process.env.GRANTTAP_BOOTSTRAP_PLATFORM : process.platform;\nconst nodeRoot = dryRun && process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT\n  ? process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT : dirname(process.execPath);\nconst pathRoots = (process.env.PATH || \"\").split(delimiter).filter(Boolean);\nconst appData = process.env.APPDATA;\nconst roots = [nodeRoot, ...pathRoots, ...(appData ? [join(appData, \"npm\")] : [])];\nconst first = (paths) => paths.find((path) => existsSync(path));\n\nfunction launch() {\n  if (platform !== \"win32\") {\n    const installed = first(roots.map((root) => join(root, \"granttap-mcp\")));\n    if (installed) return { command: installed, args: [] };\n    const npx = first(roots.map((root) => join(root, \"npx\"))) || \"npx\";\n    return { command: npx, args: [\"-y\", PACKAGE] };\n  }\n  const installed = first(roots.map((root) =>\n    join(root, \"node_modules\", \"granttap-mcp\", \"bin\", \"granttap-mcp.mjs\")));\n  if (installed) return { command: process.execPath, args: [installed] };\n  const npx = first(roots.map((root) =>\n    join(root, \"node_modules\", \"npm\", \"bin\", \"npx-cli.js\")));\n  if (npx) return { command: process.execPath, args: [npx, \"-y\", PACKAGE] };\n  throw new Error(\"Node.js/npm 22.13.0+ is required on this Windows device. Install npm and retry GrantTap.\");\n}\n\nlet target;\ntry { target = launch(); }\ncatch (error) {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n}\n\nif (dryRun) {\n  process.stdout.write(JSON.stringify(target));\n  process.exit(0);\n}\n\nconst child = spawn(target.command, target.args, { stdio: \"inherit\", windowsHide: true });\nchild.on(\"error\", (error) => {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n});\nchild.on(\"exit\", (code, signal) => {\n  if (signal && platform !== \"win32\") {\n    try { process.kill(process.pid, signal); } catch { process.exit(code ?? 1); }\n    return;\n  }\n  process.exit(code ?? 1);\n});\n"
+        "\"use strict\";\n\n// Cursor may start this MCP from any cwd. Execute JavaScript entry points with\n// Node itself: Windows batch shims require shell quoting that differs by host.\nconst { spawn } = require(\"node:child_process\");\nconst { existsSync } = require(\"node:fs\");\nconst { delimiter, dirname, join } = require(\"node:path\");\n\nconst PACKAGE = \"granttap-mcp@0.8.107\";\nconst dryRun = process.env.GRANTTAP_BOOTSTRAP_DRY_RUN === \"1\";\nconst platform = dryRun && process.env.GRANTTAP_BOOTSTRAP_PLATFORM\n  ? process.env.GRANTTAP_BOOTSTRAP_PLATFORM : process.platform;\nconst nodeRoot = dryRun && process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT\n  ? process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT : dirname(process.execPath);\nconst pathRoots = (process.env.PATH || \"\").split(delimiter).filter(Boolean);\nconst appData = process.env.APPDATA;\nconst roots = [nodeRoot, ...pathRoots, ...(appData ? [join(appData, \"npm\")] : [])];\nconst first = (paths) => paths.find((path) => existsSync(path));\n\nfunction launch() {\n  if (platform !== \"win32\") {\n    const installed = first(roots.map((root) => join(root, \"granttap-mcp\")));\n    if (installed) return { command: installed, args: [] };\n    const npx = first(roots.map((root) => join(root, \"npx\"))) || \"npx\";\n    return { command: npx, args: [\"-y\", PACKAGE] };\n  }\n  const installed = first(roots.map((root) =>\n    join(root, \"node_modules\", \"granttap-mcp\", \"bin\", \"granttap-mcp.mjs\")));\n  if (installed) return { command: process.execPath, args: [installed] };\n  const npx = first(roots.map((root) =>\n    join(root, \"node_modules\", \"npm\", \"bin\", \"npx-cli.js\")));\n  if (npx) return { command: process.execPath, args: [npx, \"-y\", PACKAGE] };\n  throw new Error(\"Node.js/npm 22.13.0+ is required on this Windows device. Install npm and retry GrantTap.\");\n}\n\nlet target;\ntry { target = launch(); }\ncatch (error) {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n}\n\nif (dryRun) {\n  process.stdout.write(JSON.stringify(target));\n  process.exit(0);\n}\n\nconst child = spawn(target.command, target.args, { stdio: \"inherit\", windowsHide: true });\nchild.on(\"error\", (error) => {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n});\nchild.on(\"exit\", (code, signal) => {\n  if (signal && platform !== \"win32\") {\n    try { process.kill(process.pid, signal); } catch { process.exit(code ?? 1); }\n    return;\n  }\n  process.exit(code ?? 1);\n});\n"
       ]
     }
   }

package/cursor-plugin/stdio-bootstrap.cjs

@@ -7,7 +7,7 @@ const { spawn } = require("node:child_process");
 const { existsSync } = require("node:fs");
 const { delimiter, dirname, join } = require("node:path");
 
-const PACKAGE = "granttap-mcp@0.8.105";
+const PACKAGE = "granttap-mcp@0.8.107";
 const dryRun = process.env.GRANTTAP_BOOTSTRAP_DRY_RUN === "1";
 const platform = dryRun && process.env.GRANTTAP_BOOTSTRAP_PLATFORM
   ? process.env.GRANTTAP_BOOTSTRAP_PLATFORM : process.platform;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "granttap-mcp",
-  "version": "0.8.105",
+  "version": "0.8.107",
   "description": "Commercial computer runtime connecting local coding agents to GrantTap on Mac, iPhone, iPad and Apple Watch.",
   "type": "module",
   "bin": {

package/packages/protocol/messages/project-policy.ts

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { ProjectRestrictionSet } from "./restrictions";
+export * from "./restrictions";
 import { Identifier, Label, MeshProvider } from "./mesh/endpoint";
 
 export const ProjectCapabilityKind = z.enum([
@@ -89,45 +91,6 @@ export const ProjectExecutionPolicy = z.object({
 });
 export type ProjectExecutionPolicy = z.infer<typeof ProjectExecutionPolicy>;
 
-/** Quality gates a Project can share with CI and its repository. */
-export const ProjectRestrictionKind = z.enum([
-  "max_file_lines", "max_function_lines", "max_file_bytes", "custom",
-]);
-export type ProjectRestrictionKind = z.infer<typeof ProjectRestrictionKind>;
-export const ProjectRestrictionScope = z.enum([
-  "project", "project_and_repo", "sync_from_repo",
-]);
-export type ProjectRestrictionScope = z.infer<typeof ProjectRestrictionScope>;
-export const ProjectRestrictionRule = z.object({
-  ruleId: Identifier,
-  kind: ProjectRestrictionKind,
-  limit: z.number().int().positive().max(1_000_000).optional(),
-  name: Label.optional(),
-  paths: z.array(z.string().trim().min(1).max(256)).max(16).optional(),
-  effect: z.enum(["ask", "deny"]).default("deny"),
-}).strict().superRefine((value, ctx) => {
-  if (value.kind !== "custom" && value.limit == null) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom, path: ["limit"], message: "limit required",
-    });
-  }
-  if (value.kind === "custom" && !value.name) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom, path: ["name"], message: "custom needs a name",
-    });
-  }
-});
-export type ProjectRestrictionRule = z.infer<typeof ProjectRestrictionRule>;
-export const ProjectRestrictionSet = z.object({
-  projectId: Identifier,
-  revision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  scope: ProjectRestrictionScope,
-  repositoryId: z.string().trim().min(1).max(512).optional(),
-  rules: z.array(ProjectRestrictionRule).max(32),
-  source: z.enum(["phone", "repo"]).default("phone"),
-}).strict();
-export type ProjectRestrictionSet = z.infer<typeof ProjectRestrictionSet>;
-
 /** Shared Project environment. Secret values travel under the Project key only. */
 export const ProjectEnvVar = z.object({
   key: z.string().regex(/^[A-Z][A-Z0-9_]{0,127}$/),

package/packages/protocol/messages/restrictions/index.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { Identifier, Label } from '../mesh/endpoint';
+
+export const ProjectRestrictionKind = z.enum([
+  'max_file_lines', 'max_function_lines', 'max_file_bytes', 'custom',
+]);
+export type ProjectRestrictionKind = z.infer<typeof ProjectRestrictionKind>;
+export const ProjectRestrictionScope = z.enum(['project', 'project_and_repo', 'sync_from_repo']);
+export type ProjectRestrictionScope = z.infer<typeof ProjectRestrictionScope>;
+export const ProjectRestrictionRule = z.object({
+  ruleId: Identifier, kind: ProjectRestrictionKind,
+  limit: z.number().int().positive().max(1_000_000).optional(),
+  name: Label.optional(),
+  paths: z.array(z.string().trim().min(1).max(256)).max(16).optional(),
+  effect: z.enum(['ask', 'deny']).default('deny'),
+}).strict().superRefine((value, ctx) => {
+  if (value.kind !== 'custom' && value.limit == null) {
+    ctx.addIssue({ code: 'custom', path: ['limit'], message: 'limit required' });
+  }
+  if (value.kind === 'custom' && !value.name) {
+    ctx.addIssue({ code: 'custom', path: ['name'], message: 'custom needs a name' });
+  }
+});
+export type ProjectRestrictionRule = z.infer<typeof ProjectRestrictionRule>;
+
+/** Agent preferences, never a claim that a semantic rule has a machine checker. */
+export const ProjectRestrictionGuidance = z.object({
+  principles: z.array(z.enum([
+    'single_responsibility', 'small_interfaces', 'composition', 'dependency_inversion',
+    'behavior_tests', 'clear_names', 'explicit_errors', 'no_duplication',
+  ])).max(8).refine(items => new Set(items).size === items.length, 'duplicate principle'),
+  architecture: z.enum([
+    'preserve', 'feature_modules', 'layered', 'clean', 'hexagonal', 'modular_monolith', 'mvvm',
+  ]),
+  classLineTarget: z.number().int().positive().max(1_000_000).optional(),
+  parameterTarget: z.number().int().positive().max(1_000).optional(),
+  markdown: z.string().refine(text => !text.includes('\0') && new TextEncoder().encode(text).length <= 12_000,
+    'Markdown must fit 12000 UTF-8 bytes and contain no NUL'),
+}).strict();
+export type ProjectRestrictionGuidance = z.infer<typeof ProjectRestrictionGuidance>;
+
+export const ProjectRestrictionSet = z.object({
+  projectId: Identifier,
+  revision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  scope: ProjectRestrictionScope,
+  repositoryId: z.string().trim().min(1).max(512).optional(),
+  rules: z.array(ProjectRestrictionRule).max(32),
+  source: z.enum(['phone', 'repo']).default('phone'),
+  guidance: ProjectRestrictionGuidance.optional(),
+}).strict();
+export type ProjectRestrictionSet = z.infer<typeof ProjectRestrictionSet>;