feat(strategy): Add minimal strategy layer with decision → goal decomposition

src/cli/cli.tsx

@@ -25,6 +25,7 @@ import {
   runIngestCommand,
   runNgrokCommand,
   runPrintCommand,
+  runStrategyCommand,
   runVisualizeCommand,
 } from "./runners.js";
 import { runIntegrationsCommand, runMcpCommand } from "./integrations.js";
@@ -91,6 +92,8 @@ async function runStandardCommand(
     await runCronCommand(command);
   } else if (command.kind === "book") {
     await runBookCommand(command, command.mode);
+  } else if (command.kind === "strategy") {
+    await runStrategyCommand(command);
   } else if (command.kind === "ingest") {
     await runIngestCommand(command);
   } else if (command.kind === "visualize") {

src/cli/commands.ts

@@ -151,6 +151,12 @@ export type CliCommand =
       name: string | null;
       query: string | null;
     }
+  | {
+      kind: "strategy";
+      action: "seed" | "list";
+      exitCode: 0;
+      description: string | null;
+    }
   | { kind: "help"; exitCode: 0 }
   | {
       kind: "run";
@@ -192,6 +198,10 @@ export function parseCommand(argv: string[]): CliCommand {
     return parseBookCommand(argv.slice(1));
   }
 
+  if (argv[0] === "strategy") {
+    return parseStrategyCommand(argv.slice(1));
+  }
+
   if (argv[0] === "auth") {
     const action =
       argv[1] === "configure"
@@ -832,6 +842,34 @@ function parseBookCommand(argv: string[]): CliCommand {
   return { action, exitCode: 0, force, kind: "book", mode, name, query };
 }
 
+function parseStrategyCommand(argv: string[]): CliCommand {
+  const action = argv[0];
+
+  if (action !== "seed" && action !== "list") {
+    return {
+      exitCode: 1,
+      kind: "error",
+      message: "Usage: stratiki strategy seed <description> | list",
+    };
+  }
+
+  if (action === "list") {
+    return { action: "list", description: null, exitCode: 0, kind: "strategy" };
+  }
+
+  const description = argv.slice(1).join(" ").trim();
+
+  if (description.length === 0) {
+    return {
+      exitCode: 1,
+      kind: "error",
+      message: "Usage: stratiki strategy seed <description>",
+    };
+  }
+
+  return { action: "seed", description, exitCode: 0, kind: "strategy" };
+}
+
 /**
  * Builds the registry-derived integration usage error.
  *

src/cli/runners.ts

@@ -426,6 +426,69 @@ export async function runBookCommand(
   await refreshBook(bookDir, bookDbPath);
 }
 
+/**
+ * Dispatches `stratiki strategy` subcommands: seed, list.
+ */
+export async function runStrategyCommand(
+  command: Extract<CliCommand, { kind: "strategy" }>,
+): Promise<void> {
+  const { parseDecisionSeed } = await import("../strategy/parser.js");
+  const { decomposeDecision } = await import("../strategy/decomposer.js");
+  const { FileStrategyStore } = await import("../strategy/store.js");
+  const {
+    getStratikiStrategyDir,
+    getStratikiCompanyWikiDir,
+    ensureStratikiHome,
+  } = await import("../config/openwiki-home.js");
+  const bookDir = getStratikiCompanyWikiDir();
+  const store = new FileStrategyStore(getStratikiStrategyDir());
+
+  if (command.action === "list") {
+    const decisions = await store.listDecisions();
+    if (decisions.length === 0) {
+      process.stdout.write("No decisions seeded yet.\n");
+      return;
+    }
+
+    process.stdout.write(`Decisions (${decisions.length}):\n`);
+    for (const decision of decisions) {
+      const goals = await store.getGoalsForDecision(decision.id);
+      process.stdout.write(
+        `\n${decision.id}: ${decision.description}\n  Status: ${decision.status}\n  Goals: ${goals.length}\n`,
+      );
+    }
+    return;
+  }
+
+  if (command.description === null) {
+    process.stderr.write("Description is required for seed action.\n");
+    process.exitCode = 1;
+    return;
+  }
+
+  const decision = parseDecisionSeed({ description: command.description });
+  const index = await ContextIndex.buildFromDirectory(bookDir);
+  try {
+    const result = decomposeDecision(decision, index);
+    await ensureStratikiHome();
+    await store.saveDecision(result.decision);
+    await store.saveGoals(result.goals);
+
+    process.stdout.write(`Seeded decision: ${result.decision.id}\n`);
+    process.stdout.write(`  ${result.decision.description}\n`);
+    process.stdout.write(`\nGenerated ${result.goals.length} goal(s):\n`);
+
+    const sortedGoals = [...result.goals].sort((a, b) => b.rank - a.rank);
+    for (const goal of sortedGoals) {
+      process.stdout.write(
+        `\n- [rank ${goal.rank}] ${goal.description}\n  Grounded in: ${goal.groundedIn.length > 0 ? goal.groundedIn.join(", ") : "none"}\n`,
+      );
+    }
+  } finally {
+    index.close();
+  }
+}
+
 async function initBookManifest(
   bookDir: string,
   command: Extract<CliCommand, { kind: "book" }>,

src/config/openwiki-home.ts

@@ -84,6 +84,7 @@ export const openWikiEnvDisplayPath = `${openWikiHomeDisplayPath}/.env`;
 let _stratikiHomeDir: string | undefined;
 let _stratikiCompanyWikiDir: string | undefined;
 let _stratikiBookDbPath: string | undefined;
+let _stratikiStrategyDir: string | undefined;
 
 export function getStratikiHomeDir(): string {
   if (_stratikiHomeDir === undefined) {
@@ -106,6 +107,13 @@ export function getStratikiBookDbPath(): string {
   return _stratikiBookDbPath;
 }
 
+export function getStratikiStrategyDir(): string {
+  if (_stratikiStrategyDir === undefined) {
+    _stratikiStrategyDir = path.join(getStratikiHomeDir(), "strategy");
+  }
+  return _stratikiStrategyDir;
+}
+
 export function getConnectorDir(connectorId: string): string {
   return path.join(openWikiConnectorsDir, connectorId);
 }
@@ -139,10 +147,12 @@ export async function ensureOpenWikiHome(): Promise<void> {
 export async function ensureStratikiHome(): Promise<void> {
   const homeDir = getStratikiHomeDir();
   const wikiDir = getStratikiCompanyWikiDir();
+  const strategyDir = getStratikiStrategyDir();
   await mkdir(homeDir, { recursive: true, mode: 0o700 });
   await chmodIfExists(homeDir, 0o700);
   await restrictDirToCurrentUser(homeDir);
   await mkdir(wikiDir, { recursive: true, mode: 0o700 });
+  await mkdir(strategyDir, { recursive: true, mode: 0o700 });
 }
 
 export async function ensureConnectorHome(connectorId: string): Promise<void> {

src/strategy/decomposer.ts

@@ -0,0 +1,122 @@
+import { randomUUID } from "node:crypto";
+import type { ContextIndex, ContextPacketEntry } from "../book/packet.js";
+import type { Decision, DecompositionResult, Goal } from "./types.js";
+
+/**
+ * Decomposes a decision into goals, grounded in the company brain context.
+ *
+ * This is a minimal implementation that:
+ * 1. Searches the book for relevant context
+ * 2. Decomposes the decision into simple goals
+ * 3. Ranks goals based on how well they're grounded in existing knowledge
+ */
+export function decomposeDecision(
+  decision: Decision,
+  bookIndex: ContextIndex,
+): DecompositionResult {
+  const contextEntries = bookIndex.search(decision.description, 10);
+  const goals = extractGoalsFromDecision(decision, contextEntries);
+
+  return {
+    decision,
+    goals,
+  };
+}
+
+/**
+ * Extracts goals from a decision description and ranks them by grounding.
+ */
+function extractGoalsFromDecision(
+  decision: Decision,
+  contextEntries: readonly ContextPacketEntry[],
+): Goal[] {
+  const now = new Date();
+  const groundingPaths = new Set(contextEntries.map((entry) => entry.path));
+
+  const rawGoals = parseGoalsFromDescription(decision.description);
+
+  return rawGoals.map((goalDesc, index) => {
+    const grounding = findGroundingForGoal(goalDesc, contextEntries);
+    const rank = calculateRank(grounding, groundingPaths, index);
+
+    return {
+      createdAt: now,
+      decisionId: decision.id,
+      description: goalDesc,
+      groundedIn: grounding,
+      id: randomUUID(),
+      rank,
+      status: "pending",
+      updatedAt: now,
+    };
+  });
+}
+
+/**
+ * Naive goal extraction: split by sentence boundaries or bullet points.
+ * In a real implementation, this would use an LLM.
+ */
+function parseGoalsFromDescription(description: string): string[] {
+  const bulletPattern = /^[-*•]\s+(.+)$/gmu;
+  const bullets: string[] = [];
+  let match;
+
+  while ((match = bulletPattern.exec(description)) !== null) {
+    bullets.push(match[1].trim());
+  }
+
+  if (bullets.length > 0) {
+    return bullets;
+  }
+
+  const sentences = description
+    .split(/[.!?]+/u)
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+
+  return sentences.slice(0, 3);
+}
+
+/**
+ * Finds book context paths that are relevant to a goal.
+ */
+function findGroundingForGoal(
+  goalDesc: string,
+  contextEntries: readonly ContextPacketEntry[],
+): string[] {
+  const goalWords = new Set(
+    goalDesc
+      .toLowerCase()
+      .split(/\W+/u)
+      .filter((w) => w.length > 3),
+  );
+
+  return contextEntries
+    .filter((entry) => {
+      const entryWords = new Set(
+        entry.excerpt
+          .toLowerCase()
+          .split(/\W+/u)
+          .filter((w) => w.length > 3),
+      );
+
+      const commonWords = [...goalWords].filter((w) => entryWords.has(w));
+      return commonWords.length >= 1;
+    })
+    .map((entry) => entry.path);
+}
+
+/**
+ * Calculates a goal's rank based on how well it's grounded.
+ * Higher rank = better grounded = should be prioritized.
+ */
+function calculateRank(
+  grounding: string[],
+  _allPaths: Set<string>,
+  baseIndex: number,
+): number {
+  const groundingScore = Math.min(grounding.length, 5) * 10;
+  const positionPenalty = baseIndex;
+
+  return 100 + groundingScore - positionPenalty;
+}

src/strategy/parser.ts

@@ -0,0 +1,24 @@
+import { randomUUID } from "node:crypto";
+import type { Decision, DecisionSeedRequest } from "./types.js";
+
+/**
+ * Parses a decision seed request and creates a Decision record.
+ */
+export function parseDecisionSeed(request: DecisionSeedRequest): Decision {
+  const description = request.description.trim();
+
+  if (description.length === 0) {
+    throw new Error("Decision description cannot be empty");
+  }
+
+  if (description.length > 500) {
+    throw new Error("Decision description must be 500 characters or less");
+  }
+
+  return {
+    createdAt: new Date(),
+    description,
+    id: randomUUID(),
+    status: "active",
+  };
+}