@lotagate/cli 0.1.24 → 0.1.26

package/dist/domain/media/media-execution-policy.js

@@ -0,0 +1 @@
+import{CliError as E}from"../errors/cli-error.js";import{CLI_ERROR_CODES as I}from"../errors/error-codes.js";import{DEFAULT_MEDIA_DOWNLOAD_TIMEOUT_MS as O,DEFAULT_VIDEO_POLL_INTERVAL_MS as A,DEFAULT_VIDEO_WAIT_TIMEOUT_MS as n}from"./media-constants.js";function D(t=process.env){const _=r(t,"LOTAGATE_VIDEO_POLL_INTERVAL_MS",A),o=r(t,"LOTAGATE_VIDEO_WAIT_TIMEOUT_MS",n);if(o<_)throw T("LOTAGATE_VIDEO_WAIT_TIMEOUT_MS must not be smaller than LOTAGATE_VIDEO_POLL_INTERVAL_MS.");return{videoPollIntervalMs:_,videoWaitTimeoutMs:o,downloadTimeoutMs:r(t,"LOTAGATE_MEDIA_DOWNLOAD_TIMEOUT_MS",O)}}function r(t,_,o){const e=t[_];if(e===void 0||e.trim().length===0)return o;if(!/^\d+$/u.test(e))throw T(`${_} must be a positive integer.`);const i=Number(e);if(!Number.isSafeInteger(i)||i<=0)throw T(`${_} must be a positive integer.`);return i}function T(t){return new E(I.CONFIG_SCHEMA_INVALID,t,{category:"config",userMessage:t})}export{D as resolveMediaExecutionPolicy};

package/dist/domain/memory/memory-constants.d.ts

@@ -0,0 +1,3 @@
+export declare const SEARCH_TOKEN_MIN_LENGTH = 2;
+export declare const BM25_K1 = 1.2;
+export declare const BM25_B = 0.75;

package/dist/domain/memory/memory-constants.js

@@ -0,0 +1 @@
+const o=2,t=1.2,_=.75;export{_ as BM25_B,t as BM25_K1,o as SEARCH_TOKEN_MIN_LENGTH};

package/dist/domain/memory/memory-kinds.d.ts

@@ -0,0 +1,15 @@
+import type { IntentKind } from '../intent/intent-contract.js';
+export declare const MEMORY_KINDS: readonly ["fact", "preference", "decision", "constraint", "goal", "procedure", "episodic", "lesson"];
+export type MemoryKind = typeof MEMORY_KINDS[number];
+export interface MemoryKindDefinition {
+    readonly id: MemoryKind;
+    readonly description: string;
+    readonly captureSignals: readonly string[];
+    readonly intentKinds: readonly IntentKind[];
+    readonly retrievalRole: 'grounding' | 'behavior' | 'control' | 'planning' | 'workflow' | 'experience';
+    readonly freshness: 'stable' | 'latest' | 'expiring' | 'decaying';
+    readonly consolidationPolicy: 'merge' | 'supersede' | 'retain' | 'retain-on-conflict';
+}
+export declare const MEMORY_KIND_DEFINITIONS: readonly MemoryKindDefinition[];
+export declare function isMemoryKind(value: unknown): value is MemoryKind;
+export declare function memoryKindDefinition(kind: MemoryKind): MemoryKindDefinition;

package/dist/domain/memory/memory-kinds.js

@@ -0,0 +1 @@
+const o=["fact","preference","decision","constraint","goal","procedure","episodic","lesson"],i=[{id:"fact",description:"A stable declarative fact about the user, project, or environment.",captureSignals:["is","uses","has","located"],intentKinds:["answer","research","change","automation"],retrievalRole:"grounding",freshness:"stable",consolidationPolicy:"retain-on-conflict"},{id:"preference",description:"A user preference about how the agent should behave or communicate.",captureSignals:["prefer","always","do not","style"],intentKinds:["answer","research"],retrievalRole:"behavior",freshness:"latest",consolidationPolicy:"supersede"},{id:"decision",description:"An accepted choice and its rationale that can be superseded later.",captureSignals:["decided","choose","approved","will use"],intentKinds:["answer","research","change","automation"],retrievalRole:"control",freshness:"latest",consolidationPolicy:"supersede"},{id:"constraint",description:"An active rule describing what the agent must or must not do.",captureSignals:["must","must not","required","never"],intentKinds:["change","automation"],retrievalRole:"control",freshness:"stable",consolidationPolicy:"retain-on-conflict"},{id:"goal",description:"A durable future objective that is distinct from one running session goal.",captureSignals:["want to","goal","plan to","target"],intentKinds:["change","automation"],retrievalRole:"planning",freshness:"expiring",consolidationPolicy:"supersede"},{id:"procedure",description:"A reusable workflow or method for accomplishing an operation.",captureSignals:["step","workflow","run","process"],intentKinds:["change","automation"],retrievalRole:"workflow",freshness:"latest",consolidationPolicy:"supersede"},{id:"episodic",description:"A bounded past event, outcome, or failure with temporal context.",captureSignals:["completed","failed","happened","outcome"],intentKinds:["research","change","automation"],retrievalRole:"experience",freshness:"decaying",consolidationPolicy:"retain"},{id:"lesson",description:"A generalizable lesson distilled from one or more past experiences.",captureSignals:["learned","lesson","avoid","because"],intentKinds:["research","change","automation"],retrievalRole:"experience",freshness:"decaying",consolidationPolicy:"merge"}];function t(e){return typeof e=="string"&&o.includes(e)}function r(e){return i.find(n=>n.id===e)}export{o as MEMORY_KINDS,i as MEMORY_KIND_DEFINITIONS,t as isMemoryKind,r as memoryKindDefinition};

package/dist/domain/memory/memory-retrieval-policy.d.ts

@@ -0,0 +1,3 @@
+import type { IntentKind } from '../intent/intent-contract.js';
+import { type MemoryKind } from './memory-kinds.js';
+export declare function preferredMemoryKinds(intentKind: IntentKind | undefined): readonly MemoryKind[] | undefined;

package/dist/domain/memory/memory-retrieval-policy.js

@@ -0,0 +1 @@
+import{MEMORY_KIND_DEFINITIONS as n}from"./memory-kinds.js";function i(r){return r===void 0?void 0:n.filter(e=>e.intentKinds.includes(r)).map(e=>e.id)}export{i as preferredMemoryKinds};

package/dist/domain/memory/memory-search.d.ts

