@jmanuelcorral/openteam 0.2.2 → 0.9.0

package/dist/memory/traverse.d.ts

@@ -0,0 +1,80 @@
+import { type RecallDeps } from "./recall";
+import { type Embedding, type MemoryRecord, type RecallQuery, type RecallResult } from "./types";
+/**
+ * Pure, deterministic multi-hop traversal over the relation-edge graph (W5-S02).
+ * The graph nodes are entity identifiers (an edge's `from`/`to`) and the arcs are
+ * the typed relation edges introduced in W5-S01. This module has no I/O, clock,
+ * randomness, or env access: the reference instant `asOf` (epoch ms) and the
+ * owner scope are always injected, exactly like `recall`/`temporal`.
+ *
+ * Traversal is:
+ * - owner-scoped: only edges visible to `ownerKey` (plus the shared sentinel when
+ *   `includeShared`) are walked, so a traversal can never cross `ownerKey`.
+ * - bitemporal: an edge is only walked if it is active at `asOf` (reusing
+ *   `isActiveAt`), so invalidated or superseded edges drop out of the graph.
+ * - depth-bounded and cycle-safe: BFS by depth up to `maxDepth`, each node
+ *   visited once.
+ *
+ * It WRAPS vector recall (`recallGraph`): the seed is a node reached by the
+ * existing similarity pipeline; recall behaviour is left byte-identical for
+ * callers that do not ask for traversal.
+ */
+/** A node reached by traversal, tagged with its hop distance from the seed. */
+export type TraversalNode = {
+    id: string;
+    depth: number;
+};
+/** An edge walked during traversal; `depth` is the hop distance of `to`. */
+export type TraversalEdge = {
+    from: string;
+    to: string;
+    predicate: string;
+    depth: number;
+};
+/** The reachable sub-graph from a seed node. */
+export type TraversalResult = {
+    seed: string;
+    nodes: TraversalNode[];
+    edges: TraversalEdge[];
+};
+/** Owner-scoped, bitemporal, depth-bounded traversal request. */
+export type TraversalQuery = {
+    /** Entity identifier to start from (matched against edge `from`). */
+    seed: string;
+    ownerKey: string;
+    /** Reference instant (epoch ms) for bitemporal activity. */
+    asOf: number;
+    /** Maximum hop distance; `0` returns only the seed. */
+    maxDepth: number;
+    /** Include the shared sentinel owner. Defaults to `true`, like recall. */
+    includeShared?: boolean;
+};
+/**
+ * Walks the relation-edge graph from `query.seed` up to `query.maxDepth` hops,
+ * returning the reachable nodes (including the seed at depth 0) and the edges
+ * used to reach them. Only owner-scoped, bitemporally active edges participate.
+ */
+export declare function traverseRelations(records: readonly MemoryRecord[], query: TraversalQuery): TraversalResult;
+/** Extra knobs for the graph-aware wrapper around vector recall. */
+export type GraphRecallOptions = {
+    maxDepth: number;
+    includeShared?: boolean;
+};
+/** A traversal anchored on one recalled seed record. */
+export type GraphSeedTraversal = {
+    seedRecordId: string;
+    traversal: TraversalResult;
+};
+/** Vector recall plus the sub-graph reachable from each graph-bearing seed. */
+export type GraphRecallResult = {
+    recall: RecallResult[];
+    traversals: GraphSeedTraversal[];
+};
+/**
+ * Wraps `recall`: runs the unchanged vector pipeline to pick seeds, then walks
+ * the relation graph from each seed that names a node (entities and relations).
+ * The `recall` field is exactly what `recall(...)` returns today, so existing
+ * non-graph callers are unaffected; `traversals` is the additive layer.
+ */
+export declare function recallGraph(records: readonly MemoryRecord[], queryEmbedding: Embedding, query: RecallQuery, options: GraphRecallOptions, deps: RecallDeps): GraphRecallResult;
+//# sourceMappingURL=traverse.d.ts.map

package/dist/memory/traverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traverse.d.ts","sourceRoot":"","sources":["../../src/memory/traverse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAU,MAAM,UAAU,CAAC;AAEnD,OAAO,EACL,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,YAAY,EAGlB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;GAkBG;AAEH,+EAA+E;AAC/E,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,4EAA4E;AAC5E,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,gDAAgD;AAChD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB,CAAC;AAEF,iEAAiE;AACjE,MAAM,MAAM,cAAc,GAAG;IAC3B,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAcF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,KAAK,EAAE,cAAc,GACpB,eAAe,CAmDjB;AAWD,oEAAoE;AACpE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,wDAAwD;AACxD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,eAAe,CAAC;CAC5B,CAAC;AAEF,+EAA+E;AAC/E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,UAAU,EAAE,kBAAkB,EAAE,CAAC;CAClC,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,cAAc,EAAE,SAAS,EACzB,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,kBAAkB,EAC3B,IAAI,EAAE,UAAU,GACf,iBAAiB,CAsBnB"}

