causantic 0.6.1 → 0.7.0

package/dist/cli/skill-templates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skill-templates.d.ts","sourceRoot":"","sources":["../../src/cli/skill-templates.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,aAAa;IAC5B,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,gBAAgB,EAAE,aAAa,EAuyC3C,CAAC;AAEF;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAoGhD"}
+{"version":3,"file":"skill-templates.d.ts","sourceRoot":"","sources":["../../src/cli/skill-templates.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,aAAa;IAC5B,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,gBAAgB,EAAE,aAAa,EA6yC3C,CAAC;AAEF;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAsGhD"}

package/dist/cli/skill-templates.js

@@ -31,6 +31,7 @@ Pass these to the \`recall\` MCP tool:
 
 - **query** (required): A specific topic, decision, or problem to trace
 - **project**: Filter to a specific project slug (use \`/causantic-list-projects\` to discover names)
+- **agent**: Filter to a specific agent (e.g., "researcher"). Use for team sessions to scope recall to a single agent's work. The filter applies to seed selection only — chain walking crosses agent boundaries freely.
 
 ## When to Use
 
@@ -79,6 +80,7 @@ Pass these to the \`search\` MCP tool:
 
 - **query** (required): What to search for in memory
 - **project**: Filter to a specific project slug (use \`/causantic-list-projects\` to discover names)
+- **agent**: Filter to a specific agent (e.g., "researcher"). Use for team sessions to scope search to a single agent's contributions.
 
 ## When to Use
 
@@ -119,6 +121,7 @@ Pass these to the \`predict\` MCP tool:
 
 - **context** (required): A concise summary of the current task, topic, or question
 - **project**: Filter to a specific project slug
+- **agent**: Filter to a specific agent (e.g., "researcher"). Use for team sessions to scope predictions to a single agent's context.
 
 ## When to Use
 
@@ -311,6 +314,7 @@ Present a concise briefing:
 - Highlight unfinished work prominently — that's what the user needs most
 - If the last session ended mid-task, flag that clearly
 - For broader context beyond the last session, use timeline mode: call \`reconstruct\` with just \`project\` (no \`previous_session\`)
+- For team sessions: note the team composition (which agents were involved), what each agent worked on, and any inter-agent coordination that occurred
 `,
     },
     {
@@ -357,6 +361,7 @@ Use the \`list-sessions\` and \`reconstruct\` MCP tools from \`causantic\` to re
 - **previous_session**: Get the session before the current one (set to \`true\`)
 - **current_session_id**: Required when \`previous_session\` is true
 - **keep_newest**: Keep newest chunks when truncating (default: true)
+- **agent**: Filter to a specific agent (e.g., "researcher"). For team sessions, reconstructs only that agent's chunks. Agent boundaries are shown automatically when multiple agents are present.
 
 ## Interpreting User Intent
 
@@ -512,6 +517,7 @@ Summarize recent work across sessions by combining session browsing with context
 - Highlight work that was started but not completed — this is the most actionable info
 - If the time range has many sessions, prioritize breadth over depth
 - If no sessions found for the time range, suggest widening the range
+- For team sessions: attribute work to specific agents (e.g., "researcher explored X, tester validated Y") when agent boundaries are visible in the reconstructed context
 `,
     },
     {
@@ -1377,6 +1383,8 @@ Long-term memory is available via the \`causantic\` MCP server.
 
 **Key distinction:** \`recall\` is semantic (finds best topic match regardless of time). \`reconstruct\`/\`resume\` are time-ordered (finds most recent work). For any question about "last", "recent", or "latest" → use \`reconstruct\` or \`resume\`, never \`recall\`.
 
+**Agent filtering:** For team sessions (multiple agents), all retrieval tools accept an optional \`agent\` parameter to scope results to a specific agent (e.g., "researcher"). Agent boundaries are shown automatically in output when multiple agents contributed.
+
 ### Proactive Memory Usage
 
 **Check memory automatically (no skill needed) when:**

package/dist/cli/skill-templates.js.map

@@ -1 +1 @@
-{"version":3,"file":"skill-templates.js","sourceRoot":"","sources":["../../src/cli/skill-templates.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"skill-templates.js","sourceRoot":"","sources":["../../src/cli/skill-templates.ts"],"names":[],"mappings":"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"}

package/dist/ingest/edge-creator.d.ts

@@ -3,6 +3,7 @@
  * Creates only forward edges (earlier → later). Direction is inferred at query time.
  */
 import type { TransitionResult } from './edge-detector.js';
+import type { TeamEdgePoint } from './team-edge-detector.js';
 /**
  * Result of edge creation.
  */
@@ -33,4 +34,16 @@ export declare function createBriefEdge(parentLastChunkId: string, subAgentFirst
  * Create a debrief edge: last sub-agent chunk → first parent chunk after return.
  */
 export declare function createDebriefEdge(subAgentLastChunkId: string, parentFirstChunkId: string): Promise<void>;
+/**
+ * Create team edges from detected team edge points.
+ *
+ * Weights by edge type:
+ * - team-spawn: 0.9 (lead dispatching work)
+ * - team-report: 0.9 (teammate reporting results)
+ * - peer-message: 0.85 (lateral communication)
+ *
+ * @param points - Detected team edge points
+ * @returns Number of edges created
+ */
+export declare function createTeamEdges(points: TeamEdgePoint[]): Promise<number>;
 //# sourceMappingURL=edge-creator.d.ts.map

package/dist/ingest/edge-creator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"edge-creator.d.ts","sourceRoot":"","sources":["../../src/ingest/edge-creator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,sCAAsC;IACtC,YAAY,EAAE,MAAM,CAAC;IACrB,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAsB,0BAA0B,CAC9C,WAAW,EAAE,gBAAgB,EAAE,EAC/B,QAAQ,EAAE,MAAM,EAAE,GACjB,OAAO,CAAC,kBAAkB,CAAC,CAwB7B;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,cAAc,GAAG,eAAe,GAAG,OAAO,GAAG,SAAS,GACpE,OAAO,CAAC,IAAI,CAAC,CAUf;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,mBAAmB,EAAE,MAAM,EAC3B,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,MAAM,CAAC,CAYjB;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,iBAAiB,EAAE,MAAM,EACzB,oBAAoB,EAAE,MAAM,GAC3B,OAAO,CAAC,IAAI,CAAC,CAUf;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,mBAAmB,EAAE,MAAM,EAC3B,kBAAkB,EAAE,MAAM,GACzB,OAAO,CAAC,IAAI,CAAC,CAUf"}
+{"version":3,"file":"edge-creator.d.ts","sourceRoot":"","sources":["../../src/ingest/edge-creator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,sCAAsC;IACtC,YAAY,EAAE,MAAM,CAAC;IACrB,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAsB,0BAA0B,CAC9C,WAAW,EAAE,gBAAgB,EAAE,EAC/B,QAAQ,EAAE,MAAM,EAAE,GACjB,OAAO,CAAC,kBAAkB,CAAC,CAwB7B;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,cAAc,GAAG,eAAe,GAAG,OAAO,GAAG,SAAS,GACpE,OAAO,CAAC,IAAI,CAAC,CAUf;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,mBAAmB,EAAE,MAAM,EAC3B,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,MAAM,CAAC,CAYjB;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,iBAAiB,EAAE,MAAM,EACzB,oBAAoB,EAAE,MAAM,GAC3B,OAAO,CAAC,IAAI,CAAC,CAUf;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,mBAAmB,EAAE,MAAM,EAC3B,kBAAkB,EAAE,MAAM,GACzB,OAAO,CAAC,IAAI,CAAC,CAUf;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA2B9E"}

package/dist/ingest/edge-creator.js

@@ -85,4 +85,40 @@ export async function createDebriefEdge(subAgentLastChunkId, parentFirstChunkId)
         },
     ]);
 }
+/**
+ * Create team edges from detected team edge points.
+ *
+ * Weights by edge type:
+ * - team-spawn: 0.9 (lead dispatching work)
+ * - team-report: 0.9 (teammate reporting results)
+ * - peer-message: 0.85 (lateral communication)
+ *
+ * @param points - Detected team edge points
+ * @returns Number of edges created
+ */
+export async function createTeamEdges(points) {
+    const edges = [];
+    const weights = {
+        'team-spawn': 0.9,
+        'team-report': 0.9,
+        'peer-message': 0.85,
+    };
+    for (const point of points) {
+        for (const sourceId of point.sourceChunkIds) {
+            for (const targetId of point.targetChunkIds) {
+                edges.push({
+                    sourceChunkId: sourceId,
+                    targetChunkId: targetId,
+                    edgeType: 'forward',
+                    referenceType: point.edgeType,
+                    initialWeight: weights[point.edgeType],
+                });
+            }
+        }
+    }
+    if (edges.length > 0) {
+        createEdges(edges);
+    }
+    return edges.length;
+}
 //# sourceMappingURL=edge-creator.js.map

package/dist/ingest/edge-creator.js.map

@@ -1 +1 @@
-{"version":3,"file":"edge-creator.js","sourceRoot":"","sources":["../../src/ingest/edge-creator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAcvD;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAC9C,WAA+B,EAC/B,QAAkB;IAElB,MAAM,KAAK,GAAgB,EAAE,CAAC;IAE9B,KAAK,MAAM,CAAC,IAAI,WAAW,EAAE,CAAC;QAC5B,MAAM,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;QACzC,MAAM,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;QAEzC,KAAK,CAAC,IAAI,CAAC;YACT,aAAa,EAAE,QAAQ;YACvB,aAAa,EAAE,QAAQ;YACvB,QAAQ,EAAE,SAAS;YACnB,aAAa,EAAE,CAAC,CAAC,IAAI;YACrB,aAAa,EAAE,GAAG;SACnB,CAAC,CAAC;IACL,CAAC;IAED,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACrB,WAAW,CAAC,KAAK,CAAC,CAAC;IACrB,CAAC;IAED,OAAO;QACL,YAAY,EAAE,KAAK,CAAC,MAAM;QAC1B,UAAU,EAAE,KAAK,CAAC,MAAM;KACzB,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,aAAqB,EACrB,aAAqB,EACrB,aAAqE;IAErE,WAAW,CAAC;QACV;YACE,aAAa;YACb,aAAa;YACb,QAAQ,EAAE,SAAS;YACnB,aAAa;YACb,aAAa,EAAE,GAAG;SACnB;KACF,CAAC,CAAC;AACL,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,mBAA2B,EAC3B,eAAuB;IAEvB,WAAW,CAAC;QACV;YACE,aAAa,EAAE,mBAAmB;YAClC,aAAa,EAAE,eAAe;YAC9B,QAAQ,EAAE,SAAS;YACnB,aAAa,EAAE,eAAe;YAC9B,aAAa,EAAE,GAAG;SACnB;KACF,CAAC,CAAC;IAEH,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,iBAAyB,EACzB,oBAA4B;IAE5B,WAAW,CAAC;QACV;YACE,aAAa,EAAE,iBAAiB;YAChC,aAAa,EAAE,oBAAoB;YACnC,QAAQ,EAAE,SAAS;YACnB,aAAa,EAAE,OAAO;YACtB,aAAa,EAAE,GAAG;SACnB;KACF,CAAC,CAAC;AACL,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,mBAA2B,EAC3B,kBAA0B;IAE1B,WAAW,CAAC;QACV;YACE,aAAa,EAAE,mBAAmB;YAClC,aAAa,EAAE,kBAAkB;YACjC,QAAQ,EAAE,SAAS;YACnB,aAAa,EAAE,SAAS;YACxB,aAAa,EAAE,GAAG;SACnB;KACF,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"edge-creator.js","sourceRoot":"","sources":["../../src/ingest/edge-creator.ts"],"names":[],"mappings":"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"}

package/dist/ingest/index.d.ts

@@ -7,8 +7,12 @@ export { batchIngest, batchIngestDirectory, discoverSessions } from './batch-ing
 export type { BatchIngestOptions, BatchIngestResult } from './batch-ingest.js';
 export { detectCausalTransitions, detectTransitions, getTimeGapMs } from './edge-detector.js';
 export type { TransitionResult, DetectionOptions } from './edge-detector.js';
-export { createEdgesFromTransitions, createForwardEdge, createCrossSessionEdges, createBriefEdge, createDebriefEdge, } from './edge-creator.js';
+export { createEdgesFromTransitions, createForwardEdge, createCrossSessionEdges, createBriefEdge, createDebriefEdge, createTeamEdges, } from './edge-creator.js';
 export type { EdgeCreationResult } from './edge-creator.js';
 export { linkCrossSession, linkAllSessions, isContinuedSession } from './cross-session-linker.js';
 export type { CrossSessionLinkResult } from './cross-session-linker.js';
+export { detectTeamTopology, groupTeammateFiles } from './team-detector.js';
+export type { TeamTopology, TeammateFileGroup } from './team-detector.js';
+export { detectTeamEdges } from './team-edge-detector.js';
+export type { TeamEdgePoint } from './team-edge-detector.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/ingest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ingest/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAClE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGvE,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACxF,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAG/E,OAAO,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC9F,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG7E,OAAO,EACL,0BAA0B,EAC1B,iBAAiB,EACjB,uBAAuB,EACvB,eAAe,EACf,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAG5D,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAClG,YAAY,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ingest/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAClE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGvE,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACxF,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAG/E,OAAO,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC9F,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG7E,OAAO,EACL,0BAA0B,EAC1B,iBAAiB,EACjB,uBAAuB,EACvB,eAAe,EACf,iBAAiB,EACjB,eAAe,GAChB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAG5D,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAClG,YAAY,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAGxE,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAG1E,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,YAAY,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/ingest/index.js

@@ -8,7 +8,11 @@ export { batchIngest, batchIngestDirectory, discoverSessions } from './batch-ing
 // Edge detection
 export { detectCausalTransitions, detectTransitions, getTimeGapMs } from './edge-detector.js';
 // Edge creation
-export { createEdgesFromTransitions, createForwardEdge, createCrossSessionEdges, createBriefEdge, createDebriefEdge, } from './edge-creator.js';
+export { createEdgesFromTransitions, createForwardEdge, createCrossSessionEdges, createBriefEdge, createDebriefEdge, createTeamEdges, } from './edge-creator.js';
 // Cross-session linking
 export { linkCrossSession, linkAllSessions, isContinuedSession } from './cross-session-linker.js';
+// Team detection
+export { detectTeamTopology, groupTeammateFiles } from './team-detector.js';
+// Team edge detection
+export { detectTeamEdges } from './team-edge-detector.js';
 //# sourceMappingURL=index.js.map

package/dist/ingest/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/ingest/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,iBAAiB;AACjB,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGlE,kBAAkB;AAClB,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAGxF,iBAAiB;AACjB,OAAO,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAG9F,gBAAgB;AAChB,OAAO,EACL,0BAA0B,EAC1B,iBAAiB,EACjB,uBAAuB,EACvB,eAAe,EACf,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAG3B,wBAAwB;AACxB,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/ingest/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,iBAAiB;AACjB,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGlE,kBAAkB;AAClB,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAGxF,iBAAiB;AACjB,OAAO,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAG9F,gBAAgB;AAChB,OAAO,EACL,0BAA0B,EAC1B,iBAAiB,EACjB,uBAAuB,EACvB,eAAe,EACf,iBAAiB,EACjB,eAAe,GAChB,MAAM,mBAAmB,CAAC;AAG3B,wBAAwB;AACxB,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAGlG,iBAAiB;AACjB,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAG5E,sBAAsB;AACtB,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/ingest/ingest-session.d.ts

@@ -64,6 +64,12 @@ export interface IngestResult {
     cacheMisses?: number;
     /** Reason for skip if skipped */
     skipReason?: 'already_ingested' | 'unchanged_file' | 'no_new_turns';
+    /** Number of team edges created */
+    teamEdges: number;
+    /** Number of dead-end sub-agent files skipped */
+    deadEndFilesSkipped: number;
+    /** Whether this session uses agent teams */
+    isTeamSession: boolean;
 }
 /**
  * Ingest a single session file.

package/dist/ingest/ingest-session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ingest-session.d.ts","sourceRoot":"","sources":["../../src/ingest/ingest-session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAaH,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAkBjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,KAAK,EAAQ,MAAM,oBAAoB,CAAC;AAKtD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,+CAA+C;IAC/C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,8CAA8C;IAC9C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,iDAAiD;IACjD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+CAA+C;IAC/C,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,iDAAiD;IACjD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,uDAAuD;IACvD,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,yCAAyC;IACzC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,0EAA0E;IAC1E,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,0CAA0C;IAC1C,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,+EAA+E;IAC/E,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,iBAAiB;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,+BAA+B;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,8BAA8B;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,4CAA4C;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,OAAO,EAAE,OAAO,CAAC;IACjB,iCAAiC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,qCAAqC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uCAAuC;IACvC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iCAAiC;IACjC,UAAU,CAAC,EAAE,kBAAkB,GAAG,gBAAgB,GAAG,cAAc,CAAC;CACrE;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC,CAqUvB;AA6ED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAarD"}
+{"version":3,"file":"ingest-session.d.ts","sourceRoot":"","sources":["../../src/ingest/ingest-session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAaH,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAyBjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,KAAK,EAAQ,MAAM,oBAAoB,CAAC;AAQtD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,+CAA+C;IAC/C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,8CAA8C;IAC9C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,iDAAiD;IACjD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+CAA+C;IAC/C,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,iDAAiD;IACjD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,uDAAuD;IACvD,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,yCAAyC;IACzC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,0EAA0E;IAC1E,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,0CAA0C;IAC1C,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,+EAA+E;IAC/E,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,iBAAiB;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,+BAA+B;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,8BAA8B;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,4CAA4C;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,OAAO,EAAE,OAAO,CAAC;IACjB,iCAAiC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,qCAAqC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uCAAuC;IACvC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iCAAiC;IACjC,UAAU,CAAC,EAAE,kBAAkB,GAAG,gBAAgB,GAAG,cAAc,CAAC;IACpE,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,mBAAmB,EAAE,MAAM,CAAC;IAC5B,4CAA4C;IAC5C,aAAa,EAAE,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC,CAmkBvB;AAyID;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAarD"}

package/dist/ingest/ingest-session.js

@@ -17,11 +17,15 @@ import { getModel } from '../models/model-registry.js';
 import { insertChunks, isSessionIngested } from '../storage/chunk-store.js';
 import { vectorStore } from '../storage/vector-store.js';
 import { detectCausalTransitions } from './edge-detector.js';
-import { createEdgesFromTransitions, createBriefEdge, createDebriefEdge } from './edge-creator.js';
+import { createEdgesFromTransitions, createBriefEdge, createDebriefEdge, createTeamEdges, } from './edge-creator.js';
 import { linkCrossSession } from './cross-session-linker.js';
 import { detectBriefPoints, detectDebriefPoints, buildChunkIdsByTurn, } from './brief-debrief-detector.js';
+import { detectTeamTopology, groupTeammateFiles } from './team-detector.js';
+import { detectTeamEdges } from './team-edge-detector.js';
 import { getCheckpoint, saveCheckpoint } from '../storage/checkpoint-store.js';
 import { computeContentHash, getCachedEmbeddingsBatch, cacheEmbeddingsBatch, } from '../storage/embedding-cache.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('ingest-session');
 /** Threshold for streaming file parsing (10MB) */
 const STREAMING_THRESHOLD_BYTES = 10 * 1024 * 1024;
 /**
@@ -54,6 +58,9 @@ export async function ingestSession(sessionPath, options = {}) {
                 skipReason: 'unchanged_file',
                 durationMs: Date.now() - startTime,
                 subAgentCount: 0,
+                teamEdges: 0,
+                deadEndFilesSkipped: 0,
+                isTeamSession: false,
             };
         }
     }
@@ -70,6 +77,9 @@ export async function ingestSession(sessionPath, options = {}) {
             skipReason: 'already_ingested',
             durationMs: Date.now() - startTime,
             subAgentCount: 0,
+            teamEdges: 0,
+            deadEndFilesSkipped: 0,
+            isTeamSession: false,
         };
     }
     // Use streaming for large files
@@ -113,6 +123,9 @@ export async function ingestSession(sessionPath, options = {}) {
             skipReason: startTurnIndex > 0 ? 'no_new_turns' : undefined,
             durationMs: Date.now() - startTime,
             subAgentCount: 0,
+            teamEdges: 0,
+            deadEndFilesSkipped: 0,
+            isTeamSession: false,
         };
     }
     // Set up embedding — single embedder, sequential inference
@@ -138,49 +151,226 @@ export async function ingestSession(sessionPath, options = {}) {
         let totalChunkCount = 0;
         let totalEdgeCount = 0;
         let subAgentEdges = 0;
+        let teamEdgeCount = 0;
+        let deadEndFilesSkipped = 0;
         const subAgentData = new Map();
-        // 1. Discover and process sub-agents first (if enabled)
+        // 1. Discover sub-agents (if enabled)
         let subAgentInfos = [];
         if (processSubAgents) {
             subAgentInfos = await discoverSubAgents(sessionPath);
-            for (const subAgent of subAgentInfos) {
-                // Parse sub-agent session
-                const subMessages = await readSessionMessages(subAgent.filePath, {
-                    includeSidechains: true,
+            // Filter out dead-end files
+            const activeSubAgents = [];
+            for (const sa of subAgentInfos) {
+                if (sa.isDeadEnd) {
+                    deadEndFilesSkipped++;
+                    log.debug('Skipping dead-end sub-agent file', {
+                        agentId: sa.agentId,
+                        lineCount: sa.lineCount,
+                    });
+                }
+                else {
+                    activeSubAgents.push(sa);
+                }
+            }
+            // Detect team topology using ALL turns (not turnsToProcess — needs full history)
+            const topology = detectTeamTopology(turns, activeSubAgents);
+            if (topology.isTeamSession) {
+                log.info('Detected team session', {
+                    teamName: topology.teamName,
+                    teammates: topology.teammates.size,
+                    teamAgentIds: topology.teamAgentIds.size,
                 });
-                const subTurns = assembleTurns(subMessages);
-                if (subTurns.length === 0)
-                    continue;
-                // Chunk sub-agent turns
-                const subChunks = chunkTurns(subTurns, {
+                // Partition sub-agents: team members vs regular sub-agents
+                const regularSubAgents = [];
+                const teamSubAgents = [];
+                for (const sa of activeSubAgents) {
+                    if (topology.teamAgentIds.has(sa.agentId)) {
+                        teamSubAgents.push(sa);
+                    }
+                    else {
+                        regularSubAgents.push(sa);
+                    }
+                }
+                // Process regular sub-agents through existing brief/debrief pipeline
+                for (const subAgent of regularSubAgents) {
+                    const result = await processSubAgent(subAgent, info.sessionId, projectSlug, projectPath, maxTokensPerChunk, includeThinking, embedAllFn, embeddingModel, useEmbeddingCache);
+                    if (!result)
+                        continue;
+                    totalChunkCount += result.chunkCount;
+                    totalEdgeCount += result.edgeCount;
+                    totalCacheHits += result.cacheHits;
+                    totalCacheMisses += result.cacheMisses;
+                    subAgentData.set(subAgent.agentId, { turns: result.turns, chunks: result.chunks });
+                }
+                // Process team members: group by teammate name, then process each file
+                const teammateGroups = groupTeammateFiles(teamSubAgents, topology);
+                const teamAgentData = new Map();
+                for (const group of teammateGroups) {
+                    for (const subAgent of group.files) {
+                        const subMessages = await readSessionMessages(subAgent.filePath, {
+                            includeSidechains: true,
+                        });
+                        const subTurns = assembleTurns(subMessages);
+                        if (subTurns.length === 0)
+                            continue;
+                        const subChunks = chunkTurns(subTurns, {
+                            maxTokens: maxTokensPerChunk,
+                            includeThinking,
+                            sessionId: info.sessionId,
+                            sessionSlug: projectSlug,
+                        });
+                        if (subChunks.length === 0)
+                            continue;
+                        // Store with human-readable agentId and teamName
+                        const subChunkInputs = subChunks.map((chunk) => ({
+                            ...chunkToInput(chunk),
+                            projectPath,
+                            agentId: group.humanName,
+                            teamName: topology.teamName ?? undefined,
+                        }));
+                        const subChunkIds = insertChunks(subChunkInputs);
+                        // Embed
+                        const { embeddings: subEmbeddings, cacheHits: ch, cacheMisses: cm, } = await embedChunksWithCache(subChunks, embedAllFn, embeddingModel, useEmbeddingCache);
+                        totalCacheHits += ch;
+                        totalCacheMisses += cm;
+                        await vectorStore.insertBatch(subChunkIds.map((id, i) => ({ id, embedding: subEmbeddings[i] })));
+                        // Create within-chain edges
+                        const subTransitions = detectCausalTransitions(subChunks);
+                        const subEdgeResult = await createEdgesFromTransitions(subTransitions, subChunkIds);
+                        totalChunkCount += subChunkIds.length;
+                        totalEdgeCount += subEdgeResult.totalCount;
+                        // Store for team edge detection (use ChunkInput with IDs)
+                        const chunkInputsWithIds = subChunkInputs.map((c, i) => ({ ...c, id: subChunkIds[i] }));
+                        const existing = teamAgentData.get(group.humanName);
+                        if (existing) {
+                            existing.turns.push(...subTurns);
+                            existing.chunks.push(...chunkInputsWithIds);
+                        }
+                        else {
+                            teamAgentData.set(group.humanName, {
+                                turns: subTurns,
+                                chunks: chunkInputsWithIds,
+                            });
+                        }
+                    }
+                }
+                // 2. Chunk main session (only new turns)
+                const mainChunks = chunkTurns(turnsToProcess, {
                     maxTokens: maxTokensPerChunk,
                     includeThinking,
                     sessionId: info.sessionId,
                     sessionSlug: projectSlug,
                 });
-                if (subChunks.length === 0)
+                if (mainChunks.length === 0) {
+                    return {
+                        sessionId: info.sessionId,
+                        sessionSlug: projectSlug,
+                        chunkCount: totalChunkCount,
+                        edgeCount: totalEdgeCount,
+                        crossSessionEdges: 0,
+                        subAgentEdges: 0,
+                        skipped: false,
+                        durationMs: Date.now() - startTime,
+                        subAgentCount: subAgentInfos.length,
+                        cacheHits: totalCacheHits,
+                        cacheMisses: totalCacheMisses,
+                        teamEdges: 0,
+                        deadEndFilesSkipped,
+                        isTeamSession: true,
+                    };
+                }
+                // Store main chunks
+                const mainChunkInputs = mainChunks.map((chunk) => ({
+                    ...chunkToInput(chunk),
+                    projectPath,
+                }));
+                const mainChunkIds = insertChunks(mainChunkInputs);
+                // Embed main chunks
+                const { embeddings: mainEmbeddings, cacheHits: mainCH, cacheMisses: mainCM, } = await embedChunksWithCache(mainChunks, embedAllFn, embeddingModel, useEmbeddingCache);
+                totalCacheHits += mainCH;
+                totalCacheMisses += mainCM;
+                await vectorStore.insertBatch(mainChunkIds.map((id, i) => ({ id, embedding: mainEmbeddings[i] })));
+                // Create main intra-session edges
+                const mainTransitions = detectCausalTransitions(mainChunks);
+                const mainEdgeResult = await createEdgesFromTransitions(mainTransitions, mainChunkIds);
+                totalChunkCount += mainChunkIds.length;
+                totalEdgeCount += mainEdgeResult.totalCount;
+                // Brief/debrief edges for regular sub-agents
+                if (subAgentData.size > 0) {
+                    const chunkIdsByTurn = buildChunkIdsByTurn(mainChunks.map((c, i) => ({ ...c, id: mainChunkIds[i] })));
+                    const briefPoints = detectBriefPoints(turnsToProcess, chunkIdsByTurn, undefined, 0);
+                    for (const brief of briefPoints) {
+                        const subData = subAgentData.get(brief.agentId);
+                        if (subData && subData.chunks.length > 0) {
+                            const lastParentChunkId = brief.parentChunkIds[brief.parentChunkIds.length - 1];
+                            const firstSubAgentChunkId = subData.chunks[0].id;
+                            await createBriefEdge(lastParentChunkId, firstSubAgentChunkId);
+                            subAgentEdges += 1;
+                        }
+                    }
+                    const debriefPoints = detectDebriefPoints(turnsToProcess, new Map(Array.from(subAgentData.entries()).map(([k, v]) => [k, v.chunks])), mainChunks.map((c, i) => ({ ...c, id: mainChunkIds[i] })), chunkIdsByTurn, undefined, 1);
+                    for (const debrief of debriefPoints) {
+                        const lastAgentChunkId = debrief.agentFinalChunkIds[debrief.agentFinalChunkIds.length - 1];
+                        const firstParentChunkId = debrief.parentChunkIds[0];
+                        await createDebriefEdge(lastAgentChunkId, firstParentChunkId);
+                        subAgentEdges += 1;
+                    }
+                }
+                // Detect and create team edges
+                if (teamAgentData.size > 0) {
+                    const mainChunkInputsForEdges = mainChunks.map((c, i) => ({
+                        ...chunkToInput(c),
+                        projectPath,
+                        id: mainChunkIds[i],
+                    }));
+                    const teamEdgePoints = detectTeamEdges(turns, // Use ALL turns for detection
+                    mainChunkInputsForEdges, teamAgentData, topology);
+                    teamEdgeCount = await createTeamEdges(teamEdgePoints);
+                    totalEdgeCount += teamEdgeCount;
+                }
+                // Save checkpoint
+                if (useIncrementalIngestion) {
+                    saveCheckpoint({
+                        sessionId: info.sessionId,
+                        projectSlug,
+                        lastTurnIndex: startTurnIndex + turnsToProcess.length - 1,
+                        lastChunkId: mainChunkIds[mainChunkIds.length - 1],
+                        fileMtime,
+                    });
+                }
+                // Link cross-sessions
+                let crossSessionEdges = 0;
+                if (linkCrossSessions) {
+                    const linkResult = await linkCrossSession(info.sessionId, projectSlug);
+                    crossSessionEdges = linkResult.edgeCount;
+                }
+                return {
+                    sessionId: info.sessionId,
+                    sessionSlug: projectSlug,
+                    chunkCount: totalChunkCount,
+                    edgeCount: totalEdgeCount,
+                    crossSessionEdges,
+                    subAgentEdges,
+                    skipped: false,
+                    durationMs: Date.now() - startTime,
+                    subAgentCount: subAgentInfos.length,
+                    cacheHits: totalCacheHits,
+                    cacheMisses: totalCacheMisses,
+                    teamEdges: teamEdgeCount,
+                    deadEndFilesSkipped,
+                    isTeamSession: true,
+                };
+            }
+            // Non-team session: process all active sub-agents through existing pipeline
+            for (const subAgent of activeSubAgents) {
+                const result = await processSubAgent(subAgent, info.sessionId, projectSlug, projectPath, maxTokensPerChunk, includeThinking, embedAllFn, embeddingModel, useEmbeddingCache);
+                if (!result)
                     continue;
-                // Store sub-agent chunks
-                const subChunkInputs = subChunks.map((chunk) => ({ ...chunkToInput(chunk), projectPath }));
-                const subChunkIds = insertChunks(subChunkInputs);
-                // Embed with caching and true batch embedding
-                const { embeddings: subEmbeddings, cacheHits, cacheMisses, } = await embedChunksWithCache(subChunks, embedAllFn, embeddingModel, useEmbeddingCache);
-                totalCacheHits += cacheHits;
-                totalCacheMisses += cacheMisses;
-                await vectorStore.insertBatch(subChunkIds.map((id, i) => ({
-                    id,
-                    embedding: subEmbeddings[i],
-                })));
-                // Create intra-agent edges
-                const subTransitions = detectCausalTransitions(subChunks);
-                const subEdgeResult = await createEdgesFromTransitions(subTransitions, subChunkIds);
-                totalChunkCount += subChunkIds.length;
-                totalEdgeCount += subEdgeResult.totalCount;
-                // Store for brief/debrief detection
-                subAgentData.set(subAgent.agentId, {
-                    turns: subTurns,
-                    chunks: subChunks.map((c, i) => ({ ...c, id: subChunkIds[i] })),
-                });
+                totalChunkCount += result.chunkCount;
+                totalEdgeCount += result.edgeCount;
+                totalCacheHits += result.cacheHits;
+                totalCacheMisses += result.cacheMisses;
+                subAgentData.set(subAgent.agentId, { turns: result.turns, chunks: result.chunks });
             }
         }
         // 2. Chunk main session (only new turns)
@@ -203,6 +393,9 @@ export async function ingestSession(sessionPath, options = {}) {
                 subAgentCount: subAgentInfos.length,
                 cacheHits: totalCacheHits,
                 cacheMisses: totalCacheMisses,
+                teamEdges: 0,
+                deadEndFilesSkipped,
+                isTeamSession: false,
             };
         }
         // Store main chunks
@@ -275,6 +468,9 @@ export async function ingestSession(sessionPath, options = {}) {
             subAgentCount: subAgentInfos.length,
             cacheHits: totalCacheHits,
             cacheMisses: totalCacheMisses,
+            teamEdges: 0,
+            deadEndFilesSkipped,
+            isTeamSession: false,
         };
     }
     finally {
@@ -283,6 +479,40 @@ export async function ingestSession(sessionPath, options = {}) {
         }
     }
 }
+/**
+ * Process a single sub-agent file: parse, chunk, embed, store, create edges.
+ * Extracted to reduce duplication between team and non-team paths.
+ */
+async function processSubAgent(subAgent, sessionId, sessionSlug, projectPath, maxTokensPerChunk, includeThinking, embedAllFn, embeddingModel, useEmbeddingCache) {
+    const subMessages = await readSessionMessages(subAgent.filePath, {
+        includeSidechains: true,
+    });
+    const subTurns = assembleTurns(subMessages);
+    if (subTurns.length === 0)
+        return null;
+    const subChunks = chunkTurns(subTurns, {
+        maxTokens: maxTokensPerChunk,
+        includeThinking,
+        sessionId,
+        sessionSlug,
+    });
+    if (subChunks.length === 0)
+        return null;
+    const subChunkInputs = subChunks.map((chunk) => ({ ...chunkToInput(chunk), projectPath }));
+    const subChunkIds = insertChunks(subChunkInputs);
+    const { embeddings: subEmbeddings, cacheHits, cacheMisses, } = await embedChunksWithCache(subChunks, embedAllFn, embeddingModel, useEmbeddingCache);
+    await vectorStore.insertBatch(subChunkIds.map((id, i) => ({ id, embedding: subEmbeddings[i] })));
+    const subTransitions = detectCausalTransitions(subChunks);
+    const subEdgeResult = await createEdgesFromTransitions(subTransitions, subChunkIds);
+    return {
+        turns: subTurns,
+        chunks: subChunks.map((c, i) => ({ ...c, id: subChunkIds[i] })),
+        chunkCount: subChunkIds.length,
+        edgeCount: subEdgeResult.totalCount,
+        cacheHits,
+        cacheMisses,
+    };
+}
 /**
  * Embed chunks with optional content-hash caching.
  *