@@ -0,0 +1,33 @@
+import type { MemoryKind } from './memory-kinds.js';
+import type { MemoryRecord } from './memory.js';
+export interface MemorySearchQuery {
+    readonly text: string;
+    readonly maximum: number;
+    readonly preferredKinds?: readonly MemoryKind[];
+}
+export interface MemorySearchHit {
+    readonly record: MemoryRecord;
+    readonly lexicalScore: number;
+    readonly rank: number;
+}
+export interface MemorySemanticHit {
+    readonly record: MemoryRecord;
+    readonly similarity: number;
+    readonly rank: number;
+}
+export interface MemorySearchDocument {
+    readonly id: string;
+    readonly termFrequency: Readonly<Record<string, number>>;
+    readonly length: number;
+}
+export interface MemorySearchIndex {
+    readonly documents: Readonly<Record<string, MemorySearchDocument>>;
+    readonly postings: Readonly<Record<string, readonly string[]>>;
+    readonly documentFrequency: Readonly<Record<string, number>>;
+    readonly averageDocumentLength: number;
+}
+export declare function buildMemorySearchIndex(records: readonly MemoryRecord[]): MemorySearchIndex;
+export declare function searchMemoryIndex(recordsById: Readonly<Record<string, MemoryRecord>>, index: MemorySearchIndex, query: MemorySearchQuery): readonly MemorySearchHit[];
+export declare function normalizeSearchText(value: string): string;
+export declare function uniqueTokens(value: string): readonly string[];
+export declare function isMemoryRetrievable(record: MemoryRecord, now?: number): boolean;

package/dist/domain/memory/memory-search.js

@@ -0,0 +1,2 @@
+import{BM25_B as d,BM25_K1 as f,SEARCH_TOKEN_MIN_LENGTH as h}from"./memory-constants.js";function k(e){const n=new Map,c={};let i=0;for(const r of e){const t=new Map;for(const s of y(r))t.set(s,(t.get(s)??0)+1);const o=Object.fromEntries(t.entries()),a=Object.values(o).reduce((s,l)=>s+l,0);c[r.id]={id:r.id,termFrequency:o,length:a},i+=a;for(const s of t.keys()){const l=n.get(s)??new Set;l.add(r.id),n.set(s,l)}}const u=Object.fromEntries([...n.entries()].map(([r,t])=>[r,[...t].sort()])),m=Object.fromEntries(Object.entries(u).map(([r,t])=>[r,t.length]));return{documents:c,postings:u,documentFrequency:m,averageDocumentLength:e.length===0?0:i/e.length}}function F(e,n,c){if(c.maximum<=0)return[];const i=p(c.text);if(i.length===0)return[];const u=new Set;for(const t of i)for(const o of n.postings[t]??[])u.add(o);const m=Object.keys(n.documents).length,r=[...u].flatMap(t=>{const o=e[t],a=n.documents[t];if(o===void 0||a===void 0||!b(o))return[];const s=M(a,i,n,m);return s>0?[{record:o,lexicalScore:s,rank:0}]:[]});return r.sort((t,o)=>o.lexicalScore-t.lexicalScore||o.record.updatedAt.localeCompare(t.record.updatedAt)||t.record.id.localeCompare(o.record.id)),r.slice(0,c.maximum).map((t,o)=>({...t,rank:o+1}))}function x(e){return e.normalize("NFKC").toLocaleLowerCase()}function p(e){const n=x(e),c=n.normalize("NFD").replace(/[\u0300-\u036f]/gu,"");return[...new Set([...g(n),...g(c)])]}function b(e,n=Date.now()){return e.state==="active"&&(e.expiresAt===void 0||Date.parse(e.expiresAt)>n)}function y(e){return p([e.statement,e.rationale??"",...e.topics].join(`
+`))}function g(e){return e.split(/[^\p{L}\p{N}_-]+/u).filter(n=>n.length>=h)}function M(e,n,c,i){return c.averageDocumentLength<=0||e.length<=0?0:n.reduce((u,m)=>{const r=e.termFrequency[m]??0,t=c.documentFrequency[m]??0;if(r===0||t===0)return u;const o=Math.log(1+(i-t+.5)/(t+.5)),a=r+f*(1-d+d*e.length/c.averageDocumentLength);return u+o*r*(f+1)/a},0)}export{k as buildMemorySearchIndex,b as isMemoryRetrievable,x as normalizeSearchText,F as searchMemoryIndex,p as uniqueTokens};

package/dist/domain/memory/memory.d.ts

@@ -0,0 +1,48 @@
+import { type MemoryKind } from './memory-kinds.js';
+export { MEMORY_KINDS, isMemoryKind } from './memory-kinds.js';
+export type { MemoryKind } from './memory-kinds.js';
+export declare const MEMORY_SCHEMA_VERSION: 2;
+export declare const MEMORY_STATES: readonly ["active", "superseded", "expired"];
+export declare const MEMORY_SOURCES: readonly ["user-explicit", "host-evidence", "model-inferred", "imported"];
+export type MemoryState = typeof MEMORY_STATES[number];
+export type MemorySource = typeof MEMORY_SOURCES[number];
+export interface MemoryRecord {
+    readonly id: string;
+    readonly kind: MemoryKind;
+    readonly state: MemoryState;
+    readonly statement: string;
+    readonly rationale?: string;
+    readonly topics: readonly string[];
+    readonly source: MemorySource;
+    readonly evidenceRefs: readonly string[];
+    readonly supersedes: readonly string[];
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly expiresAt?: string;
+    readonly lastRetrievedAt?: string;
+    readonly retrievalCount: number;
+}
+export interface MemoryDraft {
+    readonly kind: MemoryKind;
+    readonly state?: MemoryState;
+    readonly statement: string;
+    readonly rationale?: string;
+    readonly topics?: readonly string[];
+    readonly source?: MemorySource;
+    readonly evidenceRefs?: readonly string[];
+    readonly supersedes?: readonly string[];
+    readonly expiresAt?: string;
+}
+export interface MemoryBundle {
+    readonly schemaVersion: typeof MEMORY_SCHEMA_VERSION;
+    readonly exportedAt: string;
+    readonly records: readonly MemoryRecord[];
+}
+export declare function isMemoryState(value: unknown): value is MemoryState;
+export declare function isMemorySource(value: unknown): value is MemorySource;
+export declare function normalizeMemoryDraft(input: MemoryDraft): MemoryDraft;
+export declare function normalizeMemoryRecord(value: unknown): MemoryRecord;
+export declare function normalizeMemoryBundle(value: unknown): MemoryBundle;
+export declare function memoryRecordFromDraft(id: string, draft: MemoryDraft, timestamp: string): MemoryRecord;
+/** Returns the record state visible to callers without rewriting the journal. */
+export declare function effectiveMemoryRecord(record: MemoryRecord, now?: number): MemoryRecord;

package/dist/domain/memory/memory.js