package/dist/memory/types.d.ts

@@ -45,7 +45,7 @@ export declare const FactSchema: z.ZodObject<{
     predicate: z.ZodString;
     object: z.ZodString;
     category: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 /** Preferencia del usuario/proyecto en una categoría. */
 export declare const PreferenceSchema: z.ZodObject<{
     id: z.ZodString;
@@ -63,7 +63,7 @@ export declare const PreferenceSchema: z.ZodObject<{
     context: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     lastAccessedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
     accessCount: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 /** Entidad canónica (persona/objeto/lugar/evento/organización). */
 export declare const EntitySchema: z.ZodObject<{
     id: z.ZodString;
@@ -79,7 +79,37 @@ export declare const EntitySchema: z.ZodObject<{
     canonicalName: z.ZodString;
     type: z.ZodString;
     aliases: z.ZodDefault<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
+}, z.core.$strict>;
+/**
+ * First-class typed relation edge between two entity endpoints (W5). A relation
+ * is the edge analogue of a `fact`: `from`/`to`/`predicate` are structural
+ * identifiers (entity canonicalNames + a typed label) that survive ADR-5
+ * redaction exactly like a fact's `subject`/`predicate`, while the optional
+ * free-text `annotation` is the only value redacted when `storeContent=false`.
+ * No raw prompt text is ever stored — the transcript only becomes `sourceHash`.
+ *
+ * decision/component are entity `type` values (see `EntitySchema.type`), not new
+ * memory kinds, so the graph is a set of entities connected by these edges. The
+ * relation inherits the full bitemporal + provenance base, so an edge can be
+ * invalidated (consolidation tombstone) or superseded (a newer edge in the same
+ * `{from, predicate, owner}` slot) just like a fact.
+ */
+export declare const RelationSchema: z.ZodObject<{
+    id: z.ZodString;
+    ownerKey: z.ZodString;
+    confidence: z.ZodNumber;
+    validFrom: z.ZodNumber;
+    validUntil: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    createdAt: z.ZodNumber;
+    invalidatedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    sourceHash: z.ZodString;
+    supersededBy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"relation">;
+    from: z.ZodString;
+    to: z.ZodString;
+    predicate: z.ZodString;
+    annotation: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
 export declare const MemoryRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     id: z.ZodString;
     ownerKey: z.ZodString;
@@ -95,7 +125,7 @@ export declare const MemoryRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     predicate: z.ZodString;
     object: z.ZodString;
     category: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-}, z.core.$strip>, z.ZodObject<{
+}, z.core.$strict>, z.ZodObject<{
     id: z.ZodString;
     ownerKey: z.ZodString;
     confidence: z.ZodNumber;
@@ -111,7 +141,7 @@ export declare const MemoryRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     context: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     lastAccessedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
     accessCount: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>, z.ZodObject<{
+}, z.core.$strict>, z.ZodObject<{
     id: z.ZodString;
     ownerKey: z.ZodString;
     confidence: z.ZodNumber;
@@ -125,7 +155,22 @@ export declare const MemoryRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     canonicalName: z.ZodString;
     type: z.ZodString;
     aliases: z.ZodDefault<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    ownerKey: z.ZodString;
+    confidence: z.ZodNumber;
+    validFrom: z.ZodNumber;
+    validUntil: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    createdAt: z.ZodNumber;
+    invalidatedAt: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    sourceHash: z.ZodString;
+    supersededBy: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodLiteral<"relation">;
+    from: z.ZodString;
+    to: z.ZodString;
+    predicate: z.ZodString;
+    annotation: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>], "kind">;
 /** Consulta de recall (dueño-scoped, temporal y semántica). */
 export declare const RecallQuerySchema: z.ZodObject<{
     ownerKey: z.ZodString;
@@ -138,11 +183,12 @@ export declare const RecallQuerySchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodNumber>;
     minSimilarity: z.ZodDefault<z.ZodNumber>;
     includeShared: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export type MemoryKind = z.infer<typeof MemoryKindSchema>;
 export type Fact = z.infer<typeof FactSchema>;
 export type Preference = z.infer<typeof PreferenceSchema>;
 export type Entity = z.infer<typeof EntitySchema>;
+export type Relation = z.infer<typeof RelationSchema>;
 export type MemoryRecord = z.infer<typeof MemoryRecordSchema>;
 export type RecallQuery = z.infer<typeof RecallQuerySchema>;
 /** Vector de embedding (dimensiones configurables). */

package/dist/memory/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/memory/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,qBAAqB,EAAG,CAAU,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAG,GAAY,CAAC;AAE7C,eAAO,MAAM,cAAc,aAAoB,CAAC;AAEhD,eAAO,MAAM,gBAAgB;;;;EAA2C,CAAC;AAiBzE,6EAA6E;AAC7E,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;iBAMrB,CAAC;AAEH,yDAAyD;AACzD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;iBAO3B,CAAC;AAEH,mEAAmE;AACnE,eAAO,MAAM,YAAY;;;;;;;;;;;;;;iBAKvB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAI7B,CAAC;AAEH,+DAA+D;AAC/D,eAAO,MAAM,iBAAiB;;;;;;;;;;;iBAQ5B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAClD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,uDAAuD;AACvD,MAAM,MAAM,SAAS,GAAG,SAAS,MAAM,EAAE,CAAC;AAE1C,yDAAyD;AACzD,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,kEAAkE;AAClE,MAAM,MAAM,YAAY,GAAG,eAAe,GAAG;IAC3C,KAAK,EAAE,MAAM,CAAC;CACf,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/memory/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,qBAAqB,EAAG,CAAU,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAG,GAAY,CAAC;AAE7C,eAAO,MAAM,cAAc,aAAoB,CAAC;AAEhD,eAAO,MAAM,gBAAgB;;;;EAA2C,CAAC;AAmBzE,6EAA6E;AAC7E,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;kBAMrB,CAAC;AAEH,yDAAyD;AACzD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;kBAO3B,CAAC;AAEH,mEAAmE;AACnE,eAAO,MAAM,YAAY;;;;;;;;;;;;;;kBAKvB,CAAC;AAEH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;kBAMzB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAK7B,CAAC;AAEH,+DAA+D;AAC/D,eAAO,MAAM,iBAAiB;;;;;;;;;;;kBAUnB,CAAC;AAEZ,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAClD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,uDAAuD;AACvD,MAAM,MAAM,SAAS,GAAG,SAAS,MAAM,EAAE,CAAC;AAE1C,yDAAyD;AACzD,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,kEAAkE;AAClE,MAAM,MAAM,YAAY,GAAG,eAAe,GAAG;IAC3C,KAAK,EAAE,MAAM,CAAC;CACf,CAAC"}

package/dist/messages/commands.d.ts

@@ -0,0 +1,84 @@
+/**
+ * User-facing message catalog for the `openteam` CLI command surface.
+ *
+ * Part of the `src/messages/**` boundary (see `./index.ts` for the full design
+ * decision). This file holds the English strings rendered by individual
+ * `src/commands/*` handlers, grouped one exported object per command, so a
+ * future translation edits one place instead of grepping call sites.
+ *
+ * Pure: data plus deterministic string builders only. No I/O, filesystem,
+ * network, clock, randomness, env vars, or logging. Static text is a typed
+ * constant; parameterised text is a small pure function returning `string`.
+ * Layout concerns (column widths, `padEnd` alignment) stay in the command
+ * handlers — only the human-readable text lives here.
+ */
+/** Messages for `openteam clear-cache`. */
+export declare const clearCacheMessages: {
+    readonly header: "openteam clear-cache — frozen plugin cache entries:";
+    readonly columns: {
+        readonly specDir: "spec dir";
+        readonly pinned: "spec-pinned";
+        readonly installed: "installed";
+        readonly mtime: "mtime";
+    };
+    readonly reparseSkipSuffix: "  [SKIP — reparse point]";
+    readonly deletedLabel: "deleted.";
+    readonly lockedLabel: (message: string) => string;
+    readonly pathOutsideWarning: (specDir: string, absolutePath: string) => string;
+    readonly processed: (count: number) => string;
+    readonly found: (count: number) => string;
+};
+/** Messages for `openteam baseline`. */
+export declare const baselineMessages: {
+    readonly effectiveAuto: "cheapest-capable (auto)";
+    readonly pinnedSuffix: (ref: string) => string;
+    readonly summary: (params: {
+        mode: string;
+        pinned: string;
+        hardDefault: string;
+        effective: string;
+    }) => string[];
+    readonly invalidModel: (input: string) => string;
+    readonly pinnedTo: (ref: string) => string;
+    readonly autoMode: "Baseline set to auto mode (cheapest-capable).";
+};
+/** Messages for `openteam local`. */
+export declare const localMessages: {
+    readonly noRuntimes: "none";
+    readonly modeFrontierOnly: "frontier-only (frontierOnly)";
+    readonly modeLocalFirst: "local-first";
+    readonly summary: (params: {
+        mode: string;
+        frontierOnly: boolean;
+        privacy: string;
+        runtimes: string;
+    }) => string[];
+    readonly frontierOnlyNoChange: "No change: already in frontier-only mode.";
+    readonly privacyAdjustedNote: " Privacy adjusted to 'consentBeforeFrontier' (forceLocalOnSensitive requires a local runtime).";
+    readonly frontierOnlyEnabled: "Frontier-only mode enabled (frontierOnly=true).";
+    readonly localFirstNoChange: "No change: local-first routing is already active.";
+    readonly localFirstReEnabled: "Local-first routing re-enabled (frontierOnly=false). Make sure a local runtime is reachable.";
+};
+/** Messages for the frontier catalog rendered during `init`. */
+export declare const frontierCatalogMessages: {
+    readonly free: "free";
+    readonly costPerMillion: (inputUSD: number, outputUSD: number) => string;
+};
+/** Messages for `openteam migrate`. */
+export declare const migrateMessages: {
+    readonly header: "openteam migrate:";
+    readonly nothingToMigrate: "  nothing to migrate — the P15b layout is already in place.";
+    readonly counts: (params: {
+        moved: number;
+        deduped: number;
+        conflicts: number;
+    }) => string[];
+    readonly relocatedHeader: "  relocated:";
+    readonly relocatedEntry: (from: string, to: string, deduped: boolean) => string;
+    readonly conflictsHeader: "  ⚠ left in place (destination exists with different content — no data lost):";
+    readonly conflictEntry: (from: string, to: string) => string;
+    readonly manualWorktreesHeader: "  ⚠ legacy git worktree(s) need a manual move (run `git worktree move`):";
+    readonly manualWorktreeEntry: (label: string, from: string, to: string) => string;
+    readonly success: "  ✓ machine-local runtime output relocated under .opencode/openteam-local/.";
+};
+//# sourceMappingURL=commands.d.ts.map

package/dist/messages/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../src/messages/commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,2CAA2C;AAC3C,eAAO,MAAM,kBAAkB;aAC7B,MAAM,EAAE,qDAAqD;aAC7D,OAAO;iBACL,OAAO,EAAE,UAAU;iBACnB,MAAM,EAAE,aAAa;iBACrB,SAAS,EAAE,WAAW;iBACtB,KAAK,EAAE,OAAO;;aAEhB,iBAAiB,EAAE,0BAA0B;aAC7C,YAAY,EAAE,UAAU;aACxB,WAAW,YAAY,MAAM,KAAG,MAAM;aACtC,kBAAkB,YAAY,MAAM,gBAAgB,MAAM,KAAG,MAAM;aAEnE,SAAS,UAAU,MAAM,KAAG,MAAM;aAClC,KAAK,UAAU,MAAM,KAAG,MAAM;CAEtB,CAAC;AAEX,wCAAwC;AACxC,eAAO,MAAM,gBAAgB;aAC3B,aAAa,EAAE,yBAAyB;aACxC,YAAY,QAAQ,MAAM,KAAG,MAAM;aACnC,OAAO,WAAW;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,EAAE,MAAM,CAAC;QACpB,SAAS,EAAE,MAAM,CAAC;KACnB,KAAG,MAAM,EAAE;aAOZ,YAAY,UAAU,MAAM,KAAG,MAAM;aAErC,QAAQ,QAAQ,MAAM,KAAG,MAAM;aAC/B,QAAQ,EAAE,+CAA+C;CACjD,CAAC;AAEX,qCAAqC;AACrC,eAAO,MAAM,aAAa;aACxB,UAAU,EAAE,MAAM;aAClB,gBAAgB,EAAE,8BAA8B;aAChD,cAAc,EAAE,aAAa;aAC7B,OAAO,WAAW;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,YAAY,EAAE,OAAO,CAAC;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;KAClB,KAAG,MAAM,EAAE;aAOZ,oBAAoB,EAAE,2CAA2C;aACjE,mBAAmB,EACjB,gGAAgG;aAClG,mBAAmB,EAAE,iDAAiD;aACtE,kBAAkB,EAAE,mDAAmD;aACvE,mBAAmB,EACjB,8FAA8F;CACxF,CAAC;AAEX,gEAAgE;AAChE,eAAO,MAAM,uBAAuB;aAClC,IAAI,EAAE,MAAM;aACZ,cAAc,aAAa,MAAM,aAAa,MAAM,KAAG,MAAM;CAErD,CAAC;AAEX,uCAAuC;AACvC,eAAO,MAAM,eAAe;aAC1B,MAAM,EAAE,mBAAmB;aAC3B,gBAAgB,EACd,6DAA6D;aAC/D,MAAM,WAAW;QACf,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;KACnB,KAAG,MAAM,EAAE;aAKZ,eAAe,EAAE,cAAc;aAC/B,cAAc,SAAS,MAAM,MAAM,MAAM,WAAW,OAAO,KAAG,MAAM;aAEpE,eAAe,EACb,+EAA+E;aACjF,aAAa,SAAS,MAAM,MAAM,MAAM,KAAG,MAAM;aACjD,qBAAqB,EACnB,0EAA0E;aAC5E,mBAAmB,UAAU,MAAM,QAAQ,MAAM,MAAM,MAAM,KAAG,MAAM;aAEtE,OAAO,EACL,6EAA6E;CACvE,CAAC"}

package/dist/messages/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * `src/messages/**` — the openteam user-facing message catalog.
+ *
+ * ## What this boundary is
+ * A **pure**, **single-locale (English)** catalog of every string a user reads:
+ * CLI stdout/stderr text, section headings, warnings, hints, wizard prompts and
+ * labels, and human-readable error text. Static text is an exported typed
+ * constant; parameterised text is a small exported pure function returning
+ * `string`. It is data + pure string functions only.
+ *
+ * ## Purity contract
+ * Like `src/router/**`, this boundary has **no I/O, filesystem, network, clock,
+ * randomness, env vars, or logging**. Handlers keep their layout logic (column
+ * widths, `padEnd` alignment, `\n` joins); the catalog owns only the text. This
+ * keeps the catalog deterministic and trivially testable, and lets the coverage
+ * gate hold it to 100% the same way it holds `src/router/**`.
+ *
+ * ## Why a catalog (the design decision)
+ * Centralising user-facing text is what makes the *next* translation cheap: one
+ * place to swap, instead of grepping ~1000 literals across the tree. Extraction
+ * is deliberately **opportunistic and incremental** (see issue #145), never a
+ * big-bang sweep — a mechanical 100+ file diff hides accidental code changes and
+ * cannot be reviewed. Files are migrated a safe slice at a time, preserving
+ * byte-identical output.
+ *
+ * ## Single-locale on purpose — no i18n runtime
+ * There is **exactly one locale (English) today**. The shape (typed constants +
+ * pure functions behind a stable export surface) means a second locale *could*
+ * be added later by swapping the catalog implementation without touching call
+ * sites. But we deliberately **do not** build an i18n runtime, locale loader,
+ * `Intl` plumbing, or any non-English resources now: that would be unused,
+ * speculative complexity. Add the machinery only when a real second locale
+ * lands.
+ *
+ * ## What counts as a "message"
+ * In the catalog: CLI stdout/stderr text, section headings, warnings, hints,
+ * human-readable error text, wizard prompts and labels.
+ *
+ * Deliberately **not** in the catalog (left where they are): object keys, ids,
+ * enum/discriminant values, file paths, URLs, protocol/JSON field names, SQL,
+ * CSS/HTML attribute names, provider/model identifiers, and anything only ever
+ * compared programmatically. Over-extraction buries real text in noise and is as
+ * harmful as under-extraction, so the boundary is kept strict.
+ */
+export * from "./commands";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/messages/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,cAAc,YAAY,CAAC"}

package/dist/opencodeArtifacts/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `src/opencodeArtifacts/**` — generated `.opencode/**` artifact content.
+ *
+ * This boundary holds the builders and path constants for the files that
+ * `openteam setup` writes into a project's `.opencode/**` tree:
+ * - `orchestratorAgent.ts` → `.opencode/agent/openteam.md` (the orchestrator
+ *   agent's system-prompt / instructions Markdown), and
+ * - `slashCommand.ts` → `.opencode/command/*.md` (slash-command definitions).
+ *
+ * ## Why this is its own boundary (read before moving anything here)
+ * The string literals in these modules are **model-/opencode-facing prose** — an
+ * LLM system prompt and opencode command definitions — NOT user-facing CLI
+ * output. They are therefore deliberately:
+ *
+ * 1. **NOT part of the `src/messages/**` user-message catalog.** Extracting this
+ *    prose into the catalog and translating it as if it were UI text would
+ *    corrupt the convention: an LLM system prompt is content, not a translatable
+ *    interface string.
+ * 2. **Outside the `messages-catalog-ratchet` gate's scope BY CONSTRUCTION.** That
+ *    gate scopes `src/commands/**` + `src/console/**`. These templates once lived
+ *    under `src/commands/` and were kept green only by a per-file `ARTIFACT`
+ *    allowlist — an unguarded laundering channel that would have let a real
+ *    CLI-message file be silenced just by listing it. Moving them into their own
+ *    boundary removes them from the gated scope structurally, so the gate is now
+ *    a clean two-list ratchet (MIGRATED + LEGACY) with no allowlist to append to.
+ *
+ * These files are not CLI commands. They only ever emit `.opencode/**` file
+ * content and produce no CLI stdout/stderr of their own. New generated-artifact
+ * builders belong here; a file that prints to the user does not.
+ */
+export { buildOrchestratorAgent, OPENTEAM_ROSTER_PATH, ORCHESTRATOR_AGENT_PATH, } from "./orchestratorAgent";
+export { buildOpenteamCommand, buildOpenteamCommands, OPENTEAM_COMMAND_DIR, type SlashCommandFile, } from "./slashCommand";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/opencodeArtifacts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,uBAAuB,GACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,KAAK,gBAAgB,GACtB,MAAM,gBAAgB,CAAC"}

package/dist/opencodeArtifacts/orchestratorAgent.d.ts

@@ -0,0 +1,29 @@
+import type { FrontierChoice } from "../commands/setup";
+/**
+ * Relative path (from cwd) to the primary agent that `openteam setup` generates. The
+ * filename (`openteam`) is the agent name in opencode.
+ */
+export declare const ORCHESTRATOR_AGENT_PATH = ".opencode/agent/openteam.md";
+/**
+ * Path to the casting registry (universe + name→role→model table). Lives
+ * **outside** `.opencode/agent/` intentionally: opencode loads as an agent every
+ * `.md` in that folder, so a stray roster markdown file inside would appear as a
+ * phantom agent in the Tab-switcher. It is portable team-state (P15b), so it lives
+ * in the git-tracked `.opencode/openteam/` directory alongside the decisions log.
+ */
+export declare const OPENTEAM_ROSTER_PATH = ".opencode/openteam/roster.md";
+/**
+ * Builds the Markdown for the `openteam` primary agent (multi-agent orchestrator):
+ * an orchestrator that appears in the Tab-switcher, chooses a thematic universe,
+ * casts the team, and creates subagents on demand (including the standard roles
+ * scribe, ralph and guardian). Pure: no I/O.
+ *
+ * `frontier` sets the orchestrator's `model` (baseline cheapest-capable), a
+ * real and resolvable `provider/model`; the openteam plugin continues routing per
+ * message, so subagents it creates can inherit the default and be
+ * routed local-first.
+ */
+export declare function buildOrchestratorAgent(frontier: FrontierChoice, options?: {
+    yolo?: boolean;
+}): string;
+//# sourceMappingURL=orchestratorAgent.d.ts.map

package/dist/opencodeArtifacts/orchestratorAgent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestratorAgent.d.ts","sourceRoot":"","sources":["../../src/opencodeArtifacts/orchestratorAgent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,gCAAgC,CAAC;AAErE;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,iCAAiC,CAAC;AAInE;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,cAAc,EACxB,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GAC/B,MAAM,CAiOR"}

package/dist/opencodeArtifacts/slashCommand.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Directory (relative to cwd) where opencode discovers the project's slash commands.
+ * opencode scans `{command,commands}/**\/*.md` (singular and plural) in
+ * each `.opencode/` in the tree and in `~/.config/opencode/`; the filename
+ * is the command name (verified in the opencode v1.17.8 source:
+ * `packages/opencode/src/config/command.ts`).
+ */
+export declare const OPENTEAM_COMMAND_DIR = ".opencode/command";
+export type SlashCommandFile = {
+    /** Command name (file `<name>.md`), invocable as `/<name>`. */
+    name: string;
+    path: string;
+    /** Markdown content (frontmatter + template). */
+    contents: string;
+};
+/**
+ * Builds the Markdown for the `/openteam` slash command (catch-all). Teaches the
+ * agent to map user arguments to a single `openteam` tool call. Must stay
+ * aligned with the actions of `commandArgv` in `src/plugin/commandTool.ts`.
+ * Pure/deterministic: no I/O.
+ */
+export declare function buildOpenteamCommand(): string;
+/**
+ * All slash commands that `openteam setup` writes to
+ * `.opencode/command/`. In addition to the catch-all `/openteam`, generates a flat
+ * command per action (`/openteam-doctor`, `/openteam-agents`, …) so that all
+ * appear and autocomplete in opencode's command palette when typing `/openteam`.
+ * Pure/deterministic: no I/O.
+ */
+export declare function buildOpenteamCommands(): SlashCommandFile[];
+//# sourceMappingURL=slashCommand.d.ts.map

package/dist/opencodeArtifacts/slashCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slashCommand.d.ts","sourceRoot":"","sources":["../../src/opencodeArtifacts/slashCommand.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,sBAAsB,CAAC;AAExD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAkBF;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAoB7C;AAqBD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,IAAI,gBAAgB,EAAE,CAmD1D"}

package/dist/orchestrator/coordinator.d.ts

@@ -1,10 +1,14 @@
+import { z } from "zod";
 import type { BudgetState } from "../capabilities/budget";
 import type { ModelCapabilityProfile } from "../capabilities/types";
 import type { OpenTeamConfig } from "../config/schema";
+import type { RuntimeConcurrencyLimiter } from "../local/concurrency";
+import type { LocalRuntimeId } from "../local/types";
 import type { AvailableModel, RoutingDecision, TaskSignals } from "../router/types";
 import { type EventSink } from "../telemetry/eventLog";
 import { type MeetingEvent, type RouteEvent } from "../telemetry/events";
 import type { CostRecord } from "../telemetry/types";
+import { type AgentRoleProfile } from "./roles";
 import { type OpencodeSessionClient, type SubsessionResult } from "./subsessions";
 export type RoleTaskInput = {
     roleID: string;
@@ -18,6 +22,14 @@ export type RoleTaskInput = {
     title?: string;
     systemPrompt?: string;
     directory?: string;
+    /**
+     * Dispatch alias override for the roleID/agentName split (#172, W3-S02). When a
+     * roster themes a role (e.g. roleID `scribe` → agentName `gandalf`), routing
+     * still keys on `roleID` but opencode must dispatch to the themed `agentName`.
+     * When set, it wins over the role profile's `opencodeAgent`; when absent, the
+     * profile's `opencodeAgent` is used exactly as before.
+     */
+    agentOverride?: string;
     /** Correlación opcional con una tarea del loop SDD/backlog (Fase D). */
     taskID?: string;
     /** Role IDs this task depends on. Dependents only run after dependencies succeed. */
@@ -29,6 +41,58 @@ export type CoordinatorDeps = {
     now: () => number;
     newDecisionID: () => string;
     timeoutMs?: number;
+    /** Optional warn sink; defaults to `console.warn`. Injectable for tests. */
+    warn?: (message?: unknown) => void;
+    /**
+     * Caller-owned Set for once-per-roleID dedup of `warnUnknownRole`. Production
+     * callers pass a long-lived Set (one per plugin instance) so the warning is
+     * emitted at most once per session. Test callers pass `new Set()` per case
+     * for full isolation. When absent, every call to `warnUnknownRole` emits.
+     */
+    warnedRoles?: Set<string>;
+    /**
+     * Reachability probe for local runtimes (#143). A REQUIRED injected I/O port —
+     * probing lives in `src/local/**`; the coordinator receives only the boolean
+     * result, so this module stays I/O-free. Consulted ONLY for roles that carry
+     * `requiresLocalRuntime === true`; returns true when at least one local runtime
+     * is reachable, treating a configured-but-unreachable runtime as absent.
+     *
+     * Deliberately required, with NO fallback. A prohibition must never fail open:
+     * an enabled-but-unreachable runtime (e.g. a stopped daemon) is the very case
+     * #143 exists to catch, and an `enabled`-flag fallback would pass the gate for
+     * it. Making the port mandatory also turns a missing composition-root wiring
+     * into a compile error, so the gate cannot be silently bypassed by dropping the
+     * injection.
+     */
+    localRuntimeReachable: () => boolean | Promise<boolean>;
+    /**
+     * Optional per-runtime reachability probe (#144). Returns the set of local
+     * runtime ids currently reachable, so the dispatcher can fail over across the
+     * ordered list a role declares (`localRuntimes`): an unreachable runtime is
+     * absent from the set and is skipped in favour of the next listed one.
+     *
+     * Injected I/O port, like `localRuntimeReachable` — probing lives in
+     * `src/local/**`. Optional so existing callers (and the many test construction
+     * sites) need no change and keep the pre-#144 boolean-only behaviour; when it
+     * is absent the coordinator falls back to `localRuntimeReachable` and roles
+     * without a list are unaffected. When present alongside a role that declares a
+     * list, it is the single probe consulted for the batch, and `any reachable` is
+     * derived from it — the two ports are never both probed for one batch.
+     */
+    reachableRuntimeIds?: () => ReadonlySet<LocalRuntimeId> | Promise<ReadonlySet<LocalRuntimeId>>;
+    /**
+     * Optional per-runtime concurrency limiter (#144). Caps concurrent generations
+     * per runtime to its configured slot count and QUEUES excess work rather than
+     * dropping it or spilling it to another runtime. Optional so existing callers
+     * need no change; when absent, no cap is enforced (pre-#144 behaviour).
+     *
+     * The coordinator takes a slot with the synchronous `tryAcquire` on the happy
+     * path — adding no `await` before dispatch, so concurrent telemetry emission
+     * order within a wave is unperturbed — and only awaits `acquire` when the
+     * runtime is saturated. A task holds its slot for the whole subsession and is
+     * released in a `finally`, so it stays pinned to its runtime for its duration.
+     */
+    runtimeLimiter?: RuntimeConcurrencyLimiter;
 };
 export type CorrelatedCostRecord = CostRecord & {
     decisionID: string;
@@ -44,6 +108,51 @@ export type RoleTaskResult = {
     subsession: SubsessionResult;
     record: CorrelatedCostRecord;
 };
+/**
+ * Emits an observable warning the first time an unknown roleID is encountered
+ * within a given `warnedRoles` Set. Callers own the Set and its lifetime:
+ * production callers pass a long-lived Set (no repeat logs); test callers pass
+ * a fresh `new Set()` per case (full isolation). When `warnedRoles` is not
+ * provided the warning is emitted unconditionally on every call.
+ *
+ * Follows the `warn*` convention used throughout the codebase
+ * (see `warnInertPrivacySetting`, `warnCostRecordRejections`).
+ */
+export declare function warnUnknownRole(roleID: string, warn?: (message?: unknown) => void, warnedRoles?: Set<string>): void;
+/**
+ * Actionable, English pre-dispatch failure for a role that requires a local
+ * runtime when none is reachable (#143). Names the role, states the hard
+ * requirement, lists the three supported local runtimes a user typically forgot
+ * to start, and points at `openteam doctor`. Deliberately not a generic provider
+ * error: a forgotten daemon is the overwhelmingly likely cause.
+ */
+export declare function mandatoryLocalRuntimeMessage(roleID: string): string;
+/**
+ * Enforces the mandatory-local requirement (#143) BEFORE any model dispatch.
+ * For a role with `requiresLocalRuntime === true`, refuses the request when no
+ * local runtime is reachable — it never falls through to frontier. This does not
+ * overturn the 2026-08-26 fallback ruling: that ruling preserves explicit
+ * prohibitions, and this is one such prohibition, carried per role.
+ *
+ * Reachability is resolved ONCE per batch by `resolveLocalRuntimeReachable` and
+ * passed in as data, so this check is synchronous and adds no `await` inside a
+ * concurrent wave (telemetry emission order is unperturbed). There is
+ * deliberately no fallback: a prohibition must fail closed, so anything other
+ * than an explicit `true` refuses the request.
+ */
+export declare function assertLocalRuntimeForRole(role: AgentRoleProfile, roleID: string, reachable: boolean | undefined): void;
+/**
+ * Reachability resolved once for a batch (#143/#144). `any` is whether at least
+ * one local runtime is reachable (the #143 boolean signal); `set`, when present,
+ * is the per-runtime reachability used to fail over across a role's ordered list
+ * and to select which runtime a task pins to. `set` is `undefined` when the
+ * per-runtime port is not wired or the batch has no role that declares a list —
+ * in which case only the boolean path is used, preserving pre-#144 behaviour.
+ */
+export type BatchReachability = {
+    readonly any: boolean | undefined;
+    readonly set: ReadonlySet<LocalRuntimeId> | undefined;
+};
 /**
  * Classifies a raw failure reason into a bounded, non-free-form code for
  * persisted telemetry. The raw `failureReason` from `errorReason()` in
@@ -59,8 +168,50 @@ export type RoleTaskResult = {
  *
  * Pure: no I/O, clock, random, or env.
  */
-export type TelemetryFailureClass = "create-rejected" | "create-no-id" | "prompt-rejected" | "prompt-timeout" | "unknown";
+/**
+ * Classifies a raw failure reason into a bounded, non-free-form code for
+ * persisted telemetry AND the console failure viewer (P11c, see #195). The raw
+ * `failureReason` from `errorReason()` in `subsessions.ts` can contain SDK error
+ * messages that echo request content (provider content-filter rejections,
+ * validation errors quoting the payload). Persisting or rendering those verbatim
+ * violates the project's telemetry policy: "auditable JSONL with a hashed prompt
+ * by default; do not store sensitive prompts."
+ *
+ * The classified code preserves the debugging signal that actually gets
+ * aggregated (timeout vs. auth vs. rate-limit vs. rejection vs. missing session)
+ * while carrying no payload. The raw string remains available in-memory via
+ * `CorrelatedCostRecord.failureReason` for the tool response.
+ *
+ * Pure: no I/O, clock, random, or env.
+ */
+export declare const TelemetryFailureClassSchema: z.ZodEnum<{
+    "create-no-id": "create-no-id";
+    "create-rejected": "create-rejected";
+    "prompt-auth": "prompt-auth";
+    "prompt-connection": "prompt-connection";
+    "prompt-content-filter": "prompt-content-filter";
+    "prompt-context-length": "prompt-context-length";
+    "prompt-rate-limited": "prompt-rate-limited";
+    "prompt-rejected": "prompt-rejected";
+    "prompt-server": "prompt-server";
+    "prompt-timeout": "prompt-timeout";
+    "prompt-validation": "prompt-validation";
+    unknown: "unknown";
+}>;
+export type TelemetryFailureClass = z.infer<typeof TelemetryFailureClassSchema>;
 export declare function classifyFailureForTelemetry(failureReason: string, failureStage: string | undefined): TelemetryFailureClass;
+/**
+ * Console-facing classifier for an opencode `session.error` frame (P11c, see
+ * #195). The console failure viewer currently renders `error.message` verbatim;
+ * this maps the frame to a bounded {@link TelemetryFailureClass} so the viewer can
+ * render a class instead of a free-form provider string. Total and content-free:
+ * a frame with no recognised cause — or no message at all — maps to `unknown`, and
+ * the raw message is never returned.
+ */
+export declare function classifyOpencodeSessionError(error: {
+    readonly name?: string | undefined;
+    readonly message?: string | undefined;
+} | undefined): TelemetryFailureClass;
 /**
  * Mapea un `CorrelatedCostRecord` a un `route` event preservando la correlación
  * (decisionID/agent/success/batchID/failureStage) que el sink de