@research-copilot/core 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ldm2060
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,235 @@
+declare const KINDS: readonly ["literature", "ideation", "experiment", "writing", "polish", "review", "rebuttal"];
+type Kind = (typeof KINDS)[number];
+declare const STATUSES: readonly ["planning", "in_progress", "verify", "completed"];
+type Status = (typeof STATUSES)[number];
+type Priority = "P0" | "P1" | "P2" | "P3";
+interface Gap {
+    desc: string;
+    suggest_kind: Kind;
+    status: "open" | "resolved";
+}
+interface TaskRecord {
+    id: string;
+    title: string;
+    kind: Kind;
+    status: Status;
+    priority: Priority;
+    venue?: string;
+    parent?: string;
+    children: string[];
+    depends_on: string[];
+    gaps: Gap[];
+    branch?: string;
+    created: string;
+    updated: string;
+}
+declare function isKind(x: string): x is Kind;
+
+interface ResearchPaths {
+    root: string;
+    tasks: string;
+    spec: string;
+    workspace: string;
+    runtime: string;
+    workflow: string;
+    config: string;
+    activeTask: string;
+    graphIndex: string;
+    taskDir(id: string): string;
+}
+declare function researchPaths(repoRoot: string): ResearchPaths;
+
+declare function slugify(title: string): string;
+interface CreateInput {
+    title: string;
+    kind: Kind;
+    date: string;
+    priority?: Priority;
+    venue?: string;
+    parent?: string;
+    now?: string;
+}
+declare function createTask(repo: string, input: CreateInput): TaskRecord;
+declare function taskJsonPath(repo: string, id: string): string;
+declare function writeTask(repo: string, task: TaskRecord, now?: string): void;
+declare function readTask(repo: string, id: string): TaskRecord;
+declare function listTasks(repo: string): TaskRecord[];
+declare function setStatus(repo: string, id: string, to: Status, now: string): void;
+
+declare const TRANSITIONS: Record<Status, Status[]>;
+declare function nextStatuses(from: Status): Status[];
+declare function canTransition(from: Status, to: Status): boolean;
+declare function assertTransition(from: Status, to: Status): void;
+
+interface GraphNode {
+    task: TaskRecord;
+    blocked: boolean;
+    dependents: string[];
+}
+type Graph = Map<string, GraphNode>;
+declare function buildGraph(tasks: TaskRecord[]): Graph;
+
+interface Recommendation {
+    action: "resume" | "create";
+    taskId?: string;
+    suggestKind?: Kind;
+    reason: string;
+    sourceGap?: string;
+    score: number;
+}
+interface ResearchState {
+    active: {
+        id: string;
+        kind: Kind;
+        status: Status;
+    } | null;
+    graph: {
+        completed: number;
+        in_progress: number;
+        blocked: number;
+        planning: number;
+    };
+    openGaps: {
+        taskId: string;
+        desc: string;
+        suggest_kind: Kind;
+    }[];
+    recommendations: Recommendation[];
+    turnTs: string;
+}
+declare function computeResearchState(tasks: TaskRecord[], now: string, activeId?: string): ResearchState;
+
+declare function extractWorkflowState(md: string, state: Status | "no_task"): string | null;
+
+type Phase = "execute" | "verify";
+interface ContextRef {
+    type: "spec" | "context";
+    path: string;
+    reason: string;
+}
+interface VerifyRow {
+    check: string;
+    kind: string;
+    args?: Record<string, unknown>;
+}
+declare function readPrdGoal(repo: string, id: string): string | null;
+declare function appendContext(repo: string, id: string, phase: Phase, row: ContextRef | VerifyRow): void;
+declare function readContext(repo: string, id: string, phase: Phase): unknown[];
+
+interface CheckResult {
+    ok: boolean;
+    missing: string[];
+}
+declare function numberTraceability(draft: string, artifactsText: string): CheckResult;
+declare function citationCompliance(tex: string, bibtex: string): CheckResult;
+
+declare function setActive(repo: string, id: string): void;
+declare function getActive(repo: string): string | null;
+
+interface BuildOptions {
+    format: "text" | "json";
+    now: string;
+    eventName?: string;
+}
+declare function renderResearchState(rs: ResearchState): string;
+declare function buildContext(repo: string, opts: BuildOptions): string;
+
+/**
+ * Skillpack manifest schema
+ *
+ * A skillpack is a git repository containing:
+ * - agents/*.md (agent definitions)
+ * - specs/*.md (task specifications)
+ * - meta.yaml (pack metadata)
+ */
+interface SkillpackManifest {
+    /** Pack identifier (kebab-case) */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** Git repository URL */
+    source: string;
+    /** Version constraint (git tag/branch, semver-style) */
+    version?: string;
+    /** Whether this pack is enabled by default */
+    enabled?: boolean;
+}
+interface SkillpacksYaml {
+    /** List of available skillpacks */
+    packs: SkillpackManifest[];
+}
+/**
+ * Resolved skillpack with local filesystem path
+ */
+interface ResolvedSkillpack extends SkillpackManifest {
+    /** Local cache path where pack is stored */
+    localPath: string;
+    /** Resolved git ref (commit SHA) */
+    resolvedRef: string;
+}
+
+/**
+ * Parse skillpacks.yaml file
+ *
+ * @param path - Path to skillpacks.yaml
+ * @returns Parsed skillpacks manifest
+ * @throws If file doesn't exist or YAML is invalid
+ */
+declare function parseSkillpacks(path: string): SkillpacksYaml;
+
+/**
+ * Resolve and fetch skillpacks to local cache
+ *
+ * @param packs - List of pack manifests from skillpacks.yaml
+ * @param cacheDir - Directory to store cached packs (e.g., ~/.cache/research-copilot/skillpacks)
+ * @returns List of resolved packs with local paths
+ */
+declare function resolveSkillpacks(packs: SkillpackManifest[], cacheDir: string): ResolvedSkillpack[];
+/**
+ * Remove cached skillpack
+ *
+ * @param packName - Name of pack to remove
+ * @param cacheDir - Cache directory
+ */
+declare function removeSkillpack(packName: string, cacheDir: string): void;
+
+/**
+ * Lock file entry for a synced skillpack
+ */
+interface SkillpackLockEntry {
+    name: string;
+    source: string;
+    resolvedRef: string;
+    syncedAt: string;
+    agentCount: number;
+    specCount: number;
+}
+interface SkillpackLock {
+    syncedAt: string;
+    packs: SkillpackLockEntry[];
+}
+/**
+ * Sync skillpacks from skillpacks.yaml to target directory
+ *
+ * @param repoRoot - Repository root (where skillpacks.yaml lives)
+ * @param cacheDir - Cache directory for cloned packs
+ * @param targetDir - Target directory to write agents/specs (e.g., research-kit/)
+ * @returns Lock data recording what was synced
+ */
+declare function syncSkillpacks(repoRoot: string, cacheDir: string, targetDir: string): SkillpackLock;
+/**
+ * Write skillpacks lock file
+ *
+ * @param lockPath - Path to skillpacks.lock.yaml
+ * @param lock - Lock data
+ */
+declare function writeLockFile(lockPath: string, lock: SkillpackLock): void;
+/**
+ * Read skillpacks lock file
+ *
+ * @param lockPath - Path to skillpacks.lock.yaml
+ * @returns Lock data, or null if file doesn't exist
+ */
+declare function readLockFile(lockPath: string): SkillpackLock | null;
+
+export { type BuildOptions, type CheckResult, type ContextRef, type CreateInput, type Gap, type Graph, type GraphNode, KINDS, type Kind, type Phase, type Priority, type Recommendation, type ResearchPaths, type ResearchState, type ResolvedSkillpack, STATUSES, type SkillpackLock, type SkillpackLockEntry, type SkillpackManifest, type SkillpacksYaml, type Status, TRANSITIONS, type TaskRecord, type VerifyRow, appendContext, assertTransition, buildContext, buildGraph, canTransition, citationCompliance, computeResearchState, createTask, extractWorkflowState, getActive, isKind, listTasks, nextStatuses, numberTraceability, parseSkillpacks, readContext, readLockFile, readPrdGoal, readTask, removeSkillpack, renderResearchState, researchPaths, resolveSkillpacks, setActive, setStatus, slugify, syncSkillpacks, taskJsonPath, writeLockFile, writeTask };

