pi-chalin 0.1.0

package/src/commands.ts

@@ -0,0 +1,140 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { sessionModelOverrides, sessionThinkingOverrides } from "./agent-overrides.ts";
+import { AgentCatalog } from "./agents.ts";
+import { ArtifactStore } from "./artifacts.ts";
+import { loadEffectiveConfig, writeProjectConfig } from "./config.ts";
+import { MemoryStore } from "./memory.ts";
+import { getActiveRun, getLatestRun } from "./runtime-state.ts";
+import { openAgentManager } from "./ui-agents.ts";
+import {
+  openMemoryReview,
+  openArtifactPanel,
+  openActivityMonitor,
+  openWebFetchAuditPanel,
+  openSmartPanel,
+} from "./ui.ts";
+import { setChalinStatus } from "./ui-status.ts";
+import { listWebFetchAudit } from "./webfetch.ts";
+
+export function registerChalinCommands(pi: ExtensionAPI): void {
+  pi.registerCommand("chalin", {
+    description: "Open pi-chalin Smart Panel or toggle autonomous routing with: /chalin on|off",
+    getArgumentCompletions: (prefix) => {
+      const values = ["on", "off", "agents", "memory", "artifacts", "activity", "web", "status"];
+      const filtered = values.filter((value) => value.startsWith(prefix.trim()));
+      return filtered.length > 0 ? filtered.map((value) => ({ value, label: value })) : null;
+    },
+    handler: async (args, ctx) => {
+      const commandLine = args.trim();
+      const [command = "", ...rest] = commandLine.split(/\s+/);
+
+      if (command === "on" || command === "off") {
+        const enabled = command === "on";
+        const loaded = writeProjectConfig({ cwd: ctx.cwd }, { enabled });
+        setChalinStatus(ctx, { kind: enabled ? "on" : "off" });
+        ctx.ui.notify(`pi-chalin autonomous routing ${enabled ? "enabled" : "disabled"} for this project.`, "info");
+        if (loaded.diagnostics.length > 0) ctx.ui.notify(loaded.diagnostics.join("\n"), "warning");
+        return;
+      }
+
+      const loaded = loadEffectiveConfig({ cwd: ctx.cwd });
+      const catalog = AgentCatalog.load({ cwd: ctx.cwd });
+      const memory = new MemoryStore({ cwd: ctx.cwd });
+      const artifacts = new ArtifactStore({ cwd: ctx.cwd });
+      const agents = catalog.list();
+      const diagnostics = [...loaded.diagnostics, ...catalog.diagnostics.warnings, ...catalog.diagnostics.errors];
+      const pendingMemories = await memory.list("pending");
+      const activeRun = getActiveRun();
+      const lastRun = getLatestRun();
+
+      if (command === "agents") {
+        await openAgentManager(ctx, agents, sessionModelOverrides, sessionThinkingOverrides, loaded.config.agents.modelOverrides, loaded.config.agents.thinkingOverrides);
+        return;
+      }
+
+      if (command === "memory") {
+        const query = rest.join(" ").trim();
+        if (query) {
+          const bundle = await memory.retrieve({ query, sourceAgent: "human-command", limit: 10, tokenBudget: 1200, includeEvidence: true });
+          ctx.ui.notify(bundle.text || "No memory matches.", "info");
+        } else {
+          await openMemoryReview(ctx, await memory.list(), {
+            approve: (id) => void memory.approve(id),
+            reject: (id) => void memory.reject(id),
+            delete: (id) => void memory.delete(id),
+          });
+        }
+        return;
+      }
+
+
+      if (command === "artifacts") {
+        const featureId = rest.join(" ").trim();
+        if (featureId) {
+          ctx.ui.notify(await artifacts.resumeContext(featureId), "info");
+          return;
+        }
+        await openArtifactPanel(ctx, artifacts);
+        return;
+      }
+
+      if (command === "activity" || command === "runs") {
+        await openActivityMonitor(ctx, activeRun ?? lastRun);
+        return;
+      }
+
+      if (command === "web" || command === "webfetch") {
+        await openWebFetchAuditPanel(ctx, await listWebFetchAudit({ cwd: ctx.cwd }));
+        return;
+      }
+
+      if (command === "status") {
+        ctx.ui.notify(
+          [
+            `routing: ${loaded.config.enabled ? "on" : "off"}`,
+            `autonomy: ${loaded.config.autonomy}`,
+            `approval threshold: ${loaded.config.safety.approvalRiskThreshold}`,
+            `agents: ${agents.length}`,
+            `pending memory: ${pendingMemories.length}`,
+            `last activity: ${lastRun?.id ?? "none"}`,
+            lastRun ? `guards: ${lastRun.metrics?.policyViolations?.length ?? 0} policy violations · ${lastRun.metrics?.budgetStopCount ?? 0} budget stops` : "guards: no run yet",
+          ].join("\n"),
+          "info",
+        );
+        return;
+      }
+
+      if (command && command !== "panel") {
+        ctx.ui.notify(`Unknown /chalin argument '${command}'. Use /chalin, /chalin activity, /chalin artifacts, /chalin web, /chalin on, or /chalin off. Normal prompts are routed automatically when enabled.`, "warning");
+        return;
+      }
+
+      if (activeRun) {
+        await openActivityMonitor(ctx, activeRun);
+        return;
+      }
+
+      await openSmartPanel(ctx, {
+        state: {
+          autoRoutingEnabled: loaded.config.enabled,
+          pendingApprovals: 0,
+          activeRuns: activeRun ? 1 : 0,
+          pendingMemoryCandidates: pendingMemories.length,
+          lastRun,
+        },
+        agents,
+        diagnostics,
+        pendingMemories,
+        onSelectAgents: () => openAgentManager(ctx, agents, sessionModelOverrides, sessionThinkingOverrides, loaded.config.agents.modelOverrides, loaded.config.agents.thinkingOverrides),
+        onSelectActivity: () => openActivityMonitor(ctx, activeRun ?? lastRun),
+        onSelectMemory: async () => openMemoryReview(ctx, await memory.list(), {
+          approve: (id) => void memory.approve(id),
+          reject: (id) => void memory.reject(id),
+          delete: (id) => void memory.delete(id),
+        }),
+        onSelectArtifacts: () => openArtifactPanel(ctx, artifacts),
+        onSelectWebFetch: async () => openWebFetchAuditPanel(ctx, await listWebFetchAudit({ cwd: ctx.cwd })),
+      });
+    },
+  });
+}