@@ -0,0 +1 @@
+import{CliError as M}from"../errors/cli-error.js";import{CLI_ERROR_CODES as g}from"../errors/error-codes.js";import{RESOURCE_LIMITS as n}from"../runtime/resource-limits.js";import{findUnexpectedRecordKey as c,isRecord as f}from"../validation/record-schema.js";import{isMemoryKind as p}from"./memory-kinds.js";import{MEMORY_KINDS as U,isMemoryKind as q}from"./memory-kinds.js";const y=2,l=["active","superseded","expired"],w=["user-explicit","host-evidence","model-inferred","imported"];function u(e){return typeof e=="string"&&l.includes(e)}function A(e){return typeof e=="string"&&w.includes(e)}function S(e){const r=c(e,["kind","state","statement","rationale","topics","source","evidenceRefs","supersedes","expiresAt"]);if(r!==void 0)throw o(`Unsupported memory draft field: ${r}.`);return{kind:m(e.kind,p,"memory kind"),...e.state===void 0?{}:{state:m(e.state,u,"memory state")},statement:d(e.statement,n.memoryStatementBytes,"memory statement"),...e.rationale===void 0?{}:{rationale:d(e.rationale,n.memoryRationaleBytes,"memory rationale")},topics:x(e.topics??[]),source:e.source===void 0?"model-inferred":m(e.source,A,"memory source"),evidenceRefs:R(e.evidenceRefs??[]),supersedes:h(e.supersedes??[],"memory supersedes"),...e.expiresAt===void 0?{}:{expiresAt:s(e.expiresAt,"memory expiresAt")}}}function E(e){if(!f(e))throw o("Memory record must be an object.");const r=c(e,["id","kind","state","statement","rationale","topics","source","evidenceRefs","supersedes","createdAt","updatedAt","expiresAt","lastRetrievedAt","retrievalCount"]);if(r!==void 0)throw o(`Unsupported memory record field: ${r}.`);return{id:a(e.id),kind:m(e.kind,p,"memory kind"),state:m(e.state,u,"memory state"),statement:d(e.statement,n.memoryStatementBytes,"memory statement"),topics:x(e.topics),source:m(e.source,A,"memory source"),evidenceRefs:R(e.evidenceRefs),supersedes:h(e.supersedes,"memory supersedes"),createdAt:s(e.createdAt,"memory createdAt"),updatedAt:s(e.updatedAt,"memory updatedAt"),retrievalCount:b(e.retrievalCount,"memory retrievalCount"),...e.rationale===void 0?{}:{rationale:d(e.rationale,n.memoryRationaleBytes,"memory rationale")},...e.expiresAt===void 0?{}:{expiresAt:s(e.expiresAt,"memory expiresAt")},...e.lastRetrievedAt===void 0?{}:{lastRetrievedAt:s(e.lastRetrievedAt,"memory lastRetrievedAt")}}}function N(e){if(!f(e))throw o("Memory bundle must be an object.");const r=c(e,["schemaVersion","exportedAt","records"]);if(r!==void 0)throw o(`Unsupported memory bundle field: ${r}.`);if(e.schemaVersion!==y)throw o("Unsupported memory bundle schema version.");if(!Array.isArray(e.records)||e.records.length>n.memoryRecords)throw o("Memory bundle records are invalid or exceed the supported limit.");return{schemaVersion:y,exportedAt:s(e.exportedAt,"memory exportedAt"),records:e.records.map(i=>E(i))}}function $(e,r,i){const t=S(r);return{id:a(e),kind:t.kind,state:t.state??"active",statement:t.statement,topics:t.topics??[],source:t.source??"model-inferred",evidenceRefs:t.evidenceRefs??[],supersedes:t.supersedes??[],createdAt:s(i,"memory timestamp"),updatedAt:s(i,"memory timestamp"),retrievalCount:0,...t.rationale===void 0?{}:{rationale:t.rationale},...t.expiresAt===void 0?{}:{expiresAt:t.expiresAt}}}function B(e,r=Date.now()){return e.state==="active"&&e.expiresAt!==void 0&&Date.parse(e.expiresAt)<=r?{...e,state:"expired"}:e}function x(e){if(!Array.isArray(e)||e.length>n.memoryTopics||e.some(r=>typeof r!="string"))throw o("Memory topics are invalid.");return[...new Set(e.map(r=>r.trim()).filter(r=>r.length>0).map(r=>d(r,n.memoryTopicBytes,"memory topic")))].sort()}function R(e){if(!Array.isArray(e)||e.length>n.memoryEvidenceReferences||e.some(r=>typeof r!="string"))throw o("Memory evidence references are invalid.");return I(e,n.memoryEvidenceReferenceBytes,"memory evidence reference")}function h(e,r){if(!Array.isArray(e)||e.length>n.memorySupersedes||e.some(i=>typeof i!="string"))throw o(`${r} are invalid.`);return[...new Set(e.map(i=>a(i)))]}function I(e,r,i){return[...new Set(e.map(t=>t.trim()).map(t=>d(t,r,i)))]}function m(e,r,i){if(!r(e))throw o(`Invalid ${i}.`);return e}function d(e,r,i){if(typeof e!="string"||e.trim().length===0||Buffer.byteLength(e,"utf8")>r)throw o(`Invalid ${i}.`);return e.trim()}function a(e){if(typeof e!="string"||!/^[A-Za-z0-9_-]{1,128}$/u.test(e))throw o("Invalid memory id.");return e}function s(e,r){if(typeof e!="string"||Number.isNaN(Date.parse(e)))throw o(`Invalid ${r}.`);return e}function b(e,r){if(typeof e!="number"||!Number.isSafeInteger(e)||e<0)throw o(`Invalid ${r}.`);return e}function o(e){return new M(g.MEMORY_INVALID,e,{category:"memory",userMessage:e})}export{U as MEMORY_KINDS,y as MEMORY_SCHEMA_VERSION,w as MEMORY_SOURCES,l as MEMORY_STATES,B as effectiveMemoryRecord,q as isMemoryKind,A as isMemorySource,u as isMemoryState,$ as memoryRecordFromDraft,N as normalizeMemoryBundle,S as normalizeMemoryDraft,E as normalizeMemoryRecord};

package/dist/domain/orchestration/goal.d.ts

@@ -0,0 +1,57 @@
+export type GoalStatus = 'active' | 'paused' | 'completed' | 'blocked' | 'budget_limited' | 'usage_limited';
+export type GoalDecision = 'continue' | 'complete' | 'blocked' | 'budget_limited' | 'usage_limited';
+export interface GoalEvaluation {
+    decision: GoalDecision;
+    reason: string;
+    evidence: readonly string[];
+    timestamp: string;
+    evaluatorModel?: string;
+}
+export interface GoalUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    modelCalls: number;
+    estimated: boolean;
+}
+export interface GoalUsageDelta {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    modelCalls?: number;
+    estimated?: boolean;
+}
+export interface GoalState {
+    id: string;
+    sessionId: string;
+    objective: string;
+    status: GoalStatus;
+    createdAt: string;
+    updatedAt: string;
+    startedAt: string;
+    turns: number;
+    evaluatorRuns: number;
+    usage: GoalUsage;
+    tokenBudget?: number;
+    maxTurns?: number;
+    maxDurationMs?: number;
+    lastEvaluation?: GoalEvaluation;
+    lastError?: string;
+}
+export interface CreateGoalInput {
+    objective: string;
+    tokenBudget?: number;
+    maxTurns?: number;
+    maxDurationMs?: number;
+}
+export declare function validateGoalInput(input: CreateGoalInput): CreateGoalInput;
+/** Identifies journal events that must carry a complete goal snapshot. */
+export declare function isGoalEventType(value: string): boolean;
+/** Validates the complete durable goal state before it controls execution limits. */
+export declare function isGoalState(value: unknown): value is GoalState;
+/** Validates the durable evaluator result embedded in a goal snapshot. */
+export declare function isGoalEvaluation(value: unknown): value is GoalEvaluation;
+/** Validates the data payload written by a durable goal lifecycle event. */
+export declare function isPersistedGoalEventData(value: unknown): boolean;
+export declare function addGoalUsage(current: GoalUsage, delta: GoalUsageDelta): GoalUsage;
+export declare const EMPTY_GOAL_USAGE: GoalUsage;

