openplanr 3.0.0 → 3.1.0

package/lib/host-packages/claude/openplanr/runtime/plan/scripts/design-protocol-contracts.mjs

@@ -120,17 +120,179 @@ var matchesType = (v, t) => {
 };
 var FORMAT_DATE = /^\d{4}-\d{2}-\d{2}$/;
 var FORMAT_DATETIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+var SUPPORTED_FORMATS = /* @__PURE__ */ new Set(["date", "date-time"]);
+var ANNOTATION_KEYWORDS = [
+  "$schema",
+  "$id",
+  "$defs",
+  "$comment",
+  "title",
+  "description",
+  "default",
+  "examples",
+  "deprecated",
+  "readOnly",
+  "writeOnly"
+];
+var VALIDATION_KEYWORDS = [
+  "$ref",
+  "type",
+  "const",
+  "enum",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "format",
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "minItems",
+  "maxItems",
+  "prefixItems",
+  "items",
+  "uniqueItems",
+  "contains",
+  "minContains",
+  "maxContains",
+  "required",
+  "properties",
+  "additionalProperties",
+  "maxProperties",
+  "dependentRequired",
+  "unevaluatedProperties",
+  "oneOf",
+  "anyOf",
+  "allOf",
+  "if",
+  "then",
+  "else",
+  "not"
+];
+var KNOWN_KEYWORDS = /* @__PURE__ */ new Set([...ANNOTATION_KEYWORDS, ...VALIDATION_KEYWORDS]);
+var TYPE_NAMES = /* @__PURE__ */ new Set(["array", "boolean", "integer", "null", "number", "object", "string"]);
+var isSchema = (value) => typeof value === "boolean" || value !== null && typeof value === "object" && !Array.isArray(value);
+var isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var isCount = (value) => Number.isSafeInteger(value) && value >= 0;
+var isUniqueStrings = (value) => Array.isArray(value) && value.every((item2) => typeof item2 === "string") && new Set(value).size === value.length;
+var isSchemaArray = (value) => Array.isArray(value) && value.length > 0 && value.every(isSchema);
+var isSchemaMap = (value) => isPlainObject(value) && Object.values(value).every(isSchema);
+var compiledPatterns = /* @__PURE__ */ new Map();
+var MAX_COMPILED_PATTERNS = 1024;
+var tryCompilePattern = (source) => {
+  try {
+    return new RegExp(source);
+  } catch (error) {
+    if (error instanceof SyntaxError) return null;
+    throw error;
+  }
+};
+var compilePattern = (source) => {
+  if (!compiledPatterns.has(source)) {
+    if (compiledPatterns.size >= MAX_COMPILED_PATTERNS) compiledPatterns.clear();
+    compiledPatterns.set(source, tryCompilePattern(source));
+  }
+  return compiledPatterns.get(source) ?? null;
+};
+var describeValue = (value) => {
+  const text3 = String(JSON.stringify(value));
+  return text3.length > 80 ? `${text3.slice(0, 77)}...` : text3;
+};
+var KEYWORD_SHAPES = {
+  $ref: ["a string", (value) => typeof value === "string"],
+  $defs: ["an object of schemas", isSchemaMap],
+  type: [
+    "a type name or a non-empty array of unique type names",
+    (value) => typeof value === "string" && TYPE_NAMES.has(value) || isUniqueStrings(value) && value.length > 0 && value.every((name) => TYPE_NAMES.has(name))
+  ],
+  enum: ["an array", Array.isArray],
+  minLength: ["a non-negative integer", isCount],
+  maxLength: ["a non-negative integer", isCount],
+  pattern: [
+    "a valid regular expression string",
+    (value) => typeof value === "string" && compilePattern(value) !== null
+  ],
+  minimum: ["a finite number", Number.isFinite],
+  maximum: ["a finite number", Number.isFinite],
+  exclusiveMinimum: ["a finite number", Number.isFinite],
+  minItems: ["a non-negative integer", isCount],
+  maxItems: ["a non-negative integer", isCount],
+  prefixItems: ["a non-empty array of schemas", isSchemaArray],
+  items: ["a schema", isSchema],
+  uniqueItems: ["a boolean", (value) => typeof value === "boolean"],
+  contains: ["a schema", isSchema],
+  minContains: ["a non-negative integer", isCount],
+  maxContains: ["a non-negative integer", isCount],
+  required: ["an array of unique strings", isUniqueStrings],
+  properties: ["an object of schemas", isSchemaMap],
+  additionalProperties: ["a schema", isSchema],
+  maxProperties: ["a non-negative integer", isCount],
+  dependentRequired: [
+    "an object of unique string arrays",
+    (value) => isPlainObject(value) && Object.values(value).every(isUniqueStrings)
+  ],
+  unevaluatedProperties: ["a schema", isSchema],
+  oneOf: ["a non-empty array of schemas", isSchemaArray],
+  anyOf: ["a non-empty array of schemas", isSchemaArray],
+  allOf: ["a non-empty array of schemas", isSchemaArray],
+  if: ["a schema", isSchema],
+  then: ["a schema", isSchema],
+  else: ["a schema", isSchema],
+  not: ["a schema", isSchema]
+};
 function resolveJsonPointer(root, reference) {
   if (reference === "#") return root;
   if (!reference.startsWith("#/")) return null;
   return reference.slice(2).split("/").map((part) => part.replaceAll("~1", "/").replaceAll("~0", "~")).reduce((value, part) => value?.[part], root);
 }