package/src/config.ts

@@ -0,0 +1,189 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { resolveChalinPaths, type ChalinPathsOptions } from "./paths.ts";
+import { isAgentThinkingLevel, riskRank, type AgentScope, type AgentThinkingLevel, type ApprovalDecision, type RouteDecision, type RouteRisk } from "./schemas.ts";
+
+export type AutonomyLevel = "low" | "balanced" | "high";
+export type ApprovalRiskThreshold = RouteRisk;
+export type ModelPersistenceTarget = "session" | "project" | "user";
+
+export interface ChalinConfig {
+  enabled: boolean;
+  autonomy: AutonomyLevel;
+  safety: {
+    approvalRiskThreshold: ApprovalRiskThreshold;
+    recursionGuard: boolean;
+    singleWriterGuard: boolean;
+    mutationExpectationGuard: boolean;
+    blockCritical: boolean;
+  };
+  agents: {
+    modelOverrides: Record<string, string>;
+    thinkingOverrides: Record<string, AgentThinkingLevel>;
+    modelPersistenceDefaults: Record<AgentScope, ModelPersistenceTarget>;
+  };
+}
+
+export interface LoadedChalinConfig {
+  config: ChalinConfig;
+  diagnostics: string[];
+  paths: ReturnType<typeof resolveChalinPaths>;
+}
+
+export const DEFAULT_CONFIG: ChalinConfig = {
+  enabled: true,
+  autonomy: "balanced",
+  safety: {
+    approvalRiskThreshold: "medium",
+    recursionGuard: true,
+    singleWriterGuard: true,
+    mutationExpectationGuard: true,
+    blockCritical: true,
+  },
+  agents: {
+    modelOverrides: {},
+    thinkingOverrides: {},
+    modelPersistenceDefaults: {
+      "built-in": "user",
+      user: "user",
+      project: "project",
+    },
+  },
+};
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function deepMerge<T>(base: T, override: unknown): T {
+  if (!isObject(base) || !isObject(override)) return override === undefined ? base : (override as T);
+  const result: Record<string, unknown> = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    const current = result[key];
+    result[key] = isObject(current) && isObject(value) ? deepMerge(current, value) : value;
+  }
+  return result as T;
+}
+
+function readJsonObject(filePath: string, diagnostics: string[]): Record<string, unknown> {
+  if (!fs.existsSync(filePath)) return {};
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8")) as unknown;
+    if (!isObject(parsed)) {
+      diagnostics.push(`Config '${filePath}' must contain a JSON object.`);
+      return {};
+    }
+    return parsed;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    diagnostics.push(`Failed to read config '${filePath}': ${message}`);
+    return {};
+  }
+}
+
+function coerceConfig(input: ChalinConfig, diagnostics: string[]): ChalinConfig {
+  const config = deepMerge(DEFAULT_CONFIG, input);
+
+  if (!["low", "balanced", "high"].includes(config.autonomy)) {
+    diagnostics.push(`Invalid autonomy '${String(config.autonomy)}'; using '${DEFAULT_CONFIG.autonomy}'.`);
+    config.autonomy = DEFAULT_CONFIG.autonomy;
+  }
+
+  if (!["low", "medium", "high", "critical"].includes(config.safety.approvalRiskThreshold)) {
+    diagnostics.push(
+      `Invalid safety.approvalRiskThreshold '${String(config.safety.approvalRiskThreshold)}'; using '${DEFAULT_CONFIG.safety.approvalRiskThreshold}'.`,
+    );
+    config.safety.approvalRiskThreshold = DEFAULT_CONFIG.safety.approvalRiskThreshold;
+  }
+
+  if (riskRank(config.safety.approvalRiskThreshold) > riskRank(DEFAULT_CONFIG.safety.approvalRiskThreshold)) {
+    diagnostics.push(
+      `Safety non-downgrade enforced: approvalRiskThreshold '${config.safety.approvalRiskThreshold}' is weaker than '${DEFAULT_CONFIG.safety.approvalRiskThreshold}'.`,
+    );
+    config.safety.approvalRiskThreshold = DEFAULT_CONFIG.safety.approvalRiskThreshold;
+  }
+
+  for (const key of ["recursionGuard", "singleWriterGuard", "mutationExpectationGuard", "blockCritical"] as const) {
+    if (DEFAULT_CONFIG.safety[key] && config.safety[key] !== true) {
+      diagnostics.push(`Safety non-downgrade enforced: safety.${key} cannot be disabled.`);
+      config.safety[key] = true;
+    }
+  }
+
+  if (!isObject(config.agents.modelOverrides)) config.agents.modelOverrides = {};
+  if (!isObject(config.agents.thinkingOverrides)) config.agents.thinkingOverrides = {};
+  for (const [agentRef, level] of Object.entries(config.agents.thinkingOverrides)) {
+    if (typeof level !== "string" || !isAgentThinkingLevel(level)) {
+      diagnostics.push(`Invalid agents.thinkingOverrides['${agentRef}']='${String(level)}'; removing override.`);
+      delete config.agents.thinkingOverrides[agentRef];
+    }
+  }
+  return config;
+}
+
+export function loadEffectiveConfig(options: ChalinPathsOptions): LoadedChalinConfig {
+  const paths = resolveChalinPaths(options);
+  const diagnostics: string[] = [];
+  const projectConfig = readJsonObject(paths.projectConfigPath, diagnostics);
+  const userConfig = readJsonObject(paths.userConfigPath, diagnostics);
+  const merged = deepMerge(deepMerge(DEFAULT_CONFIG, projectConfig), userConfig);
+  return { config: coerceConfig(merged, diagnostics), diagnostics, paths };
+}
+
+export function writeProjectConfig(options: ChalinPathsOptions, configPatch: Partial<ChalinConfig>): LoadedChalinConfig {
+  const loaded = loadEffectiveConfig(options);
+  const current = readJsonObject(loaded.paths.projectConfigPath, []);
+  const next = deepMerge(current, configPatch);
+  fs.mkdirSync(path.dirname(loaded.paths.projectConfigPath), { recursive: true });
+  fs.writeFileSync(loaded.paths.projectConfigPath, `${JSON.stringify(next, null, 2)}\n`, "utf-8");
+  return loadEffectiveConfig(options);
+}
+
+export function writeUserConfig(options: ChalinPathsOptions, configPatch: Partial<ChalinConfig>): LoadedChalinConfig {
+  const loaded = loadEffectiveConfig(options);
+  const current = readJsonObject(loaded.paths.userConfigPath, []);
+  const next = deepMerge(current, configPatch);
+  fs.mkdirSync(path.dirname(loaded.paths.userConfigPath), { recursive: true });
+  fs.writeFileSync(loaded.paths.userConfigPath, `${JSON.stringify(next, null, 2)}\n`, "utf-8");
+  return loadEffectiveConfig(options);
+}
+
+export function setAgentModelOverride(
+  options: ChalinPathsOptions,
+  agentRef: string,
+  model: string | undefined,
+  target: Exclude<ModelPersistenceTarget, "session">,
+): LoadedChalinConfig {
+  const loaded = loadEffectiveConfig(options);
+  const overrides = { ...loaded.config.agents.modelOverrides };
+  if (model) overrides[agentRef] = model;
+  else delete overrides[agentRef];
+  const patch: Partial<ChalinConfig> = { agents: { ...loaded.config.agents, modelOverrides: overrides } };
+  return target === "project" ? writeProjectConfig(options, patch) : writeUserConfig(options, patch);
+}
+
+export function setAgentThinkingOverride(
+  options: ChalinPathsOptions,
+  agentRef: string,
+  thinking: AgentThinkingLevel | undefined,
+  target: Exclude<ModelPersistenceTarget, "session">,
+): LoadedChalinConfig {
+  const loaded = loadEffectiveConfig(options);
+  const overrides = { ...loaded.config.agents.thinkingOverrides };
+  if (thinking && thinking !== "inherit") overrides[agentRef] = thinking;
+  else delete overrides[agentRef];
+  const patch: Partial<ChalinConfig> = { agents: { ...loaded.config.agents, thinkingOverrides: overrides } };
+  return target === "project" ? writeProjectConfig(options, patch) : writeUserConfig(options, patch);
+}
+
+export function approvalDecision(config: ChalinConfig, route: RouteDecision): ApprovalDecision {
+  if (route.kind === "bypass" || route.kind === "memory-only") return { action: "allow", reason: "No subagent execution required." };
+  if (route.risk === "critical" && config.safety.blockCritical) {
+    return { action: "block", reason: "Critical routes are blocked by default safety policy." };
+  }
+  const threshold = config.autonomy === "low" ? "low" : config.safety.approvalRiskThreshold;
+  if (riskRank(route.risk) >= riskRank(threshold)) {
+    return { action: "ask", reason: `Route risk '${route.risk}' meets approval threshold '${threshold}'.` };
+  }
+  return { action: "allow", reason: `Route risk '${route.risk}' is below approval threshold '${threshold}'.` };
+}