package/dist/domain/orchestration/goal.js

@@ -0,0 +1 @@
+import{RESOURCE_LIMITS as n}from"../runtime/resource-limits.js";import{CliError as c}from"../errors/cli-error.js";import{CLI_ERROR_CODES as p}from"../errors/error-codes.js";const l=new Set(["goal.created","goal.replaced","goal.paused","goal.resumed","goal.evaluated","goal.completed","goal.blocked","goal.budget_limited","goal.usage_limited","goal.usage_recorded","goal.cleared","goal.turn.started"]);function S(t){const e=t.objective.trim();if(e.length===0||Buffer.byteLength(e,"utf8")>n.goalObjectiveBytes||/\0/u.test(e))throw d(`Goal objective must contain between 1 and ${n.goalObjectiveBytes} bytes and must not contain null characters.`);for(const[r,i]of Object.entries(t))if(!(r==="objective"||i===void 0)&&(!Number.isSafeInteger(i)||i<=0))throw d(`Goal limit ${r} must be a positive integer.`);if(t.maxDurationMs!==void 0&&t.maxDurationMs>n.goalMaximumMaxDurationMs)throw d("Goal maxDurationMs cannot exceed the supported maximum.");return{objective:e,...t.tokenBudget===void 0?{}:{tokenBudget:t.tokenBudget},...t.maxTurns===void 0?{}:{maxTurns:t.maxTurns},...t.maxDurationMs===void 0?{}:{maxDurationMs:t.maxDurationMs}}}function B(t){return l.has(t)}function b(t){return a(t)?typeof t.id=="string"&&typeof t.sessionId=="string"&&G(t.objective)&&y(t.status)&&f(t.createdAt)&&f(t.updatedAt)&&f(t.startedAt)&&o(t.turns)&&o(t.evaluatorRuns)&&k(t.usage)&&g(t.tokenBudget)&&g(t.maxTurns)&&E(t.maxDurationMs)&&x(t.lastEvaluation)&&(t.lastError===void 0||typeof t.lastError=="string"&&Buffer.byteLength(t.lastError,"utf8")<=n.goalReasonBytes):!1}function u(t){return a(t)?T(t.decision)&&typeof t.reason=="string"&&Buffer.byteLength(t.reason,"utf8")<=n.goalReasonBytes&&Array.isArray(t.evidence)&&t.evidence.length<=n.goalEvidenceItems&&t.evidence.every(e=>typeof e=="string"&&Buffer.byteLength(e,"utf8")<=n.goalEvidenceBytes)&&f(t.timestamp)&&(t.evaluatorModel===void 0||typeof t.evaluatorModel=="string"):!1}function D(t){return!a(t)||!b(t.goal)?!1:t.evaluation===void 0||u(t.evaluation)}function h(t,e){const r=s(t.inputTokens+(e.inputTokens??0)),i=s(t.outputTokens+(e.outputTokens??0)),m=s(t.totalTokens+(e.totalTokens??(e.inputTokens??0)+(e.outputTokens??0)));return{inputTokens:r,outputTokens:i,totalTokens:m,modelCalls:s(t.modelCalls+(e.modelCalls??0)),estimated:t.estimated||e.estimated===!0}}const A=Object.freeze({inputTokens:0,outputTokens:0,totalTokens:0,modelCalls:0,estimated:!1});function s(t){return Number.isSafeInteger(t)&&t>=0?t:Number.MAX_SAFE_INTEGER}function a(t){return typeof t=="object"&&t!==null&&!Array.isArray(t)}function y(t){return t==="active"||t==="paused"||t==="completed"||t==="blocked"||t==="budget_limited"||t==="usage_limited"}function T(t){return t==="continue"||t==="complete"||t==="blocked"||t==="budget_limited"||t==="usage_limited"}function k(t){return a(t)?o(t.inputTokens)&&o(t.outputTokens)&&o(t.totalTokens)&&o(t.modelCalls)&&typeof t.estimated=="boolean":!1}function x(t){return t===void 0||u(t)}function g(t){return t===void 0||typeof t=="number"&&Number.isSafeInteger(t)&&t>0}function E(t){return t===void 0||typeof t=="number"&&Number.isSafeInteger(t)&&t>0&&t<=n.goalMaximumMaxDurationMs}function o(t){return typeof t=="number"&&Number.isSafeInteger(t)&&t>=0}function f(t){return typeof t=="string"&&Number.isFinite(Date.parse(t))}function G(t){return typeof t=="string"&&t.trim().length>0&&Buffer.byteLength(t,"utf8")<=n.goalObjectiveBytes&&!/\0/u.test(t)}function d(t){return new c(p.INVALID_ARGUMENT,t,{category:"goal",userMessage:t})}export{A as EMPTY_GOAL_USAGE,h as addGoalUsage,u as isGoalEvaluation,B as isGoalEventType,b as isGoalState,D as isPersistedGoalEventData,S as validateGoalInput};

package/dist/domain/orchestration/subagent-identity.d.ts

@@ -0,0 +1,2 @@
+/** Returns a concise, stable display identity for one parent-session subagent. */
+export declare function subagentDisplayName(sequence: number): string;

package/dist/domain/orchestration/subagent-identity.js

@@ -0,0 +1 @@
+const t=["Atlas","Nova","Orion","Sage","Lyra","Ember","Aster","Coda"];function r(e){const a=Math.max(0,Math.floor(e)),n=t[a%t.length]??"Agent",o=Math.floor(a/t.length)+1;return o===1?n:`${n} ${o}`}export{r as subagentDisplayName};

package/dist/domain/orchestration/subagent.d.ts