package/dist/index.js

@@ -0,0 +1,463 @@
+// src/types.ts
+var KINDS = [
+  "literature",
+  "ideation",
+  "experiment",
+  "writing",
+  "polish",
+  "review",
+  "rebuttal"
+];
+var STATUSES = ["planning", "in_progress", "verify", "completed"];
+function isKind(x) {
+  return KINDS.includes(x);
+}
+
+// src/paths.ts
+import * as path from "path";
+function researchPaths(repoRoot) {
+  const root = path.join(repoRoot, ".research");
+  const runtime = path.join(root, ".runtime");
+  return {
+    root,
+    tasks: path.join(root, "tasks"),
+    spec: path.join(root, "spec"),
+    workspace: path.join(root, "workspace"),
+    runtime,
+    workflow: path.join(root, "workflow.md"),
+    config: path.join(root, "config.yaml"),
+    activeTask: path.join(runtime, "active-task"),
+    graphIndex: path.join(runtime, "graph-index.json"),
+    taskDir: (id) => path.join(root, "tasks", id)
+  };
+}
+
+// src/task-store.ts
+import * as fs from "fs";
+import * as path2 from "path";
+
+// src/lifecycle.ts
+var TRANSITIONS = {
+  planning: ["in_progress"],
+  in_progress: ["verify"],
+  verify: ["in_progress", "completed"],
+  completed: []
+};
+function nextStatuses(from) {
+  return TRANSITIONS[from];
+}
+function canTransition(from, to) {
+  return TRANSITIONS[from].includes(to);
+}
+function assertTransition(from, to) {
+  if (!canTransition(from, to)) {
+    throw new Error(`illegal transition: ${from} -> ${to} (allowed: ${TRANSITIONS[from].join(", ") || "none"})`);
+  }
+}
+
+// src/task-store.ts
+function slugify(title) {
+  return title.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+}
+function createTask(repo, input) {
+  const id = `${input.date}-${slugify(input.title)}`;
+  const now = input.now ?? input.date + "T00:00:00Z";
+  const task = {
+    id,
+    title: input.title,
+    kind: input.kind,
+    status: "planning",
+    priority: input.priority ?? "P2",
+    venue: input.venue,
+    parent: input.parent,
+    children: [],
+    depends_on: [],
+    gaps: [],
+    created: now,
+    updated: now
+  };
+  writeTask(repo, task, now);
+  return task;
+}
+function taskJsonPath(repo, id) {
+  return path2.join(researchPaths(repo).taskDir(id), "task.json");
+}
+function writeTask(repo, task, now) {
+  if (now) task.updated = now;
+  const dir2 = researchPaths(repo).taskDir(task.id);
+  fs.mkdirSync(path2.join(dir2, "research"), { recursive: true });
+  fs.mkdirSync(path2.join(dir2, "artifacts"), { recursive: true });
+  fs.writeFileSync(taskJsonPath(repo, task.id), JSON.stringify(task, null, 2) + "\n", "utf8");
+}
+function readTask(repo, id) {
+  return JSON.parse(fs.readFileSync(taskJsonPath(repo, id), "utf8"));
+}
+function listTasks(repo) {
+  const dir2 = researchPaths(repo).tasks;
+  if (!fs.existsSync(dir2)) return [];
+  return fs.readdirSync(dir2).filter((id) => fs.existsSync(taskJsonPath(repo, id))).map((id) => readTask(repo, id));
+}
+function setStatus(repo, id, to, now) {
+  const t = readTask(repo, id);
+  assertTransition(t.status, to);
+  t.status = to;
+  writeTask(repo, t, now);
+}
+
+// src/graph.ts
+function buildGraph(tasks) {
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  const g = /* @__PURE__ */ new Map();
+  for (const t of tasks) {
+    const blocked = t.depends_on.some((d) => byId.get(d)?.status !== "completed");
+    g.set(t.id, { task: t, blocked, dependents: [] });
+  }
+  for (const t of tasks) {
+    for (const d of t.depends_on) {
+      g.get(d)?.dependents.push(t.id);
+    }
+  }
+  return g;
+}
+
+// src/research-state.ts
+var PRIORITY_RANK = { P0: 3, P1: 2, P2: 1, P3: 0 };
+var LIFECYCLE_BONUS = { in_progress: 2, verify: 1, planning: 0.5, completed: 0 };
+var W = { priority: 3, unblocking: 2, lifecycle: 1, age: 1e-3 };
+var MAX_RECS = 3;
+function computeResearchState(tasks, now, activeId) {
+  const g = buildGraph(tasks);
+  const counts = { completed: 0, in_progress: 0, blocked: 0, planning: 0 };
+  for (const n of g.values()) {
+    if (n.blocked) counts.blocked++;
+    if (n.task.status === "completed") counts.completed++;
+    else if (n.task.status === "in_progress") counts.in_progress++;
+    else if (n.task.status === "planning") counts.planning++;
+  }
+  const openGaps = tasks.flatMap((t) => t.gaps.filter((gp) => gp.status === "open").map((gp) => ({ taskId: t.id, desc: gp.desc, suggest_kind: gp.suggest_kind })));
+  const ageDays = (iso) => Math.max(0, (Date.parse(now) - Date.parse(iso)) / 864e5);
+  const recs = [];
+  for (const n of g.values()) {
+    if (n.task.status === "completed" || n.blocked) continue;
+    const score = W.priority * PRIORITY_RANK[n.task.priority] + W.lifecycle * LIFECYCLE_BONUS[n.task.status] + W.age * ageDays(n.task.updated);
+    recs.push({
+      action: "resume",
+      taskId: n.task.id,
+      score,
+      reason: `resume ${n.task.kind} task ${n.task.id} (${n.task.status})`
+    });
+  }
+  for (const t of tasks) {
+    const dependents = g.get(t.id)?.dependents.length ?? 0;
+    for (const gp of t.gaps.filter((x) => x.status === "open")) {
+      const score = W.priority * PRIORITY_RANK[t.priority] + W.unblocking * dependents + W.lifecycle * LIFECYCLE_BONUS[t.status];
+      recs.push({
+        action: "create",
+        suggestKind: gp.suggest_kind,
+        sourceGap: gp.desc,
+        score,
+        reason: `create ${gp.suggest_kind} task to resolve "${gp.desc}" (from ${t.id})`
+      });
+    }
+  }
+  recs.sort((x, y) => y.score - x.score || (x.taskId ?? x.sourceGap ?? "").localeCompare(y.taskId ?? y.sourceGap ?? ""));
+  const active = activeId ? (() => {
+    const n = g.get(activeId);
+    return n ? { id: n.task.id, kind: n.task.kind, status: n.task.status } : null;
+  })() : null;
+  return { active, graph: counts, openGaps, recommendations: recs.slice(0, MAX_RECS), turnTs: now };
+}
+
+// src/workflow.ts
+function extractWorkflowState(md, state) {
+  const re = new RegExp(
+    `\\[workflow-state:${state}\\]\\r?\\n([\\s\\S]*?)\\r?\\n\\[/workflow-state\\]`
+  );
+  const m = md.match(re);
+  return m ? m[1].trim() : null;
+}
+
+// src/artifacts.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+function dir(repo, id) {
+  return researchPaths(repo).taskDir(id);
+}
+function readPrdGoal(repo, id) {
+  const p = path3.join(dir(repo, id), "prd.md");
+  if (!fs2.existsSync(p)) return null;
+  const md = fs2.readFileSync(p, "utf8");
+  const m = md.match(/##\s*Goal\s*\r?\n([\s\S]*?)(\r?\n\s*\r?\n|\r?\n##|$)/);
+  return m ? m[1].trim() : null;
+}
+function appendContext(repo, id, phase, row) {
+  const p = path3.join(dir(repo, id), `${phase}.jsonl`);
+  fs2.appendFileSync(p, JSON.stringify(row) + "\n", "utf8");
+}
+function readContext(repo, id, phase) {
+  const p = path3.join(dir(repo, id), `${phase}.jsonl`);
+  if (!fs2.existsSync(p)) return [];
+  return fs2.readFileSync(p, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
+}
+
+// src/verify.ts
+var NUMBER_RE = /-?\d+(?:\.\d+)?/g;
+var norm = (s) => s.replace(/^(-?)0+(\d)/, "$1$2");
+function numberTraceability(draft, artifactsText) {
+  const present = new Set((artifactsText.match(NUMBER_RE) ?? []).map(norm));
+  const missing = [];
+  for (const tok of draft.match(NUMBER_RE) ?? []) {
+    if (!present.has(norm(tok)) && !missing.includes(tok)) missing.push(tok);
+  }
+  return { ok: missing.length === 0, missing };
+}
+function citationCompliance(tex, bibtex) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const m of bibtex.matchAll(/@\w+\s*\{\s*([^,\s}]+)/g)) keys.add(m[1]);
+  const missing = [];
+  for (const m of tex.matchAll(/\\cite[a-zA-Z]*(?:\[[^\]]*\])*\{([^}]*)\}/g)) {
+    for (const key of m[1].split(",").map((k) => k.trim()).filter(Boolean)) {
+      if (!keys.has(key) && !missing.includes(key)) missing.push(key);
+    }
+  }
+  return { ok: missing.length === 0, missing };
+}
+
+// src/active.ts
+import * as fs3 from "fs";
+function setActive(repo, id) {
+  const p = researchPaths(repo);
+  fs3.mkdirSync(p.runtime, { recursive: true });
+  fs3.writeFileSync(p.activeTask, id, "utf8");
+}
+function getActive(repo) {
+  const p = researchPaths(repo).activeTask;
+  return fs3.existsSync(p) ? fs3.readFileSync(p, "utf8").trim() || null : null;
+}
+
+// src/context.ts
+import * as fs4 from "fs";
+function renderResearchState(rs) {
+  const lines = ["[research-state]"];
+  lines.push(`Active: ${rs.active ? `${rs.active.id} (${rs.active.kind}, ${rs.active.status})` : "none"}`);
+  lines.push(`Graph: ${rs.graph.completed} completed \xB7 ${rs.graph.in_progress} in_progress \xB7 ${rs.graph.blocked} blocked`);
+  if (rs.openGaps.length) {
+    lines.push("Open gaps:");
+    for (const g of rs.openGaps) lines.push(`  - [from ${g.taskId}] ${g.desc} -> suggests: ${g.suggest_kind}`);
+  }
+  if (rs.recommendations.length) {
+    lines.push("Recommended next (you decide, nothing auto-created):");
+    rs.recommendations.forEach((r, i) => lines.push(`  ${i + 1}. ${r.reason}`));
+  }
+  lines.push(`turn-ts: ${rs.turnTs}`);
+  return lines.join("\n");
+}
+function buildContext(repo, opts) {
+  const tasks = listTasks(repo);
+  const active = getActive(repo) ?? void 0;
+  const activeStatus = active ? tasks.find((t) => t.id === active)?.status : void 0;
+  const rs = computeResearchState(tasks, opts.now, active);
+  const wfPath = researchPaths(repo).workflow;
+  const wfMd = fs4.existsSync(wfPath) ? fs4.readFileSync(wfPath, "utf8") : "";
+  const stateKey = activeStatus ?? "no_task";
+  const wfBlock = extractWorkflowState(wfMd, stateKey) ?? "Refer to workflow.md for current step.";
+  const text = `[workflow-state:${stateKey}]
+${wfBlock}
+[/workflow-state]
+
+${renderResearchState(rs)}`;
+  if (opts.format === "json") {
+    return JSON.stringify({
+      hookSpecificOutput: { hookEventName: opts.eventName ?? "UserPromptSubmit", additionalContext: text }
+    });
+  }
+  return text;
+}
+
+// src/parse-skillpacks.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { parse as parseYaml } from "yaml";
+function parseSkillpacks(path4) {
+  const content = readFileSync5(path4, "utf-8");
+  const data = parseYaml(content);
+  if (!data || typeof data !== "object") {
+    throw new Error("skillpacks.yaml must be an object");
+  }
+  if (!Array.isArray(data.packs)) {
+    throw new Error("skillpacks.yaml must have 'packs' array");
+  }
+  for (const pack of data.packs) {
+    if (!pack.name || typeof pack.name !== "string") {
+      throw new Error("Each pack must have a 'name' string");
+    }
+    if (!pack.source || typeof pack.source !== "string") {
+      throw new Error(`Pack '${pack.name}' must have a 'source' URL`);
+    }
+  }
+  return data;
+}
+
+// src/resolve-skillpacks.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, rmSync } from "fs";
+import { join as join4 } from "path";
+function resolveSkillpacks(packs, cacheDir) {
+  mkdirSync3(cacheDir, { recursive: true });
+  const resolved = [];
+  for (const pack of packs) {
+    const packDir = join4(cacheDir, pack.name);
+    if (!existsSync5(packDir)) {
+      console.error(`[skillpacks] Cloning ${pack.name} from ${pack.source}...`);
+      execSync(`git clone "${pack.source}" "${packDir}"`, {
+        stdio: "inherit",
+        encoding: "utf-8"
+      });
+    } else {
+      console.error(`[skillpacks] Updating ${pack.name}...`);
+      execSync(`git fetch origin`, {
+        cwd: packDir,
+        stdio: "inherit",
+        encoding: "utf-8"
+      });
+    }
+    const ref = pack.version || "main";
+    try {
+      execSync(`git checkout "${ref}"`, {
+        cwd: packDir,
+        stdio: "pipe",
+        encoding: "utf-8"
+      });
+      if (!pack.version) {
+        execSync(`git pull origin "${ref}"`, {
+          cwd: packDir,
+          stdio: "pipe",
+          encoding: "utf-8"
+        });
+      }
+    } catch (err) {
+      throw new Error(`Failed to checkout ${ref} for pack ${pack.name}: ${err}`);
+    }
+    const resolvedRef = execSync("git rev-parse HEAD", {
+      cwd: packDir,
+      encoding: "utf-8"
+    }).trim();
+    resolved.push({
+      ...pack,
+      localPath: packDir,
+      resolvedRef
+    });
+  }
+  return resolved;
+}
+function removeSkillpack(packName, cacheDir) {
+  const packDir = join4(cacheDir, packName);
+  if (existsSync5(packDir)) {
+    rmSync(packDir, { recursive: true, force: true });
+  }
+}
+
+// src/sync-skillpacks.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync3, copyFileSync } from "fs";
+import { join as join5 } from "path";
+import { stringify as stringifyYaml, parse as parseYaml2 } from "yaml";
+function syncSkillpacks(repoRoot, cacheDir, targetDir) {
+  const yamlPath = join5(repoRoot, "skillpacks.yaml");
+  if (!existsSync6(yamlPath)) {
+    throw new Error(`skillpacks.yaml not found at ${yamlPath}`);
+  }
+  const manifest = parseSkillpacks(yamlPath);
+  const enabledPacks = manifest.packs.filter((p) => p.enabled !== false);
+  if (enabledPacks.length === 0) {
+    console.error("[sync] No enabled packs found in skillpacks.yaml");
+    return { syncedAt: (/* @__PURE__ */ new Date()).toISOString(), packs: [] };
+  }
+  const resolved = resolveSkillpacks(enabledPacks, cacheDir);
+  const agentsDir = join5(targetDir, "agents");
+  const specsDir = join5(targetDir, "specs");
+  mkdirSync4(agentsDir, { recursive: true });
+  mkdirSync4(specsDir, { recursive: true });
+  const lockEntries = [];
+  for (const pack of resolved) {
+    let agentCount = 0;
+    let specCount = 0;
+    const packAgentsDir = join5(pack.localPath, "agents");
+    if (existsSync6(packAgentsDir)) {
+      const agents = readdirSync2(packAgentsDir).filter((f) => f.endsWith(".md"));
+      for (const agent of agents) {
+        const src = join5(packAgentsDir, agent);
+        const dest = join5(agentsDir, agent);
+        copyFileSync(src, dest);
+        agentCount++;
+      }
+    }
+    const packSpecsDir = join5(pack.localPath, "specs");
+    if (existsSync6(packSpecsDir)) {
+      const specs = readdirSync2(packSpecsDir).filter((f) => f.endsWith(".md"));
+      for (const spec of specs) {
+        const src = join5(packSpecsDir, spec);
+        const dest = join5(specsDir, spec);
+        copyFileSync(src, dest);
+        specCount++;
+      }
+    }
+    lockEntries.push({
+      name: pack.name,
+      source: pack.source,
+      resolvedRef: pack.resolvedRef,
+      syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      agentCount,
+      specCount
+    });
+    console.error(`[sync] ${pack.name}: ${agentCount} agents, ${specCount} specs`);
+  }
+  return {
+    syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    packs: lockEntries
+  };
+}
+function writeLockFile(lockPath, lock) {
+  const yaml = stringifyYaml(lock);
+  writeFileSync3(lockPath, yaml, "utf-8");
+}
+function readLockFile(lockPath) {
+  if (!existsSync6(lockPath)) {
+    return null;
+  }
+  const content = readFileSync6(lockPath, "utf-8");
+  return parseYaml2(content);
+}
+export {
+  KINDS,
+  STATUSES,
+  TRANSITIONS,
+  appendContext,
+  assertTransition,
+  buildContext,
+  buildGraph,
+  canTransition,
+  citationCompliance,
+  computeResearchState,
+  createTask,
+  extractWorkflowState,
+  getActive,
+  isKind,
+  listTasks,
+  nextStatuses,
+  numberTraceability,
+  parseSkillpacks,
+  readContext,
+  readLockFile,
+  readPrdGoal,
+  readTask,
+  removeSkillpack,
+  renderResearchState,
+  researchPaths,
+  resolveSkillpacks,
+  setActive,
+  setStatus,
+  slugify,
+  syncSkillpacks,
+  taskJsonPath,
+  writeLockFile,
+  writeTask
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@research-copilot/core",
+  "version": "1.0.0",
+  "description": "Core library for research-copilot",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "research",
+    "copilot",
+    "ai"
+  ],
+  "author": "ldm2060",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ldm2060/research_copilot.git",
+    "directory": "packages/core"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "yaml": "^2.6.0",
+    "zod": "^3.23.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts"
+  }
+}