@trycedar/argus 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+## 0.1.0 - 2026-05-13
+
+Initial dogfood release candidate. Published as `@trycedar/argus` (codename Argus). The CLI binary is `proactive` in this release and will be renamed to `argus` in 0.2.0.
+
+### Added
+
+- `proactive` CLI package skeleton.
+- Workspace initialization with `proactive init`.
+- CEO instruction capture with `proactive ceo`.
+- Task, agent, inbox, and event listing/management commands.
+- Local-first Markdown/frontmatter workspace models.
+- Append-only JSONL event log.
+- Agent wake planning and bounded agent runner.
+- Codex provider behind an `AIProvider` abstraction.
+- Stub provider with self-dogfood and property-management scenarios.
+- Dry-run previews, duplicate action detection, and one-agent default for write-producing runs.
+- Human inbox approve/reject flow.
+- Property-management demo workspace under `demos/property-management`.
+
+### Safety
+
+- Comment actions enforce `can_comment` permissions.
+- Artifact creation refuses to overwrite existing files.
+- Scanner emits deletion events for tracked workspace files.
+- CI validation sets up Node and pnpm before running checks.

package/README.md

@@ -0,0 +1,120 @@
+# Proactive AI
+
+> A Git-native agentic organization framework where a human CEO directs proactive role agents that create tasks, produce artifacts, request approvals, and help build software products.
+
+## Vision
+
+Proactive AI is not multi-agent chat. It is a local-first company workspace where agents participate proactively in software development.
+
+- The human is the CEO.
+- Agents have roles, responsibilities, permissions, and wake triggers.
+- Memory lives in version-controlled Markdown artifacts.
+- Tasks are Markdown files with structured frontmatter.
+- Human approvals flow through an inbox.
+- Events are appended to an audit log.
+- Codex is the default AI provider for v0.
+
+## Current status
+
+This repository has an initial v0 CLI/runtime foundation and dogfoods Proactive AI against itself. `0.1.0` is a local-first release candidate; publishing still requires explicit human approval.
+
+Key docs:
+
+- `docs/prd-v0.md`
+- `docs/technical-design-v0.md`
+- `docs/architecture-v0.md`
+- `docs/self-hosting-and-release.md`
+- `docs/agent-system-and-harness.md`
+- `docs/pi-project-template-evaluation.md`
+
+## Dogfood workspace
+
+This repo includes the initial Proactive AI workspace structure:
+
+```text
+.proactive/
+company/
+tasks/
+artifacts/
+comments/
+inbox/
+events/
+agents/
+```
+
+The workspace tracks the development of Proactive AI itself.
+
+## Development harness
+
+This repo uses `pi-project-template` conventions:
+
+- `AGENTS.md` — hard rules for agents
+- `docs/memory/` — short/long-term shared memory
+- `docs/plans/` — active plans
+- `docs/records/` — completed records
+- `docs/decisions/` — ADRs
+- `docs/log.md` — append-only change log
+- `.github/workflows/codex.yml` — Codex issue pickup workflow
+- `scripts/validate.sh` — merge validation contract
+
+## Install
+
+From source:
+
+```bash
+pnpm install
+pnpm build
+pnpm link --global
+proactive --help
+```
+
+After npm publication:
+
+```bash
+npm install -g @trycedar/argus
+proactive --help
+```
+
+## CLI
+
+The initial CLI/runtime foundation is implemented.
+
+```bash
+pnpm install
+pnpm exec tsx src/cli/index.ts init demo-company
+pnpm exec tsx src/cli/index.ts ceo "Build a property management SaaS"
+pnpm exec tsx src/cli/index.ts run --no-ai
+pnpm exec tsx src/cli/index.ts run --provider stub
+pnpm exec tsx src/cli/index.ts tasks
+pnpm exec tsx src/cli/index.ts inbox
+pnpm exec tsx src/cli/index.ts approve <item-id> --response "Approved"
+pnpm exec tsx src/cli/index.ts reject <item-id> --response "Rejected"
+pnpm exec tsx src/cli/index.ts agents
+```
+
+`proactive run --no-ai` scans the workspace and plans agent wakeups without invoking Codex. `proactive run --provider stub` performs a controlled dogfood run with deterministic stubbed agent output. Running without `--no-ai` uses the default `CodexProvider`, which shells out to `codex exec`; set `PROACTIVE_CODEX_COMMAND` if the executable name differs.
+
+## Property-management demo
+
+A deterministic external demo workspace lives at `demos/property-management`.
+
+To recreate it:
+
+```bash
+rm -rf demos/property-management
+pnpm build
+pnpm exec tsx src/cli/index.ts init property-management-demo --root demos/property-management
+cd demos/property-management
+node ../../dist/index.js ceo "We are building property management software for landlords, property managers, and tenants. Find the best MVP."
+node ../../dist/index.js run --no-ai
+node ../../dist/index.js run --provider stub --scenario property-management --max-agents 4
+node ../../dist/index.js run --provider stub --scenario property-management --max-agents 4
+```
+
+Expected outputs include property-management MVP tasks, an engineering feasibility artifact, and a CEO decision request.
+
+## Validation
+
+```bash
+./scripts/validate.sh --check
+```

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,1188 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+import path12 from "path";
+import { mkdir as mkdir6, readFile as readFile9, writeFile as writeFile7 } from "fs/promises";
+
+// src/workspace/init.ts
+import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
+import path3 from "path";
+import YAML from "yaml";
+
+// src/markdown/frontmatter.ts
+import matter from "gray-matter";
+function parseMarkdown(raw, parseData) {
+  const parsed = matter(raw);
+  return {
+    data: parseData(parsed.data),
+    content: parsed.content.trimStart()
+  };
+}
+function stringifyMarkdown(data, content) {
+  return matter.stringify(content.trimStart(), dropUndefined(data)).trimEnd() + "\n";
+}
+function dropUndefined(data) {
+  return Object.fromEntries(
+    Object.entries(data).filter(([, value]) => value !== void 0)
+  );
+}
+
+// src/events/event-log.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+
+// src/schemas/entities.ts
+import { z } from "zod";
+var dateStringSchema = z.preprocess((value) => {
+  if (value instanceof Date) return value.toISOString();
+  return value;
+}, z.string().min(1));
+var taskStatusSchema = z.enum([
+  "backlog",
+  "ready",
+  "in_progress",
+  "review",
+  "done",
+  "blocked",
+  "cancelled"
+]);
+var prioritySchema = z.enum(["low", "medium", "high", "critical"]);
+var agentSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  role: z.string().min(1),
+  status: z.enum(["active", "paused"]).default("active"),
+  wake_triggers: z.array(z.string()).default([]),
+  can_edit: z.array(z.string()).default([]),
+  can_comment: z.array(z.string()).default([]),
+  requires_approval: z.array(z.string()).default([])
+});
+var taskSchema = z.object({
+  id: z.string().min(1),
+  title: z.string().min(1),
+  status: taskStatusSchema,
+  priority: prioritySchema.default("medium"),
+  owner: z.string().optional(),
+  created_by: z.string().min(1),
+  created_at: dateStringSchema,
+  updated_at: dateStringSchema,
+  mentions: z.array(z.string()).default([]),
+  depends_on: z.array(z.string()).default([]),
+  artifacts: z.array(z.string()).default([]),
+  approval_required: z.boolean().default(false),
+  reviewer: z.string().optional()
+});
+var inboxItemSchema = z.object({
+  id: z.string().min(1),
+  type: z.enum(["decision_request", "approval_request", "digest"]),
+  status: z.enum(["awaiting_human", "approved", "rejected", "closed"]),
+  priority: prioritySchema.default("medium"),
+  requested_by: z.string().min(1),
+  related_task: z.string().optional(),
+  related_artifacts: z.array(z.string()).default([]),
+  created_at: dateStringSchema,
+  updated_at: dateStringSchema.optional()
+});
+var eventSchema = z.object({
+  id: z.string().min(1),
+  type: z.string().min(1),
+  actor: z.string().min(1),
+  timestamp: dateStringSchema,
+  summary: z.string().min(1),
+  task: z.string().optional(),
+  files: z.array(z.string()).optional()
+});
+var workspaceStateSchema = z.object({
+  last_event_id: z.string().default("evt-000"),
+  last_scan_at: dateStringSchema.default(""),
+  file_hashes: z.record(z.string(), z.string()).default({}),
+  next_ids: z.object({
+    task: z.number().int().positive().default(1),
+    event: z.number().int().positive().default(1),
+    decision: z.number().int().positive().default(1),
+    approval: z.number().int().positive().default(1)
+  })
+});
+
+// src/events/event-log.ts
+function formatEventId(next) {
+  return `evt-${String(next).padStart(3, "0")}`;
+}
+async function appendEvent(workspaceRoot, event) {
+  const eventPath = path.join(workspaceRoot, "events", "events.jsonl");
+  await mkdir(path.dirname(eventPath), { recursive: true });
+  const parsed = eventSchema.parse(event);
+  await writeFile(eventPath, `${JSON.stringify(parsed)}
+`, { flag: "a" });
+}
+async function readEvents(workspaceRoot) {
+  const eventPath = path.join(workspaceRoot, "events", "events.jsonl");
+  try {
+    const raw = await readFile(eventPath, "utf8");
+    return raw.split("\n").filter(Boolean).map((line) => eventSchema.parse(JSON.parse(line)));
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+
+// src/workspace/state.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
+function initialState() {
+  return {
+    last_event_id: "evt-001",
+    last_scan_at: (/* @__PURE__ */ new Date(0)).toISOString(),
+    file_hashes: {},
+    next_ids: { task: 1, event: 2, decision: 1, approval: 1 }
+  };
+}
+async function readState(workspaceRoot) {
+  const statePath = path2.join(workspaceRoot, ".proactive", "state.json");
+  try {
+    return workspaceStateSchema.parse(
+      JSON.parse(await readFile2(statePath, "utf8"))
+    );
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return initialState();
+    throw error;
+  }
+}
+async function writeState(workspaceRoot, state) {
+  const statePath = path2.join(workspaceRoot, ".proactive", "state.json");
+  await writeFile2(
+    statePath,
+    `${JSON.stringify(workspaceStateSchema.parse(state), null, 2)}
+`
+  );
+}
+function allocateId(state, kind, prefix) {
+  const id = `${prefix}-${String(state.next_ids[kind]).padStart(3, "0")}`;
+  state.next_ids[kind] += 1;
+  return id;
+}
+
+// src/workspace/templates.ts
+var defaultAgents = [
+  {
+    filename: "chief-of-staff-agent.md",
+    data: {
+      id: "chief-of-staff-agent",
+      name: "Chief of Staff Agent",
+      role: "Chief of Staff",
+      status: "active",
+      wake_triggers: [
+        "ceo_instruction_created",
+        "task_status_changed",
+        "approval_requested"
+      ],
+      can_edit: ["/tasks/**", "/inbox/human/**", "/artifacts/**"],
+      can_comment: ["/**"],
+      requires_approval: ["company_strategy_change", "schema_change"]
+    },
+    body: "## Responsibilities\n\n- Coordinate active work.\n- Detect blockers.\n- Prepare CEO digests.\n"
+  },
+  {
+    filename: "strategy-agent.md",
+    data: {
+      id: "strategy-agent",
+      name: "Strategy Agent",
+      role: "Strategy",
+      status: "active",
+      wake_triggers: ["ceo_instruction_created", "strategy_artifact_changed"],
+      can_edit: [
+        "/tasks/**",
+        "/artifacts/research/**",
+        "/artifacts/marketing/**"
+      ],
+      can_comment: ["/company/**", "/artifacts/**"],
+      requires_approval: ["company_strategy_change", "positioning_change"]
+    },
+    body: "## Responsibilities\n\n- Clarify positioning.\n- Identify market assumptions and risks.\n"
+  },
+  {
+    filename: "pm-agent.md",
+    data: {
+      id: "pm-agent",
+      name: "Product Manager Agent",
+      role: "Product Manager",
+      status: "active",
+      wake_triggers: [
+        "ceo_instruction_created",
+        "product_artifact_changed",
+        "task_assigned",
+        "agent_mentioned"
+      ],
+      can_edit: ["/tasks/**", "/artifacts/product/**"],
+      can_comment: ["/artifacts/engineering/**", "/company/**"],
+      requires_approval: ["mvp_scope_finalization", "company_strategy_change"]
+    },
+    body: "## Responsibilities\n\n- Maintain product scope.\n- Draft PRDs.\n- Convert strategy into implementation tasks.\n"
+  },
+  {
+    filename: "engineer-agent.md",
+    data: {
+      id: "engineer-agent",
+      name: "Engineer Agent",
+      role: "Engineer",
+      status: "active",
+      wake_triggers: [
+        "engineering_task_created",
+        "task_assigned",
+        "agent_mentioned"
+      ],
+      can_edit: [
+        "/tasks/**",
+        "/artifacts/engineering/**",
+        "/src/**",
+        "/tests/**"
+      ],
+      can_comment: ["/artifacts/product/**", "/company/**"],
+      requires_approval: [
+        "schema_change",
+        "default_provider_change",
+        "external_side_effect",
+        "release_publish"
+      ]
+    },
+    body: "## Responsibilities\n\n- Design implementation plans.\n- Implement approved engineering tasks.\n- Run validation.\n"
+  }
+];
+function missionTemplate(workspaceName) {
+  return `# Mission
+
+Build ${workspaceName} with a proactive AI workspace.
+
+## Current Objective
+
+Define the initial direction and let agents create tasks, artifacts, and human decision requests.
+`;
+}
+var strategyTemplate = `# Strategy
+
+## Positioning
+
+_TBD by the human CEO and Strategy Agent._
+`;
+var decisionsTemplate = `# Decisions
+
+`;
+
+// src/workspace/init.ts
+var directories = [
+  ".proactive",
+  "company",
+  "tasks/backlog",
+  "tasks/ready",
+  "tasks/in-progress",
+  "tasks/review",
+  "tasks/done",
+  "tasks/blocked",
+  "tasks/cancelled",
+  "artifacts/product",
+  "artifacts/engineering",
+  "artifacts/research",
+  "artifacts/marketing",
+  "comments",
+  "inbox/human",
+  "events",
+  "agents"
+];
+async function initializeWorkspace(workspaceRoot, workspaceName) {
+  for (const directory of directories) {
+    await mkdir2(path3.join(workspaceRoot, directory), { recursive: true });
+  }
+  await writeFile3(
+    path3.join(workspaceRoot, ".proactive", "config.yaml"),
+    YAML.stringify({
+      workspace_name: workspaceName,
+      schema_version: 0,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      default_ai_provider: "codex",
+      human_actor: "human-ceo"
+    })
+  );
+  await writeState(workspaceRoot, initialState());
+  await writeFile3(
+    path3.join(workspaceRoot, "company", "mission.md"),
+    missionTemplate(workspaceName)
+  );
+  await writeFile3(
+    path3.join(workspaceRoot, "company", "strategy.md"),
+    strategyTemplate
+  );
+  await writeFile3(
+    path3.join(workspaceRoot, "company", "decisions.md"),
+    decisionsTemplate
+  );
+  for (const agent of defaultAgents) {
+    await writeFile3(
+      path3.join(workspaceRoot, "agents", agent.filename),
+      stringifyMarkdown(agent.data, agent.body)
+    );
+  }
+  const event = {
+    id: "evt-001",
+    type: "workspace.created",
+    actor: "human-ceo",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    summary: `Initialized workspace ${workspaceName}.`
+  };
+  await appendEvent(workspaceRoot, event);
+}
+
+// src/workspace/paths.ts
+import path4 from "path";
+var taskStatusToDirectory = {
+  backlog: "backlog",
+  ready: "ready",
+  in_progress: "in-progress",
+  review: "review",
+  done: "done",
+  blocked: "blocked",
+  cancelled: "cancelled"
+};
+function resolveWorkspace(root = process.cwd()) {
+  return path4.resolve(root);
+}
+
+// src/tasks/task-store.ts
+import { mkdir as mkdir3, readFile as readFile3, rename, writeFile as writeFile4 } from "fs/promises";
+import path5 from "path";
+import fg from "fast-glob";
+function taskFilename(task) {
+  const slug = task.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
+  return `${task.id}-${slug || "task"}.md`;
+}
+async function listTasks(workspaceRoot) {
+  const files = await fg("tasks/**/*.md", {
+    cwd: workspaceRoot,
+    onlyFiles: true
+  });
+  const tasks = await Promise.all(
+    files.map((file) => readTaskAt(workspaceRoot, file))
+  );
+  return tasks.sort((a, b) => a.task.id.localeCompare(b.task.id));
+}
+async function readTaskAt(workspaceRoot, relativePath) {
+  const raw = await readFile3(path5.join(workspaceRoot, relativePath), "utf8");
+  const parsed = parseMarkdown(raw, (data) => taskSchema.parse(data));
+  return { task: parsed.data, content: parsed.content, path: relativePath };
+}
+async function writeTask(workspaceRoot, task, content) {
+  const parsed = taskSchema.parse(task);
+  const directory = path5.join("tasks", taskStatusToDirectory[parsed.status]);
+  await mkdir3(path5.join(workspaceRoot, directory), { recursive: true });
+  const relativePath = path5.join(directory, taskFilename(parsed));
+  await writeFile4(
+    path5.join(workspaceRoot, relativePath),
+    stringifyMarkdown(parsed, content)
+  );
+  return relativePath;
+}
+
+// src/inbox/inbox-store.ts
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
+import path6 from "path";
+import fg2 from "fast-glob";
+function inboxFilename(item) {
+  return `${item.id}.md`;
+}
+async function listInboxItems(workspaceRoot) {
+  const files = await fg2("inbox/human/*.md", {
+    cwd: workspaceRoot,
+    onlyFiles: true
+  });
+  const items = await Promise.all(
+    files.map((file) => readInboxAt(workspaceRoot, file))
+  );
+  return items.sort((a, b) => a.item.id.localeCompare(b.item.id));
+}
+async function findInboxItem(workspaceRoot, itemId) {
+  return (await listInboxItems(workspaceRoot)).find(
+    (item) => item.item.id === itemId
+  );
+}
+async function readInboxAt(workspaceRoot, relativePath) {
+  const raw = await readFile4(path6.join(workspaceRoot, relativePath), "utf8");
+  const parsed = parseMarkdown(raw, (data) => inboxItemSchema.parse(data));
+  return { item: parsed.data, content: parsed.content, path: relativePath };
+}
+async function writeInboxItem(workspaceRoot, item, content) {
+  const parsed = inboxItemSchema.parse(item);
+  await mkdir4(path6.join(workspaceRoot, "inbox", "human"), { recursive: true });
+  const relativePath = path6.join("inbox", "human", inboxFilename(parsed));
+  await writeFile5(
+    path6.join(workspaceRoot, relativePath),
+    stringifyMarkdown(parsed, content)
+  );
+  return relativePath;
+}
+async function respondToInboxItem(workspaceRoot, doc, status, response) {
+  await writeInboxItem(
+    workspaceRoot,
+    { ...doc.item, status, updated_at: (/* @__PURE__ */ new Date()).toISOString() },
+    `${doc.content.trimEnd()}
+
+## CEO Response
+
+${response}
+`
+  );
+}
+
+// src/agents/agent-store.ts
+import { readFile as readFile5 } from "fs/promises";
+import path7 from "path";
+import fg3 from "fast-glob";
+async function listAgents(workspaceRoot) {
+  const files = await fg3("agents/*.md", {
+    cwd: workspaceRoot,
+    onlyFiles: true
+  });
+  const agents = await Promise.all(
+    files.map((file) => readAgentAt(workspaceRoot, file))
+  );
+  return agents.sort((a, b) => a.agent.id.localeCompare(b.agent.id));
+}
+async function readAgentAt(workspaceRoot, relativePath) {
+  const raw = await readFile5(path7.join(workspaceRoot, relativePath), "utf8");
+  const parsed = parseMarkdown(raw, (data) => agentSchema.parse(data));
+  return {
+    agent: parsed.data,
+    instructions: parsed.content,
+    path: relativePath
+  };
+}
+
+// src/workspace/scanner.ts
+import { createHash } from "crypto";
+import { readFile as readFile6 } from "fs/promises";
+import fg4 from "fast-glob";
+var scanPatterns = [
+  "tasks/**/*.md",
+  "artifacts/**/*.md",
+  "inbox/human/*.md",
+  "company/*.md",
+  "agents/*.md"
+];
+async function hashWorkspaceFile(workspaceRoot, file) {
+  const raw = await readFile6(`${workspaceRoot}/${file}`);
+  return createHash("sha256").update(raw).digest("hex");
+}
+async function detectWorkspaceChanges(workspaceRoot) {
+  const state = await readState(workspaceRoot);
+  const files = await fg4(scanPatterns, { cwd: workspaceRoot, onlyFiles: true });
+  const nextHashes = {};
+  let changeCount = 0;
+  for (const file of files.sort()) {
+    const hash = await hashWorkspaceFile(workspaceRoot, file);
+    nextHashes[file] = hash;
+    if (state.file_hashes[file] && state.file_hashes[file] !== hash) {
+      await appendEvent(workspaceRoot, {
+        id: formatEventId(state.next_ids.event++),
+        type: semanticType(file, false),
+        actor: "orchestrator",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        summary: `Detected update to ${file}.`,
+        files: [file]
+      });
+      changeCount += 1;
+    } else if (!state.file_hashes[file]) {
+      await appendEvent(workspaceRoot, {
+        id: formatEventId(state.next_ids.event++),
+        type: semanticType(file, true),
+        actor: "orchestrator",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        summary: `Detected new file ${file}.`,
+        files: [file]
+      });
+      changeCount += 1;
+    }
+  }
+  for (const deletedFile of Object.keys(state.file_hashes).filter((file) => !(file in nextHashes)).sort()) {
+    await appendEvent(workspaceRoot, {
+      id: formatEventId(state.next_ids.event++),
+      type: semanticType(deletedFile, false).replace(/\.updated$/, ".deleted"),
+      actor: "orchestrator",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      summary: `Detected deletion of ${deletedFile}.`,
+      files: [deletedFile]
+    });
+    changeCount += 1;
+  }
+  state.file_hashes = nextHashes;
+  state.last_scan_at = (/* @__PURE__ */ new Date()).toISOString();
+  state.last_event_id = formatEventId(Math.max(1, state.next_ids.event - 1));
+  await writeState(workspaceRoot, state);
+  return changeCount;
+}
+function semanticType(file, created) {
+  if (file.startsWith("tasks/"))
+    return created ? "task.created" : "task.updated";
+  if (file.startsWith("artifacts/"))
+    return created ? "artifact.created" : "artifact.updated";
+  if (file.startsWith("inbox/"))
+    return created ? "approval.requested" : "approval.updated";
+  if (file.startsWith("agents/"))
+    return created ? "agent.created" : "agent.updated";
+  return created ? "file.created" : "file.updated";
+}
+
+// src/agents/wake-planner.ts
+function planAgentWakeups(agents, events, tasks) {
+  const recentTypes = new Set(
+    events.slice(-20).map((event) => event.type.replaceAll(".", "_"))
+  );
+  return agents.filter((agentDoc) => {
+    if (agentDoc.agent.status !== "active") return false;
+    if (agentDoc.agent.wake_triggers.some((trigger) => recentTypes.has(trigger)))
+      return true;
+    if (tasks.some(
+      (task) => task.task.owner === agentDoc.agent.id && ["ready", "in_progress"].includes(task.task.status)
+    )) {
+      return true;
+    }
+    if (tasks.some((task) => task.task.mentions.includes(agentDoc.agent.id)))
+      return true;
+    return false;
+  });
+}
+
+// src/agents/runner.ts
+import { access, mkdir as mkdir5, writeFile as writeFile6 } from "fs/promises";
+import path10 from "path";
+
+// src/agents/actions.ts
+import { z as z2 } from "zod";
+var agentActionSchema = z2.discriminatedUnion("type", [
+  z2.object({
+    type: z2.literal("create_task"),
+    title: z2.string().min(1),
+    priority: z2.enum(["low", "medium", "high", "critical"]).default("medium"),
+    owner: z2.string().optional(),
+    content: z2.string().min(1),
+    mentions: z2.array(z2.string()).default([])
+  }),
+  z2.object({
+    type: z2.literal("create_artifact"),
+    path: z2.string().min(1),
+    content: z2.string().min(1)
+  }),
+  z2.object({
+    type: z2.literal("create_inbox_item"),
+    kind: z2.enum(["decision_request", "approval_request"]),
+    title: z2.string().min(1),
+    priority: z2.enum(["low", "medium", "high", "critical"]).default("medium"),
+    content: z2.string().min(1),
+    related_task: z2.string().optional()
+  }),
+  z2.object({
+    type: z2.literal("comment"),
+    path: z2.string().min(1),
+    content: z2.string().min(1)
+  })
+]);
+var agentOutputSchema = z2.object({
+  thought_summary: z2.string().min(1),
+  actions: z2.array(agentActionSchema).default([])
+});
+function parseAgentOutput(raw) {
+  const jsonMatch = raw.match(/```json\s*([\s\S]*?)```/) ?? raw.match(/({[\s\S]*})/);
+  const json = jsonMatch ? jsonMatch[1] : raw;
+  return agentOutputSchema.parse(JSON.parse(json));
+}
+
+// src/agents/context.ts
+import { readFile as readFile7 } from "fs/promises";
+import path8 from "path";
+async function readOptional(workspaceRoot, relativePath) {
+  try {
+    return await readFile7(path8.join(workspaceRoot, relativePath), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return "";
+    throw error;
+  }
+}
+async function buildAgentPrompt(workspaceRoot, agentDoc) {
+  const [mission, strategy, decisions, events, tasks] = await Promise.all([
+    readOptional(workspaceRoot, "company/mission.md"),
+    readOptional(workspaceRoot, "company/strategy.md"),
+    readOptional(workspaceRoot, "company/decisions.md"),
+    readEvents(workspaceRoot),
+    listTasks(workspaceRoot)
+  ]);
+  const relevantTasks = tasks.filter(
+    (task) => task.task.owner === agentDoc.agent.id || task.task.mentions.includes(agentDoc.agent.id)
+  );
+  return `You are ${agentDoc.agent.name} (${agentDoc.agent.role}) in Proactive AI.
+
+${agentDoc.instructions}
+
+# Mission
+${mission}
+
+# Strategy
+${strategy}
+
+# Decisions
+${decisions}
+
+# Recent Events
+${events.slice(-10).map((event) => `- ${event.id} ${event.type}: ${event.summary}`).join("\n")}
+
+# Relevant Tasks
+${relevantTasks.map((task) => `- ${task.task.id} [${task.task.status}] ${task.task.title}`).join(
+    "\n"
+  )}
+
+# Output Contract
+Return ONLY JSON matching this shape:
+{
+  "thought_summary": "brief reason",
+  "actions": [
+    { "type": "create_task", "title": "...", "priority": "medium", "owner": "agent-id", "content": "markdown body", "mentions": [] }
+  ]
+}
+
+Allowed action types and required fields:
+- create_task: { "type": "create_task", "title": "...", "priority": "low|medium|high|critical", "owner": "agent-id", "content": "markdown body", "mentions": [] }
+- create_artifact: { "type": "create_artifact", "path": "artifacts/...", "content": "markdown body" }
+- create_inbox_item: { "type": "create_inbox_item", "kind": "decision_request", "title": "...", "priority": "low|medium|high|critical", "content": "markdown body" }
+- comment: { "type": "comment", "path": "target/file.md", "content": "markdown body" }
+
+For create_inbox_item, kind MUST be exactly "decision_request" or "approval_request". Do not use "decision".
+Produce at most 2 actions. If no action is needed, return an empty actions array.`;
+}
+
+// src/agents/dedup.ts
+function actionFingerprint(action) {
+  if (action.type === "create_task")
+    return `create_task:${normalize(action.title)}`;
+  if (action.type === "create_artifact")
+    return `create_artifact:${normalizePath(action.path)}`;
+  if (action.type === "create_inbox_item")
+    return `create_inbox_item:${action.kind}:${normalize(action.title)}`;
+  return `comment:${normalizePath(action.path)}:${normalize(action.content).slice(0, 80)}`;
+}
+function isDuplicateAction(action, existingTasks, existingInboxItems = []) {
+  if (action.type === "create_task") {
+    const title = normalize(action.title);
+    return existingTasks.some(
+      (task) => !["done", "cancelled"].includes(task.task.status) && normalize(task.task.title) === title
+    );
+  }
+  if (action.type === "create_inbox_item") {
+    const title = normalize(action.title);
+    return existingInboxItems.some(
+      (item) => item.item.status === "awaiting_human" && normalize(firstHeading(item.content)) === title
+    );
+  }
+  return false;
+}
+function firstHeading(content) {
+  return content.split("\n").find((line) => line.startsWith("# "))?.replace(/^# /, "") ?? "";
+}
+function normalize(value) {
+  return value.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function normalizePath(value) {
+  return value.trim().replace(/^\/+/, "").replace(/\/+/g, "/");
+}
+
+// src/agents/permissions.ts
+import path9 from "path";
+import { minimatch } from "minimatch";
+function canEditPath(agent, targetPath) {
+  return matchesAny(agent.can_edit, targetPath);
+}
+function canCommentPath(agent, targetPath) {
+  return matchesAny(agent.can_comment, targetPath);
+}
+function matchesAny(patterns, targetPath) {
+  const normalized = `/${targetPath.replace(/^\/+/, "")}`;
+  return patterns.some((pattern) => minimatch(normalized, pattern));
+}
+function assertSafeRelativePath(targetPath) {
+  if (path9.isAbsolute(targetPath) || targetPath.includes("..")) {
+    throw new Error(`Unsafe path: ${targetPath}`);
+  }
+}
+
+// src/agents/runner.ts
+async function runAgent(workspaceRoot, agentDoc, provider, options = {}) {
+  const prompt = await buildAgentPrompt(workspaceRoot, agentDoc);
+  const response = await provider.complete({
+    agentId: agentDoc.agent.id,
+    prompt
+  });
+  const output = parseAgentOutput(response.text);
+  let actionCount = 0;
+  let skippedCount = 0;
+  const previews = [];
+  const fingerprints = options.actionFingerprints ?? /* @__PURE__ */ new Set();
+  for (const action of output.actions.slice(0, 2)) {
+    const fingerprint = actionFingerprint(action);
+    const [existingTasks, existingInboxItems] = await Promise.all([
+      listTasks(workspaceRoot),
+      listInboxItems(workspaceRoot)
+    ]);
+    if (fingerprints.has(fingerprint) || isDuplicateAction(action, existingTasks, existingInboxItems)) {
+      skippedCount += 1;
+      previews.push(`skip duplicate ${fingerprint}`);
+      continue;
+    }
+    fingerprints.add(fingerprint);
+    if (options.dryRun) {
+      previews.push(`would apply ${fingerprint}`);
+      actionCount += 1;
+      continue;
+    }
+    const applied = await applyAction(workspaceRoot, agentDoc, action);
+    previews.push(
+      `applied ${fingerprint} -> ${applied.join(", ") || "no files"}`
+    );
+    actionCount += 1;
+  }
+  return { agentId: agentDoc.agent.id, actionCount, skippedCount, previews };
+}
+async function applyAction(workspaceRoot, agentDoc, action) {
+  const state = await readState(workspaceRoot);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (action.type === "create_task") {
+    const task = {
+      id: allocateId(state, "task", "task"),
+      title: action.title,
+      status: "backlog",
+      priority: action.priority,
+      owner: action.owner,
+      created_by: agentDoc.agent.id,
+      created_at: now,
+      updated_at: now,
+      mentions: action.mentions,
+      depends_on: [],
+      artifacts: [],
+      approval_required: false
+    };
+    const written = await writeTask(workspaceRoot, task, action.content);
+    state.last_event_id = formatEventId(state.next_ids.event);
+    await record(
+      workspaceRoot,
+      state.next_ids.event++,
+      "task.created",
+      agentDoc.agent.id,
+      `Created ${task.id}: ${task.title}`,
+      [written]
+    );
+    state.file_hashes[written] = await hashWorkspaceFile(
+      workspaceRoot,
+      written
+    );
+    await writeState(workspaceRoot, state);
+    return [written];
+  }
+  if (action.type === "create_artifact") {
+    const target = action.path.replace(/^\/+/, "");
+    assertSafeRelativePath(target);
+    if (!canEditPath(agentDoc.agent, target))
+      throw new Error(`${agentDoc.agent.id} cannot edit ${target}`);
+    if (await fileExists(path10.join(workspaceRoot, target)))
+      throw new Error(`Refusing to overwrite existing artifact: ${target}`);
+    await mkdir5(path10.dirname(path10.join(workspaceRoot, target)), {
+      recursive: true
+    });
+    await writeFile6(
+      path10.join(workspaceRoot, target),
+      action.content.endsWith("\n") ? action.content : `${action.content}
+`
+    );
+    state.last_event_id = formatEventId(state.next_ids.event);
+    await record(
+      workspaceRoot,
+      state.next_ids.event++,
+      "artifact.created",
+      agentDoc.agent.id,
+      `Created ${target}`,
+      [target]
+    );
+    state.file_hashes[target] = await hashWorkspaceFile(workspaceRoot, target);
+    await writeState(workspaceRoot, state);
+    return [target];
+  }
+  if (action.type === "create_inbox_item") {
+    const id = allocateId(
+      state,
+      action.kind === "decision_request" ? "decision" : "approval",
+      action.kind === "decision_request" ? "decision" : "approval"
+    );
+    const item = {
+      id,
+      type: action.kind,
+      status: "awaiting_human",
+      priority: action.priority,
+      requested_by: agentDoc.agent.id,
+      related_task: action.related_task,
+      related_artifacts: [],
+      created_at: now
+    };
+    const written = await writeInboxItem(
+      workspaceRoot,
+      item,
+      `# ${action.title}
+
+${action.content}
+
+## CEO Response
+
+<!-- Human writes here. -->
+`
+    );
+    state.last_event_id = formatEventId(state.next_ids.event);
+    await record(
+      workspaceRoot,
+      state.next_ids.event++,
+      "approval.requested",
+      agentDoc.agent.id,
+      `Requested human input: ${action.title}`,
+      [written]
+    );
+    state.file_hashes[written] = await hashWorkspaceFile(
+      workspaceRoot,
+      written
+    );
+    await writeState(workspaceRoot, state);
+    return [written];
+  }
+  if (action.type === "comment") {
+    const target = action.path.replace(/^\/+/, "");
+    assertSafeRelativePath(target);
+    if (!canCommentPath(agentDoc.agent, target))
+      throw new Error(`${agentDoc.agent.id} cannot comment on ${target}`);
+    const commentPath = path10.join(
+      "comments",
+      `${Date.now()}-${agentDoc.agent.id}.md`
+    );
+    await mkdir5(path10.join(workspaceRoot, "comments"), { recursive: true });
+    await writeFile6(
+      path10.join(workspaceRoot, commentPath),
+      `# Comment on ${target}
+
+${action.content}
+`
+    );
+    state.last_event_id = formatEventId(state.next_ids.event);
+    await record(
+      workspaceRoot,
+      state.next_ids.event++,
+      "comment.created",
+      agentDoc.agent.id,
+      `Commented on ${target}`,
+      [commentPath]
+    );
+    state.file_hashes[commentPath] = await hashWorkspaceFile(
+      workspaceRoot,
+      commentPath
+    );
+    await writeState(workspaceRoot, state);
+    return [commentPath];
+  }
+  return [];
+}
+async function fileExists(targetPath) {
+  try {
+    await access(targetPath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+async function record(workspaceRoot, eventNumber, type, actor, summary, files) {
+  const event = {
+    id: formatEventId(eventNumber),
+    type,
+    actor,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    summary,
+    files
+  };
+  await appendEvent(workspaceRoot, event);
+}
+
+// src/providers/codex/codex-provider.ts
+import { mkdtemp, readFile as readFile8, rm } from "fs/promises";
+import os from "os";
+import path11 from "path";
+import { execa } from "execa";
+var CodexProvider = class {
+  constructor(command = process.env.PROACTIVE_CODEX_COMMAND ?? "codex") {
+    this.command = command;
+  }
+  command;
+  async complete(request) {
+    const tempDir = await mkdtemp(path11.join(os.tmpdir(), "proactive-codex-"));
+    const outputPath = path11.join(tempDir, "last-message.txt");
+    try {
+      const result = await execa(
+        this.command,
+        [
+          "exec",
+          "--sandbox",
+          "read-only",
+          "--ignore-rules",
+          "--ephemeral",
+          "--output-last-message",
+          outputPath,
+          `${request.prompt}
+
+Do not inspect files or run commands. Return only the JSON object requested above.`
+        ],
+        {
+          reject: false,
+          env: process.env,
+          stdin: "ignore",
+          timeout: Number.parseInt(
+            process.env.PROACTIVE_CODEX_TIMEOUT_MS ?? "120000",
+            10
+          )
+        }
+      );
+      if (result.exitCode !== 0) {
+        throw new Error(
+          `Codex failed for ${request.agentId}: ${result.stderr || result.stdout}`
+        );
+      }
+      const text = await readFile8(outputPath, "utf8").catch(
+        () => result.stdout
+      );
+      if (!text.trim()) {
+        throw new Error(
+          `Codex produced no final message for ${request.agentId}: ${result.stderr || result.stdout}`
+        );
+      }
+      return { text };
+    } finally {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+  }
+};
+
+// src/providers/stub/stub-provider.ts
+var StubProvider = class {
+  constructor(scenario = "self-dogfood") {
+    this.scenario = scenario;
+  }
+  scenario;
+  async complete(request) {
+    const actions = this.scenario === "property-management" ? propertyManagementActions(request.agentId) : selfDogfoodActions();
+    return {
+      text: JSON.stringify({
+        thought_summary: `Stubbed ${this.scenario} response for ${request.agentId}.`,
+        actions
+      })
+    };
+  }
+};
+function selfDogfoodActions() {
+  return [
+    {
+      type: "create_task",
+      title: "Harden self-dogfood agent execution path",
+      priority: "high",
+      owner: "engineer-agent",
+      content: "## Context\n\nA stubbed Proactive AI run created this task while dogfooding the repo.\n\n## Request\n\nHarden the agent execution path before relying on live Codex runs.\n\n## Acceptance Criteria\n\n- [ ] Add provider contract tests.\n- [ ] Add dry-run/action preview mode.\n- [ ] Improve event id/state consistency.\n- [ ] Document safe live Codex invocation.\n",
+      mentions: ["engineer-agent"]
+    }
+  ];
+}
+function propertyManagementActions(agentId) {
+  if (agentId === "strategy-agent") {
+    return [
+      {
+        type: "create_task",
+        title: "Define initial property-management target customer",
+        priority: "high",
+        owner: "strategy-agent",
+        content: "## Context\n\nThe CEO wants to build property-management software for landlords, property managers, and tenants.\n\n## Request\n\nCompare independent landlords, property managers, and tenants as initial ICPs. Recommend one starting segment.\n\n## Acceptance Criteria\n\n- [ ] Identifies the strongest initial ICP.\n- [ ] Lists assumptions and risks.\n- [ ] Recommends what to validate first.\n",
+        mentions: ["pm-agent"]
+      }
+    ];
+  }
+  if (agentId === "pm-agent") {
+    return [
+      {
+        type: "create_task",
+        title: "Draft MVP PRD for property-management SaaS",
+        priority: "high",
+        owner: "pm-agent",
+        content: "## Context\n\nThe product needs a narrow MVP scope.\n\n## Request\n\nDraft an MVP PRD focused on the selected initial customer segment. Include personas, workflows, non-goals, and open CEO decisions.\n\n## Acceptance Criteria\n\n- [ ] Defines MVP user and problem.\n- [ ] Lists core workflows.\n- [ ] Names non-goals.\n- [ ] Tags engineering for feasibility.\n",
+        mentions: ["engineer-agent"]
+      }
+    ];
+  }
+  if (agentId === "engineer-agent") {
+    return [
+      {
+        type: "create_artifact",
+        path: "artifacts/engineering/property-management-feasibility.md",
+        content: "# Property Management MVP Feasibility\n\n## Initial Read\n\nA simple v0 can avoid payment processing and focus on tenant directory, property/unit records, lease reminders, and maintenance requests.\n\n## Risks\n\n- Rent collection introduces payment/compliance complexity.\n- Multi-role permissions can expand scope quickly.\n\n## Recommendation\n\nDefer rent collection until after workflow validation.\n"
+      }
+    ];
+  }
+  return [
+    {
+      type: "create_inbox_item",
+      kind: "decision_request",
+      title: "Choose property-management MVP scope",
+      priority: "high",
+      content: "## Context\n\nAgents recommend starting with independent landlords and deferring rent collection.\n\n## Recommendation\n\nApprove an MVP focused on tenant directory, property/unit records, lease reminders, and maintenance requests.\n\n## CEO Response\n\n<!-- Approve, reject, or adjust scope. -->\n"
+    }
+  ];
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("proactive").description("Git-native proactive AI workspace CLI").version("0.1.0");
+program.command("init").argument("<workspace-name>").option("--root <path>", "workspace root; defaults to ./<workspace-name>").action(async (workspaceName, options) => {
+  const root = path12.resolve(options.root ?? workspaceName);
+  await initializeWorkspace(root, workspaceName);
+  console.log(`Initialized Proactive AI workspace at ${root}`);
+});
+program.command("ceo").argument("<instruction>").action(async (instruction) => {
+  const root = resolveWorkspace();
+  const state = await readState(root);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await mkdir6(path12.join(root, "company"), { recursive: true });
+  await writeFile7(
+    path12.join(root, "company", "latest-ceo-instruction.md"),
+    `# CEO Instruction
+
+${instruction}
+`
+  );
+  const eventId = formatEventId(state.next_ids.event++);
+  await appendEvent(root, {
+    id: eventId,
+    type: "ceo.instruction.created",
+    actor: "human-ceo",
+    timestamp: now,
+    summary: instruction
+  });
+  state.last_event_id = eventId;
+  await writeState(root, state);
+  console.log(`Recorded CEO instruction: ${instruction}`);
+});
+program.command("tasks").action(async () => {
+  const tasks = await listTasks(resolveWorkspace());
+  for (const doc of tasks)
+    console.log(
+      `${doc.task.id}	${doc.task.status}	${doc.task.priority}	${doc.task.title}`
+    );
+});
+program.command("inbox").action(async () => {
+  const items = (await listInboxItems(resolveWorkspace())).filter(
+    (doc) => doc.item.status === "awaiting_human"
+  );
+  if (items.length === 0) {
+    console.log("Inbox is empty.");
+    return;
+  }
+  for (const doc of items)
+    console.log(
+      `${doc.item.id}	${doc.item.priority}	${doc.item.type}	${doc.path}`
+    );
+});
+async function respond(itemId, status, response) {
+  const root = resolveWorkspace();
+  const doc = await findInboxItem(root, itemId);
+  if (!doc) throw new Error(`Inbox item not found: ${itemId}`);
+  await respondToInboxItem(root, doc, status, response);
+  if (doc.item.type === "decision_request" && status === "approved") {
+    const decisionsPath = path12.join(root, "company", "decisions.md");
+    const existing = await readFile9(decisionsPath, "utf8").catch(
+      () => "# Decisions\n\n"
+    );
+    await writeFile7(
+      decisionsPath,
+      `${existing.trimEnd()}
+
+## ${(/* @__PURE__ */ new Date()).toISOString()}: ${itemId}
+
+${response}
+`
+    );
+  }
+  const state = await readState(root);
+  const eventId = formatEventId(state.next_ids.event++);
+  await appendEvent(root, {
+    id: eventId,
+    type: status === "approved" ? "approval.approved" : "approval.rejected",
+    actor: "human-ceo",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    summary: `${status} ${itemId}: ${response}`
+  });
+  state.last_event_id = eventId;
+  await writeState(root, state);
+  console.log(`${status} ${itemId}`);
+}
+program.command("approve").argument("<item-id>").requiredOption("--response <text>").action(
+  async (itemId, options) => respond(itemId, "approved", options.response)
+);
+program.command("reject").argument("<item-id>").requiredOption("--response <text>").action(
+  async (itemId, options) => respond(itemId, "rejected", options.response)
+);
+program.command("agents").action(async () => {
+  const agents = await listAgents(resolveWorkspace());
+  for (const doc of agents)
+    console.log(`${doc.agent.id}	${doc.agent.status}	${doc.agent.role}`);
+});
+program.command("run").option("--no-ai", "detect changes and plan wakeups without invoking Codex").option(
+  "--dry-run",
+  "call the provider and preview actions without writing files"
+).option("--provider <provider>", "AI provider to use: codex or stub", "codex").option(
+  "--scenario <scenario>",
+  "stub scenario to run: self-dogfood or property-management",
+  "self-dogfood"
+).option(
+  "--max-agents <count>",
+  "maximum agents to run when AI is enabled",
+  "1"
+).action(
+  async (options) => {
+    const root = resolveWorkspace();
+    const changes = await detectWorkspaceChanges(root);
+    const [events, agents, tasks] = await Promise.all([
+      readEvents(root),
+      listAgents(root),
+      listTasks(root)
+    ]);
+    const wakeups = planAgentWakeups(agents, events, tasks);
+    console.log(
+      `Detected ${changes} change(s). Wakeups: ${wakeups.map((doc) => doc.agent.id).join(", ") || "none"}`
+    );
+    if (!options.ai) return;
+    const provider = options.provider === "stub" ? new StubProvider(options.scenario) : new CodexProvider();
+    const maxAgents = Number.parseInt(options.maxAgents, 10);
+    const selectedWakeups = wakeups.slice(
+      0,
+      Number.isFinite(maxAgents) && maxAgents > 0 ? maxAgents : 1
+    );
+    const actionFingerprints = /* @__PURE__ */ new Set();
+    for (const agent of selectedWakeups) {
+      const result = await runAgent(root, agent, provider, {
+        dryRun: options.dryRun,
+        actionFingerprints
+      });
+      console.log(
+        `${options.dryRun ? "Previewed" : "Ran"} ${result.agentId}: ${result.actionCount} action(s), ${result.skippedCount} skipped`
+      );
+      for (const preview of result.previews) console.log(`  - ${preview}`);
+    }
+  }
+);
+program.parseAsync().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@trycedar/argus",
+  "version": "0.1.0",
+  "description": "Git-native proactive AI agent organization framework CLI.",
+  "type": "module",
+  "packageManager": "pnpm@10.25.0",
+  "bin": {
+    "proactive": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/cli/index.ts",
+    "format:check": "prettier --check .",
+    "format": "prettier --write .",
+    "lint": "tsc --noEmit",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "commander": "^14.0.2",
+    "execa": "^9.6.0",
+    "fast-glob": "^3.3.3",
+    "gray-matter": "^4.0.3",
+    "minimatch": "^10.1.1",
+    "yaml": "^2.8.1",
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "prettier": "^3.6.2",
+    "tsup": "^8.5.1",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.14"
+  }
+}