package/src/discovery.ts

@@ -0,0 +1,190 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export type DiscoveryEntryType = "file" | "dir" | "symlink" | "other";
+
+export interface DiscoveryEntry {
+  path: string;
+  type: DiscoveryEntryType;
+  depth: number;
+  ext?: string;
+  sizeBytes?: number;
+  childCount?: number;
+}
+
+export interface ProjectDiscoveryIndex {
+  version: 1;
+  createdAt: string;
+  cwd: string;
+  entries: DiscoveryEntry[];
+  truncated: boolean;
+  ignoredDirs: string[];
+  extensionHistogram: Record<string, number>;
+  shallowFiles: string[];
+  instructionFiles: string[];
+  configLikeFiles: string[];
+  testLikeFiles: string[];
+}
+
+export interface ProjectDiscoveryOptions {
+  maxDepth?: number;
+  maxEntries?: number;
+  maxChildrenPerDir?: number;
+}
+
+const DEFAULT_MAX_DEPTH = 4;
+const DEFAULT_MAX_ENTRIES = 450;
+const DEFAULT_MAX_CHILDREN_PER_DIR = 120;
+const IGNORED_DIRS = new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  ".pi-chalin",
+  "node_modules",
+  "vendor",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  "target",
+  "__pycache__",
+]);
+
+export function buildProjectDiscoveryIndex(cwdInput: string, options: ProjectDiscoveryOptions = {}): ProjectDiscoveryIndex {
+  const cwd = path.resolve(cwdInput);
+  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  const maxChildrenPerDir = options.maxChildrenPerDir ?? DEFAULT_MAX_CHILDREN_PER_DIR;
+  const entries: DiscoveryEntry[] = [];
+  const ignoredDirs = new Set<string>();
+  let truncated = false;
+
+  const queue: Array<{ relativePath: string; depth: number }> = [{ relativePath: "", depth: 0 }];
+  while (queue.length > 0 && entries.length < maxEntries) {
+    const current = queue.shift()!;
+    const absolute = path.join(cwd, current.relativePath);
+    const children = safeReaddir(absolute).slice(0, maxChildrenPerDir);
+    if (children.length === maxChildrenPerDir) truncated = true;
+
+    for (const child of children) {
+      if (entries.length >= maxEntries) {
+        truncated = true;
+        break;
+      }
+      const relativePath = path.join(current.relativePath, child).replaceAll(path.sep, "/");
+      const childAbsolute = path.join(cwd, relativePath);
+      const stat = safeLstat(childAbsolute);
+      if (!stat) continue;
+      const type = entryType(stat);
+      const depth = current.depth + 1;
+      if (type === "dir" && IGNORED_DIRS.has(child)) {
+        ignoredDirs.add(relativePath);
+        continue;
+      }
+      const entry: DiscoveryEntry = {
+        path: relativePath,
+        type,
+        depth,
+        ...(type === "file" ? { ext: fileExt(child), sizeBytes: stat.size } : {}),
+        ...(type === "dir" ? { childCount: safeReaddir(childAbsolute).length } : {}),
+      };
+      entries.push(entry);
+      if (type === "dir" && depth < maxDepth) queue.push({ relativePath, depth });
+    }
+  }
+  if (queue.length > 0) truncated = true;
+
+  const files = entries.filter((entry) => entry.type === "file");
+  return {
+    version: 1,
+    createdAt: new Date().toISOString(),
+    cwd,
+    entries,
+    truncated,
+    ignoredDirs: [...ignoredDirs].sort(),
+    extensionHistogram: extensionHistogram(files),
+    shallowFiles: files.filter((entry) => entry.depth <= 2).map((entry) => entry.path).slice(0, 80),
+    instructionFiles: files.filter((entry) => isInstructionLike(entry.path)).map((entry) => entry.path).slice(0, 80),
+    configLikeFiles: files.filter((entry) => isConfigLike(entry.path)).map((entry) => entry.path).slice(0, 80),
+    testLikeFiles: files.filter((entry) => isTestLike(entry.path)).map((entry) => entry.path).slice(0, 80),
+  };
+}
+
+export function formatProjectDiscoveryIndex(index: ProjectDiscoveryIndex): string {
+  const dirs = index.entries.filter((entry) => entry.type === "dir").map((entry) => `${entry.path}/`).slice(0, 100);
+  const files = index.entries.filter((entry) => entry.type === "file").map((entry) => entry.path).slice(0, 160);
+  const histogram = Object.entries(index.extensionHistogram)
+    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+    .slice(0, 18)
+    .map(([ext, count]) => `${ext}:${count}`)
+    .join(", ");
+  return [
+    "Project discovery index (raw, non-semantic):",
+    `- cwd: ${index.cwd}`,
+    `- entries: ${index.entries.length}${index.truncated ? " (truncated)" : ""}`,
+    index.ignoredDirs.length ? `- ignored dirs: ${index.ignoredDirs.join(", ")}` : undefined,
+    histogram ? `- extension histogram: ${histogram}` : undefined,
+    dirs.length ? `- directories: ${dirs.join(", ")}` : undefined,
+    index.instructionFiles.length ? `- instruction/JIT files: ${index.instructionFiles.join(", ")}` : undefined,
+    index.shallowFiles.length ? `- shallow files: ${index.shallowFiles.join(", ")}` : undefined,
+    index.configLikeFiles.length ? `- config-like files: ${index.configLikeFiles.join(", ")}` : undefined,
+    index.testLikeFiles.length ? `- test-like files: ${index.testLikeFiles.join(", ")}` : undefined,
+    files.length ? `- sampled files: ${files.join(", ")}` : undefined,
+    "Guidance: treat this as an index only. For repositories with AGENTS.md/CONTEXT.md/JIT files, read the root instruction file and relevant package instruction files before broad code reads; then verify claims with the smallest evidence set.",
+  ].filter((line): line is string => Boolean(line)).join("\n");
+}
+
+function safeReaddir(dir: string): string[] {
+  try {
+    return fs.readdirSync(dir).sort((a, b) => a.localeCompare(b));
+  } catch {
+    return [];
+  }
+}
+
+function safeLstat(filePath: string): fs.Stats | undefined {
+  try {
+    return fs.lstatSync(filePath);
+  } catch {
+    return undefined;
+  }
+}
+
+function entryType(stat: fs.Stats): DiscoveryEntryType {
+  if (stat.isSymbolicLink()) return "symlink";
+  if (stat.isDirectory()) return "dir";
+  if (stat.isFile()) return "file";
+  return "other";
+}
+
+function fileExt(fileName: string): string {
+  const ext = path.extname(fileName).toLowerCase();
+  return ext || "[none]";
+}
+
+function extensionHistogram(files: DiscoveryEntry[]): Record<string, number> {
+  const result: Record<string, number> = {};
+  for (const file of files) result[file.ext ?? "[none]"] = (result[file.ext ?? "[none]"] ?? 0) + 1;
+  return result;
+}
+
+function isConfigLike(filePath: string): boolean {
+  const base = path.basename(filePath).toLowerCase();
+  return /(^|[.-])(config|rc|lock|workspace|manifest|project|settings|schema)([.-]|$)/.test(base)
+    || ["makefile", "dockerfile", "readme.md", "agents.md", "package.json", "go.mod", "cargo.toml", "pyproject.toml", "pom.xml", "build.gradle", "composer.json", "gemfile"].includes(base)
+    || /\.(ya?ml|toml|json|ini|env|properties)$/i.test(base);
+}
+
+function isInstructionLike(filePath: string): boolean {
+  const base = path.basename(filePath).toLowerCase();
+  return ["agents.md", "claude.md", "context.md"].includes(base)
+    || /(^|\/)(docs\/adr|adr)\//i.test(filePath)
+    || /(^|\/)\.agents\/skills\/readme\.md$/i.test(filePath);
+}
+
+function isTestLike(filePath: string): boolean {
+  return /(^|\/)(test|tests|spec|__tests__|e2e)(\/|$)/i.test(filePath)
+    || /(?:^|[._-])(test|spec)\.[a-z0-9]+$/i.test(path.basename(filePath));
+}

