pi-subagents-j0k3r 1.0.0

package/index.ts

@@ -0,0 +1,531 @@
+import { SubagentManager } from './src/manager.js';
+import { readSubagentsConfig } from './src/config.js';
+import { registerSubagentTools, triggerClaudeBackgroundHandoff } from './src/tools.js';
+import { runSubagentModelsCommand } from './src/model-profiles-ui.js';
+import { SubagentsHistoryPanel } from './src/ui.js';
+import type { SubagentTask } from './src/types.js';
+
+type ClaudeBackgroundWidgetEntry = {
+  key: string;
+  line: string;
+};
+
+type ClaudeBackgroundTerminalAction =
+  | { type: 'focus-editor' }
+  | { type: 'open-task'; taskId: string };
+
+type ClaudeBackgroundTerminalInputResult = {
+  consume?: boolean;
+  data?: string;
+  action?: ClaudeBackgroundTerminalAction;
+} | undefined;
+
+function matchesKey(data: string, key: string): boolean {
+  const keys: Record<string, string[]> = {
+    escape: ['\u001b'],
+    'ctrl+c': ['\u0003'],
+    'ctrl+o': ['\u000f'],
+    'ctrl+w': ['\u0017'],
+    q: ['q', 'Q'],
+    up: ['\u001b[A'],
+    down: ['\u001b[B'],
+    right: ['\u001b[C'],
+    left: ['\u001b[D'],
+    pageUp: ['\u001b[5~'],
+    pageDown: ['\u001b[6~'],
+    home: ['\u001b[H', '\u001b[1~', '\u001bOH'],
+    end: ['\u001b[F', '\u001b[4~', '\u001bOF'],
+  };
+  return keys[key]?.includes(data) ?? data === key;
+}
+
+const PANEL_KEYBINDINGS: Record<string, string[]> = {
+  escape: ['app.interrupt', 'tui.select.cancel'],
+  'ctrl+c': ['tui.select.cancel'],
+  'ctrl+o': ['app.tools.expand'],
+  detailCancel: ['subagents.detail.cancel'],
+  up: ['tui.select.up', 'tui.editor.cursorUp'],
+  down: ['tui.select.down', 'tui.editor.cursorDown'],
+  right: ['tui.editor.cursorRight'],
+  left: ['tui.editor.cursorLeft'],
+  pageUp: ['tui.select.pageUp', 'tui.editor.pageUp'],
+  pageDown: ['tui.select.pageDown', 'tui.editor.pageDown'],
+  home: ['tui.editor.cursorLineStart'],
+  end: ['tui.editor.cursorLineEnd'],
+};
+
+export function createSubagentsPanelKeyMatcher(keybindings?: { matches?: (data: string, keybinding: string) => boolean }) {
+  return (data: string, key: string): boolean => {
+    const bindings = PANEL_KEYBINDINGS[key];
+    if (bindings?.some((binding) => keybindings?.matches?.(data, binding))) return true;
+    return matchesKey(data, key);
+  };
+}
+
+function visibleWidth(text: string): number {
+  return [...text.replace(/\u001b\][^\u001b\u0007]*(?:\u001b\\|\u0007)|\u001b\[[0-?]*[ -/]*[@-~]/g, '')].length;
+}
+
+function truncateToWidth(text: string, width: number): string {
+  const chars = [...text];
+  return chars.length > width ? chars.slice(0, Math.max(0, width - 1)).join('') + '…' : text;
+}
+
+function wrapLineToWidth(line: string, width: number): string[] {
+  const max = Math.max(1, width);
+  if (!line) return [''];
+  if ([...line].length <= max) return [line];
+  const out: string[] = [];
+  let current = '';
+  for (const word of line.split(/\s+/).filter(Boolean)) {
+    const wordLength = [...word].length;
+    const currentLength = [...current].length;
+    if (!current) {
+      if (wordLength <= max) {
+        current = word;
+      } else {
+        const chars = [...word];
+        for (let index = 0; index < chars.length; index += max) out.push(chars.slice(index, index + max).join(''));
+      }
+      continue;
+    }
+    if (currentLength + 1 + wordLength <= max) {
+      current += ` ${word}`;
+      continue;
+    }
+    out.push(current);
+    current = '';
+    if (wordLength <= max) {
+      current = word;
+    } else {
+      const chars = [...word];
+      for (let index = 0; index < chars.length; index += max) out.push(chars.slice(index, index + max).join(''));
+    }
+  }
+  if (current) out.push(current);
+  return out.length ? out : [''];
+}
+
+function currentSessionId(ctx: any): string | undefined {
+  const direct = ctx?.sessionManager?.getSessionId?.() ?? ctx?.sessionId;
+  if (typeof direct === 'string' && direct.length > 0) return direct;
+  const file = ctx?.sessionManager?.getSessionFile?.();
+  return typeof file === 'string' && file.length > 0 ? file : undefined;
+}
+
+function setMouseTracking(tui: any, enabled: boolean): void {
+  const write = tui?.terminal?.write?.bind(tui.terminal);
+  if (typeof write !== 'function') return;
+  write(enabled ? '\u001b[?1000h\u001b[?1006h' : '\u001b[?1006l\u001b[?1000l');
+}
+
+function toolFromRegistry(registry: any, name: string): unknown {
+  if (!registry) return undefined;
+  if (typeof registry.get === 'function') return registry.get(name);
+  if (Array.isArray(registry)) return registry.find((tool) => tool?.name === name);
+  if (typeof registry === 'object') return registry[name];
+  return undefined;
+}
+
+export function resolveRegisteredToolDefinition(ctx: any, pi: any, name: string): unknown {
+  return ctx?.pi?.getToolDefinition?.(name)
+    ?? pi?.getToolDefinition?.(name)
+    ?? ctx?.getToolDefinition?.(name)
+    ?? toolFromRegistry(ctx?.pi?.tools, name)
+    ?? toolFromRegistry(pi?.tools, name)
+    ?? toolFromRegistry(ctx?.tools, name);
+}
+
+function clip(text: string | undefined, limit = 120): string {
+  if (!text) return '';
+  const normalized = text.replace(/\s+/g, ' ').trim();
+  return normalized.length > limit ? `${normalized.slice(0, Math.max(0, limit - 1))}…` : normalized;
+}
+
+function isActiveBackgroundTask(task: SubagentTask): boolean {
+  return task.mode === 'background' && (task.status === 'queued' || task.status === 'running');
+}
+
+function buildClaudeBackgroundWidgetEntries(tasks: SubagentTask[]): ClaudeBackgroundWidgetEntry[] {
+  const active = tasks.filter(isActiveBackgroundTask);
+  if (!active.length) return [];
+  return [
+    { key: 'main', line: 'main' },
+    ...active.map((task) => ({ key: task.id, line: `${task.agent} ${clip(task.last_activity ?? task.task ?? task.id)}` })),
+  ];
+}
+
+function coerceClaudeBackgroundSelection(entries: ClaudeBackgroundWidgetEntry[], selectedKey: string | undefined): string {
+  if (!entries.length) return 'main';
+  return entries.some((entry) => entry.key === selectedKey) ? selectedKey! : entries[0]!.key;
+}
+
+export function moveClaudeBackgroundWidgetSelection(tasks: SubagentTask[], selectedKey: string | undefined, direction: 'up' | 'down'): string {
+  const entries = buildClaudeBackgroundWidgetEntries(tasks);
+  if (!entries.length) return 'main';
+  const current = coerceClaudeBackgroundSelection(entries, selectedKey);
+  const index = entries.findIndex((entry) => entry.key === current);
+  const nextIndex = direction === 'down'
+    ? Math.min(index + 1, entries.length - 1)
+    : Math.max(index - 1, 0);
+  return entries[nextIndex]?.key ?? current;
+}
+
+export function renderClaudeBackgroundWidgetLines(tasks: SubagentTask[], selectedKey?: string): string[] | undefined {
+  const entries = buildClaudeBackgroundWidgetEntries(tasks);
+  if (!entries.length) return undefined;
+  const current = selectedKey === undefined ? undefined : coerceClaudeBackgroundSelection(entries, selectedKey);
+  return entries.map((entry) => `${entry.key === current ? '●' : '○'} ${entry.line}`);
+}
+
+export class ClaudeBackgroundWidgetState {
+  private selectedKey = 'main';
+  private navigationActive = false;
+
+  constructor(
+    private getTasks: () => SubagentTask[],
+    private onChange?: () => void,
+  ) {}
+
+  getSelectedKey(): string {
+    this.selectedKey = coerceClaudeBackgroundSelection(buildClaudeBackgroundWidgetEntries(this.getTasks()), this.selectedKey);
+    return this.selectedKey;
+  }
+
+  renderLines(): string[] {
+    return renderClaudeBackgroundWidgetLines(this.getTasks(), this.navigationActive ? this.getSelectedKey() : undefined) ?? [];
+  }
+
+  handleWidgetInput(data: string): void {
+    this.handleTerminalInput(data);
+  }
+
+  handleTerminalInput(data: string): ClaudeBackgroundTerminalInputResult {
+    const tasks = this.getTasks();
+    if (!tasks.some(isActiveBackgroundTask)) {
+      if (this.navigationActive || this.selectedKey !== 'main') {
+        this.selectedKey = 'main';
+        this.navigationActive = false;
+        this.onChange?.();
+      }
+      return undefined;
+    }
+
+    if (matchesKey(data, 'down')) {
+      this.navigationActive = true;
+      const next = moveClaudeBackgroundWidgetSelection(tasks, this.getSelectedKey(), 'down');
+      if (next !== this.selectedKey) {
+        this.selectedKey = next;
+        this.onChange?.();
+      }
+      return { consume: true };
+    }
+
+    if (matchesKey(data, 'up')) {
+      if (!this.navigationActive) return undefined;
+      if (this.getSelectedKey() === 'main') {
+        this.navigationActive = false;
+        this.onChange?.();
+        return { consume: true };
+      }
+      const next = moveClaudeBackgroundWidgetSelection(tasks, this.selectedKey, 'up');
+      if (next !== this.selectedKey) {
+        this.selectedKey = next;
+        this.onChange?.();
+      }
+      return { consume: true };
+    }
+
+    if (this.navigationActive && (data === '\r' || data === '\n')) {
+      const selectedKey = this.getSelectedKey();
+      this.navigationActive = false;
+      this.onChange?.();
+      if (selectedKey === 'main') return { consume: true, action: { type: 'focus-editor' } };
+      return { consume: true, action: { type: 'open-task', taskId: selectedKey } };
+    }
+
+    if (this.navigationActive && (matchesKey(data, 'left') || matchesKey(data, 'right') || matchesKey(data, 'escape'))) {
+      this.navigationActive = false;
+      this.onChange?.();
+      return { consume: true, action: { type: 'focus-editor' } };
+    }
+
+    if (this.navigationActive) return { consume: true };
+    return undefined;
+  }
+}
+
+export class ClaudeBackgroundWidget {
+  constructor(
+    private state: ClaudeBackgroundWidgetState,
+    private theme: any,
+  ) {}
+
+  invalidate(): void {}
+
+  render(width: number): string[] {
+    return this.state.renderLines().map((line) => truncateToWidth(this.decorate(line), width));
+  }
+
+  handleInput(data: string): void {
+    this.state.handleWidgetInput(data);
+  }
+
+  private decorate(line: string): string {
+    if (!line.startsWith('● ')) return line;
+    return this.theme?.fg?.('warning', this.theme?.bold?.(line) ?? line) ?? line;
+  }
+}
+
+export function completionMessage(task: any): string {
+  const result = task.result ?? task.error ?? task.output_preview ?? '(no result captured)';
+  return [
+    `Subagent ${task.agent} ${task.status}: ${task.id}`,
+    '',
+    'Read only this final response from the subagent. Do not reread the full execution transcript unless the user explicitly asks for debugging details.',
+    '',
+    '## response sent to the orchestrator',
+    '',
+    result,
+  ].join('\n');
+}
+
+export function renderSubagentCompletionMessage(message: any, options: any, theme: any) {
+  const details = message.details ?? {};
+  const task = details.task ?? details;
+  const status = task.status ?? 'completed';
+  const failed = status === 'failed' || status === 'cancelled';
+  const expanded = Boolean(options?.expanded);
+  const result = details.full_result ?? task.result ?? task.error ?? '';
+  const title = `[subagent] ${task.agent ?? 'subagent'} ${status}: ${task.id ?? task.task_id ?? ''}`.trim();
+  const sections: Array<{ text: string; style?: 'label' | 'status' | 'dim' | 'body' | 'heading' }> = [
+    { text: title, style: 'label' },
+    { text: `response: ${expanded ? 'expanded' : 'collapsed'}${expanded ? '' : ' · ctrl+o to expand'}`, style: expanded ? 'status' : 'dim' },
+  ];
+  if (expanded && result) {
+    sections.push(
+      { text: '─'.repeat(24), style: 'dim' },
+      { text: 'response sent to the orchestrator', style: 'heading' },
+      ...String(result).split('\n').map((line) => ({ text: line, style: 'body' as const })),
+    );
+  }
+  const color = (section: { text: string; style?: 'label' | 'status' | 'dim' | 'body' | 'heading' }, text: string) => {
+    if (section.style === 'label') return theme.fg?.(failed ? 'error' : 'customMessageLabel', text) ?? text;
+    if (section.style === 'status') return theme.fg?.(failed ? 'error' : 'success', text) ?? text;
+    if (section.style === 'dim') return theme.fg?.('dim', text) ?? text;
+    if (section.style === 'heading') return theme.fg?.('toolTitle', text) ?? text;
+    if (section.style === 'body') return theme.fg?.('customMessageText', text) ?? text;
+    return text;
+  };
+  return {
+    invalidate() {},
+    render(width: number) {
+      const blockWidth = Math.max(1, width);
+      const contentWidth = Math.max(1, blockWidth - 2);
+      return sections.flatMap((section) => wrapLineToWidth(section.text, contentWidth).map((line) => {
+        const styled = color(section, line);
+        const paddedVisibleWidth = Math.min(blockWidth, [...` ${line}`].length);
+        const rightPadding = ' '.repeat(Math.max(0, blockWidth - paddedVisibleWidth));
+        const padded = ` ${styled}${rightPadding}`;
+        return theme.bg?.('customMessageBg', padded) ?? padded;
+      }));
+    },
+  };
+}
+
+export default function subagentsExtension(pi: any): void {
+  pi.registerMessageRenderer?.('subagent-completion', renderSubagentCompletionMessage);
+  const manager = new SubagentManager(undefined, undefined, (task) => {
+    pi.sendMessage?.({
+      customType: 'subagent-completion',
+      content: completionMessage(task),
+      display: true,
+      details: {
+        full_result: task.result ?? task.error ?? task.output_preview,
+        task: {
+          id: task.id,
+          agent: task.agent,
+          status: task.status,
+          mode: task.mode,
+          model: task.model,
+          effort: task.effort,
+          usage: task.usage,
+          result: task.result,
+          error: task.error,
+        },
+      },
+    }, {
+      triggerTurn: true,
+      deliverAs: 'followUp',
+    });
+  });
+  registerSubagentTools(pi, manager);
+
+  let widgetTimer: NodeJS.Timeout | undefined;
+  let widgetCtx: any;
+  let widgetRequestRender: (() => void) | undefined;
+  let removeTerminalInputListener: (() => void) | undefined;
+  let widgetState: ClaudeBackgroundWidgetState | undefined;
+  let widgetInputSuspended = false;
+  let activePanelCancelSelected: (() => void) | undefined;
+  let activePanelRequestRender: (() => void) | undefined;
+
+  const installClaudeBackgroundWidget = (ctx: any): boolean => {
+    if (typeof ctx?.ui?.setWidget !== 'function') return false;
+    const cwd = ctx?.cwd ?? process.cwd();
+    const config = readSubagentsConfig(cwd);
+    if (config.mode !== 'claude') {
+      ctx.ui.setWidget('subagents-claude-background', undefined);
+      return false;
+    }
+    const sessionId = currentSessionId(ctx);
+    widgetState = new ClaudeBackgroundWidgetState(
+      () => manager.listSessionTasks(cwd, sessionId).slice(0, 100),
+      () => widgetRequestRender?.(),
+    );
+    if (typeof ctx?.ui?.onTerminalInput === 'function') {
+      removeTerminalInputListener = ctx.ui.onTerminalInput((data: string) => {
+        if (widgetInputSuspended) return undefined;
+        const result = widgetState?.handleTerminalInput(data);
+        if (result?.action?.type === 'open-task' && widgetCtx) void showSubagentsPanel(widgetCtx, result.action.taskId);
+        return result;
+      });
+    }
+    ctx.ui.setWidget('subagents-claude-background', (tui: any, theme: any) => {
+      widgetRequestRender = () => tui?.requestRender?.();
+      return new ClaudeBackgroundWidget(widgetState!, theme);
+    }, { placement: 'belowEditor' });
+    return true;
+  };
+
+  const clearClaudeBackgroundWidget = () => {
+    if (widgetTimer) clearInterval(widgetTimer);
+    widgetTimer = undefined;
+    widgetRequestRender = undefined;
+    removeTerminalInputListener?.();
+    removeTerminalInputListener = undefined;
+    widgetState = undefined;
+    widgetInputSuspended = false;
+    widgetCtx?.ui?.setWidget?.('subagents-claude-background', undefined);
+    widgetCtx = undefined;
+  };
+
+  pi.on?.('session_start', (_event: unknown, ctx: any) => {
+    clearClaudeBackgroundWidget();
+    if (typeof ctx?.ui?.setWidget !== 'function') return;
+    widgetCtx = ctx;
+    if (!installClaudeBackgroundWidget(ctx)) return;
+    widgetTimer = setInterval(() => widgetRequestRender?.(), 250);
+    widgetTimer.unref?.();
+  });
+
+  pi.on?.('session_shutdown', () => {
+    clearClaudeBackgroundWidget();
+  });
+
+  async function showSubagentsPanel(ctx: any, selectedTaskId?: string) {
+    const cwd = ctx?.cwd ?? process.cwd();
+    const sessionId = currentSessionId(ctx);
+    let refresh: NodeJS.Timeout | undefined;
+    widgetInputSuspended = true;
+    try {
+      await ctx.ui.custom(
+      (tui: any, theme: any, _keybindings: any, done: () => void) => {
+        setMouseTracking(tui, true);
+        const close = () => {
+          if (refresh) clearInterval(refresh);
+          setMouseTracking(tui, false);
+          done();
+        };
+        const config = readSubagentsConfig(cwd);
+        const baseMatchesKey = createSubagentsPanelKeyMatcher(_keybindings);
+        const panel = new SubagentsHistoryPanel(
+          () => manager.listSessionTasks(cwd, sessionId).slice(0, 100),
+          theme,
+          close,
+          (data: string, key: string) => {
+            if (key !== 'detailCancel') return baseMatchesKey(data, key);
+            const detailShortcut = config.detail_cancel_shortcut ?? 'x';
+            return baseMatchesKey(data, detailShortcut)
+              || baseMatchesKey(data, 'detailCancel')
+              || (detailShortcut === 'ctrl+w' && _keybindings?.matches?.(data, 'tui.editor.deleteWordBackward'));
+          },
+          visibleWidth,
+          truncateToWidth,
+          {
+            theme,
+            tui,
+            cwd,
+            visibleWidth,
+            truncateToWidth,
+            getToolDefinition: (name: string) => resolveRegisteredToolDefinition(ctx, pi, name),
+            getMessageRenderer: (customType: string) => ctx?.pi?.getMessageRenderer?.(customType) ?? ctx?.pi?.customMessageRenderers?.get?.(customType) ?? ctx?.customMessageRenderers?.get?.(customType),
+            showImages: ctx?.showImages,
+            imageWidthCells: ctx?.imageWidthCells,
+          },
+          () => Math.max(12, process.stdout.rows || 42),
+          (id: string) => manager.getTask(id, cwd),
+          selectedTaskId,
+          (id: string) => manager.cancel(id, 'cancelled from subagents detail view'),
+          config.detail_cancel_shortcut ?? 'x',
+        );
+        activePanelCancelSelected = () => panel.cancelSelectedActiveTask();
+        activePanelRequestRender = () => tui.requestRender?.();
+        refresh = setInterval(() => tui.requestRender?.(), 1000);
+        return {
+          render: (width: number) => panel.render(width),
+          invalidate: () => panel.invalidate(),
+          handleInput: (data: string) => { panel.handleInput(data); tui.requestRender?.(); },
+        };
+      },
+      undefined,
+    );
+    } finally {
+      activePanelCancelSelected = undefined;
+      activePanelRequestRender = undefined;
+      widgetInputSuspended = false;
+    }
+  }
+
+  const historyPanelShortcut = readSubagentsConfig(process.cwd()).history_panel_shortcut ?? 'ctrl+,';
+  pi.registerShortcut?.(historyPanelShortcut, {
+    description: 'Show subagent history panel',
+    handler: async (ctx: any) => {
+      const cwd = ctx?.cwd ?? process.cwd();
+      if (readSubagentsConfig(cwd).mode === 'claude') return;
+      await showSubagentsPanel(ctx);
+    },
+  });
+
+  const detailCancelShortcut = readSubagentsConfig(process.cwd()).detail_cancel_shortcut ?? 'x';
+  if (detailCancelShortcut.startsWith('ctrl+')) {
+    pi.registerShortcut?.(detailCancelShortcut, {
+      description: 'Cancel selected running subagent from the active subagents detail panel',
+      handler: async () => {
+        activePanelCancelSelected?.();
+        activePanelRequestRender?.();
+      },
+    });
+  }
+
+  const backgroundHandoffShortcut = readSubagentsConfig(process.cwd()).background_handoff_shortcut ?? 'ctrl+h';
+  pi.registerShortcut?.(backgroundHandoffShortcut, {
+    description: 'Send running claude subagent task to background',
+    handler: async (ctx: any) => {
+      const cwd = ctx?.cwd ?? process.cwd();
+      if (readSubagentsConfig(cwd).mode !== 'claude') return;
+      triggerClaudeBackgroundHandoff();
+    },
+  });
+
+  pi.registerCommand?.('subagents', {
+    description: 'Show subagent history panel',
+    handler: async (_args: string, ctx: any) => showSubagentsPanel({ ...ctx, pi }),
+  });
+
+  pi.registerCommand?.('subagent-models', {
+    description: 'Configure subagent and SDD phase model profiles',
+    handler: async (_args: string, ctx: any) => runSubagentModelsCommand({ ...ctx, pi }),
+  });
+
+}

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "pi-subagents-j0k3r",
+  "version": "1.0.0",
+  "description": "Installable Pi package that adds markdown-defined subagents, delegated task tools, history, and model profiles.",
+  "type": "module",
+  "license": "MIT",
+  "author": "j0k3r",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/j0k3r-dev-rgl/pi-subagents-j0k3r.git"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi",
+    "subagents",
+    "coding-agent",
+    "agent",
+    "delegation"
+  ],
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "main": "./index.ts",
+  "files": [
+    "index.ts",
+    "src",
+    "skills",
+    "scripts/verify-package-files.mjs",
+    ".releaserc.json",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "scripts": {
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "verify:package": "node scripts/verify-package-files.mjs",
+    "pack:dry-run": "npm pack --dry-run",
+    "check": "npm run typecheck && npm test && npm run verify:package",
+    "release": "semantic-release",
+    "prepublishOnly": "npm run check"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    },
+    "typebox": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@semantic-release/github": "12.0.8",
+    "@semantic-release/npm": "13.1.5",
+    "@types/node": "24.10.1",
+    "semantic-release": "25.0.5",
+    "typebox": "1.1.38",
+    "typescript": "5.9.3",
+    "vitest": "4.1.7"
+  }
+}