@@ -0,0 +1,33 @@
+export type SubagentStatus = 'queued' | 'running' | 'completed' | 'completed_with_warning' | 'failed' | 'cancelled';
+export type SubagentLimitReason = 'iteration' | 'timeout' | 'tokens' | 'tool_calls';
+export type SubagentMode = 'research' | 'worker';
+export interface SubagentHandoff {
+    readonly summary: string;
+    readonly filesInspected: readonly string[];
+    readonly filesChanged: readonly string[];
+    readonly commandsRun: readonly string[];
+    readonly verification: readonly string[];
+    readonly warnings: readonly string[];
+}
+export interface SubagentRequest {
+    readonly task: string;
+    readonly context?: string;
+    readonly model?: string;
+    readonly mode?: SubagentMode;
+    readonly background?: boolean;
+    readonly writeScope?: readonly string[];
+}
+export interface SubagentResult {
+    readonly id: string;
+    readonly displayName: string;
+    readonly task: string;
+    readonly status: SubagentStatus;
+    readonly mode: SubagentMode;
+    readonly model: string;
+    readonly summary: string;
+    readonly handoff: SubagentHandoff;
+    readonly toolsUsed: readonly string[];
+    readonly estimatedTokens?: number;
+    readonly limitReason?: SubagentLimitReason;
+    readonly durationMs: number;
+}

package/dist/domain/orchestration/work-plan.d.ts

@@ -0,0 +1,15 @@
+export type WorkItemStatus = 'queued' | 'active' | 'completed' | 'failed' | 'blocked';
+export interface WorkItem {
+    id: string;
+    title: string;
+    description: string;
+    dependencies: readonly string[];
+    status: WorkItemStatus;
+    assignedAgent?: string;
+}
+export interface SchedulerLimits {
+    maxConcurrency: number;
+    maxTasks: number;
+    maxDurationMs: number;
+    maxTokens?: number;
+}

package/dist/domain/project/project-identity.d.ts

@@ -0,0 +1,6 @@
+export interface ProjectIdentity {
+    canonicalPath: string;
+    gitRoot?: string;
+    fingerprint: string;
+}
+export declare function createProjectFingerprint(canonicalPath: string, gitRoot?: string): string;

package/dist/domain/project/project-identity.js

@@ -0,0 +1 @@
+import r from"node:crypto";function a(t,e){return r.createHash("sha256").update(`${t}\0${e??""}`,"utf8").digest("hex")}export{a as createProjectFingerprint};

package/dist/domain/runtime/assistant-delta-normalizer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Repairs an SSE frame prefix only when a compatibility gateway attaches it
+ * directly to preceding assistant text. Prefixes after whitespace or at the
+ * beginning of a new line are preserved because they can be intentional text
+ * or code.
+ */
+export declare class AssistantDeltaNormalizer {
+    private previousCharacter;
+    normalize(content: string): string;
+    private isAttachedToAssistantText;
+}

package/dist/domain/runtime/assistant-delta-normalizer.js

@@ -0,0 +1 @@
+class n{previousCharacter;normalize(s){const t=s.replace(/data:\s+/gu,(e,a,r)=>this.isAttachedToAssistantText(r,a)?"":e);return t.length>0&&(this.previousCharacter=t.at(-1)),t}isAttachedToAssistantText(s,t){const e=t===0?this.previousCharacter:s.at(t-1);return e!==void 0&&!/\s/.test(e)}}export{n as AssistantDeltaNormalizer};

package/dist/domain/runtime/assistant-stream-text.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Converts a provider assistant frame into the text that has not already been
+ * emitted for the current model segment.
+ *
+ * Providers normally send incremental frames, but compatibility gateways can
+ * send cumulative snapshots or replay an already-complete text fragment. The
+ * model boundary is the single place where those representations are
+ * normalized before they reach the Agent SDK and the desktop JSONL protocol.
+ */
+export declare function normalizeAssistantDelta(previousText: string, incomingDelta: string): string;
+export declare function mergeAssistantText(previousText: string, incomingDelta: string): string;

package/dist/domain/runtime/assistant-stream-text.js

@@ -0,0 +1 @@
+function d(t,n){if(n.length===0)return"";const i=n.startsWith(t)?n.slice(t.length):n,r=f(i);return r.length===0||t.endsWith(r)&&c(r)?"":r}function h(t,n){return`${t}${d(t,n)}`}function f(t){if(t.length<2)return t;const n=new Array(t.length).fill(0);for(let s=1;s<t.length;s+=1){let e=n[s-1]??0;for(;e>0&&t[s]!==t[e];)e=n[e-1]??0;t[s]===t[e]&&(e+=1),n[s]=e}const i=n.at(-1)??0,r=t.length-i,o=t.slice(0,r);return i>0&&t.length%r===0&&c(o)?o:t}function c(t){const n=t.trimEnd().at(-1);return n!==void 0&&/[\p{P}\p{S}]/u.test(n)}export{h as mergeAssistantText,d as normalizeAssistantDelta};

package/dist/domain/runtime/gateway-request-budget.d.ts

@@ -0,0 +1,19 @@
+/** Public Gateway JSON body limit mirrored from the server and SDK contract. */
+export declare const GATEWAY_JSON_BODY_LIMIT_BYTES: number;
+export declare const GATEWAY_JSON_NEAR_LIMIT_RATIO = 0.8;
+export interface GatewayAttachmentBudgetInput {
+    readonly byteLength: number;
+    readonly mimeType: string;
+    readonly name?: string;
+}
+export interface GatewayRequestBudget {
+    readonly projectedBytes: number;
+    readonly limitBytes: number;
+    readonly remainingBytes: number;
+    readonly utilization: number;
+    readonly isWithinLimit: boolean;
+    readonly isNearLimit: boolean;
+}
+export declare function estimateGatewayMessageBytes(prompt: string, attachments?: readonly GatewayAttachmentBudgetInput[]): number;
+export declare function evaluateGatewayRequestBudget(prompt: string, attachments?: readonly GatewayAttachmentBudgetInput[], reservedBytes?: number): GatewayRequestBudget;
+export declare function base64ByteLength(byteLength: number): number;

package/dist/domain/runtime/gateway-request-budget.js

@@ -0,0 +1 @@
+const T=2e7,u=.8;function a(e,t=[]){const i=t.length===0?{role:"user",content:e}:{role:"user",content:[{type:"text",text:e},...t.map(o)]};return Buffer.byteLength(JSON.stringify({messages:[i]}),"utf8")+t.reduce((_,r)=>_+s(r.byteLength),0)}function A(e,t=[],i=0){const n=a(e,t)+Math.max(0,i),_=2e7-n;return{projectedBytes:n,limitBytes:2e7,remainingBytes:_,utilization:n/2e7,isWithinLimit:n<=2e7,isNearLimit:n>=2e7*.8}}function s(e){if(!Number.isSafeInteger(e)||e<0)throw new RangeError("Attachment byte length must be a non-negative safe integer.");return Math.ceil(e/3)*4}function o(e){const t=`data:${e.mimeType};base64:`;return e.mimeType.startsWith("image/")?{type:"image_url",image_url:{url:t,detail:"auto"}}:{type:"input_file",file_data:t,filename:e.name??"attachment",media_type:e.mimeType}}export{T as GATEWAY_JSON_BODY_LIMIT_BYTES,u as GATEWAY_JSON_NEAR_LIMIT_RATIO,s as base64ByteLength,a as estimateGatewayMessageBytes,A as evaluateGatewayRequestBudget};