+var wellFormedSchemas = /* @__PURE__ */ new WeakSet();
+var isFrozenNode = (schema6) => Object.isFrozen(schema6) && Object.values(schema6).every(Object.isFrozen) && (!isPlainObject(schema6.dependentRequired) || Object.values(schema6.dependentRequired).every(Object.isFrozen));
+var checkSchemaNode = (schema6, path, context) => {
+  if (wellFormedSchemas.has(schema6) || context.checkedSchemas.has(schema6)) return;
+  context.checkedSchemas.add(schema6);
+  const errorCount = context.schemaErrors.length;
+  for (const keyword of Object.keys(schema6)) {
+    if (!KNOWN_KEYWORDS.has(keyword) && !keyword.startsWith("x-")) {
+      context.schemaErrors.push({
+        path,
+        rule: "unsupported-keyword",
+        detail: `schema keyword '${keyword}' is not supported by this validator`
+      });
+    }
+  }
+  if (Object.hasOwn(schema6, "format") && !SUPPORTED_FORMATS.has(schema6.format)) {
+    context.schemaErrors.push({
+      path,
+      rule: "unsupported-format",
+      detail: `schema format ${JSON.stringify(schema6.format)} is not supported by this validator`
+    });
+  }
+  for (const [keyword, [expected, isValid]] of Object.entries(KEYWORD_SHAPES)) {
+    if (Object.hasOwn(schema6, keyword) && !isValid(schema6[keyword])) {
+      context.schemaErrors.push({
+        path,
+        rule: "schema",
+        detail: `schema keyword '${keyword}' must be ${expected}, got ${describeValue(schema6[keyword])}`
+      });
+    }
+  }
+  if (context.schemaErrors.length === errorCount && isFrozenNode(schema6)) {
+    wellFormedSchemas.add(schema6);
+  }
+};
+var reportReference = (schema6, path, detail, context) => {
+  if (context.reportedReferences.has(schema6)) return;
+  context.reportedReferences.add(schema6);
+  context.schemaErrors.push({ path, rule: "$ref", detail });
+};
 var validateNode = (value, schema6, path, errs, context) => {
-  if (schema6 === true) return;
+  const evaluated = /* @__PURE__ */ new Set();
+  if (schema6 === true) return evaluated;
   if (schema6 === false) {
     errs.push({ path, rule: "schema:false", detail: "value not allowed" });
-    return;
+    return evaluated;
   }
+  if (!isSchema(schema6)) return evaluated;
+  checkSchemaNode(schema6, path, context);
   if (typeof schema6?.$ref === "string") {
     const reference = schema6.$ref;
     let resolved;
@@ -144,21 +306,23 @@ var validateNode = (value, schema6, path, errs, context) => {
       nextRoot = result?.rootSchema ?? resolved;
       resolvedBase = result?.base ?? resolved?.$id ?? context.base;
     }
-    if (!resolved) {
-      errs.push({ path, rule: "$ref", detail: `could not resolve schema reference ${reference}` });
-      return;
+    if (!isSchema(resolved)) {
+      const detail = resolved === void 0 || resolved === null ? `could not resolve schema reference ${reference}` : `schema reference ${reference} resolved to ${typeOf(resolved)}, not a schema`;
+      reportReference(schema6, path, detail, context);
+      return evaluated;
     }
-    const referenceKey = `${context.base ?? "<root>"}:${reference}`;
+    const referenceKey = `${path} ${context.base ?? "<root>"}:${reference}`;
     if (context.referenceStack.includes(referenceKey)) {
-      errs.push({ path, rule: "$ref", detail: `circular schema reference ${reference}` });
-      return;
+      reportReference(schema6, path, `circular schema reference ${reference}`, context);
+      return evaluated;
     }
-    validateNode(value, resolved, path, errs, {
+    const referenced = validateNode(value, resolved, path, errs, {
       ...context,
       rootSchema: nextRoot,
       base: resolvedBase,
       referenceStack: [...context.referenceStack, referenceKey]
     });
+    for (const key of referenced) evaluated.add(key);
   }
   if (schema6.type !== void 0) {
     const types = Array.isArray(schema6.type) ? schema6.type : [schema6.type];
@@ -168,7 +332,7 @@ var validateNode = (value, schema6, path, errs, context) => {
         rule: "type",
         detail: `expected ${types.join("|")}, got ${typeOf(value)}`
       });
-      return;
+      return evaluated;
     }
   }
   if (schema6.const !== void 0) {
@@ -204,22 +368,13 @@ var validateNode = (value, schema6, path, errs, context) => {
         detail: `length ${value.length} > ${schema6.maxLength}`
       });
     }
-    if (typeof schema6.pattern === "string") {
-      try {
-        if (!new RegExp(schema6.pattern).test(value)) {
-          errs.push({
-            path,
-            rule: "pattern",
-            detail: `value ${JSON.stringify(value)} does not match /${schema6.pattern}/`
-          });
-        }
-      } catch (e) {
-        errs.push({
-          path,
-          rule: "pattern",
-          detail: `invalid regex /${schema6.pattern}/: ${e instanceof Error ? e.message : String(e)}`
-        });
-      }
+    const pattern = typeof schema6.pattern === "string" ? compilePattern(schema6.pattern) : null;
+    if (pattern && !pattern.test(value)) {
+      errs.push({
+        path,
+        rule: "pattern",
+        detail: `value ${JSON.stringify(value)} does not match /${schema6.pattern}/`
+      });
     }
     if (typeof schema6.format === "string") {
       if (schema6.format === "date" && !FORMAT_DATE.test(value)) {
@@ -244,6 +399,13 @@ var validateNode = (value, schema6, path, errs, context) => {
     if (typeof schema6.maximum === "number" && value > schema6.maximum) {
       errs.push({ path, rule: "maximum", detail: `value ${value} > ${schema6.maximum}` });
     }
+    if (typeof schema6.exclusiveMinimum === "number" && value <= schema6.exclusiveMinimum) {
+      errs.push({
+        path,
+        rule: "exclusiveMinimum",
+        detail: `value ${value} <= ${schema6.exclusiveMinimum}`
+      });
+    }
   }
   if (Array.isArray(value)) {
     if (typeof schema6.minItems === "number" && value.length < schema6.minItems) {
@@ -307,8 +469,31 @@ var validateNode = (value, schema6, path, errs, context) => {
         }
       }
     }
+    if (typeof schema6.maxProperties === "number" && Object.keys(value).length > schema6.maxProperties) {
+      errs.push({
+        path,
+        rule: "maxProperties",
+        detail: `property count ${Object.keys(value).length} > ${schema6.maxProperties}`
+      });
+    }
+    if (schema6.dependentRequired !== null && typeof schema6.dependentRequired === "object") {
+      for (const [trigger, dependencies] of Object.entries(schema6.dependentRequired)) {
+        if (!Object.hasOwn(value, trigger) || !Array.isArray(dependencies)) continue;
+        for (const dependency of dependencies) {
+          if (!Object.hasOwn(value, dependency)) {
+            errs.push({
+              path,
+              rule: "dependentRequired",
+              detail: `property '${trigger}' requires property '${dependency}'`
+            });
+          }
+        }
+      }
+    }
     const props = schema6.properties || {};
     for (const [k, v] of Object.entries(value)) {
+      if (Object.hasOwn(props, k)) evaluated.add(k);
+      else if (schema6.additionalProperties !== void 0) evaluated.add(k);
       if (!Object.hasOwn(props, k)) {
         if (schema6.additionalProperties === false) {
           errs.push({ path, rule: "additionalProperties", detail: `unknown property '${k}'` });
@@ -325,8 +510,11 @@ var validateNode = (value, schema6, path, errs, context) => {
     let matched = 0;
     for (const sub of schema6.oneOf) {
       const e = [];
-      validateNode(value, sub, path, e, context);
-      if (e.length === 0) matched++;
+      const branch = validateNode(value, sub, path, e, context);
+      if (e.length === 0) {
+        matched++;
+        for (const key of branch) evaluated.add(key);
+      }
     }
     if (matched !== 1) {
       const titles = schema6.oneOf.map((s) => s.title || "(unnamed)").join(" | ");
@@ -341,8 +529,11 @@ var validateNode = (value, schema6, path, errs, context) => {
     let matched = 0;
     for (const sub of schema6.anyOf) {
       const candidateErrors = [];
-      validateNode(value, sub, path, candidateErrors, context);
-      if (candidateErrors.length === 0) matched += 1;
+      const branch = validateNode(value, sub, path, candidateErrors, context);
+      if (candidateErrors.length === 0) {
+        matched += 1;
+        for (const key of branch) evaluated.add(key);
+      }
     }
     if (matched === 0) {
       const titles = schema6.anyOf.map((sub) => sub.title || "(unnamed)").join(" | ");
@@ -355,14 +546,21 @@ var validateNode = (value, schema6, path, errs, context) => {
   }
   if (Array.isArray(schema6.allOf)) {
     for (const sub of schema6.allOf) {
-      validateNode(value, sub, path, errs, context);
+      for (const key of validateNode(value, sub, path, errs, context)) evaluated.add(key);
     }
   }
   if (schema6.if !== void 0) {
     const conditionErrors = [];
-    validateNode(value, schema6.if, path, conditionErrors, context);
-    const branch = conditionErrors.length === 0 ? schema6.then : schema6.else;
-    if (branch !== void 0) validateNode(value, branch, path, errs, context);
+    const condition = validateNode(value, schema6.if, path, conditionErrors, context);
+    const passed = conditionErrors.length === 0;
+    if (passed) for (const key of condition) evaluated.add(key);
+    const branch = passed ? schema6.then : schema6.else;
+    if (branch !== void 0) {
+      const branchErrors = [];
+      const branchEvaluated = validateNode(value, branch, path, branchErrors, context);
+      errs.push(...branchErrors);
+      if (branchErrors.length === 0) for (const key of branchEvaluated) evaluated.add(key);
+    }
   }
   if (schema6.not !== void 0) {
     const e = [];
@@ -371,6 +569,18 @@ var validateNode = (value, schema6, path, errs, context) => {
       errs.push({ path, rule: "not", detail: "value matched a forbidden subschema" });
     }
   }
+  if (schema6.unevaluatedProperties !== void 0 && value !== null && typeof value === "object" && !Array.isArray(value)) {
+    for (const [k, v] of Object.entries(value)) {
+      if (evaluated.has(k)) continue;
+      if (schema6.unevaluatedProperties === false) {
+        errs.push({ path, rule: "unevaluatedProperties", detail: `unevaluated property '${k}'` });
+      } else {
+        validateNode(v, schema6.unevaluatedProperties, `${path}.${k}`, errs, context);
+      }
+      evaluated.add(k);
+    }
+  }
+  return evaluated;
 };
 var validateJson = (value, schema6, {
   resolveRef,
@@ -380,13 +590,26 @@ var validateJson = (value, schema6, {
   )
 } = {}) => {
   const errs = [];
+  const schemaErrors = [];
+  if (!isSchema(schema6)) {
+    return [
+      {
+        path: "$",
+        rule: "schema",
+        detail: `expected a schema object or boolean, got ${typeOf(schema6)}`
+      }
+    ];
+  }
   validateNode(value, schema6, "$", errs, {
     rootSchema: schema6,
     resolveRef,
     base,
-    referenceStack: []
+    referenceStack: [],
+    schemaErrors,
+    checkedSchemas: /* @__PURE__ */ new WeakSet(),
+    reportedReferences: /* @__PURE__ */ new WeakSet()
   });
-  return errs;
+  return [...schemaErrors, ...errs];
 };
 
 // packages/protocol/src/enterprise-contracts.mjs

package/lib/host-packages/claude/openplanr/runtime/plan/scripts/runtime/packages/protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openplanr/protocol",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "type": "module",
   "description": "Canonical OpenPlanr schemas, registries, typed errors, and portable contract validation",
   "license": "MIT",
@@ -115,6 +115,10 @@
     "./sharing-security-contracts": {
       "types": "./src/sharing-security-contracts.d.mts",
       "import": "./src/sharing-security-contracts.mjs"
+    },
+    "./enterprise-journey-contracts": {
+      "types": "./src/enterprise-journey-contracts.d.mts",
+      "import": "./src/enterprise-journey-contracts.mjs"
     }
   },
   "files": [
@@ -143,9 +147,9 @@
     "access": "public"
   },
   "devDependencies": {
-    "esbuild": "0.28.1",
-    "miniflare": "4.20260708.1",
-    "playwright": "1.61.1",
+    "esbuild": "0.28.2",
+    "miniflare": "4.20260730.0",
+    "playwright": "1.64.0",
     "typescript": "6.0.2"
   }
 }

package/lib/host-packages/claude/openplanr/skills/connect/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: connect
+description: Report which chat, project tracker and source control connections the host has, and guide connecting the missing ones through the host. Use when the user wants to connect a service for OpenPlanr or asks what is connected.
+argument-hint: "[chat|project-tracker|source-control|product]"
+license: MIT
+disable-model-invocation: true
+---
+
+# OpenPlanr Connect
+
+Report which service categories this host can reach and help the user connect
+the missing ones through the host's own connectors. OpenPlanr installs no
+connector and never handles a credential: the vendor publishes the connector and
+the user signs in through the host.
+
+## Check each category
+
+The categories are ~~chat, ~~project tracker and ~~source control; their
+products and per-host steps are in [connectors](references/connectors.md). With an
+argument, check only that category; a product name from connectors selects the
+category it belongs to.
+
+A category is connected when the host exposes a tool for one of its products,
+loaded or deferred; search the host's deferred tool list by product name when it
+has one. For ~~project tracker and ~~source control, a signed-in GitHub CLI also
+counts: `gh auth status --hostname github.com` succeeds. Judge by the tools you
+can see; never call a tool that writes, posts or changes anything to find out.
+
+## Connect a missing category
+
+Work through these steps in order for each missing category:
+
+1. **Already available.** If a matching tool appeared since the last check,
+   report the category as connected and name the product. If the host lists the
+   product's connector but offers only a sign-in or authentication notice instead
+   of its tools, report it as configured but not signed in, tell the user to sign
+   in from the host's connector settings, and skip the next two steps for it.
+2. **Connector suggestions.** If the host offers a connector-suggestion
+   capability, such as a tool that searches its connector directory and another
+   that shows a Connect card from a search result, search with the category's
+   product names and the category name, show the card for the best match, and
+   wait for the user to connect. Do not assume any particular tool name.
+3. **Host step.** Otherwise print the current host's step and the vendor's
+   documentation link from [connectors](references/connectors.md).
+
+Then ask the user to run `/planr:connect` again once signed in. Do not retry on
+your own. If a workspace admin must approve the vendor's app first, say so.
+
+## Rules
+
+- Never ask for, read, store or print a token, key or password. If the user
+  pastes one, do not repeat it, and tell them OpenPlanr does not need it.
+- Never edit host configuration, run install or sign-in commands, or sign in on
+  the user's behalf.
+- Recommend the vendor's own connector from the catalog, never a third-party one.
+
+## Return
+
+One line per category: connected (product), configured but not signed in
+(product), or missing with the step shown (Connect card or host step). End with what the user does next.

package/lib/host-packages/claude/openplanr/skills/connect/references/connectors.md

@@ -0,0 +1,62 @@
+# Connectors
+
+OpenPlanr skills name a kind of service, such as `~~chat`, instead of a product. Connect
+the product your team uses through your host: the vendor publishes the connector, and
+you sign in through the host. OpenPlanr bundles no connectors; they and their credentials
+live in your host. Two optional features need a token: Linear sync (`openplanr linear`) and
+company sign-in (`openplanr company login`). Only when you use them does OpenPlanr store a
+token, in your OS keychain, or in an encrypted file at `~/.planr/credentials.enc` if you set
+`PLANR_CREDENTIAL_FILE_PASSPHRASE`. Tokens are sent only to Linear or to the company server
+you sign in to.
+`openplanr company logout` removes company tokens.
+Every skill also works with nothing connected and reports any remote step it skipped.
+
+| Category | Placeholder | Products |
+| --- | --- | --- |
+| Chat | `~~chat` | Slack, Microsoft Teams |
+| Project tracker | `~~project tracker` | Linear, GitHub Issues, Jira, Asana |
+| Source control | `~~source control` | GitHub, GitLab, Bitbucket |
+
+Never paste a token into a chat, file or command for OpenPlanr. After you connect a
+service, start a new request so the host loads its tools.
+
+## Chat (`~~chat`)
+
+Share a status report, sprint note or release notes as a message draft that you review and send yourself.
+
+| Product | Use | Claude Code | Codex | Cursor |
+| --- | --- | --- | --- | --- |
+| Slack | Message drafts | Run `/plugin install slack@claude-plugins-official`, then sign in to Slack from `/mcp`. A workspace admin may need to approve the app. | Install Slack from `/plugins` and sign in when asked. A workspace admin may need to approve the app. | Run `/add-plugin slack`, or install Slack from Customize, then sign in when asked. A workspace admin may need to approve the app. |
+
+Message format for Slack, drafting through the connector: standard Markdown, which the connector converts on send ([Slack's messaging guidance](https://github.com/slackapi/slack-mcp-plugin/blob/main/skills/slack-messaging/SKILL.md)): `**bold**`, `_italic_`, `[link text](https://example.com)`, `-` lists, `>` quotes. Do not use mrkdwn's `*bold*` or `<url|text>` here.
+
+Message format for Slack, text to paste: Slack mrkdwn ([formatting](https://docs.slack.dev/messaging/formatting-message-text)): `*bold*`, `_italic_`, `<https://example.com|link text>`, lines starting with `•` or `-` for lists, `>` for quotes; no headings or tables; escape `&`, `<` and `>` as `&amp;`, `&lt;` and `&gt;`.
+
+Also works with: [Microsoft Teams](https://learn.microsoft.com/en-us/microsoft-copilot-studio/mcp-teams-tools) (read for context). Add the vendor's connector in your host the same way.
+
+Verified: [Slack](https://docs.slack.dev/ai/slack-mcp-server) on 2026-10-09, [Microsoft Teams](https://learn.microsoft.com/en-us/microsoft-copilot-studio/mcp-teams-tools) on 2026-10-09.
+
+## Project tracker (`~~project tracker`)
+
+Push planning status to linked issues after you approve each change, and read issue state back.
+
+| Product | Use | Claude Code | Codex | Cursor |
+| --- | --- | --- | --- | --- |
+| Linear | OpenPlanr syncs with it | Run `/plugin install linear@claude-plugins-official`, then sign in to Linear from `/mcp`. | Install Linear from `/plugins` and sign in when asked. | Run `/add-plugin linear`, or install Linear from Customize, then sign in when asked. |
+| GitHub Issues | OpenPlanr syncs with it | Install the GitHub CLI from cli.github.com and run `gh auth login`. | Install GitHub from `/plugins` and sign in when asked, or install the GitHub CLI and run `gh auth login`. | Install the GitHub CLI from cli.github.com and run `gh auth login`. |
+
+Also works with: [Jira](https://support.atlassian.com/atlassian-ai-gateway/docs/get-started-with-the-atlassian-remote-mcp-server/) (read for context), [Asana](https://developers.asana.com/docs/using-asanas-mcp-server) (read for context). Add the vendor's connector in your host the same way.
+
+Verified: [Linear](https://linear.app/docs/mcp) on 2026-10-09, [GitHub Issues](https://cli.github.com/manual/gh_auth_login) on 2026-10-09, [Jira](https://support.atlassian.com/atlassian-ai-gateway/docs/get-started-with-the-atlassian-remote-mcp-server/) on 2026-10-09, [Asana](https://developers.asana.com/docs/using-asanas-mcp-server) on 2026-10-09.
+
+## Source control (`~~source control`)
+
+Read pull request and branch state for status reports and sprint reviews.
+
+| Product | Use | Claude Code | Codex | Cursor |
+| --- | --- | --- | --- | --- |
+| GitHub | Read for context | Install the GitHub CLI from cli.github.com and run `gh auth login`. | Install GitHub from `/plugins` and sign in when asked, or install the GitHub CLI and run `gh auth login`. | Install the GitHub CLI from cli.github.com and run `gh auth login`. |
+
+Also works with: [GitLab](https://docs.gitlab.com/user/gitlab_duo/model_context_protocol/mcp_server/) (read for context), [Bitbucket](https://support.atlassian.com/atlassian-ai-gateway/docs/get-started-with-the-atlassian-remote-mcp-server/) (read for context). Add the vendor's connector in your host the same way.
+
+Verified: [GitHub](https://cli.github.com/manual/gh_auth_login) on 2026-10-09, [GitLab](https://docs.gitlab.com/user/gitlab_duo/model_context_protocol/mcp_server/) on 2026-10-09, [Bitbucket](https://support.atlassian.com/atlassian-ai-gateway/docs/get-started-with-the-atlassian-remote-mcp-server/) on 2026-10-09.

package/lib/host-packages/claude/openplanr/skills/openplanr/SKILL.md

@@ -31,6 +31,8 @@ Claude Code and `$planr:plan` in Codex). Do not perform the routed work here.
 | Refine the open backlog and select the sprint for the next release cut | `planr-sprint` |
 | See planning or Operate state in the browser | `planr-dashboard` |
 | Check artifacts for graph, status, or schema drift | `planr-sync` |
+| Post a status, sprint, or release update to chat | `planr-share` (user-invoked) |
+| Connect chat, a tracker, or source control, or see what is connected | `planr-connect` (user-invoked) |
 | Judge release readiness or prepare a landing sequence | `planr-land` |
 | Pick a versioning scheme, bump versions, write release notes | `planr-release` |
 | Diagnose the CLI, plugins, installation, or upgrade state | `planr-doctor` |
@@ -47,6 +49,8 @@ Claude Code and `$planr:plan` in Codex). Do not perform the routed work here.
   review code does not request implementation delegation.
 - PLAN and SHIP are separate user-invoked workflows. Route to one; never chain
   `planr-plan` into `planr-ship` on the user's behalf.
+- `planr-share` and `planr-connect` run only when the user invokes them. When a
+  request matches one, name the command for the user to run instead of running it.
 - When a request spans several skills, route to the earliest step in that
   order (spec → plan → plan-review → ship → land → release) and name the rest.
 - When the request is not OpenPlanr work at all, say so and answer directly

package/lib/host-packages/claude/openplanr/skills/plan/SKILL.md

@@ -77,7 +77,10 @@ Write stories and tasks directly in the repository's active planning mode.
 
 - Allocate project-global monotonic `US-NNN` and `T-NNN` IDs. Never reuse a
   deleted ID. The packaged [planning ID helper](scripts/planning-ids.mjs) may
-  inspect or reserve IDs; it never generates content.
+  inspect or reserve IDs; it never generates content. Pass `--root` with the
+  `specs` folder under the project's configured planning path (`.planr/specs`
+  by default). It exits non-zero when that folder is missing or is not the one
+  `.planr/config.json` configures; never fall back to `US-001` or `T-001`.
 - Give each story stable acceptance IDs starting at `AC-001`.
 - Split each story into tasks that are coherent and independently verifiable.
   Separate by ownership first: UI work is a `UI` task for the frontend role and

package/lib/host-packages/claude/openplanr/skills/plan/scripts/planning-ids.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
-import { mkdir, open, readdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
+import { open, readdir, readFile, rename, stat, unlink, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
 
 const KINDS = Object.freeze(['SPEC', 'US', 'T']);
 const EMPTY = Object.freeze({ SPEC: 1, US: 1, T: 1 });
@@ -71,9 +71,55 @@ function parseArgs(argv) {
   return options;
 }
 
+const shellQuote = (value) => (/^[\w./-]+$/u.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`);
+
+/** Returns the nearest `.planr/config.json` at or above `directory` and the specs folder it configures. */
+async function configuredRoot(directory) {
+  for (let current = directory; ; current = dirname(current)) {
+    const configPath = join(current, '.planr', 'config.json');
+    const raw = await readFile(configPath, 'utf8').catch((error) => {
+      if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return null;
+      throw error;
+    });
+    if (raw !== null) {
+      let agile;
+      try {
+        agile = JSON.parse(raw).outputPaths?.agile ?? '.planr';
+      } catch (error) {
+        throw new Error(`Project config ${configPath} is not valid JSON: ${error.message}`);
+      }
+      if (typeof agile !== 'string') throw new Error(`Project config ${configPath} has a non-string outputPaths.agile.`);
+      return { configPath, expected: resolve(current, agile, 'specs') };
+    }
+    if (dirname(current) === current) return null;
+  }
+}
+
+/** Accepts only an existing directory that the nearest project config names as its planning folder. */
+async function assertPlanningRoot(planningRoot) {
+  const project = await configuredRoot(planningRoot);
+  if (!project) {
+    throw new Error(`Planning root ${planningRoot} is not inside an OpenPlanr project: no .planr/config.json in it or any parent directory.`);
+  }
+  const { configPath, expected } = project;
+  if (planningRoot !== expected) {
+    throw new Error(`Planning root ${planningRoot} is not the planning folder configured by ${configPath}, which expects ${expected}.`);
+  }
+  const status = await stat(planningRoot).catch((error) => {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  });
+  if (!status) {
+    throw new Error(
+      `Planning root ${planningRoot} does not exist; ${configPath} expects it. Create it with \`mkdir -p ${shellQuote(planningRoot)}\`, or fix outputPaths.agile in ${configPath}.`,
+    );
+  }
+  if (!status.isDirectory()) throw new Error(`Planning root ${planningRoot} is not a directory; ${configPath} expects a directory there.`);
+}
+
 async function reserve({ root, preview, counts }) {
   const planningRoot = resolve(root);
-  if (!preview) await mkdir(planningRoot, { recursive: true });
+  await assertPlanningRoot(planningRoot);
   const run = async () => {
     const sequence = await currentSequence(planningRoot);
     const ids = Object.fromEntries(