pan-wizard 3.32.0 → 3.34.0

package/bin/install-lib.cjs

@@ -438,7 +438,7 @@ function convertClaudeCommandToCodexSkill(content, skillName) {
   description = toSingleLine(description);
   const shortDescription = description.length > 180 ? `${description.slice(0, 177)}...` : description;
   const adapter = getCodexSkillAdapterHeader(skillName);
-  return `---\nname: ${yamlQuote(skillName)}\ndescription: ${yamlQuote(description)}\nmetadata:\n  short-description: ${yamlQuote(shortDescription)}\n---\n\n${adapter}\n\n${body.trimStart()}`;
+  return `---\nname: ${yamlQuote(skillName)}\ndescription: ${yamlQuote(description)}\nlicense: ${yamlQuote(SKILL_LICENSE)}\nmetadata:\n  short-description: ${yamlQuote(shortDescription)}\n---\n\n${adapter}\n\n${body.trimStart()}`;
 }
 
 /**
@@ -474,6 +474,12 @@ ${note ? `\n${note}\n` : ''}</pan_skill_adapter>`;
  * for environment requirements (max 500 chars). Kept short and factual: these
  * are the two things a host cannot infer and that every PAN skill depends on.
  */
+// The Agent Skills `license` field: optional in the spec, and GitHub's validator
+// (`gh skill publish --dry-run`) warns on every skill without it (market-ideas M30).
+// Read from package.json so the skills always carry the package's own licence.
+const SKILL_LICENSE = (() => {
+  try { return require('../package.json').license || 'MIT'; } catch { return 'MIT'; }
+})();
 const SKILL_COMPATIBILITY = 'Requires Node.js (skills invoke the bundled pan-tools CLI) and a project with a .planning/ directory, created by /pan-new-project or /pan-map-codebase.';
 
 function convertClaudeCommandToUnifiedSkill(content, skillName, opts = {}) {
@@ -500,7 +506,7 @@ function convertClaudeCommandToUnifiedSkill(content, skillName, opts = {}) {
   // Deliberately NOT emitting `allowed-tools`: it is marked experimental in the
   // spec, and ADR-0028's frontmatter rule is that anything unverified stays out
   // until a live per-runtime check confirms no parser rejects it.
-  return `---\nname: ${yamlQuote(skillName)}\ndescription: ${yamlQuote(description)}\ncompatibility: ${yamlQuote(SKILL_COMPATIBILITY)}\nmetadata:\n  short-description: ${yamlQuote(shortDescription)}\n---\n\n${adapter}\n\n${body.trimStart()}`;
+  return `---\nname: ${yamlQuote(skillName)}\ndescription: ${yamlQuote(description)}\nlicense: ${yamlQuote(SKILL_LICENSE)}\ncompatibility: ${yamlQuote(SKILL_COMPATIBILITY)}\nmetadata:\n  short-description: ${yamlQuote(shortDescription)}\n---\n\n${adapter}\n\n${body.trimStart()}`;
 }
 
 // ─── Unified-skill content rewrites (extracted from bin/install.js, 2026-09) ──
@@ -558,6 +564,8 @@ function rewriteSharedCoreMarkdown(content, { corePrefix, pathPrefix, projectDir
   content = content.replace(/\.\/\.claude\/agents\//g, `${corePrefix}pan-wizard-core/agents/`);
   content = content.replace(/~\/\.claude\//g, pathPrefix);
   content = content.replace(/\.\/\.claude\//g, projectDirPrefix);
+  // No `pan-tools` bin is on PATH: invoke it via node, as the skill rewrite does.
+  content = content.replace(/\bpan-tools\b(?=\s+[a-z])/g, `node ${corePrefix}pan-wizard-core/bin/pan-tools.cjs`);
   content = processAttribution(content, attribution);
   return convertSlashCommandsToCopilotSkillMentions(content);
 }
@@ -567,9 +575,29 @@ function rewriteSharedCoreMarkdown(content, { corePrefix, pathPrefix, projectDir
  * under `<shared core>/agents/` — reading material for agents, not a runtime
  * registration (ADR-0028 agent-ref canonicalization).
  */
+/**
+ * Name the agent file this runtime actually installs. A prompt that says "read
+ * ~/.claude/agents/pan-planner.md for your role" becomes `<prefix>agents/pan-planner.md`
+ * after the prefix rewrite, but Codex installs agents as `pan-planner.toml` and Copilot
+ * as `pan-planner.agent.md`, so the spawned agent read nothing and ran with no role.
+ * Idempotent; other runtimes keep `.md`.
+ * @param {string} content
+ * @param {string} runtime - claude | codex | gemini | opencode | copilot
+ * @param {string} pathPrefix - the runtime's rewritten config-dir prefix (ends in `/`)
+ * @returns {string}
+ */
+function rewriteAgentFileRefs(content, runtime, pathPrefix) {
+  const ext = runtime === 'codex' ? '.toml' : runtime === 'copilot' ? '.agent.md' : null;
+  if (!ext || !pathPrefix) return content;
+  const prefix = pathPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return content.replace(new RegExp(`(${prefix}agents/pan-[a-z0-9_-]+)\\.md\\b`, 'g'), (_, base) => base + ext);
+}
+
 function rewriteAgentReferenceCopy(content, corePrefix) {
   content = content.replace(/~\/\.claude\/pan-wizard-core\//g, `${corePrefix}pan-wizard-core/`);
   content = content.replace(/\.\/\.claude\/pan-wizard-core\//g, `${corePrefix}pan-wizard-core/`);
+  // No `pan-tools` bin is on PATH: invoke it via node, as the skill rewrite does.
+  content = content.replace(/\bpan-tools\b(?=\s+[a-z])/g, `node ${corePrefix}pan-wizard-core/bin/pan-tools.cjs`);
   return convertSlashCommandsToCopilotSkillMentions(content);
 }
 
@@ -707,6 +735,65 @@ function agentPluginSkillAdapterNote(kind = 'skill') {
 - \`${AGENT_PLUGIN_RUNTIME_HOME_TOKEN}\` is your runtime's user-level configuration directory (for example \`~/.claude\`, \`~/.codex\`, \`~/.gemini\`, \`~/.config/opencode\`, \`~/.copilot\`) and \`${AGENT_PLUGIN_RUNTIME_DIR_TOKEN}\` its project-level directory (\`.claude\`, \`.codex\`, \`.gemini\`, \`.opencode\`, \`.github\`). Substitute the one that applies to the runtime you are.`;
 }
 
+// ─── Agent Plugin skills over Codex's prompt cut (market-ideas S8) ──────────
+// Codex injects at most the first 8,000 bytes of a skill that came from an Agent
+// Plugin (codex-rs/ext/skills/src/render.rs `MAX_SKILL_PROMPT_BYTES`, host_prompt.rs).
+// Measured on Codex CLI 0.157.1 on 2026-10-03: a 56,540-byte PAN skill reached the
+// model as its first 8,000 bytes, cut mid-sentence; the same skill from an install's
+// .agents/skills/ arrived whole, so only the bundle is affected. A bundle skill over
+// the cut ships as a short SKILL.md that keeps its frontmatter and adapter block and
+// points at the full instructions in references/instructions.md, the Agent Skills
+// directory for files a skill loads on demand.
+const AGENT_PLUGIN_SKILL_MAX_BYTES = 8000;
+const AGENT_PLUGIN_SKILL_REFERENCE = 'references/instructions.md';
+const SKILL_SUMMARY_MIN_CHARS = 40;
+
+/**
+ * Split a converted bundle skill that is longer than Codex loads into a pointer
+ * SKILL.md and a reference file. Pure. A skill within the limit comes back as is.
+ * @param {string} skillMd - the unified converter's output (frontmatter + adapter + body)
+ * @param {string} skillName
+ * @param {number} [maxBytes]
+ * @returns {{skill: string, reference: string|null}}
+ */
+function splitOversizedSkill(skillMd, skillName, maxBytes = AGENT_PLUGIN_SKILL_MAX_BYTES) {
+  if (Buffer.byteLength(skillMd, 'utf8') <= maxBytes) return { skill: skillMd, reference: null };
+  const close = '</pan_skill_adapter>';
+  const end = skillMd.indexOf(close);
+  if (end === -1) throw new Error(`splitOversizedSkill: ${skillName} has no adapter block to keep`);
+  const head = skillMd.slice(0, end + close.length);
+  const body = skillMd.slice(end + close.length).replace(/^\s+/, '');
+  const pointer = (summary) => [
+    head,
+    '',
+    '## Instructions',
+    '',
+    `This skill's full instructions are in \`${AGENT_PLUGIN_SKILL_REFERENCE}\`, in the same directory as this SKILL.md: they are longer than some runtimes load into a prompt. Before you do anything else, read that file in full with your file-reading tool, then follow it exactly. It is the complete procedure, and nothing on this page replaces it.`,
+    ...(summary ? ['', '## What this skill does', '', summary] : []),
+    '',
+  ].join('\n');
+  // The command's own <objective> is the summary, else its first plain prose
+  // paragraph; trimmed at word boundaries until the page fits, and dropped when
+  // too little of it would be left.
+  let summary = ((body.match(/<objective>\s*([\s\S]*?)\s*<\/objective>/) || [])[1] || '').trim();
+  if (!summary) {
+    summary = body.split(/\n\s*\n/).map((p) => p.trim())
+      .find((p) => p.length >= SKILL_SUMMARY_MIN_CHARS && !/^[#<`|>\-*]/.test(p) && !/^\d+\./.test(p)) || '';
+  }
+  let skill = pointer(summary);
+  while (summary && Buffer.byteLength(skill, 'utf8') > maxBytes) {
+    summary = summary.slice(0, Math.floor(summary.length * 0.8)).replace(/\s+\S*$/, '');
+    if (summary.length < SKILL_SUMMARY_MIN_CHARS) summary = '';
+    else summary += ' …';
+    skill = pointer(summary);
+  }
+  if (Buffer.byteLength(skill, 'utf8') > maxBytes) {
+    throw new Error(`splitOversizedSkill: ${skillName}'s frontmatter and adapter alone exceed ${maxBytes} bytes`);
+  }
+  const reference = `# ${skillName}: full instructions\n\nRead from \`${skillName}/SKILL.md\`, whose adapter block defines \`${AGENT_PLUGIN_ROOT_TOKEN}\`, \`{{PAN_ARGS}}\` and the runtime-directory tokens used below.\n\n${body}`;
+  return { skill, reference };
+}
+
 /** Generate Copilot CLI skill adapter header */
 function getCopilotSkillAdapterHeader(skillName) {
   const invocation = `/pan-${skillName.replace(/^pan-/, '')}`;
@@ -743,7 +830,7 @@ function convertClaudeCommandToCopilotSkill(content, skillName) {
   description = toSingleLine(description);
   const shortDescription = description.length > 180 ? `${description.slice(0, 177)}...` : description;
   const adapter = getCopilotSkillAdapterHeader(skillName);
-  return `---\nname: ${yamlQuote(skillName)}\ndescription: ${yamlQuote(description)}\nmetadata:\n  short-description: ${yamlQuote(shortDescription)}\n---\n\n${adapter}\n\n${body.trimStart()}`;
+  return `---\nname: ${yamlQuote(skillName)}\ndescription: ${yamlQuote(description)}\nlicense: ${yamlQuote(SKILL_LICENSE)}\nmetadata:\n  short-description: ${yamlQuote(shortDescription)}\n---\n\n${adapter}\n\n${body.trimStart()}`;
 }
 
 /** Claude agent → Copilot .agent.md */
@@ -838,6 +925,31 @@ function convertClaudeToCopilotAgent(content, opts = {}) {
 
 // ─── Attribution Processing ─────────────────────────────────────────────────
 
+/**
+ * The commit attribution Claude Code's settings ask for, in processAttribution's
+ * terms: undefined keeps PAN's default `Co-Authored-By` line, null removes it, a
+ * string replaces it. Claude Code's settings reference (read 2026-10-03):
+ * `attribution: false` hides all attribution (2.1.281 and later); an empty
+ * `attribution.commit` hides the commit trailer and a non-empty one replaces it; once
+ * `commit` or `pr` is set the deprecated `includeCoAuthoredBy` is ignored, and before
+ * that `includeCoAuthoredBy: false` still hides the trailer. Until 2026-10-03 PAN
+ * read only `attribution.commit`, so `false` (an explicit request to hide) kept the
+ * default line.
+ * @param {object|null} settings - a parsed Claude settings.json
+ * @returns {string|null|undefined}
+ */
+function commitAttributionFromSettings(settings) {
+  const s = settings && typeof settings === 'object' ? settings : {};
+  const a = s.attribution;
+  if (a === false) return null;
+  if (a && typeof a === 'object') {
+    if (typeof a.commit === 'string') return a.commit === '' ? null : a.commit;
+    if (a.pr !== undefined) return undefined; // attribution set: includeCoAuthoredBy no longer applies
+  }
+  if (s.includeCoAuthoredBy === false) return null;
+  return undefined;
+}
+
 /**
  * Process Co-Authored-By lines based on attribution setting.
  * @param {string} content - File content
@@ -1042,16 +1154,25 @@ function stripThinkingFrontmatter(content, runtime) {
  * @param {Object} commands
  * @param {string} commands.updateCheckCommand   - node invocation for pan-check-update.js
  * @param {string} commands.contextMonitorCommand - node invocation for pan-context-monitor.js
+ * @param {string} [commands.stateReinjectMarkCommand]   - pan-state-reinject.js `--mark` (preCompact)
+ * @param {string} [commands.stateReinjectInjectCommand] - pan-state-reinject.js `--inject copilot` (postToolUse)
  * @returns {Object} A `.github/hooks/pan.json` config object
  */
 function buildCopilotHooksConfig(commands) {
-  const { updateCheckCommand, contextMonitorCommand, costLoggerCommand, traceLoggerCommand, stopGuardCommand } = commands || {};
+  const { updateCheckCommand, contextMonitorCommand, costLoggerCommand, traceLoggerCommand, stopGuardCommand,
+    stateReinjectMarkCommand, stateReinjectInjectCommand } = commands || {};
   const config = { version: 1, hooks: {} };
   if (updateCheckCommand) {
     config.hooks.sessionStart = [{ type: 'command', command: updateCheckCommand }];
   }
-  if (contextMonitorCommand) {
-    config.hooks.postToolUse = [{ type: 'command', command: contextMonitorCommand }];
+  const postToolUse = [];
+  if (contextMonitorCommand) postToolUse.push({ type: 'command', command: contextMonitorCommand });
+  // State re-injection after a compaction (M33): preCompact leaves the marker, the
+  // next postToolUse returns the block once (hooks/pan-state-reinject.js).
+  if (stateReinjectInjectCommand) postToolUse.push({ type: 'command', command: stateReinjectInjectCommand });
+  if (postToolUse.length > 0) config.hooks.postToolUse = postToolUse;
+  if (stateReinjectMarkCommand) {
+    config.hooks.preCompact = [{ type: 'command', command: stateReinjectMarkCommand }];
   }
   // subagentStop is Copilot's SubagentStop equivalent (verified docs.github.com
   // 2026-06) — carries the cost + trace loggers, same as Claude and Codex (Gemini registers neither).
@@ -1107,15 +1228,20 @@ function buildCopilotHooksConfig(commands) {
  * `compact` is where the state re-injection hook registers (M10): SessionStart with
  * the `compact` matcher (HOOK_SLOT_MATCHERS), the one event after a compaction whose
  * `hookSpecificOutput.additionalContext` reaches the model on Claude Code and Codex —
- * both hosts' PostCompact discard it (hooks references, read 2026-09-26). Gemini's
- * PreCompress fires before the summary and Copilot's preCompact is notification-only,
- * so neither gets it.
+ * both hosts' PostCompact discard it (hooks references, read 2026-09-26).
+ *
+ * `compactMark` / `compactInject` (market-ideas M33) carry it where no start event
+ * follows a compaction. Gemini's PreCompress and Copilot's preCompact are advisory,
+ * so the hook runs in two steps: a marker before the compaction, the block on the
+ * next tool result, the first point after it where both hosts take added context
+ * (gemini-cli v0.61.0 docs/hooks/reference.md; Copilot hooks reference; read
+ * 2026-10-03, and live on Copilot CLI 1.0.88 the same day).
  */
 const HOOK_EVENT_MAP = Object.freeze({
-  claude: { surface: 'settings.json', sessionStart: 'SessionStart', postToolUse: 'PostToolUse', subagentStop: 'SubagentStop', stop: 'Stop', compact: 'SessionStart' },
-  gemini: { surface: 'settings.json', sessionStart: 'SessionStart', postToolUse: null, subagentStop: null, stop: 'AfterAgent', compact: null },
-  codex: { surface: 'hooks.json', sessionStart: 'SessionStart', postToolUse: 'PostToolUse', subagentStop: 'SubagentStop', stop: 'Stop', compact: 'SessionStart' },
-  copilot: { surface: 'hooks/pan.json', sessionStart: 'sessionStart', postToolUse: 'postToolUse', subagentStop: 'subagentStop', stop: 'agentStop', compact: null },
+  claude: { surface: 'settings.json', sessionStart: 'SessionStart', postToolUse: 'PostToolUse', subagentStop: 'SubagentStop', stop: 'Stop', compact: 'SessionStart', compactMark: null, compactInject: null },
+  gemini: { surface: 'settings.json', sessionStart: 'SessionStart', postToolUse: null, subagentStop: null, stop: 'AfterAgent', compact: null, compactMark: 'PreCompress', compactInject: 'AfterTool' },
+  codex: { surface: 'hooks.json', sessionStart: 'SessionStart', postToolUse: 'PostToolUse', subagentStop: 'SubagentStop', stop: 'Stop', compact: 'SessionStart', compactMark: null, compactInject: null },
+  copilot: { surface: 'hooks/pan.json', sessionStart: 'sessionStart', postToolUse: 'postToolUse', subagentStop: 'subagentStop', stop: 'agentStop', compact: null, compactMark: 'preCompact', compactInject: 'postToolUse' },
   opencode: null,
 });
 
@@ -1140,14 +1266,16 @@ const PAN_SETTINGS_HOOKS = Object.freeze(['pan-check-update', 'pan-context-monit
  *
  * @param {object} hooks - settings.hooks
  * @param {string[]} hookNames - script basenames without `.js` (e.g. 'pan-stop-guard')
- * @param {string|null} [keepEvent] - the event the hook now belongs to, left alone
+ * @param {string|string[]|null} [keepEvent] - the event (or events: a hook such as
+ *   pan-state-reinject registers under two on Gemini) the hook now belongs to, left alone
  * @returns {string[]}
  */
 function stripPanHookEntries(hooks, hookNames, keepEvent = null) {
   const touched = [];
   if (!hooks || typeof hooks !== 'object' || Array.isArray(hooks)) return touched;
+  const keep = new Set([].concat(keepEvent || []));
   for (const event of Object.keys(hooks)) {
-    if (event === keepEvent || !Array.isArray(hooks[event])) continue;
+    if (keep.has(event) || !Array.isArray(hooks[event])) continue;
     const before = hooks[event].length;
     hooks[event] = hooks[event].filter(entry => !(entry && Array.isArray(entry.hooks)
       && entry.hooks.some(h => h && typeof h.command === 'string' && hookNames.some(n => h.command.includes(n)))));
@@ -1548,6 +1676,12 @@ function detectModelCapabilities(modelName) {
   if (n.includes('sonnet-5')) {
     return { has_1m_ctx: true, has_thinking: true, has_cache: true, tier: 'mid' };
   }
+  // Haiku 5 family (Haiku 5.5): 1M context and adaptive thinking (pricing page and
+  // Claude Code 2.1.293 changelog, read 2026-10-10). It is a forward release, so
+  // without this it took the fallback's Haiku profile, which is Haiku 4's.
+  if (n.includes('haiku-5')) {
+    return { has_1m_ctx: true, has_thinking: true, has_cache: true, tier: 'fast' };
+  }
   if (n.includes('opus-4-8') || n.includes('opus-4.8')
     || n.includes('opus-4-7') || n.includes('opus-4.7')
     || n.includes('opus-4-6') || n.includes('opus-4.6')) {
@@ -1567,10 +1701,9 @@ function detectModelCapabilities(modelName) {
   if (n.includes('sonnet-4') && !isForwardRelease) {
     return { has_1m_ctx: false, has_thinking: true, has_cache: true, tier: 'mid' };
   }
-  // Haiku 4.x — fast tier, no extended thinking. Guarded for the same reason,
-  // though today it is behavior-neutral: the fallback's Haiku profile is
-  // identical to this one, so a forward Haiku release lands on the same answer
-  // either way. The guard is here so that stops being true only deliberately.
+  // Haiku 4.x — fast tier, no extended thinking. Guarded for the same reason: a
+  // Haiku release newer than 4.5 takes the fallback's modern Haiku profile, which
+  // since Haiku 5.5 has 1M context and thinking.
   if ((n.includes('haiku-4-5') || n.includes('haiku-4.5') || n.includes('haiku-4')) && !isForwardRelease) {
     return { has_1m_ctx: false, has_thinking: false, has_cache: true, tier: 'fast' };
   }
@@ -1643,7 +1776,8 @@ function detectModelCapabilities(modelName) {
     const MODERN = {
       opus: { has_1m_ctx: true, has_thinking: true, has_cache: true, tier: 'reasoning' },
       sonnet: { has_1m_ctx: true, has_thinking: true, has_cache: true, tier: 'mid' },
-      haiku: { has_1m_ctx: false, has_thinking: false, has_cache: true, tier: 'fast' },
+      // Haiku 5.5 (the branch above) is the newest Haiku with known capabilities.
+      haiku: { has_1m_ctx: true, has_thinking: true, has_cache: true, tier: 'fast' },
     };
     return { ...MODERN[family] };
   }
@@ -1719,6 +1853,49 @@ function verifyInstall(configDir, manifest) {
   return { ok: missing.length === 0 && empty.length === 0, missing, empty, warnings };
 }
 
+/**
+ * The script a PAN hook command runs, as written in the command: `node "<path>"`
+ * (global installs, buildHookCommand) or `node <dir>/hooks/<hook>.js` (local
+ * installs, relative to the project root). Null for any other command shape.
+ * @param {string} command
+ * @returns {string|null}
+ */
+function hookCommandScript(command) {
+  // Plain arguments may follow the script (`--mark`, `--inject gemini`, M33).
+  const m = /^node\s+(?:"([^"]+)"|([^\s"]+))(?:\s+[^\s"]+)*$/.exec(String(command || '').trim());
+  return m ? (m[1] || m[2]) : null;
+}
+
+/**
+ * Check that every hook command an install is about to register runs a script
+ * that exists and has content (market-ideas M24). Read-only: nothing is executed
+ * or written. A dev install from a clone without `npm run build:hooks` copied no
+ * hook scripts and registered every hook anyway, so each session event ran a
+ * missing file. A relative script resolves against `projectRoot`, the directory a
+ * local install's hook commands run from.
+ *
+ * @param {string[]} commands - the hook commands to register
+ * @param {string} projectRoot
+ * @returns {{ok: boolean, missing: string[]}} each missing entry names the script and why
+ */
+function verifyHookEntrypoints(commands, projectRoot) {
+  const missing = [];
+  for (const command of commands) {
+    const script = hookCommandScript(command);
+    if (!script) {
+      missing.push(`${command} (not a "node <script>" command)`);
+      continue;
+    }
+    const abs = path_v.isAbsolute(script) ? script : path_v.join(projectRoot, script);
+    try {
+      if (fs_v.statSync(abs).size === 0) missing.push(`${script} (empty)`);
+    } catch {
+      missing.push(`${script} (missing)`);
+    }
+  }
+  return { ok: missing.length === 0, missing };
+}
+
 // ─── Claude Code plugin packaging (2026-06) ─────────────────────────────────
 
 /**
@@ -1886,11 +2063,11 @@ so the result is greppable out of the transcript.
 /**
  * Build the plugin's MCP registration (`.mcp.json` at the plugin root).
  *
- * Plugins may declare MCP servers in a plugin-root `.mcp.json`, and unlike
- * command markdown — where `${CLAUDE_PLUGIN_ROOT}` expansion is unverified and
- * is why marketplace publishing is still gated — hook and MCP *configs* are the
- * documented place the variable is substituted. So the same form
- * `buildPluginHooksConfig()` relies on is correct here.
+ * Plugins may declare MCP servers in a plugin-root `.mcp.json`. Hook and MCP
+ * *configs* are the documented place `${CLAUDE_PLUGIN_ROOT}` is substituted (it
+ * expands in plugin command markdown too: measured 2026-08-14, which lifted the
+ * marketplace-publishing gate). So the same form `buildPluginHooksConfig()` relies
+ * on is correct here.
  *
  * No `env` block: a plugin serves whatever project the session is in, so pinning
  * PAN_PROJECT_ROOT would be wrong, and the server resolves its engine from its
@@ -1948,7 +2125,7 @@ function buildNativeWorkflowScripts() {
   const reviewPipeline = `export const meta = {
   name: 'pan-review-pipeline',
   description: 'PAN deep review: reviewer + hardener fan-out, meta-reviewer merge',
-  whenToUse: 'Deterministic version of the /pan-review-deep fan-out. Pass the phase number or a description of the change set as args.',
+  whenToUse: 'Deterministic version of the /pan:review-deep fan-out. Pass the phase number or a description of the change set as args.',
   phases: [
     { title: 'Find', detail: 'reviewer + security hardener in parallel' },
     { title: 'Merge', detail: 'meta-reviewer dedupes, disputes, and issues the verdict' },
@@ -2013,7 +2190,7 @@ return merged
   const mapCodebase = `export const meta = {
   name: 'pan-map-codebase',
   description: 'PAN codebase mapping: shard fan-out per top-level area, then synthesis',
-  whenToUse: 'Deterministic version of the /pan-map-codebase shard pattern for repositories too large for a single pass.',
+  whenToUse: 'Deterministic version of the /pan:map-codebase shard pattern for repositories too large for a single pass.',
   phases: [
     { title: 'Scan', detail: 'discover top-level areas worth documenting' },
     { title: 'Map', detail: 'one documenter per area, in parallel' },
@@ -2074,7 +2251,7 @@ return { areas_mapped: maps.filter(Boolean).length, synthesis }
   const execWaves = `export const meta = {
   name: 'pan-exec-waves',
   description: 'PAN phase execution: wave-grouped executor fan-out for a checkpoint-free phase, then verification',
-  whenToUse: 'Deterministic version of the /pan-exec-phase wave dispatch. Pass the phase number as args. Refuses a phase that contains checkpoint plans (a workflow cannot pause for a human) — run /pan-exec-phase for those.',
+  whenToUse: 'Deterministic version of the /pan:exec-phase wave dispatch. Pass the phase number as args. Refuses a phase that contains checkpoint plans (a workflow cannot pause for a human) — run /pan:exec-phase for those.',
   phases: [
     { title: 'Index', detail: 'plan inventory with wave grouping, from the PAN engine' },
     { title: 'Execute', detail: 'one executor per plan; waves in order, plans within a wave in parallel' },
@@ -2100,6 +2277,7 @@ const INDEX = {
     phase_name: { type: 'string' },
     phase_dir: { type: 'string' },
     parallelization: { type: 'boolean' },
+    verifier_enabled: { type: 'boolean' },
     has_checkpoints: { type: 'boolean' },
     plans: {
       type: 'array',
@@ -2120,11 +2298,11 @@ const INDEX = {
   required: ['phase_found', 'has_checkpoints', 'plans'],
 }
 const index = await agent(
-  'Index phase ' + phaseArg + ' for execution using the ' + PAN_TOOLS + ' Run two verbs and merge their JSON: (1) init execute-phase ' + phaseArg + ' — take phase_found, phase_number, phase_name, phase_dir, parallelization; (2) phase-plan-index ' + phaseArg + ' — take has_checkpoints and plans[] (id, wave, autonomous, has_summary, objective; include each plan file path as file). Do not execute anything; return only the merged index.',
+  'Index phase ' + phaseArg + ' for execution using the ' + PAN_TOOLS + ' Run two verbs and merge their JSON: (1) init execute-phase ' + phaseArg + ' — take phase_found, phase_number, phase_name, phase_dir, parallelization, verifier_enabled; (2) phase-plan-index ' + phaseArg + ' — take has_checkpoints and plans[] (id, wave, autonomous, has_summary, objective; include each plan file path as file). Do not execute anything; return only the merged index.',
   { label: 'index', phase: 'Index', schema: INDEX })
 if (!index || !index.phase_found) return { error: 'phase ' + phaseArg + ' not found' }
 if (index.has_checkpoints) {
-  return { error: 'phase ' + phaseArg + ' contains checkpoint plans (autonomous: false). A workflow cannot pause for a human — run /pan-exec-phase ' + phaseArg + ' instead.', plans: index.plans.map(p => p.id) }
+  return { error: 'phase ' + phaseArg + ' contains checkpoint plans (autonomous: false). A workflow cannot pause for a human — run /pan:exec-phase ' + phaseArg + ' instead.', plans: index.plans.map(p => p.id) }
 }
 const pending = index.plans.filter(p => !p.has_summary)
 if (pending.length === 0) return { phase: phaseArg, done: true, message: 'every plan already has a summary — nothing to execute' }
@@ -2148,7 +2326,7 @@ const EXEC_RESULT = {
 const executorPrompt = (p) =>
   'Execute plan ' + p.id + ' of phase ' + (index.phase_number || phaseArg) + (index.phase_name ? '-' + index.phase_name : '') + '. Commit each task atomically. Create summary.md. Update state.md and roadmap.md (via roadmap update-plan-progress).\\n\\n'
   + 'Read first, in this order: ' + CORE_DOCS + '\\n\\n'
-  + 'Then read: ' + (p.file || (index.phase_dir + '/' + p.id)) + ' (the plan), .planning/state.md, .planning/config.json (if present), ./CLAUDE.md (if present — follow its conventions), .agents/skills/ (if present — follow relevant skills), and every .planning/memory/*.md (apply every rule without exception).\\n\\n'
+  + 'Then read: ' + (p.file || (index.phase_dir + '/' + p.id)) + ' (the plan), .planning/state.md, .planning/config.json (if present), ./CLAUDE.md (if present — follow its conventions), and .agents/skills/ (if present — follow relevant skills).\\n\\n'
   + 'Report plan_id, status (complete | failed | checkpoint), summary_path, the number of commits you made, and self_check (passed if your summary carries no "Self-Check: FAILED" marker).'
 const executed = []
 let halted = null
@@ -2177,7 +2355,11 @@ for (const w of waveNumbers) {
   }
 }
 if (halted) {
-  return { phase: phaseArg, halted, executed, next: 'Inspect the failed plan(s), then re-run /pan-exec-waves ' + phaseArg + ' (completed plans are skipped) or fall back to /pan-exec-phase ' + phaseArg }
+  return { phase: phaseArg, halted, executed, next: 'Inspect the failed plan(s), then re-run /pan-exec-waves ' + phaseArg + ' (completed plans are skipped) or fall back to /pan:exec-phase ' + phaseArg }
+}
+// workflow.verifier: false (/pan:settings) turns the phase verifier off, as in exec-phase.
+if (index.verifier_enabled === false) {
+  return { phase: phaseArg, waves_run: waveNumbers.length, plans_complete: executed.length, verification: null, next: 'Verification skipped: workflow.verifier is off. /pan:verify-phase ' + phaseArg + ' verifies on demand; then continue with /pan:exec-phase ' + phaseArg + ' (transition)' }
 }
 
 phase('Verify')
@@ -2195,13 +2377,13 @@ const verdict = await agent(
   'Verify phase ' + phaseArg + ' following the PAN verify-phase protocol (PAN core: workflows/verify-phase.md — ' + PAN_TOOLS + '). Check the phase goals against what the plans delivered, write the verification file the protocol prescribes, and report status (passed | gaps_found | human_needed | failed), the verification file path, any gaps, and a summary. Do not mark the phase complete or advance state — that decision stays with the user.',
   { agentType: 'pan-verifier', label: 'verify', phase: 'Verify', schema: VERIFY })
 
-return { phase: phaseArg, waves_run: waveNumbers.length, plans_complete: executed.length, verification: verdict, next: 'Review the verification, then continue with /pan-exec-phase ' + phaseArg + ' (transition) or /pan-plan-phase for the next phase' }
+return { phase: phaseArg, waves_run: waveNumbers.length, plans_complete: executed.length, verification: verdict, next: 'Review the verification, then continue with /pan:exec-phase ' + phaseArg + ' (transition) or /pan:plan-phase for the next phase' }
 `;
 
   const diagnoseIssues = `export const meta = {
   name: 'pan-diagnose-issues',
   description: 'PAN UAT diagnosis: one debugger per failed UAT truth, in parallel, then root causes written back',
-  whenToUse: 'Deterministic version of /pan-diagnose-issues. Pass the phase number as args. Investigates only — fixes come from /pan-plan-phase --gaps.',
+  whenToUse: 'Deterministic version of the diagnose-issues workflow. Pass the phase number as args. Investigates only — fixes come from /pan:plan-phase --gaps.',
   phases: [
     { title: 'Gaps', detail: 'read the phase UAT file and list the failed truths' },
     { title: 'Diagnose', detail: 'one pan-debugger per gap, in parallel, root cause only' },
@@ -2255,6 +2437,7 @@ const DIAGNOSIS = {
     issue_id: { type: 'string' },
     status: { type: 'string', enum: ['root_cause_found', 'inconclusive'] },
     root_cause: { type: 'string' },
+    reproduction: { type: 'string' },
     evidence: { type: 'array', items: { type: 'string' } },
     files: { type: 'array', items: { type: 'string' } },
     suggested_fix: { type: 'string' },
@@ -2264,9 +2447,9 @@ const DIAGNOSIS = {
   required: ['issue_id', 'status'],
 }
 const diagnoses = await parallel(gaps.map(g => () => agent(
-  'Debug issue UAT-' + g.test_num + ' for phase ' + phaseArg + ' — root cause ONLY, do not fix (fixes come from /pan-plan-phase --gaps).\\n\\n'
+  'Debug issue UAT-' + g.test_num + ' for phase ' + phaseArg + ' — root cause ONLY, do not fix (fixes come from /pan:plan-phase --gaps).\\n\\n'
   + 'Symptoms (pre-filled from UAT, treat as given): expected: ' + (g.expected || g.truth) + '. actual: ' + (g.reason || 'not recorded') + '. reproduction: test ' + g.test_num + ' in ' + found.uat_path + '. severity: ' + g.severity + '.\\n\\n'
-  + 'Follow the PAN debugger protocol: create the debug session file under .planning/debug/ named from the issue, investigate autonomously (read code, form hypotheses, test them), and report issue_id, status (root_cause_found | inconclusive), root_cause with evidence, files involved, a suggested fix direction, and the debug session path. If inconclusive, list the remaining possibilities. Also read ' + found.uat_path + ' and .planning/state.md for context.',
+  + 'Follow the PAN debugger protocol: create the debug session file under .planning/debug/ named from the issue, build and run a command that fails on the symptom before forming any hypothesis, investigate autonomously (read code, form hypotheses, test them), and report issue_id, status (root_cause_found | inconclusive), the reproduction command (or none, with what you tried), root_cause with evidence, files involved, a suggested fix direction, and the debug session path. If inconclusive, list the remaining possibilities. Also read ' + found.uat_path + ' and .planning/state.md for context.',
   { agentType: 'pan-debugger', label: 'debug:UAT-' + g.test_num, phase: 'Diagnose', schema: DIAGNOSIS })))
 const results = diagnoses.filter(Boolean)
 log(results.filter(r => r.status === 'root_cause_found').length + ' root cause(s) found, ' + results.filter(r => r.status === 'inconclusive').length + ' inconclusive')
@@ -2278,10 +2461,10 @@ const RECORDED = {
   required: ['uat_path', 'gaps_updated'],
 }
 const recorded = await agent(
-  'Update the Gaps section of ' + found.uat_path + ' with these diagnoses, following the PAN diagnose-issues protocol: for each gap add root_cause, artifacts (the debug session path), the files involved, and the suggested fix direction; mark inconclusive ones as needing manual review with their remaining possibilities. Edit in place — do not rewrite unrelated content. Report the path and how many gaps you updated.\\n\\nDiagnoses:\\n' + JSON.stringify(results, null, 2),
+  'Update the Gaps section of ' + found.uat_path + ' with these diagnoses, following the PAN diagnose-issues protocol: for each gap add root_cause, artifacts (each file involved, with its issue), missing (the suggested fix direction) and debug_session (the debug session path); mark inconclusive ones as needing manual review with their remaining possibilities. Edit the Gaps section in place and set the frontmatter status to diagnosed (the --gaps mode of pan-planner reads UAT gaps only from a diagnosed file); do not rewrite other content. Report the path and how many gaps you updated.\\n\\nDiagnoses:\\n' + JSON.stringify(results, null, 2),
   { label: 'record', phase: 'Record', schema: RECORDED })
 
-return { phase: phaseArg, uat_path: found.uat_path, gaps: gaps.length, root_causes_found: results.filter(r => r.status === 'root_cause_found').length, inconclusive: results.filter(r => r.status === 'inconclusive').length, recorded, next: 'Run /pan-plan-phase ' + phaseArg + ' --gaps to plan the fixes' }
+return { phase: phaseArg, uat_path: found.uat_path, gaps: gaps.length, root_causes_found: results.filter(r => r.status === 'root_cause_found').length, inconclusive: results.filter(r => r.status === 'inconclusive').length, recorded, next: 'Run /pan:plan-phase ' + phaseArg + ' --gaps to plan the fixes' }
 `;
 
   return [
@@ -2353,6 +2536,7 @@ module.exports = {
   convertClaudeToCopilotAgent,
   // Attribution
   processAttribution,
+  commitAttributionFromSettings,
   // JSONC
   parseJsonc,
   // Opus 4.7 capabilities
@@ -2382,6 +2566,7 @@ module.exports = {
   rewriteUnifiedSkillCommandContent,
   rewriteSharedCoreMarkdown,
   rewriteAgentReferenceCopy,
+  rewriteAgentFileRefs,
   stripInternalLearningsTopics,
   AGENT_PLUGINS_VERSION,
   AGENT_PLUGIN_MANIFEST_SCHEMA,
@@ -2392,6 +2577,9 @@ module.exports = {
   buildAgentPluginManifest,
   buildAgentPluginMcpConfig,
   agentPluginSkillAdapterNote,
+  AGENT_PLUGIN_SKILL_MAX_BYTES,
+  AGENT_PLUGIN_SKILL_REFERENCE,
+  splitOversizedSkill,
   buildCopilotPluginHooksConfig,
   COPILOT_PLUGIN_NAMESPACE,
   buildPluginManifest,
@@ -2400,6 +2588,8 @@ module.exports = {
   buildPluginSelfTestCommand,
   // Install verification (v3.7.10)
   verifyInstall,
+  hookCommandScript,
+  verifyHookEntrypoints,
   // AGENTS.md universal rules layer (ADR-0028 Phase 3)
   buildAgentsMdSection,
   upsertAgentsMdSection,