package/dist/domain/runtime/resource-limits.d.ts

@@ -0,0 +1,92 @@
+/** Centralized defensive limits for untrusted local, extension, and protocol data. */
+export declare const RESOURCE_LIMITS: {
+    readonly processTerminationGraceMs: 500;
+    readonly processTerminationTimeoutMs: 2000;
+    readonly configFileBytes: number;
+    readonly sessionIndexBytes: number;
+    readonly workspaceSettingsBytes: number;
+    readonly mcpConfigBytes: number;
+    readonly sessionBundleBytes: number;
+    readonly sessionJournalBytes: number;
+    readonly sessionEvents: 100000;
+    readonly sessionTranscriptEntries: 50000;
+    readonly sessionAttachments: 32;
+    readonly sessionAttachmentTotalBytes: number;
+    readonly sessionTextBytes: number;
+    readonly memoryJournalBytes: number;
+    readonly memoryIndexBytes: number;
+    readonly memoryBundleBytes: number;
+    readonly memoryRecords: 2000;
+    readonly memoryStatementBytes: number;
+    readonly memoryRationaleBytes: number;
+    readonly memoryTopics: 16;
+    readonly memoryTopicBytes: 256;
+    readonly memorySupersedes: 16;
+    readonly memoryEvidenceReferences: 32;
+    readonly memoryEvidenceReferenceBytes: 512;
+    readonly memoryContextRecords: 12;
+    readonly jsonlLineBytes: number;
+    /** Desktop protocol responses may carry bounded base64 speech payloads. */
+    readonly desktopJsonlLineBytes: number;
+    readonly desktopAttachmentChunkBytes: number;
+    readonly jsonlIdBytes: 256;
+    readonly jsonlPathBytes: 4096;
+    readonly jsonlPromptBytes: number;
+    readonly pendingAttachments: 16;
+    readonly pendingAttachmentTotalBytes: number;
+    readonly desktopAttachmentTtlMs: number;
+    readonly maxAttachmentBytes: number;
+    readonly clipboardTextBytes: number;
+    readonly clipboardTimeoutMs: 15000;
+    readonly instructionFileBytes: number;
+    readonly instructionTotalBytes: number;
+    readonly instructionFiles: 32;
+    readonly skillDocumentBytes: number;
+    readonly pluginManifestBytes: number;
+    readonly subagentTaskBytes: number;
+    readonly subagentContextBytes: number;
+    readonly subagentMaxWriteScopeItems: 32;
+    readonly subagentWriteScopeItemBytes: 512;
+    readonly subagentSummaryBytes: number;
+    readonly subagentMaxDurationMs: 1800000;
+    readonly subagentMaxTokens: 200000;
+    readonly subagentMaxConcurrent: 4;
+    readonly subagentMaxRetainedJobs: 32;
+    readonly desktopSessionStoreMaxEntries: 20;
+    readonly subagentMaxIterations: 200;
+    readonly subagentMaxToolCallsPerTurn: 100;
+    readonly agentMaxIterations: 500;
+    readonly agentMaxToolCallsPerTurn: 1;
+    readonly intentMaxCompletionAttempts: 2;
+    readonly subagentToolArgumentBytes: number;
+    readonly subagentToolResultBytes: number;
+    readonly goalObjectiveBytes: number;
+    readonly goalReasonBytes: number;
+    readonly goalEvidenceItems: 8;
+    readonly goalEvidenceBytes: number;
+    readonly goalDefaultMaxTurns: 100;
+    readonly goalMaximumMaxTurns: 10000;
+    readonly goalMaximumTokenBudget: 10000000;
+    readonly goalDefaultMaxDurationMs: number;
+    readonly goalMaximumMaxDurationMs: number;
+    readonly goalDefaultMaxEvaluatorRuns: 100;
+    readonly tuiTranscriptMessages: 2000;
+    readonly tuiAgentSessionMaxEntries: 4;
+    readonly tuiAgentSessionMaxBytes: number;
+    readonly agentPreparationCacheMaxEntries: 8;
+    readonly agentPreparationCacheMaxBytes: number;
+    readonly contextTokenCacheMaxEntries: 8;
+    readonly contextTokenCacheMaxBytes: number;
+    readonly jsonlMaxInFlight: 4;
+    readonly protocolWriteQueueEntries: 256;
+    readonly protocolWriteQueueBytes: number;
+    readonly workspaceReferenceCount: 32;
+    readonly workspaceReferenceInstructionBytes: number;
+    readonly logQueueEntries: 10000;
+    readonly logQueueBytes: number;
+    readonly internalProcessTimeoutMs: number;
+    readonly internalProcessOutputBytes: number;
+    readonly hostShellTimeoutMs: 120000;
+    readonly guestShellTimeoutMs: number;
+    readonly defaultShellTimeoutMs: 30000;
+};

package/dist/domain/runtime/resource-limits.js

@@ -0,0 +1 @@
+const e=1e6,t={processTerminationGraceMs:500,processTerminationTimeoutMs:2e3,configFileBytes:262144,sessionIndexBytes:8388608,workspaceSettingsBytes:262144,mcpConfigBytes:524288,sessionBundleBytes:20971520,sessionJournalBytes:20971520,sessionEvents:1e5,sessionTranscriptEntries:5e4,sessionAttachments:32,sessionAttachmentTotalBytes:5e7,sessionTextBytes:524288,memoryJournalBytes:8388608,memoryIndexBytes:8388608,memoryBundleBytes:8388608,memoryRecords:2e3,memoryStatementBytes:4096,memoryRationaleBytes:2048,memoryTopics:16,memoryTopicBytes:256,memorySupersedes:16,memoryEvidenceReferences:32,memoryEvidenceReferenceBytes:512,memoryContextRecords:12,jsonlLineBytes:1048576,desktopJsonlLineBytes:4194304,desktopAttachmentChunkBytes:524288,jsonlIdBytes:256,jsonlPathBytes:4096,jsonlPromptBytes:524288,pendingAttachments:16,pendingAttachmentTotalBytes:5e7,desktopAttachmentTtlMs:9e5,maxAttachmentBytes:1e7,clipboardTextBytes:1e7,clipboardTimeoutMs:15e3,instructionFileBytes:131072,instructionTotalBytes:262144,instructionFiles:32,skillDocumentBytes:524288,pluginManifestBytes:262144,subagentTaskBytes:16384,subagentContextBytes:16384,subagentMaxWriteScopeItems:32,subagentWriteScopeItemBytes:512,subagentSummaryBytes:24576,subagentMaxDurationMs:18e5,subagentMaxTokens:2e5,subagentMaxConcurrent:4,subagentMaxRetainedJobs:32,desktopSessionStoreMaxEntries:20,subagentMaxIterations:200,subagentMaxToolCallsPerTurn:100,agentMaxIterations:500,agentMaxToolCallsPerTurn:1,intentMaxCompletionAttempts:2,subagentToolArgumentBytes:65536,subagentToolResultBytes:262144,goalObjectiveBytes:16384,goalReasonBytes:2048,goalEvidenceItems:8,goalEvidenceBytes:4096,goalDefaultMaxTurns:100,goalMaximumMaxTurns:1e4,goalMaximumTokenBudget:1e7,goalDefaultMaxDurationMs:72e5,goalMaximumMaxDurationMs:288e5,goalDefaultMaxEvaluatorRuns:100,tuiTranscriptMessages:2e3,tuiAgentSessionMaxEntries:4,tuiAgentSessionMaxBytes:8388608,agentPreparationCacheMaxEntries:8,agentPreparationCacheMaxBytes:16777216,contextTokenCacheMaxEntries:8,contextTokenCacheMaxBytes:8388608,jsonlMaxInFlight:4,protocolWriteQueueEntries:256,protocolWriteQueueBytes:16777216,workspaceReferenceCount:32,workspaceReferenceInstructionBytes:16384,logQueueEntries:1e4,logQueueBytes:4194304,internalProcessTimeoutMs:12e4,internalProcessOutputBytes:4194304,hostShellTimeoutMs:12e4,guestShellTimeoutMs:6e5,defaultShellTimeoutMs:3e4};export{t as RESOURCE_LIMITS};