package/scripts/verify-package-files.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { existsSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = join(fileURLToPath(new URL('..', import.meta.url)));
+
+const requiredFiles = [
+  'index.ts',
+  'README.md',
+  'LICENSE',
+  'package.json',
+  '.releaserc.json',
+  'src/config.ts',
+  'src/debug.ts',
+  'src/history.ts',
+  'src/interaction-channel.ts',
+  'src/manager.ts',
+  'src/model-profiles-ui.ts',
+  'src/profile-resolver.ts',
+  'src/runner.ts',
+  'src/thread-view.ts',
+  'src/tools.ts',
+  'src/types.ts',
+  'src/ui.ts',
+  'skills/subagents-configuration/SKILL.md',
+];
+
+const missing = requiredFiles.filter((relativePath) => {
+  const absolutePath = join(root, relativePath);
+  return !existsSync(absolutePath) || !statSync(absolutePath).isFile();
+});
+
+if (missing.length > 0) {
+  console.error('pi-subagents-j0k3r package is missing required Pi resources:');
+  for (const relativePath of missing) console.error(`- ${relativePath}`);
+  console.error('\nRefusing to pack/publish an incomplete npm package.');
+  process.exit(1);
+}
+
+console.log(`pi-subagents-j0k3r package resource check passed (${requiredFiles.length} files).`);