package/src/index.ts

@@ -0,0 +1,40 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerChalinAutoRouter } from "./autoroute.ts";
+import { hideLegacyTopLevelChildSessions } from "./child-sessions.ts";
+import { registerChalinCommands } from "./commands.ts";
+import { registerChalinTools } from "./tools.ts";
+import { setChalinStatus } from "./ui-status.ts";
+
+const PI_CHALIN_CHILD_ENV = "PI_CHALIN_CHILD";
+const PI_CHALIN_DISABLED_ENV = "PI_CHALIN_DISABLED";
+
+export default function registerPiChalin(pi: ExtensionAPI): void {
+  if (process.env[PI_CHALIN_CHILD_ENV] === "1" || process.env[PI_CHALIN_DISABLED_ENV] === "1") return;
+
+  registerChalinCommands(pi);
+  registerChalinTools(pi);
+  registerChalinAutoRouter(pi);
+
+  pi.on("session_start", (_event, ctx) => {
+    void hideLegacyTopLevelChildSessions(ctx).then((result) => {
+      if (ctx.hasUI && result.moved.length > 0) {
+        ctx.ui.notify(`pi-chalin hid ${result.moved.length} legacy child session(s) from Pi resume.`, "info");
+      }
+    }).catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`pi-chalin legacy child session cleanup failed: ${message}`);
+    });
+    if (!ctx.hasUI) return;
+    setChalinStatus(ctx, { kind: "idle" });
+  });
+}
+
+export { PI_CHALIN_CHILD_ENV, PI_CHALIN_DISABLED_ENV };
+export { AgentCatalog, parseFrontmatter } from "./agents.ts";
+export { ArtifactStore } from "./artifacts.ts";
+export { DEFAULT_CONFIG, approvalDecision, loadEffectiveConfig, setAgentModelOverride, setAgentThinkingOverride, writeProjectConfig, writeUserConfig } from "./config.ts";
+export { ChalinKernel } from "./kernel.ts";
+export { MemoryStore, createMemoryCandidate } from "./memory.ts";
+export { MockWorkerRunner, SdkWorkerRunner, parseAgentOutput } from "./runner.ts";
+export { resolveChalinPaths } from "./paths.ts";
+export type { AgentDefinition, AgentMemoryPolicy, AgentThinkingLevel, RouteDecision, RoutePlan, RunState, MemoryCandidate, MemoryRecord } from "./schemas.ts";