package/dist/domain/session/attachment.d.ts

@@ -0,0 +1,15 @@
+export type AttachmentSource = 'clipboard' | 'file';
+export interface Attachment {
+    id: string;
+    name: string;
+    mimeType: string;
+    sizeBytes: number;
+    source: AttachmentSource;
+    /** Optional requested filename for session-backed Desktop attachments. */
+    storageName?: string;
+    storagePath?: string;
+}
+export interface AttachmentPayload {
+    attachment: Attachment;
+    bytes: Uint8Array;
+}

package/dist/domain/session/session-schema.d.ts

@@ -0,0 +1,6 @@
+import type { SessionEvent, SessionMetadata, TranscriptEntry } from './session.js';
+/** Runtime validators for session data persisted in JSON files and journals. */
+export declare function isSessionMetadata(value: unknown): value is SessionMetadata;
+export declare function isSessionEvent(value: unknown): value is SessionEvent;
+export declare function isTranscriptEntry(value: unknown): value is TranscriptEntry;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/domain/session/session-schema.js

@@ -0,0 +1 @@
+function s(t){return n(t)?typeof t.id=="string"&&typeof t.projectFingerprint=="string"&&typeof t.cwd=="string"&&(typeof t.model=="string"||t.model===null)&&(typeof t.profile=="string"||t.profile===null)&&(t.status==="active"||t.status==="completed"||t.status==="failed"||t.status==="cancelled")&&typeof t.createdAt=="string"&&typeof t.updatedAt=="string"&&(t.name===void 0||typeof t.name=="string"):!1}function i(t){return n(t)?typeof t.type=="string"&&typeof t.timestamp=="string"&&typeof t.sessionId=="string"&&(t.runId===void 0||typeof t.runId=="string")&&(t.turnId===void 0||typeof t.turnId=="string")&&(t.data===void 0||n(t.data)):!1}function e(t){return!n(t)||typeof t.timestamp!="string"||typeof t.content!="string"||t.type!=="user"&&t.type!=="assistant"&&t.type!=="system"&&t.type!=="tool"?!1:(t.turnId===void 0||typeof t.turnId=="string")&&(t.attachmentIds===void 0||Array.isArray(t.attachmentIds)&&t.attachmentIds.every(r=>typeof r=="string"))}function n(t){return typeof t=="object"&&t!==null&&!Array.isArray(t)}export{n as isRecord,i as isSessionEvent,s as isSessionMetadata,e as isTranscriptEntry};

package/dist/domain/session/session.d.ts

@@ -0,0 +1,27 @@
+export type SessionStatus = 'active' | 'completed' | 'failed' | 'cancelled';
+export interface SessionMetadata {
+    id: string;
+    name?: string;
+    projectFingerprint: string;
+    cwd: string;
+    model: string | null;
+    profile: string | null;
+    status: SessionStatus;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SessionEvent {
+    type: string;
+    timestamp: string;
+    sessionId: string;
+    runId?: string;
+    turnId?: string;
+    data?: Record<string, unknown>;
+}
+export interface TranscriptEntry {
+    type: 'user' | 'assistant' | 'system' | 'tool';
+    timestamp: string;
+    content: string;
+    turnId?: string;
+    attachmentIds?: readonly string[];
+}

package/dist/domain/settings/settings-document.d.ts

@@ -0,0 +1,8 @@
+import { type CliConfig } from '../config/config-schema.js';
+import { type WorkspacePermissionPolicy } from '../workspace/workspace-settings.js';
+export interface ValidatedSettingsDocument {
+    readonly config: Partial<CliConfig>;
+    readonly permissions?: WorkspacePermissionPolicy;
+}
+export declare function validateSettingsDocument(value: unknown): ValidatedSettingsDocument;
+export declare function permissionsFromSettings(document: ValidatedSettingsDocument): WorkspacePermissionPolicy;

package/dist/domain/settings/settings-document.js

@@ -0,0 +1 @@
+import{CliError as m}from"../errors/cli-error.js";import{CLI_ERROR_CODES as f}from"../errors/error-codes.js";import{CONFIG_SCHEMA_VERSION as p,CONFIGURABLE_KEYS as t,validateConfig as d}from"../config/config-schema.js";import{DEFAULT_WORKSPACE_SETTINGS as S,validateWorkspaceSettings as g}from"../workspace/workspace-settings.js";import{findUnexpectedRecordKey as E,isRecord as a}from"../validation/record-schema.js";const u=["schemaVersion",...t,"permissions"];function R(i){if(!a(i))throw r("Settings must be a JSON object.");const e=E(i,u);if(e!==void 0)throw r(`Unsupported settings field: \`${e}\`.`);const n={};for(const s of["schemaVersion",...t])i[s]!==void 0&&(n[s]=i[s]);const o=d(n);if(i.permissions===void 0)return{config:o};const c=g({schemaVersion:i.schemaVersion??p,permissions:i.permissions});return{config:o,permissions:c.permissions}}function V(i){return i.permissions??S.permissions}function r(i){return new m(f.CONFIG_SCHEMA_INVALID,i,{category:"config",userMessage:`Invalid settings: ${i}`})}export{V as permissionsFromSettings,R as validateSettingsDocument};

package/dist/domain/validation/record-schema.d.ts

@@ -0,0 +1,4 @@
+/** Narrows JSON-shaped values before schema-specific validation. */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** Returns the first unsupported own property in a configuration object. */
+export declare function findUnexpectedRecordKey(value: Record<string, unknown>, allowedKeys: readonly string[]): string | undefined;

package/dist/domain/validation/record-schema.js

@@ -0,0 +1 @@
+function o(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)}function c(e,n){const r=new Set(n);return Object.keys(e).find(t=>!r.has(t))}export{c as findUnexpectedRecordKey,o as isRecord};

