forgeos 0.1.0-alpha.12 → 0.1.0-alpha.13

package/src/forge/cli/parse.ts

@@ -164,6 +164,7 @@ export type ForgeCommand =
   | { kind: "do"; options: ForgeDoOptions }
   | { kind: "bench"; options: BenchCommandOptions }
   | { kind: "agent"; options: AgentCommandOptions }
+  | { kind: "mcp"; subcommand: "serve"; workspaceRoot: string }
   | { kind: "review"; options: ReviewCommandOptions }
   | { kind: "ui"; options: UiCommandOptions }
   | { kind: "manifest"; subcommand: "validate" | "import"; path: string; json: boolean; workspaceRoot: string }
@@ -336,6 +337,7 @@ export const TOP_LEVEL_COMMANDS = [
   "self-host",
   "agent-contract",
   "agent",
+  "mcp",
   "review",
   "ui",
   "doctor",
@@ -533,6 +535,10 @@ const AGENT_SUBCOMMANDS: AgentSubcommand[] = [
   "doctor",
   "print-context",
   "clean",
+  "install",
+  "ingest",
+  "context",
+  "memory",
 ];
 const REVIEW_SUBCOMMANDS: ReviewSubcommand[] = ["inspect", "list", "explain"];
 const REVIEW_MODES: ReviewMode[] = ["quick", "standard", "strict"];
@@ -890,12 +896,27 @@ export function parseCli(argv: string[]): ParsedCli {
     case "agent": {
       const subcommand = rest[0] as AgentSubcommand | undefined;
       if (!subcommand || !AGENT_SUBCOMMANDS.includes(subcommand)) {
-        errors.push("forge agent requires subcommand: list-targets, export, check, doctor, print-context, or clean");
+        errors.push("forge agent requires subcommand: list-targets, export, check, doctor, print-context, clean, install, ingest, context, or memory");
         return { command: null, workspaceRoot, errors };
       }
+      const inputRaw = parseOptionValue(argv, "--input");
+      let input: unknown;
+      if (inputRaw !== undefined) {
+        try {
+          input = JSON.parse(inputRaw);
+        } catch {
+          errors.push("--input must be valid JSON");
+        }
+      }
+      const limitRaw = parseOptionValue(argv, "--limit");
+      const limit = limitRaw ? Number(limitRaw) : undefined;
+      if (limitRaw !== undefined && (!Number.isFinite(limit) || limit! < 1)) {
+        errors.push("--limit must be a number >= 1");
+      }
       const target =
         (parseOptionValue(argv, "--target") as AgentAdapterTarget | undefined) ??
-        (subcommand === "export" || subcommand === "clean" ? "generic" : "generic");
+        (subcommand === "install" || subcommand === "ingest" ? rest[1] : undefined) ??
+        "generic";
       return {
         command: {
           kind: "agent",
@@ -909,12 +930,33 @@ export function parseCli(argv: string[]): ParsedCli {
             preserveUserSections: !parseFlag(argv, "--no-preserve-user-sections"),
             skills: !parseFlag(argv, "--no-skills"),
             rules: !parseFlag(argv, "--no-rules"),
+            eventName: parseOptionValue(argv, "--event"),
+            input,
+            entry: parseOptionValue(argv, "--entry") ?? (subcommand === "context" && rest[1] !== "--current" ? rest[1] : undefined),
+            current: parseFlag(argv, "--current"),
+            limit: limit ? Math.floor(limit) : undefined,
           },
         },
         workspaceRoot,
         errors,
       };
     }
+    case "mcp": {
+      const subcommand = rest[0];
+      if (subcommand !== "serve") {
+        errors.push("forge mcp requires subcommand: serve");
+        return { command: null, workspaceRoot, errors };
+      }
+      return {
+        command: {
+          kind: "mcp",
+          subcommand,
+          workspaceRoot,
+        },
+        workspaceRoot,
+        errors,
+      };
+    }
     case "review": {
       const requested = rest[0] as ReviewSubcommand | undefined;
       const subcommand =
@@ -2304,6 +2346,8 @@ export function hasUnknownOption(argv: string[]): string | null {
     "--policy",
     "--emit",
     "--event",
+    "--entry",
+    "--current",
     "--trigger",
     "--component",
     "--framework",
@@ -2442,6 +2486,7 @@ export function hasUnknownOption(argv: string[]): string | null {
         arg === "--policy" ||
         arg === "--emit" ||
         arg === "--event" ||
+        arg === "--entry" ||
         arg === "--trigger" ||
         arg === "--component" ||
         arg === "--package" ||

package/src/forge/delta/ids.ts

@@ -11,6 +11,8 @@ export type DeltaIdPrefix =
   | "rtcall"
   | "artifact"
   | "gitmap"
+  | "aevt"
+  | "amem"
   | "worksess"
   | "wssig"
   | "wssum";

package/src/forge/delta/schema.ts

@@ -1,4 +1,4 @@
-export const DELTA_SCHEMA_VERSION = "0.2.0";
+export const DELTA_SCHEMA_VERSION = "0.3.0";
 
 export const DELTA_SCHEMA_SQL = [
   `CREATE TABLE IF NOT EXISTS delta_meta (
@@ -179,6 +179,38 @@ export const DELTA_SCHEMA_SQL = [
     projection_version text,
     graph_hash text
   )`,
+  `CREATE TABLE IF NOT EXISTS agent_event_sources (
+    id text PRIMARY KEY,
+    source_name text NOT NULL,
+    source_kind text NOT NULL,
+    integration_kind text NOT NULL,
+    trust_level text NOT NULL,
+    config_json text,
+    created_at text NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS external_agent_events (
+    id text PRIMARY KEY,
+    source_id text NOT NULL,
+    external_session_id text,
+    external_turn_id text,
+    event_kind text NOT NULL,
+    captured_at text NOT NULL,
+    payload_redacted_json text NOT NULL,
+    payload_hash text,
+    raw_stored integer DEFAULT 0,
+    normalization_status text NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS agent_memory_events (
+    id text PRIMARY KEY,
+    external_event_id text,
+    forge_session_id text,
+    forge_change_id text,
+    operation_id text,
+    normalized_kind text NOT NULL,
+    summary text,
+    confidence real NOT NULL,
+    data_json text NOT NULL
+  )`,
   `CREATE INDEX IF NOT EXISTS operations_timestamp_idx ON operations(timestamp)`,
   `CREATE INDEX IF NOT EXISTS operations_kind_idx ON operations(kind)`,
   `CREATE INDEX IF NOT EXISTS operations_session_idx ON operations(session_id)`,
@@ -198,4 +230,9 @@ export const DELTA_SCHEMA_SQL = [
   `CREATE INDEX IF NOT EXISTS timeline_entities_event_idx ON timeline_entities(timeline_event_id)`,
   `CREATE INDEX IF NOT EXISTS timeline_edges_from_idx ON timeline_edges(from_event_id)`,
   `CREATE INDEX IF NOT EXISTS timeline_edges_to_idx ON timeline_edges(to_event_id)`,
+  `CREATE INDEX IF NOT EXISTS agent_event_sources_name_idx ON agent_event_sources(source_name, integration_kind)`,
+  `CREATE INDEX IF NOT EXISTS external_agent_events_source_idx ON external_agent_events(source_id, captured_at)`,
+  `CREATE INDEX IF NOT EXISTS external_agent_events_kind_idx ON external_agent_events(event_kind)`,
+  `CREATE INDEX IF NOT EXISTS agent_memory_events_kind_idx ON agent_memory_events(normalized_kind)`,
+  `CREATE INDEX IF NOT EXISTS agent_memory_events_operation_idx ON agent_memory_events(operation_id)`,
 ];

package/src/forge/delta/store.ts

@@ -9,6 +9,7 @@ import { createDeltaId } from "./ids.ts";
 import { redactDeltaPayload } from "./redaction.ts";
 import { classifyArtifactKind, classifyDeltaPath, type DeltaSemanticHint } from "./classifier.ts";
 import { readDeltaGitSnapshot, type DeltaGitSnapshot } from "./git-observer.ts";
+import type { AgentEventEnvelope, AgentMemoryEventRecord } from "../agent-memory/types.ts";
 
 export type DeltaActorKind = "human" | "agent" | "forge" | "ci" | "git" | "unknown";
 export type DeltaSessionSource = "forge-dev" | "forge-command" | "agent-adapter" | "git" | "auto";
@@ -88,6 +89,20 @@ export interface DeltaAppendInput {
   git?: { commitSha?: string; branch?: string; confidence?: number; metadata?: Record<string, unknown> };
 }
 
+export interface DeltaAgentMemoryEventInput {
+  envelope: AgentEventEnvelope;
+  summary?: string;
+  bindings?: {
+    toolName?: string;
+    command?: string;
+    exitCode?: number;
+    files?: string[];
+    entries?: string[];
+    proofs?: string[];
+    status?: string;
+  };
+}
+
 export interface DeltaTimelineFilter {
   target?: string;
   kind?: string;
@@ -394,6 +409,191 @@ export class DeltaStore {
     return operationId;
   }
 
+  async recordAgentMemoryEvent(input: DeltaAgentMemoryEventInput): Promise<AgentMemoryEventRecord> {
+    const envelope = input.envelope;
+    const timestamp = envelope.event.timestamp || new Date().toISOString();
+    const sourceId = deterministicTimelineId("agsrc", [
+      String(envelope.source.agent),
+      String(envelope.source.integration),
+      String(envelope.capture.trustLevel),
+    ]);
+    await this.adapter.query(
+      `INSERT INTO agent_event_sources (id, source_name, source_kind, integration_kind, trust_level, config_json, created_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)
+       ON CONFLICT (id) DO UPDATE
+       SET source_name = EXCLUDED.source_name,
+           source_kind = EXCLUDED.source_kind,
+           integration_kind = EXCLUDED.integration_kind,
+           trust_level = EXCLUDED.trust_level,
+           config_json = EXCLUDED.config_json`,
+      [
+        sourceId,
+        String(envelope.source.agent),
+        "external-agent",
+        String(envelope.source.integration),
+        envelope.capture.trustLevel,
+        JSON.stringify({ version: envelope.source.version }),
+        timestamp,
+      ],
+    );
+
+    const actorId = await this.ensureActor("agent", envelope.actor.name, {
+      source: envelope.source.agent,
+      model: envelope.actor.model,
+      integration: envelope.source.integration,
+    });
+    const forgeSessionId = envelope.session.forgeSessionId ?? await this.createSession({
+      source: "agent-adapter",
+      summary: `${envelope.source.agent} ${envelope.event.kind}`,
+      metadata: {
+        externalSessionId: envelope.session.externalSessionId,
+        source: envelope.source,
+      },
+      git: { branch: envelope.workspace.gitBranch, head: envelope.workspace.gitHead },
+    });
+    const bindings = input.bindings ?? {};
+    const operationId = await this.appendOperation({
+      sessionId: forgeSessionId,
+      actorId,
+      kind: envelope.event.kind,
+      summary: input.summary,
+      data: {
+        source: envelope.source,
+        session: envelope.session,
+        capture: envelope.capture,
+        privacy: envelope.privacy,
+        payload: envelope.payload,
+        toolName: bindings.toolName,
+        status: bindings.status,
+        entries: bindings.entries,
+        files: bindings.files,
+        proofs: bindings.proofs,
+      },
+      commandRun: bindings.command
+        ? {
+            commandName: bindings.command,
+            argv: [bindings.command],
+            exitCode: bindings.exitCode,
+          }
+        : undefined,
+      fileChanges: bindings.files?.map((path) => ({
+        path,
+        changeType: envelope.event.kind === "agent.file.changed" ? "modified" : "modified",
+        semanticHints: classifyDeltaPath(path),
+      })),
+      proof: bindings.proofs?.[0]
+        ? {
+            proofKind: bindings.proofs[0],
+            command: bindings.command,
+            result: bindings.status === "failed" ? "failed" : "passed",
+          }
+        : undefined,
+      git: envelope.workspace.gitHead || envelope.workspace.gitBranch
+        ? {
+            commitSha: envelope.workspace.gitHead,
+            branch: envelope.workspace.gitBranch,
+            confidence: envelope.capture.confidence,
+            metadata: { source: envelope.source.agent },
+          }
+        : undefined,
+    });
+
+    const externalEventId = createDeltaId("aevt");
+    const payloadJson = JSON.stringify(envelope.payload);
+    await this.adapter.query(
+      `INSERT INTO external_agent_events
+       (id, source_id, external_session_id, external_turn_id, event_kind, captured_at, payload_redacted_json, payload_hash, raw_stored, normalization_status)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 0, 'normalized')`,
+      [
+        externalEventId,
+        sourceId,
+        envelope.session.externalSessionId ?? null,
+        envelope.session.turnId ?? null,
+        envelope.event.kind,
+        timestamp,
+        payloadJson,
+        hashStable(payloadJson),
+      ],
+    );
+
+    const memoryId = createDeltaId("amem");
+    const data = {
+      envelope,
+      bindings,
+    };
+    await this.adapter.query(
+      `INSERT INTO agent_memory_events
+       (id, external_event_id, forge_session_id, forge_change_id, operation_id, normalized_kind, summary, confidence, data_json)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
+      [
+        memoryId,
+        externalEventId,
+        forgeSessionId,
+        null,
+        operationId,
+        envelope.event.kind,
+        input.summary ?? null,
+        envelope.capture.confidence,
+        JSON.stringify(data),
+      ],
+    );
+
+    return {
+      id: memoryId,
+      externalEventId,
+      sourceName: String(envelope.source.agent),
+      integrationKind: String(envelope.source.integration),
+      trustLevel: envelope.capture.trustLevel,
+      externalSessionId: envelope.session.externalSessionId,
+      externalTurnId: envelope.session.turnId,
+      eventKind: envelope.event.kind,
+      normalizedKind: envelope.event.kind,
+      summary: input.summary,
+      confidence: envelope.capture.confidence,
+      capturedAt: timestamp,
+      operationId,
+      data,
+    };
+  }
+
+  async listAgentMemoryEvents(filter: { target?: string; limit?: number } = {}): Promise<AgentMemoryEventRecord[]> {
+    const limit = Math.max(1, Math.min(filter.limit ?? 50, 200));
+    const params: unknown[] = [];
+    const clauses: string[] = [];
+    if (filter.target) {
+      params.push(`%${filter.target}%`);
+      clauses.push(`(ame.summary ILIKE $${params.length} OR ame.data_json ILIKE $${params.length})`);
+    }
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    const rows = await this.adapter.query(
+      `SELECT ame.*, e.external_session_id, e.external_turn_id, e.event_kind, e.captured_at,
+              s.source_name, s.integration_kind, s.trust_level
+       FROM agent_memory_events ame
+       JOIN external_agent_events e ON e.id = ame.external_event_id
+       JOIN agent_event_sources s ON s.id = e.source_id
+       ${where}
+       ORDER BY e.captured_at DESC, ame.id DESC
+       LIMIT ${limit}`,
+      params,
+    );
+    return rows.rows.reverse().map((row) => ({
+      id: String(row.id),
+      externalEventId: String(row.external_event_id),
+      sourceName: String(row.source_name),
+      integrationKind: String(row.integration_kind),
+      trustLevel: String(row.trust_level),
+      externalSessionId: typeof row.external_session_id === "string" ? row.external_session_id : undefined,
+      externalTurnId: typeof row.external_turn_id === "string" ? row.external_turn_id : undefined,
+      eventKind: String(row.event_kind),
+      normalizedKind: String(row.normalized_kind),
+      summary: typeof row.summary === "string" ? row.summary : undefined,
+      confidence: Number(row.confidence ?? 0),
+      capturedAt: String(row.captured_at),
+      operationId: typeof row.operation_id === "string" ? row.operation_id : undefined,
+      data: parseJsonRecord(row.data_json),
+    }));
+  }
+
   async status(): Promise<DeltaStatus> {
     const sessionRows = await this.adapter.query(
       `SELECT s.id, s.started_at, COUNT(o.id)::int AS operation_count
@@ -1093,6 +1293,7 @@ export class DeltaStore {
     const commands = uniqueStrings([
       ...commandResult.rows.map((item) => item.command_name),
       data.command,
+      data.toolName,
     ]);
     return {
       id: String(row.id),
@@ -1674,6 +1875,9 @@ function semanticEventKindForOperation(
   if (context.kind === "git.commit.detected" || context.kind === "git.mapping.detected") {
     return "git.exported";
   }
+  if (context.kind.startsWith("agent.") || context.kind.startsWith("approval.")) {
+    return context.kind;
+  }
   if (context.kind.startsWith("file.")) {
     return context.fileClusters.includes("policy.change") ? "policy.changed" : "modified";
   }
@@ -1721,14 +1925,26 @@ function semanticTitleForOperation(
   if (eventKind === "git.exported") {
     return "Exported to Git";
   }
+  if (eventKind === "agent.prompt.submitted") {
+    return `${agentNameFromContext(context) ?? "Agent"} submitted a prompt`;
+  }
+  if (eventKind.startsWith("agent.tool")) {
+    return `${agentNameFromContext(context) ?? "Agent"} ${String(context.data.toolName ?? context.commands[0] ?? "tool")} ${eventKind.split(".").pop()}`;
+  }
+  if (eventKind.startsWith("approval.")) {
+    return `${agentNameFromContext(context) ?? "Agent"} approval ${eventKind.split(".").pop()}`;
+  }
+  if (eventKind.startsWith("agent.")) {
+    return `${agentNameFromContext(context) ?? "Agent"} ${eventKind.replace(/^agent\./, "").replace(/\./g, " ")}`;
+  }
   return context.summary ?? context.kind;
 }
 
 function semanticSeverity(eventKind: string): string {
-  if (eventKind === "failed" || eventKind === "denied" || eventKind === "proof.failed") {
+  if (eventKind === "failed" || eventKind === "denied" || eventKind === "proof.failed" || eventKind.endsWith(".failed") || eventKind.endsWith(".denied")) {
     return "error";
   }
-  if (eventKind === "proof.passed" || eventKind === "executed") {
+  if (eventKind === "proof.passed" || eventKind === "executed" || eventKind.endsWith(".completed")) {
     return "success";
   }
   if (eventKind === "policy.changed" || eventKind === "dependency.added" || eventKind === "dependency.upgraded") {
@@ -1744,6 +1960,12 @@ function confidenceForSemanticEvent(context: DeltaOperationContext, eventKind: s
   if (eventKind === "policy.changed" && !context.data.policy) {
     return 0.78;
   }
+  if (context.kind.startsWith("agent.") || context.kind.startsWith("approval.")) {
+    const capture = context.data.capture && typeof context.data.capture === "object"
+      ? context.data.capture as Record<string, unknown>
+      : {};
+    return typeof capture.confidence === "number" ? capture.confidence : 0.86;
+  }
   return 0.95;
 }
 
@@ -1769,6 +1991,8 @@ function timelineEntitiesFromContext(
     add("runtime-entry", entry, eventKind === "executed" || eventKind === "denied" || eventKind === "failed" ? "primary" : "affected", 0.95);
     add("agent-tool", entry, "affected", 0.7);
   }
+  add("agent", agentNameFromContext(context), "source", 0.95);
+  add("agent-tool", context.data.toolName, eventKind.startsWith("agent.tool") ? "primary" : "affected", 0.95);
   for (const service of context.services) {
     add("external-service", service, eventKind === "imported" ? "primary" : "source", 0.88);
   }
@@ -1818,6 +2042,15 @@ function timelineEntitiesFromContext(
     : [{ kind: "session", name: context.sessionId ?? context.id, role: "source", confidence: 0.5 }];
 }
 
+function agentNameFromContext(context: DeltaOperationContext): string | undefined {
+  const source = context.data.source;
+  if (source && typeof source === "object" && !Array.isArray(source)) {
+    const agent = (source as Record<string, unknown>).agent;
+    return typeof agent === "string" && agent.length > 0 ? agent : undefined;
+  }
+  return undefined;
+}
+
 function parseTimelineEntityTarget(target: string | undefined): DeltaTimelineEntityRef | undefined {
   if (!target) {
     return undefined;

package/src/forge/version.ts

@@ -1,3 +1,3 @@
-export const FORGEOS_VERSION = "0.1.0-alpha.12";
+export const FORGEOS_VERSION = "0.1.0-alpha.13";
 export const GENERATOR_VERSION = FORGEOS_VERSION;
 export const CLI_VERSION = FORGEOS_VERSION;