package/dist/domain/workspace/workspace-settings.d.ts

@@ -0,0 +1,14 @@
+export declare const WORKSPACE_SETTINGS_SCHEMA_VERSION = 1;
+export declare const MAX_WORKSPACE_PERMISSION_RULE_LENGTH = 1024;
+export interface WorkspacePermissionPolicy {
+    readonly allow: readonly string[];
+    readonly ask: readonly string[];
+    readonly deny: readonly string[];
+}
+export interface WorkspaceSettings {
+    readonly schemaVersion: 1;
+    readonly permissions: WorkspacePermissionPolicy;
+}
+export declare const DEFAULT_WORKSPACE_SETTINGS: WorkspaceSettings;
+export declare function validateWorkspaceSettings(value: unknown): WorkspaceSettings;
+export declare function normalizePermissionRule(value: unknown, field?: string): string;

package/dist/domain/workspace/workspace-settings.js

@@ -0,0 +1 @@
+import{CliError as a}from"../errors/cli-error.js";import{CLI_ERROR_CODES as d}from"../errors/error-codes.js";import{findUnexpectedRecordKey as f,isRecord as c}from"../validation/record-schema.js";const i=1,o=1024,w={schemaVersion:i,permissions:{allow:[],ask:[],deny:[]}};function g(s){if(!c(s))throw r("Workspace settings must be a JSON object.");if(m(s,["schemaVersion","permissions"],"workspace settings"),s.schemaVersion!==void 0&&s.schemaVersion!==i)throw r("Unsupported workspace settings schema version.");const e=s.permissions===void 0?w.permissions:S(s.permissions);return{schemaVersion:i,permissions:e}}function S(s){if(!c(s))throw r("Workspace permissions must be a JSON object.");return m(s,["allow","ask","deny"],"workspace permissions"),{allow:t(s.allow,"permissions.allow"),ask:t(s.ask,"permissions.ask"),deny:t(s.deny,"permissions.deny")}}function t(s,e){if(s===void 0)return[];if(!Array.isArray(s))throw r(`${e} must be an array of non-empty strings (max ${o} characters each).`);return[...new Set(s.map(n=>h(n,e)))]}function h(s,e="permission rule"){if(typeof s!="string"||s.trim().length===0||s.length>o)throw r(`${e} must be a non-empty string (max ${o} characters).`);return s.trim()}function r(s){return new a(d.CONFIG_SCHEMA_INVALID,s,{category:"config",userMessage:`Invalid workspace settings: ${s}`})}function m(s,e,n){const p=f(s,e);if(p!==void 0)throw r(`Unsupported ${n} field: \`${p}\`.`)}export{w as DEFAULT_WORKSPACE_SETTINGS,o as MAX_WORKSPACE_PERMISSION_RULE_LENGTH,i as WORKSPACE_SETTINGS_SCHEMA_VERSION,h as normalizePermissionRule,g as validateWorkspaceSettings};

package/dist/infrastructure/agent-sdk/agent-instance-factory.d.ts

@@ -0,0 +1,22 @@
+import { LotaGateAgent, type LotaGateAgentOptions, type ToolAuthorizationRule, type ToolAuthorizationEvent } from '@lotagate/agent-sdk';
+import { type ToolExecutor } from '@lotagate/agent-sdk';
+import type { LotaGate } from '@lotagate/sdk';
+import type { ModelCallSummary } from '../../ports/model-diagnostics.js';
+import type { HostPlatformContext } from '../platform/host-platform.js';
+export interface AgentInstanceOptions extends Omit<LotaGateAgentOptions, 'modelClient'> {
+    client: LotaGate;
+    onModelComplete?: (summary: ModelCallSummary) => void;
+}
+export declare function createAgentInstance(options: AgentInstanceOptions): LotaGateAgent;
+export interface LocalAgentInstanceOptions extends Omit<AgentInstanceOptions, 'toolExecutor'> {
+    platform?: HostPlatformContext;
+    toolExecutors?: readonly ToolExecutor[];
+    allowedTools?: readonly string[];
+    deniedTools?: readonly string[];
+    requireApproval?: boolean;
+    approvalHandler?: NonNullable<LotaGateAgentOptions['toolPolicy']>['approvalHandler'];
+    authorizationRules?: readonly ToolAuthorizationRule[];
+    authorizationObserver?: (event: ToolAuthorizationEvent) => void | Promise<void>;
+    onModelComplete?: (summary: ModelCallSummary) => void;
+}
+export declare function createLocalAgentInstance(options: LocalAgentInstanceOptions): LotaGateAgent;

package/dist/infrastructure/agent-sdk/agent-instance-factory.js

@@ -0,0 +1 @@
+import{LotaGateAgent as f}from"@lotagate/agent-sdk";import{CompositeToolExecutor as m}from"@lotagate/agent-sdk";import{LocalFilesystemToolExecutor as s}from"../filesystem/local-filesystem-tool-executor.js";import{ShellToolExecutor as x}from"../shell/shell-tool-executor.js";import{createToolCallingModelClient as C}from"./tool-calling-model-client.js";function g(n){const{client:t,onModelComplete:e,...o}=n;return new f({...o,modelClient:C(t,e===void 0?{}:{onComplete:e})})}function v(n){const{toolExecutors:t,platform:e,allowedTools:o,deniedTools:l,requireApproval:r,approvalHandler:i,authorizationRules:d,authorizationObserver:a,onModelComplete:u,...c}=n,p=new m([...t??[new s,new x({...e===void 0?{}:{platform:e}})]]);return g({...c,...u===void 0?{}:{onModelComplete:u},toolExecutor:p,toolPolicy:{...o===void 0?{}:{allowedTools:o},...l===void 0?{}:{deniedTools:l},...r===void 0?{}:{requireApproval:r},...i===void 0?{}:{approvalHandler:i},...d===void 0?{}:{authorizationRules:d},...a===void 0?{}:{authorizationObserver:a}}})}export{g as createAgentInstance,v as createLocalAgentInstance};

package/dist/infrastructure/agent-sdk/model-response-metrics.d.ts

@@ -0,0 +1,7 @@
+import type { ChatUsage } from '../../ports/chat-model.js';
+export declare function textLength(content: unknown): number;
+export declare function mapUsage(usage: {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+}): ChatUsage;

package/dist/infrastructure/agent-sdk/model-response-metrics.js

@@ -0,0 +1 @@
+function r(t){return typeof t=="string"?t.length:Array.isArray(t)?t.reduce((o,e)=>{if(typeof e!="object"||e===null||!("text"in e))return o;const n=e.text;return o+(typeof n=="string"?n.length:0)},0):0}function p(t){return{...typeof t.prompt_tokens=="number"?{promptTokens:t.prompt_tokens}:{},...typeof t.completion_tokens=="number"?{completionTokens:t.completion_tokens}:{},...typeof t.total_tokens=="number"?{totalTokens:t.total_tokens}:{}}}export{p as mapUsage,r as textLength};