@lotagate/cli 0.1.23 → 0.1.25

package/dist/infrastructure/sdk/sdk-media-gateway-client.js

@@ -0,0 +1 @@
+class f{client;constructor(r){this.client=r}async generateImage(r,t){return(await this.client.images.generations.create(a(r),t)).data.map(n=>({...typeof n.b64_json=="string"?{base64:n.b64_json}:{},...typeof n.url=="string"?{url:n.url}:{},...typeof n.revised_prompt=="string"?{revisedPrompt:n.revised_prompt}:{}}))}async editImage(r,t){const s={...a(r),image:r.images,...r.mask===void 0?{}:{mask:r.mask},...r.inputFidelity===void 0?{}:{input_fidelity:r.inputFidelity}};return(await this.client.images.edits.create(s,t)).data.map(o=>({...typeof o.b64_json=="string"?{base64:o.b64_json}:{},...typeof o.url=="string"?{url:o.url}:{},...typeof o.revised_prompt=="string"?{revisedPrompt:o.revised_prompt}:{}}))}async createSpeech(r,t){const s=await this.client.audio.speech.create({model:r.model,input:r.input,voice:r.voice,...r.instructions===void 0?{}:{instructions:r.instructions},...r.responseFormat===void 0?{}:{response_format:r.responseFormat},...r.speed===void 0?{}:{speed:r.speed}},t);return d(s)}async transcribe(r,t){return(await this.client.audio.transcriptions.create(m(r),t)).text}async translate(r,t){return(await this.client.audio.translations.create(c(r),t)).text}async createVideo(r,t){const s={model:r.model,instances:[{prompt:r.prompt}],...r.parameters===void 0?{}:{parameters:r.parameters}};return i(await this.client.video.generations.create(s,t))}async getVideoOperation(r,t){return i(await this.client.video.operations.retrieve(r,t))}async downloadVideo(r,t){return d(await this.client.video.operations.download(r,t))}}function a(e){return{model:e.model,prompt:e.prompt,...e.n===void 0?{}:{n:e.n},...e.size===void 0?{}:{size:e.size},...e.quality===void 0?{}:{quality:e.quality},...e.background===void 0?{}:{background:e.background},...e.outputFormat===void 0?{}:{output_format:e.outputFormat},...e.outputCompression===void 0?{}:{output_compression:e.outputCompression},...e.moderation===void 0?{}:{moderation:e.moderation},...e.user===void 0?{}:{user:e.user}}}function m(e){const r={model:e.model,file:e.file,filename:e.filename};return e.prompt!==void 0&&(r.prompt=e.prompt),e.temperature!==void 0&&(r.temperature=e.temperature),e.responseFormat!==void 0&&(r.response_format=e.responseFormat),e.language!==void 0&&(r.language=e.language),e.timestampGranularities!==void 0&&(r.timestamp_granularities=[...e.timestampGranularities]),e.include!==void 0&&(r.include=[...e.include]),r}function c(e){const r={model:e.model,file:e.file,filename:e.filename};return e.prompt!==void 0&&(r.prompt=e.prompt),e.temperature!==void 0&&(r.temperature=e.temperature),e.responseFormat!==void 0&&(r.response_format=e.responseFormat),r}function d(e){const r=e.headers.get("content-type")?.split(";",1)[0]?.trim();return{bytes:new Uint8Array(e.data),...r===void 0||r.length===0?{}:{contentType:r}}}function i(e){return{id:e.name,done:e.done===!0,...typeof e.error?.message=="string"?{errorMessage:e.error.message}:{}}}export{f as SdkMediaGatewayClient};

package/dist/infrastructure/sessions/file-goal-store.d.ts

@@ -0,0 +1,21 @@
+import { type CreateGoalInput, type GoalEvaluation, type GoalState, type GoalUsageDelta } from '../../domain/orchestration/goal.js';
+import type { GoalStore } from '../../ports/goal-store.js';
+import type { SessionStore } from '../../ports/session-store.js';
+export declare class FileGoalStore implements GoalStore {
+    private readonly sessions;
+    constructor(sessions: SessionStore);
+    get(sessionId: string): Promise<GoalState | undefined>;
+    create(sessionId: string, input: CreateGoalInput): Promise<GoalState>;
+    replace(sessionId: string, input: CreateGoalInput): Promise<GoalState>;
+    pause(sessionId: string, reason?: string): Promise<GoalState>;
+    resume(sessionId: string): Promise<GoalState>;
+    recordTurn(sessionId: string): Promise<GoalState>;
+    recordUsage(sessionId: string, delta: GoalUsageDelta): Promise<GoalState>;
+    recordEvaluation(sessionId: string, evaluation: GoalEvaluation): Promise<GoalState>;
+    clear(sessionId: string, reason?: string): Promise<void>;
+    private requireActiveUnlocked;
+    private getOrThrowUnlocked;
+    private invalidState;
+    private appendState;
+    private append;
+}

package/dist/infrastructure/sessions/file-goal-store.js

@@ -0,0 +1 @@
+import v from"node:crypto";import{CliError as l}from"../../domain/errors/cli-error.js";import{CLI_ERROR_CODES as p}from"../../domain/errors/error-codes.js";import{RESOURCE_LIMITS as i}from"../../domain/runtime/resource-limits.js";import{addGoalUsage as w,EMPTY_GOAL_USAGE as m,isGoalEvaluation as h,isGoalEventType as y,isGoalState as E,validateGoalInput as g}from"../../domain/orchestration/goal.js";class T{sessions;constructor(t){this.sessions=t}async get(t){return c(await this.sessions.readEvents(t))}async create(t,e){return this.sessions.withLock(t,async()=>{const s=g(e),n=c(await this.sessions.readEvents(t));return n?.status==="active"||n?.status==="paused"?this.appendState(n,s,"goal.replaced"):this.appendState(void 0,s,"goal.created",t)})}async replace(t,e){return this.sessions.withLock(t,async()=>this.appendState(void 0,g(e),"goal.replaced",t))}async pause(t,e="Paused by user."){return this.sessions.withLock(t,async()=>{const n={...await this.requireActiveUnlocked(t),status:"paused",updatedAt:r(),lastError:o(e,i.goalReasonBytes)};return await this.append(n,"goal.paused",{reason:n.lastError},!0),n})}async resume(t){return this.sessions.withLock(t,async()=>{const e=await this.getOrThrowUnlocked(t);if(e.status!=="paused")throw this.invalidState(`Goal cannot be resumed from ${e.status}.`);const s=r(),n=f({...e,status:"active",startedAt:s,updatedAt:s});return await this.append(n,"goal.resumed",{},!0),n})}async recordTurn(t){return this.sessions.withLock(t,async()=>{const e=await this.requireActiveUnlocked(t),s={...e,turns:e.turns+1,updatedAt:r()};return await this.append(s,"goal.turn.started",{},!0),s})}async recordUsage(t,e){return this.sessions.withLock(t,async()=>{const s=await this.requireActiveUnlocked(t),n={...s,usage:w(s.usage,e),updatedAt:r()};return await this.append(n,"goal.usage_recorded",{},!0),n})}async recordEvaluation(t,e){return this.sessions.withLock(t,async()=>{const s=await this.requireActiveUnlocked(t);if(!h(e))throw this.invalidState("Goal evaluation is invalid.");const n=k(e.decision),u=S(e),d=f({...s,status:n,evaluatorRuns:s.evaluatorRuns+1,updatedAt:r(),lastEvaluation:u});return await this.append(d,n==="active"?"goal.evaluated":`goal.${n}`,{evaluation:u},!0),d})}async clear(t,e="Cleared by user."){await this.sessions.withLock(t,async()=>{const s=c(await this.sessions.readEvents(t));s!==void 0&&await this.append(s,"goal.cleared",{reason:o(e,i.goalReasonBytes)},!0)})}async requireActiveUnlocked(t){const e=await this.getOrThrowUnlocked(t);if(e.status!=="active")throw this.invalidState(`Goal is not active: ${e.status}.`);return e}async getOrThrowUnlocked(t){const e=c(await this.sessions.readEvents(t));if(e===void 0)throw new l(p.GOAL_NOT_FOUND,`Goal not found for session: ${t}`,{category:"goal",userMessage:"No goal is configured for this session."});return e}invalidState(t){return new l(p.GOAL_INVALID_STATE,t,{category:"goal",userMessage:t})}async appendState(t,e,s,n){const u=t?.sessionId??n;if(u===void 0)throw this.invalidState("A session id is required to create a goal.");const d=A(u,e);return await this.append(d,s,{},!0),d}async append(t,e,s,n){await this.sessions.appendEvent({type:e,timestamp:r(),sessionId:t.sessionId,data:{goal:G(t),...s}},{locked:n})}}function A(a,t){const e=r();return{id:v.randomUUID(),sessionId:a,objective:t.objective,status:"active",createdAt:e,updatedAt:e,startedAt:e,turns:0,evaluatorRuns:0,usage:{...m},...t.tokenBudget===void 0?{}:{tokenBudget:t.tokenBudget},...t.maxTurns===void 0?{}:{maxTurns:t.maxTurns},...t.maxDurationMs===void 0?{}:{maxDurationMs:t.maxDurationMs}}}function c(a){let t;for(const e of a){if(!y(e.type))continue;if(e.type==="goal.cleared"){t=void 0;continue}const s=e.data?.goal;E(s)&&(t=s,e.type==="goal.evaluated"&&e.data?.evaluation!==void 0&&h(e.data.evaluation)&&(t={...t,lastEvaluation:e.data.evaluation}))}return t}function k(a){return a==="complete"?"completed":a==="blocked"?"blocked":a==="budget_limited"?"budget_limited":a==="usage_limited"?"usage_limited":"active"}function S(a){return{decision:a.decision,reason:o(a.reason,i.goalReasonBytes),evidence:a.evidence.slice(0,i.goalEvidenceItems).map(t=>o(t,i.goalEvidenceBytes)),timestamp:a.timestamp,...a.evaluatorModel===void 0?{}:{evaluatorModel:o(a.evaluatorModel,256)}}}function G(a){return{...a,objective:o(a.objective,i.goalObjectiveBytes)}}function o(a,t){return a.length<=t?a:`${a.slice(0,t-3)}...`}function r(){return new Date().toISOString()}function f(a){return delete a.lastError,a}export{T as FileGoalStore};

package/dist/infrastructure/sessions/file-session-store.d.ts

@@ -0,0 +1,47 @@
+import type { SessionEvent, SessionMetadata, TranscriptEntry } from '../../domain/session/session.js';
+import type { Attachment } from '../../domain/session/attachment.js';
+import type { SessionStore, SessionBundle, SessionHistory, SessionJournalAppend, SessionRepairResult } from '../../ports/session-store.js';
+import type { PlatformPaths } from '../platform/platform-paths.js';
+export declare class FileSessionStore implements SessionStore {
+    private readonly paths;
+    constructor(paths: PlatformPaths);
+    create(input: Omit<SessionMetadata, 'id' | 'createdAt' | 'updatedAt'>): Promise<SessionMetadata>;
+    get(sessionId: string): Promise<SessionMetadata | undefined>;
+    list(projectFingerprint?: string): Promise<readonly SessionMetadata[]>;
+    updateStatus(sessionId: string, status: SessionMetadata['status']): Promise<SessionMetadata>;
+    rename(sessionId: string, name: string): Promise<SessionMetadata>;
+    appendEvent(event: SessionEvent, options?: {
+        locked?: boolean;
+    }): Promise<void>;
+    appendTranscript(sessionId: string, entry: TranscriptEntry): Promise<void>;
+    appendJournal(sessionId: string, records: readonly SessionJournalAppend[]): Promise<void>;
+    readEvents(sessionId: string): Promise<readonly SessionEvent[]>;
+    readTranscript(sessionId: string): Promise<readonly TranscriptEntry[]>;
+    readHistory(sessionId: string): Promise<SessionHistory>;
+    delete(sessionId: string): Promise<boolean>;
+    fork(sessionId: string, overrides?: Partial<Pick<SessionMetadata, 'model' | 'profile'>>): Promise<SessionMetadata>;
+    compact(sessionId: string, summary: string, options?: {
+        turnId?: string;
+    }): Promise<void>;
+    export(sessionId: string): Promise<SessionBundle>;
+    import(bundle: SessionBundle, projectFingerprint: string, cwd: string): Promise<SessionMetadata>;
+    saveAttachment(sessionId: string, attachment: Attachment, bytes: Uint8Array): Promise<Attachment>;
+    private persistAttachment;
+    readAttachment(sessionId: string, attachmentId: string): Promise<Uint8Array | undefined>;
+    recoverStaleLock(sessionId: string): Promise<boolean>;
+    repair(sessionId: string): Promise<SessionRepairResult>;
+    withLock<T>(sessionId: string, action: () => Promise<T>): Promise<T>;
+    private require;
+    private requirePaths;
+    private locate;
+    private locateByScan;
+    private projectKeys;
+    private readOrRebuildIndex;
+    private indexMatchesJournals;
+    private projectJournalIds;
+    private rebuildProjectIndex;
+    private readSnapshot;
+    private appendJournalLocked;
+    private readAttachmentMetadata;
+    private corrupt;
+}

package/dist/infrastructure/sessions/file-session-store.js

@@ -0,0 +1,4 @@
+import R from"node:crypto";import o from"node:fs/promises";import m from"node:path";import{CliError as h}from"../../domain/errors/cli-error.js";import{CLI_ERROR_CODES as d}from"../../domain/errors/error-codes.js";import{isRecord as F,isSessionEvent as _,isSessionMetadata as q,isTranscriptEntry as z}from"../../domain/session/session-schema.js";import{isGoalEventType as C,isPersistedGoalEventData as J}from"../../domain/orchestration/goal.js";import{isAlreadyExists as $,isFileNotFound as p}from"../filesystem/fs-errors.js";import{acquireAdvisoryFileLock as G,atomicWriteFile as x,isAdvisoryLockContention as U,releaseAdvisoryFileLock as K}from"../filesystem/atomic-file-store.js";import{isSafeProjectKey as O,resolveProjectSessionPaths as H,resolveProjectSessionPathsForKey as j}from"./project-session-paths.js";import{appendJournalRecord as y,appendJournalRecords as V,eventRecord as L,journalEvents as E,journalTranscript as P,latestMetadata as D,metadataRecord as T,readJournal as w,repairJournal as W,transcriptRecord as B}from"./session-journal.js";import{indexProjectSession as g,readProjectSessionIndex as Z,readSessionLocator as Q,removeIndexedSession as X}from"./session-index.js";import{RESOURCE_LIMITS as l}from"../../domain/runtime/resource-limits.js";import{readJsonFileBounded as I}from"../filesystem/bounded-json-reader.js";const b=/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,v=/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/,Y=300*1e3;class vt{paths;constructor(t){this.paths=t}async create(t){const a=new Date().toISOString(),e={...t,id:R.randomUUID(),createdAt:a,updatedAt:a},r=H(this.paths,e.cwd,e.id);return await o.mkdir(r.attachmentsDirectory,{recursive:!0}),await y(r.journalFile,T(e)),await g(this.paths,e,r.projectKey),e}async get(t){const a=await this.locate(t);if(a!==void 0)try{const e=D(await w(a.journalFile));if(e===void 0)throw new Error("Session metadata is missing.");return e}catch(e){throw this.corrupt(t,e)}}async list(t){const a=[];for(const e of await this.projectKeys()){const r=j(this.paths,e,"00000000-0000-4000-8000-000000000000"),n=await this.readOrRebuildIndex(r.projectIndexFile,e);for(const i of Object.values(n))(t===void 0||i.projectFingerprint===t)&&a.push(i)}return a.sort((e,r)=>r.updatedAt.localeCompare(e.updatedAt))}async updateStatus(t,a){return this.withLock(t,async()=>{const r={...await this.require(t),status:a,updatedAt:new Date().toISOString()},n=await this.requirePaths(t);return await y(n.journalFile,T(r)),await g(this.paths,r,n.projectKey),r})}async rename(t,a){const e=a.trim().replace(/\s+/gu," ");if(e.length===0||e.length>120||/[\r\n]/u.test(e)||e.includes("\0"))throw new h(d.INVALID_ARGUMENT,"Session name is invalid.",{category:"session",userMessage:"Session name must be between 1 and 120 printable characters."});return this.withLock(t,async()=>{const n={...await this.require(t),name:e,updatedAt:new Date().toISOString()},i=await this.requirePaths(t);return await y(i.journalFile,T(n)),await g(this.paths,n,i.projectKey),n})}async appendEvent(t,a={}){const e=[{kind:"event",event:t}];a.locked===!0?await this.appendJournalLocked(t.sessionId,e):await this.appendJournal(t.sessionId,e)}async appendTranscript(t,a){await this.appendJournal(t,[{kind:"transcript",entry:a}])}async appendJournal(t,a){a.length!==0&&await this.withLock(t,()=>this.appendJournalLocked(t,a))}async readEvents(t){const a=await this.requirePaths(t);return await this.require(t),E(await w(a.journalFile))}async readTranscript(t){const a=await this.requirePaths(t);return await this.require(t),P(await w(a.journalFile))}async readHistory(t){return this.withLock(t,async()=>{const a=await this.requirePaths(t);await this.require(t);const e=await w(a.journalFile);return{events:E(e),transcript:P(e)}})}async delete(t){const a=await this.get(t);return a===void 0?!1:(await this.withLock(t,async()=>{const e=await this.requirePaths(t);await o.rm(e.journalFile,{force:!0}),await o.rm(e.sessionDirectory,{recursive:!0,force:!0}),await X(this.paths,a,e.projectKey)}),!0)}async fork(t,a={}){const e=await this.readSnapshot(t),r=e.metadata,n=await this.create({projectFingerprint:r.projectFingerprint,cwd:r.cwd,model:a.model??r.model,profile:a.profile??r.profile,status:"active"});try{return await this.withLock(n.id,async()=>{const i=await this.requirePaths(n.id);for(const c of e.events){const f=tt(c.data);await y(i.journalFile,L({...c,sessionId:n.id,...f===void 0?{}:{data:f}}))}for(const c of e.transcript)await y(i.journalFile,B(c));for(const[c,f]of e.attachments)f.attachment!==void 0&&await this.persistAttachment(n.id,{...f.attachment,id:c},f.bytes)}),n}catch(i){try{await this.delete(n.id)}catch(c){throw new AggregateError([i,c],"Session fork failed and cleanup was incomplete.")}throw i}}async compact(t,a,e={}){const r=a.trim();if(r.length===0)throw new h(d.SESSION_CORRUPTED,"Compaction summary cannot be empty.",{category:"session",userMessage:"Compaction summary cannot be empty."});const n=new Date().toISOString();await this.appendJournal(t,[{kind:"transcript",entry:{type:"system",timestamp:n,content:`[Compacted context]
+${r}`,...e.turnId===void 0?{}:{turnId:e.turnId}}},{kind:"event",event:{type:"context.compacted",timestamp:n,sessionId:t,...e.turnId===void 0?{}:{turnId:e.turnId},data:{summary:r}}}])}async export(t){const a=await this.readSnapshot(t),e=[];for(const r of a.transcript)for(const n of r.attachmentIds??[]){if(e.some(f=>f.attachment.id===n))continue;const i=a.attachments.get(n);if(i===void 0)continue;const c=i.attachment??{id:n,name:n,mimeType:"application/octet-stream",sizeBytes:i.bytes.byteLength,source:"file"};e.push({attachment:c,dataBase64:Buffer.from(i.bytes).toString("base64")})}return{metadata:a.metadata,events:a.events,transcript:a.transcript,attachments:e}}async import(t,a,e){rt(t);const r=await this.create({projectFingerprint:a,cwd:e,model:t.metadata.model,profile:t.metadata.profile,status:"active"});try{for(const n of t.events){const i=et(n.data);await this.appendEvent({...n,sessionId:r.id,...i===void 0?{}:{data:i}})}for(const n of t.transcript)await this.appendTranscript(r.id,n);for(const n of t.attachments)await this.saveAttachment(r.id,n.attachment,Buffer.from(n.dataBase64,"base64"));return r}catch(n){try{await this.delete(r.id)}catch(i){throw new AggregateError([n,i],"Session import failed and cleanup was incomplete.")}throw n}}async saveAttachment(t,a,e){if(!v.test(a.id))throw new h(d.ATTACHMENT_INVALID_IMAGE,"Attachment id is invalid.",{category:"attachment",userMessage:"Attachment name is invalid."});if(a.sizeBytes<0||a.sizeBytes>l.maxAttachmentBytes)throw new h(d.ATTACHMENT_TOO_LARGE,"Attachment exceeds the allowed size.",{category:"attachment",userMessage:"Attachment exceeds the allowed size."});if(e.byteLength!==a.sizeBytes)throw new h(d.ATTACHMENT_INVALID_IMAGE,"Attachment size does not match metadata.",{category:"attachment",userMessage:"Attachment size does not match its metadata."});return this.withLock(t,()=>this.persistAttachment(t,a,e))}async persistAttachment(t,a,e){const r=await this.requirePaths(t);await this.require(t),await o.mkdir(r.attachmentsDirectory,{recursive:!0});const n=m.join(r.attachmentsDirectory,`${a.id}.bin`);return await o.writeFile(n,e,{flag:"wx",mode:384}).catch(async i=>{if(!$(i))throw i;await o.writeFile(n,e,{mode:384})}),await x(m.join(r.attachmentsDirectory,`${a.id}.json`),`${JSON.stringify(a,null,2)}
+`),{...a,storagePath:m.posix.join("attachments",`${a.id}.bin`)}}async readAttachment(t,a){const e=await this.requirePaths(t);if(await this.require(t),!v.test(a))return;const r=m.join(e.attachmentsDirectory,`${a}.bin`);try{if((await o.stat(r)).size>l.maxAttachmentBytes)throw new h(d.ATTACHMENT_TOO_LARGE,"Stored attachment exceeds the allowed size.",{category:"attachment",userMessage:"Stored attachment exceeds the allowed size."});return await o.readFile(r)}catch(n){if(p(n))return;throw n}}async recoverStaleLock(t){const a=await this.locate(t);if(a===void 0)return!1;let e;try{e=await o.stat(a.lockFile)}catch(n){if(p(n))return!1;throw n}if(Date.now()-e.mtimeMs<Y)return!1;let r={};try{r=await I(a.lockFile,4*1024)}catch{}return typeof r.pid=="number"&&at(r.pid)?!1:(await o.rm(a.lockFile,{force:!0}),!0)}async repair(t){const a=await this.requirePaths(t);return{eventsRemoved:await this.withLock(t,()=>W(a.journalFile)),transcriptRemoved:0}}async withLock(t,a){const e=await this.requirePaths(t);await o.mkdir(e.sessionDirectory,{recursive:!0});let r;try{r=await G(e.lockFile)}catch(n){const i=await U(n,e.lockFile);if(i&&await this.recoverStaleLock(t))return this.withLock(t,a);throw i?new h(d.SESSION_LOCKED,`Session is locked: ${t}`,{category:"session",userMessage:"The session is being used by another process. Try again later.",retryable:!0}):n}try{return await a()}finally{await K(r,e.lockFile)}}async require(t){const a=await this.get(t);if(a===void 0)throw new h(d.SESSION_NOT_FOUND,`Session not found: ${t}`,{category:"session",userMessage:`Session not found: ${t}.`});return a}async requirePaths(t){const a=await this.locate(t);if(a===void 0)throw new h(d.SESSION_NOT_FOUND,`Session not found: ${t}`,{category:"session",userMessage:`Session not found: ${t}.`});return a}async locate(t){if(!b.test(t))return;const e=(await Q(this.paths)).sessions[t];if(typeof e=="string"&&O(e)){const r=j(this.paths,e,t);if(await N(r.journalFile))return r}return this.locateByScan(t)}async locateByScan(t){for(const a of await this.projectKeys()){const e=j(this.paths,a,t);if(await N(e.journalFile))return e}}async projectKeys(){try{return(await o.readdir(this.paths.projectsDir,{withFileTypes:!0})).filter(t=>t.isDirectory()&&O(t.name)).map(t=>t.name)}catch(t){if(p(t))return[];throw t}}async readOrRebuildIndex(t,a){try{const e=(await Z(t,a)).sessions;return await this.indexMatchesJournals(a,e)?e:this.rebuildProjectIndex(a)}catch{return this.rebuildProjectIndex(a)}}async indexMatchesJournals(t,a){const e=await this.projectJournalIds(t),r=Object.keys(a);return e.length===r.length&&e.every(n=>a[n]!==void 0)}async projectJournalIds(t){const a=m.join(this.paths.projectsDir,t);try{return(await o.readdir(a,{withFileTypes:!0})).filter(e=>e.isFile()&&e.name.endsWith(".jsonl")).map(e=>e.name.slice(0,-6)).filter(e=>b.test(e))}catch(e){if(p(e))return[];throw e}}async rebuildProjectIndex(t){const a={},e=m.join(this.paths.projectsDir,t);for(const n of await o.readdir(e,{withFileTypes:!0}))if(!(!n.isFile()||!n.name.endsWith(".jsonl")))try{const i=D(await w(m.join(e,n.name)));i!==void 0&&(a[i.id]=i)}catch{}const r=m.join(e,"index.json");await o.mkdir(e,{recursive:!0}),await x(r,`${JSON.stringify({projectKey:t,sessions:a},null,2)}
+`);for(const n of Object.values(a))await g(this.paths,n,t);return a}async readSnapshot(t){return this.withLock(t,async()=>{const a=await this.require(t),e=await this.requirePaths(t),r=await w(e.journalFile),n=E(r),i=P(r),c=new Map;for(const f of i)for(const S of f.attachmentIds??[]){if(c.has(S))continue;const k=await this.readAttachment(t,S);k!==void 0&&c.set(S,{bytes:k,attachment:await this.readAttachmentMetadata(e,S)})}return{metadata:a,events:n,transcript:i,attachments:c}})}async appendJournalLocked(t,a){const e=await this.requirePaths(t);await this.require(t);const r=a.map(n=>{if(n.kind==="event"&&n.event.sessionId!==t)throw new h(d.SESSION_CORRUPTED,"Cannot append an event to a different session.",{category:"session",userMessage:"Session event data is invalid."});return n.kind==="event"?L(n.event):B(n.entry)});await V(e.journalFile,r)}async readAttachmentMetadata(t,a){try{return st(await I(m.join(t.attachmentsDirectory,`${a}.json`),l.configFileBytes))}catch(e){if(p(e))return;throw e}}corrupt(t,a){return new h(d.SESSION_CORRUPTED,`Session metadata is corrupted: ${t}`,{category:"session",userMessage:"Session is corrupted and its metadata cannot be read.",cause:a})}}function tt(s){return M(s)}function et(s){return M(s)}function M(s){if(s===void 0||typeof s.goal!="object"||s.goal===null)return s;const t=s.goal;return t.status!=="active"?s:{...s,goal:{...t,status:"paused",updatedAt:new Date().toISOString()},reason:"Explicit resume is required after fork or import."}}async function N(s){try{return await o.access(s),!0}catch(t){if(p(t))return!1;throw t}}function at(s){if(s===process.pid)return!0;try{return process.kill(s,0),!0}catch{return!1}}function rt(s){if(!q(s.metadata)||!Array.isArray(s.events)||!Array.isArray(s.transcript)||!Array.isArray(s.attachments))throw u("Session export file is invalid.");if(s.events.length>l.sessionEvents||s.transcript.length>l.sessionTranscriptEntries||s.attachments.length>l.sessionAttachments)throw u("Session export exceeds the supported entry limits.");for(const e of s.events){if(!_(e))throw u("Session export contains an invalid event.");if(C(e.type)&&!J(e.data))throw u("Session export contains an invalid goal event.");if(A(e.type)>256||A(e.timestamp)>128||A(e.sessionId)>128)throw u("Session event metadata is too large.")}const t=new Set;let a=0;for(const e of s.transcript){if(!z(e)||A(e.content)>l.sessionTextBytes)throw u("Session export contains an invalid transcript entry.");if(e.attachmentIds!==void 0&&(!Array.isArray(e.attachmentIds)||e.attachmentIds.some(r=>typeof r!="string"||!v.test(r))))throw u("Session transcript contains invalid attachment references.")}for(const e of s.attachments){if(!nt(e))throw u("Session export contains an invalid attachment.");const r=e.attachment;if(typeof r.id!="string"||!v.test(r.id)||t.has(r.id)||typeof r.name!="string"||typeof r.mimeType!="string"||typeof r.sizeBytes!="number"||!Number.isSafeInteger(r.sizeBytes)||r.sizeBytes<0||r.sizeBytes>l.maxAttachmentBytes||r.source!=="clipboard"&&r.source!=="file")throw u("Session export contains invalid attachment metadata.");const n=Buffer.from(e.dataBase64,"base64");if(n.toString("base64")!==e.dataBase64||n.byteLength!==r.sizeBytes)throw u("Session export contains an invalid attachment payload.");if(a+=n.byteLength,a>l.sessionAttachmentTotalBytes)throw u("Session export exceeds the total attachment limit.");t.add(r.id)}}function nt(s){if(!F(s)||!F(s.attachment)||typeof s.dataBase64!="string")return!1;const t=s.attachment;return typeof t.id=="string"&&typeof t.name=="string"&&typeof t.mimeType=="string"&&typeof t.sizeBytes=="number"&&Number.isSafeInteger(t.sizeBytes)&&(t.source==="clipboard"||t.source==="file")}function A(s){return Buffer.byteLength(s,"utf8")}function u(s){return new h(d.SESSION_CORRUPTED,s,{category:"session",userMessage:s})}function st(s){if(typeof s!="object"||s===null)throw new Error("Invalid attachment metadata.");const t=s;if(typeof t.id!="string"||typeof t.name!="string"||typeof t.mimeType!="string"||typeof t.sizeBytes!="number"||t.source!=="clipboard"&&t.source!=="file")throw new Error("Invalid attachment metadata.");return s}export{vt as FileSessionStore};

package/dist/infrastructure/sessions/project-session-paths.d.ts

@@ -0,0 +1,17 @@
+import type { PlatformPaths } from '../platform/platform-paths.js';
+import { type HostPlatformContext } from '../platform/host-platform.js';
+export interface ProjectSessionPaths {
+    projectKey: string;
+    projectDirectory: string;
+    projectIndexFile: string;
+    sessionId: string;
+    journalFile: string;
+    sessionDirectory: string;
+    attachmentsDirectory: string;
+    subagentsDirectory: string;
+    lockFile: string;
+}
+export declare function isSafeProjectKey(value: string): boolean;
+export declare function createProjectKey(cwd: string, platform?: HostPlatformContext): string;
+export declare function resolveProjectSessionPaths(paths: PlatformPaths, cwd: string, sessionId: string): ProjectSessionPaths;
+export declare function resolveProjectSessionPathsForKey(paths: PlatformPaths, projectKey: string, sessionId: string): ProjectSessionPaths;

package/dist/infrastructure/sessions/project-session-paths.js

@@ -0,0 +1 @@
+import s from"node:crypto";import r from"node:path";import{detectHostPlatform as i}from"../platform/host-platform.js";function a(o){return/^[A-Za-z0-9._-]+--[0-9a-f]{12}$/u.test(o)}function l(o,n=i()){const e=r.resolve(o),t=n.isWindows?e.toLowerCase():e,c=s.createHash("sha256").update(t,"utf8").digest("hex").slice(0,12);return`${e.replaceAll("\\","-").replaceAll("/","-").replaceAll(":","-").replace(/[^A-Za-z0-9._-]+/gu,"-").replace(/-+/gu,"-").replace(/^-|-$/gu,"").slice(0,120)||"project"}--${c}`}function h(o,n,e){const t=l(n,o.platform);return p(o,t,e)}function p(o,n,e){if(!a(n))throw new Error("Invalid project session key.");const t=r.join(o.projectsDir,n),c=r.join(t,e);return{projectKey:n,projectDirectory:t,projectIndexFile:r.join(t,"index.json"),sessionId:e,journalFile:r.join(t,`${e}.jsonl`),sessionDirectory:c,attachmentsDirectory:r.join(c,"attachments"),subagentsDirectory:r.join(c,"subagents"),lockFile:r.join(c,"lock")}}export{l as createProjectKey,a as isSafeProjectKey,h as resolveProjectSessionPaths,p as resolveProjectSessionPathsForKey};

package/dist/infrastructure/sessions/session-index.d.ts

@@ -0,0 +1,16 @@
+import type { SessionMetadata } from '../../domain/session/session.js';
+import type { PlatformPaths } from '../platform/platform-paths.js';
+interface ProjectSessionIndex {
+    projectKey: string;
+    sessions: Record<string, SessionMetadata>;
+}
+interface SessionLocatorIndex {
+    sessions: Record<string, string>;
+}
+export declare function readProjectSessionIndex(filePath: string, projectKey: string): Promise<ProjectSessionIndex>;
+export declare function writeProjectSessionIndex(filePath: string, projectKey: string, sessions: Readonly<Record<string, SessionMetadata>>): Promise<void>;
+export declare function readSessionLocator(paths: PlatformPaths): Promise<SessionLocatorIndex>;
+export declare function writeSessionLocator(paths: PlatformPaths, sessions: Readonly<Record<string, string>>): Promise<void>;
+export declare function indexProjectSession(paths: PlatformPaths, metadata: SessionMetadata, projectKey: string): Promise<void>;
+export declare function removeIndexedSession(paths: PlatformPaths, metadata: SessionMetadata, projectKey: string): Promise<void>;
+export {};

package/dist/infrastructure/sessions/session-index.js

@@ -0,0 +1,3 @@
+import c from"node:path";import{atomicWriteFile as f,withFileLock as a}from"../filesystem/atomic-file-store.js";import{isFileNotFound as l}from"../filesystem/fs-errors.js";import{resolveProjectSessionPathsForKey as p}from"./project-session-paths.js";import{readJsonFileBounded as j}from"../filesystem/bounded-json-reader.js";import{RESOURCE_LIMITS as w}from"../../domain/runtime/resource-limits.js";async function x(o,s){try{return m(await j(o,w.configFileBytes),s)}catch(t){if(l(t))return{projectKey:s,sessions:{}};throw t}}async function y(o,s,t){await f(o,`${JSON.stringify({projectKey:s,sessions:t},null,2)}
+`)}async function I(o){const s=c.join(o.projectsDir,"locator.json");try{return g(await j(s,w.configFileBytes))}catch(t){if(l(t))return{sessions:{}};throw t}}function m(o,s){if(!e(o)||o.projectKey!==s||!e(o.sessions))throw new Error("Invalid project session index.");for(const t of Object.values(o.sessions))if(!u(t))throw new Error("Invalid project session metadata.");return{projectKey:s,sessions:o.sessions}}function g(o){if(!e(o)||!e(o.sessions)||Object.values(o.sessions).some(s=>typeof s!="string"))throw new Error("Invalid session locator index.");return{sessions:o.sessions}}function u(o){return e(o)?typeof o.id=="string"&&typeof o.projectFingerprint=="string"&&typeof o.cwd=="string"&&(typeof o.model=="string"||o.model===null)&&(typeof o.profile=="string"||o.profile===null)&&(o.status==="active"||o.status==="completed"||o.status==="failed"||o.status==="cancelled")&&typeof o.createdAt=="string"&&typeof o.updatedAt=="string":!1}function e(o){return typeof o=="object"&&o!==null&&!Array.isArray(o)}async function F(o,s){await f(c.join(o.projectsDir,"locator.json"),`${JSON.stringify({sessions:s},null,2)}
+`)}async function A(o,s,t){const n=p(o,t,s.id);await a(n.projectIndexFile,async()=>{const i=await x(n.projectIndexFile,t);await y(n.projectIndexFile,t,{...i.sessions,[s.id]:s})});const d=c.join(o.projectsDir,"locator.json");await a(d,async()=>{const i=await I(o);await F(o,{...i.sessions,[s.id]:t})})}async function D(o,s,t){const n=p(o,t,s.id);await a(n.projectIndexFile,async()=>{const r={...(await x(n.projectIndexFile,t)).sessions};delete r[s.id],await y(n.projectIndexFile,t,r)});const d=c.join(o.projectsDir,"locator.json");await a(d,async()=>{const r={...(await I(o)).sessions};delete r[s.id],await F(o,r)})}export{A as indexProjectSession,x as readProjectSessionIndex,I as readSessionLocator,D as removeIndexedSession,y as writeProjectSessionIndex,F as writeSessionLocator};

package/dist/infrastructure/sessions/session-journal.d.ts

@@ -0,0 +1,22 @@
+import type { SessionEvent, SessionMetadata, TranscriptEntry } from '../../domain/session/session.js';
+export type SessionJournalRecord = {
+    recordType: 'metadata';
+    metadata: SessionMetadata;
+} | {
+    recordType: 'event';
+    event: SessionEvent;
+} | {
+    recordType: 'transcript';
+    entry: TranscriptEntry;
+};
+export declare function metadataRecord(metadata: SessionMetadata): SessionJournalRecord;
+export declare function eventRecord(event: SessionEvent): SessionJournalRecord;
+export declare function transcriptRecord(entry: TranscriptEntry): SessionJournalRecord;
+export declare function appendJournalRecord(filePath: string, record: SessionJournalRecord): Promise<void>;
+/** Appends one crash-consistent physical JSONL record for an ordered logical batch. */
+export declare function appendJournalRecords(filePath: string, records: readonly SessionJournalRecord[]): Promise<void>;
+export declare function readJournal(filePath: string): Promise<readonly SessionJournalRecord[]>;
+export declare function latestMetadata(records: readonly SessionJournalRecord[]): SessionMetadata | undefined;
+export declare function journalEvents(records: readonly SessionJournalRecord[]): readonly SessionEvent[];
+export declare function journalTranscript(records: readonly SessionJournalRecord[]): readonly TranscriptEntry[];
+export declare function repairJournal(filePath: string): Promise<number>;

package/dist/infrastructure/sessions/session-journal.js

@@ -0,0 +1,6 @@
+import a from"node:fs/promises";import T from"node:path";import{isFileNotFound as s}from"../filesystem/fs-errors.js";import{atomicWriteFile as g}from"../filesystem/atomic-file-store.js";import{isRecord as u,isSessionEvent as x,isSessionMetadata as J,isTranscriptEntry as v}from"../../domain/session/session-schema.js";import{RESOURCE_LIMITS as p}from"../../domain/runtime/resource-limits.js";function L(e){return{recordType:"metadata",metadata:e}}function M(e){return{recordType:"event",event:e}}function N(e){return{recordType:"transcript",entry:e}}async function O(e,r){await f(e,r)}async function A(e,r){r.length!==0&&await f(e,r.length===1?r[0]:{recordType:"batch",records:r})}async function f(e,r){await a.mkdir(T.dirname(e),{recursive:!0});const t=`${JSON.stringify(r)}
+`;await E(e,Buffer.byteLength(t,"utf8")),await a.appendFile(e,t,{encoding:"utf8",mode:384})}async function U(e){let r;try{await z(e),r=await a.readFile(e,"utf8")}catch(t){if(s(t))return[];throw t}try{return l(r)}catch(t){if(!R(r))throw t;return await new Promise(o=>setImmediate(o)),l(await a.readFile(e,"utf8"))}}function l(e){return e.split(/\r?\n/u).filter(Boolean).flatMap(r=>m(JSON.parse(r)))}function R(e){const r=e.replace(/\r\n/gu,`
+`);return r.length>0&&!r.endsWith(`
+`)}async function z(e){if((await a.stat(e)).size>p.sessionJournalBytes)throw new Error("Session journal exceeds the supported size limit. Repair or export the session before resuming it.")}async function E(e,r){let t=0;try{t=(await a.stat(e)).size}catch(o){if(!s(o))throw o}if(t+r>p.sessionJournalBytes)throw new Error("Session journal exceeds the supported size limit. Compact or export the session before adding more data.")}function W(e){return e.filter(r=>r.recordType==="metadata").at(-1)?.metadata}function $(e){return e.filter(r=>r.recordType==="event").map(r=>r.event)}function k(e){return e.filter(r=>r.recordType==="transcript").map(r=>r.entry)}async function _(e){const r=await a.stat(e).catch(n=>{if(!s(n))throw n});if(r===void 0)return 0;if(r.size>p.sessionJournalBytes)throw new Error("Session journal exceeds the supported size limit. Repair cannot process an oversized journal.");let t;try{t=await a.readFile(e,"utf8")}catch(n){if(s(n))return 0;throw n}const o=t.split(/\r?\n/u),c=[];let d=0;for(let n=0;n<o.length;n+=1){const i=o[n]?.trim();if(!(i===void 0||i.length===0))try{m(JSON.parse(i)),c.push(i)}catch(w){if(!o.slice(n+1).every(h=>h.trim().length===0))throw w;d+=1}}return d>0&&await g(e,c.length===0?"":`${c.join(`
+`)}
+`),d}function m(e){if(u(e)&&e.recordType==="batch"){const r=e.records;if(!Array.isArray(r)||r.length===0)throw new Error("Invalid session journal batch.");return r.map(y)}return[y(e)]}function y(e){if(!u(e))throw new Error("Invalid session journal record.");const r=e;if(r.recordType==="metadata"&&J(r.metadata))return{recordType:"metadata",metadata:r.metadata};if(r.recordType==="event"&&x(r.event))return{recordType:"event",event:r.event};if(r.recordType==="transcript"&&v(r.entry))return{recordType:"transcript",entry:r.entry};throw new Error("Unsupported or malformed session journal record.")}export{O as appendJournalRecord,A as appendJournalRecords,M as eventRecord,$ as journalEvents,k as journalTranscript,W as latestMetadata,L as metadataRecord,U as readJournal,_ as repairJournal,N as transcriptRecord};

package/dist/infrastructure/sessions/subagent-journal-store.d.ts

@@ -0,0 +1,28 @@
+import type { PlatformPaths } from '../platform/platform-paths.js';
+import type { SubagentResult } from '../../domain/orchestration/subagent.js';
+export type SubagentJournalRecord = {
+    recordType: 'created';
+    id: string;
+    displayName: string;
+    task: string;
+    mode: 'research' | 'worker';
+    model: string;
+    timestamp: string;
+} | {
+    recordType: 'started';
+    id: string;
+    displayName: string;
+    mode: 'research' | 'worker';
+    model: string;
+    timestamp: string;
+} | {
+    recordType: 'completed' | 'completed_with_warning' | 'failed' | 'cancelled';
+    result: SubagentResult;
+    timestamp: string;
+};
+/** Persists bounded child-agent lifecycle records beside the parent session. */
+export declare class SubagentJournalStore {
+    private readonly paths;
+    constructor(paths: PlatformPaths);
+    append(parentSessionId: string, cwd: string, record: SubagentJournalRecord): Promise<void>;
+}

package/dist/infrastructure/sessions/subagent-journal-store.js

@@ -0,0 +1,2 @@
+import s from"node:fs/promises";import a from"node:path";import{resolveProjectSessionPaths as u}from"./project-session-paths.js";class m{paths;constructor(e){this.paths=e}async append(e,r,o){c(e);const n=u(this.paths,r,e),i=a.join(n.subagentsDirectory,`${f(o)}.jsonl`);await s.mkdir(n.subagentsDirectory,{recursive:!0,mode:448}),await d(i,o)}}function c(t){if(!/^[A-Za-z0-9._-]{1,128}$/u.test(t))throw new Error("Invalid parent session id for subagent journal.")}async function d(t,e){const r=`${JSON.stringify(e)}
+`;if(Buffer.byteLength(r,"utf8")>32*1024)throw new Error("Subagent journal record exceeds the configured limit.");await s.appendFile(t,r,{encoding:"utf8",mode:384})}function f(t){return t.recordType==="created"||t.recordType==="started"?t.id:t.result.id}export{m as SubagentJournalStore};

package/dist/infrastructure/shell/shell-tool-executor.d.ts

@@ -0,0 +1,17 @@
+import type { ToolDefinition } from '@lotagate/sdk';
+import type { ToolExecutionContext, ToolExecutor, ToolInfo, ToolResult } from '@lotagate/agent-sdk';
+import type { ToolActivityObserver } from '../../ports/tool-activity.js';
+import { type HostPlatformContext } from '../platform/host-platform.js';
+/** Exposes the same shell capability definitions to runtime and context accounting. */
+export declare function shellToolDefinitions(): readonly ToolDefinition[];
+export declare class ShellToolExecutor implements ToolExecutor {
+    private readonly options;
+    constructor(options?: {
+        onActivity?: ToolActivityObserver;
+        readOnly?: boolean;
+        platform?: HostPlatformContext;
+    });
+    listTools(): readonly ToolDefinition[];
+    getToolInfo(toolName: string): ToolInfo | undefined;
+    execute(toolName: string, input: Record<string, unknown>, context: ToolExecutionContext): Promise<ToolResult>;
+}

package/dist/infrastructure/shell/shell-tool-executor.js

@@ -0,0 +1,2 @@
+import{resolveReadOnlyExecutable as g,readOnlyArguments as y}from"../platform/read-only-executable.js";import{resolveWorkspacePath as u}from"../filesystem/path-resolver.js";import{isReadOnlyShellRequest as w}from"../../application/security/tool-risk-classifier.js";import{detectHostPlatform as x}from"../platform/host-platform.js";import{normalizePowerShellScriptInput as E,execPlatformCommand as b}from"../platform/host-process.js";import{formatShellCommandForDisplay as S}from"../../application/agent/tool-display.js";const P=[{type:"function",function:{name:"shell.exec",description:"Execute one program with structured arguments inside the trusted workspace. Shell interpretation is disabled. On Windows, prefer powershell.exe with script for operating-system work; use direct command and args for node, npm, npx, pnpm, yarn, git, rg, and other project executables. Keep the executable in command and pass arguments separately in args (for example, git status --short means command git and args [status, --short]).",parameters:{type:"object",properties:{command:{type:"string",description:"Executable name or path."},args:{type:"array",items:{type:"string"},description:"Structured process arguments."},script:{type:"string",description:"Optional complete PowerShell script. Use only with powershell.exe or pwsh.exe; passed as one -Command argument."},cwd:{type:"string",description:"Optional workspace-relative working directory."},timeoutMs:{type:"number",description:"Timeout between 100 and 120000 milliseconds."}},required:["command"],additionalProperties:!1}}}],O="Process completed successfully with no output.";function T(){return P}class I{options;constructor(t={}){this.options=t}listTools(){return T()}getToolInfo(t){return t==="shell.exec"?{toolName:t,source:"shell",executorId:"local-shell"}:void 0}async execute(t,a,o){if(t!=="shell.exec")return{content:`Unknown shell tool: ${t}`,isError:!0};if(typeof a.command!="string"||a.command.trim().length===0)return{content:"shell.exec requires a command.",isError:!0};const n=this.options.platform??x();let r;try{r=E(a,n)}catch(s){return{content:s instanceof Error?s.message:"Invalid shell.exec PowerShell script.",isError:!0}}const e=r.args===void 0?[]:r.args;if(!Array.isArray(e)||e.some(s=>typeof s!="string"))return{content:"shell.exec args must be an array of strings.",isError:!0};const i=await w(r.command,e,o,u,r.cwd);if(this.options.readOnly&&!i)return{content:"This subagent is limited to read-only shell commands inside the trusted workspace.",isError:!0};const p=typeof r.timeoutMs=="number"?Math.min(Math.max(r.timeoutMs,100),12e4):3e4,l=await u(r.cwd??".",o),m=i?await g(r.command,o.workspaceRoot??l):void 0;if(i&&m===void 0)return{content:"Read-only executable is no longer available.",isError:!0};const h=S(r.command,e),f=this.options.onActivity?.start({key:`${o.runId}:shell.exec`,toolName:"shell.exec",source:"shell",label:h});return k(m??r.command,i?y(r.command,e):e,l,p,o,n).then(s=>(f?.complete(s.isError===!0),s))}}async function k(c,t,a,o,n,r){try{const e=await b(c,t,r,{cwd:a,timeoutMs:o,maxBufferBytes:n.maxResultBytes,rejectOnNonZero:!1,...n.signal===void 0?{}:{signal:n.signal}}),i=`${e.stdout}${e.stderr}${e.exitCode===0?"":`
+Process exited with code ${String(e.exitCode)}.`}`;return{content:d(i||O),isError:e.exitCode!==0}}catch(e){return{content:d(e instanceof Error?e.message:"Process execution failed."),isError:!0}}}function d(c){return c.replace(/Bearer\s+[^\s]+/gi,"Bearer [REDACTED]").replace(/sk-[A-Za-z0-9_-]{8,}/g,"[REDACTED]")}export{I as ShellToolExecutor,T as shellToolDefinitions};

package/dist/infrastructure/tokens/tiktoken-token-estimator.d.ts

@@ -0,0 +1,18 @@
+import type { ChatUsage } from '../../ports/chat-model.js';
+export interface TokenEstimateInput {
+    model: string;
+    prompt: string;
+    response: string;
+}
+export interface TextTokenEstimateInput {
+    model: string;
+    text: string;
+}
+/**
+ * Estimates turn usage when an upstream provider does not include usage in the
+ * streaming protocol. The result is deliberately marked as estimated because
+ * providers may use a tokenizer different from the OpenAI tokenizer family.
+ */
+export declare function estimateTurnUsage(input: TokenEstimateInput): ChatUsage | undefined;
+/** Estimates one text payload with the same tokenizer used for turn fallback accounting. */
+export declare function estimateTextTokens(input: TextTokenEstimateInput): number;

package/dist/infrastructure/tokens/tiktoken-token-estimator.js

@@ -0,0 +1 @@
+import{encoding_for_model as c,get_encoding as s}from"tiktoken";const d="o200k_base";function f(e){try{const t=r(e.model);try{const n=t.encode(e.prompt).length,o=t.encode(e.response).length;return{promptTokens:n,completionTokens:o,totalTokens:n+o,estimated:!0}}finally{t.free()}}catch{return}}function l(e){try{const t=r(e.model);try{return t.encode(e.text).length}finally{t.free()}}catch{return Math.ceil(Buffer.byteLength(e.text,"utf8")/4)}}function r(e){try{return c(e)}catch{return s(d)}}export{l as estimateTextTokens,f as estimateTurnUsage};

package/dist/infrastructure/workspace/workspace-settings-store.d.ts

@@ -0,0 +1,9 @@
+import { type WorkspaceSettings } from '../../domain/workspace/workspace-settings.js';
+export declare class WorkspaceSettingsStore {
+    ensureInitialized(cwd: string): Promise<void>;
+    load(cwd: string): Promise<WorkspaceSettings>;
+    /** Persist a user-approved rule in the ignored local project policy. */
+    rememberAllow(cwd: string, rule: string): Promise<void>;
+    private readOptional;
+    private createIfMissing;
+}

package/dist/infrastructure/workspace/workspace-settings-store.js

@@ -0,0 +1,4 @@
+import o from"node:fs/promises";import p from"node:path";import{DEFAULT_WORKSPACE_SETTINGS as a}from"../../domain/workspace/workspace-settings.js";import{permissionsFromSettings as f,validateSettingsDocument as g}from"../../domain/settings/settings-document.js";import{resolveProjectConfigPaths as l}from"../platform/platform-paths.js";import{atomicWriteFile as d,withFileLock as u}from"../filesystem/atomic-file-store.js";import{isAlreadyExists as w,isFileNotFound as h}from"../filesystem/fs-errors.js";import{readJsonFileBounded as y}from"../filesystem/bounded-json-reader.js";import{RESOURCE_LIMITS as S}from"../../domain/runtime/resource-limits.js";class A{async ensureInitialized(t){const i=l(t);await o.mkdir(i.directory,{recursive:!0}),await Promise.all([i.skillsDir,i.pluginsDir,i.hooksDir].map(s=>o.mkdir(s,{recursive:!0}))),await this.createIfMissing(i.settings,a),await this.createIfMissing(i.localSettings,a),await this.createIfMissing(p.join(i.directory,".gitignore"),`settings.local.json
+`)}async load(t){const i=l(t),[s,r]=await Promise.all([this.readOptional(i.settings),this.readOptional(i.localSettings)]);return{schemaVersion:1,permissions:k(s?.permissions,r?.permissions)}}async rememberAllow(t,i){const s=i.trim();if(s.length===0)return;const r=l(t);await o.mkdir(r.directory,{recursive:!0}),await u(r.localSettings,async()=>{const n=await this.readOptional(r.localSettings)??a;if(n.permissions.allow.includes(s))return;const m={schemaVersion:1,permissions:{...n.permissions,allow:[...n.permissions.allow,s]}};await d(r.localSettings,`${JSON.stringify(m,null,2)}
+`)})}async readOptional(t){try{const i=g(await y(t,S.workspaceSettingsBytes));return{schemaVersion:1,permissions:f(i)}}catch(i){if(h(i))return;throw i}}async createIfMissing(t,i){try{await o.writeFile(t,typeof i=="string"?i:`${JSON.stringify(i,null,2)}
+`,{encoding:"utf8",mode:384,flag:"wx"})}catch(s){if(!w(s))throw s}}}function k(e,t){return{allow:c(e?.allow,t?.allow),ask:c(e?.ask,t?.ask),deny:c(e?.deny,t?.deny)}}function c(...e){return[...new Set(e.flatMap(t=>t??[]))]}export{A as WorkspaceSettingsStore};

package/dist/main.d.ts

@@ -0,0 +1,7 @@
+import type { Readable, Writable } from 'node:stream';
+export { CLI_VERSION } from './version.js';
+export declare function main(argv: readonly string[], io?: {
+    stdin?: Readable;
+    stdout?: Writable;
+    stderr?: Writable;
+}): Promise<number>;

package/dist/main.js

@@ -0,0 +1,3 @@
+import{asCliError as x}from"./domain/errors/cli-error.js";import{createCompositionRoot as g}from"./bootstrap/composition-root.js";import{resolveStartupContext as C}from"./bootstrap/startup-sequence.js";import{parseGlobalCliOptions as y}from"./bootstrap/global-cli-options.js";import{TuiApplication as w}from"./presentation/tui/tui-application.js";import{formatCliErrorMessage as I}from"./application/commands/command-hints.js";import{COMMAND_REGISTRY as O}from"./application/commands/command-runtime.js";import{parseCommandInvocation as E}from"./application/commands/command-parser.js";import{executeApplicationCommand as v,executeInformationalCommand as R}from"./application/commands/application-command-executor.js";import{CLI_VERSION as W}from"./version.js";async function _(o,e={}){const h=e.stdin??process.stdin,n=e.stdout??process.stdout,a=e.stderr??process.stderr;let r;try{const d=y(o),t=T(d.commandTokens);if(t.length===0){r=g({stderr:a});const m=r.logger;m.info("Interactive session started.");const f=await new w(r,C(o).cwd,{output:n}).run();return m.info("Interactive session completed.",{exitCode:f}),f}const i=C(o).cwd,s=E(t,"direct",O),u=R(s,n);if(u!==void 0)return u;const c=g({stderr:a});r=c;const l=c.logger;l.info("CLI command started.",{command:s.action.id,cwd:i});const p=await v(s,{runtime:c,cwd:i,output:n,stdin:h,writableOutput:n,resumeInteractive:async m=>new w(c,i,{output:n,sessionId:m}).run()});return l.info("CLI command completed.",{command:s.action.id,exitCode:p}),p}catch(d){const t=x(d);return r?.logger.error("CLI command failed.",{code:t.code,category:t.category}),S(o)?n.write(`${JSON.stringify({error:t.toJSON()})}
+`):r!==void 0?r.logger.error(I(t,"direct"),{code:t.code,category:t.category}):a.write(`[error] ${I(t,"direct")}
+`),t.exitCode}finally{await r?.shutdown.shutdown()}}function S(o){return o.some(e=>e==="--json"||e.startsWith("--json="))}function T(o){return o.length===1&&(o[0]==="--help"||o[0]==="-h")?["help"]:o.length===1&&o[0]==="--version"?["version"]:o}export{W as CLI_VERSION,_ as main};

package/dist/ports/cache-store.d.ts

@@ -0,0 +1,10 @@
+export interface CacheWriteOptions {
+    ttlMs: number;
+}
+export interface CacheStore {
+    get<T>(namespace: string, key: string): Promise<T | undefined>;
+    set<T>(namespace: string, key: string, value: T, options: CacheWriteOptions): Promise<void>;
+    delete(namespace: string, key: string): Promise<void>;
+    clear(namespace?: string): Promise<void>;
+    prune(): Promise<void>;
+}

package/dist/ports/chat-model.d.ts

@@ -0,0 +1,30 @@
+import type { AttachmentPayload } from '../domain/session/attachment.js';
+export interface ChatModelRequest {
+    model: string;
+    prompt: string;
+    reasoningEffort?: string;
+    attachments?: readonly AttachmentPayload[];
+    signal?: AbortSignal;
+}
+export interface ChatUsage {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+    /** True when the CLI derived usage locally rather than receiving it from the provider. */
+    estimated?: boolean;
+}
+export type ChatModelEvent = {
+    type: 'activity';
+    state: 'connecting' | 'thinking' | 'writing' | 'completed';
+} | {
+    type: 'delta';
+    content: string;
+} | {
+    type: 'usage';
+    usage: ChatUsage;
+} | {
+    type: 'completed';
+};
+export interface ChatModelPort {
+    stream(request: ChatModelRequest): AsyncIterable<ChatModelEvent>;
+}

package/dist/ports/clipboard-adapter.d.ts

@@ -0,0 +1,7 @@
+export interface ClipboardImage {
+    bytes: Uint8Array;
+    mimeType: string;
+}
+export interface ClipboardAdapter {
+    readImage(): Promise<ClipboardImage | undefined>;
+}

package/dist/ports/clipboard-text-adapter.d.ts

@@ -0,0 +1,3 @@
+export interface ClipboardTextAdapter {
+    readText(): Promise<string | undefined>;
+}

package/dist/ports/credential-store.d.ts

@@ -0,0 +1,7 @@
+import type { AuthProfile, StoredCredential } from '../domain/auth/auth-profile.js';
+export interface CredentialStore {
+    list(): Promise<readonly AuthProfile[]>;
+    get(profileName: string): Promise<StoredCredential | undefined>;
+    set(credential: StoredCredential): Promise<void>;
+    delete(profileName: string): Promise<boolean>;
+}

package/dist/ports/goal-store.d.ts

@@ -0,0 +1,12 @@
+import type { CreateGoalInput, GoalEvaluation, GoalState, GoalUsageDelta } from '../domain/orchestration/goal.js';
+export interface GoalStore {
+    get(sessionId: string): Promise<GoalState | undefined>;
+    create(sessionId: string, input: CreateGoalInput): Promise<GoalState>;
+    replace(sessionId: string, input: CreateGoalInput): Promise<GoalState>;
+    pause(sessionId: string, reason?: string): Promise<GoalState>;
+    resume(sessionId: string): Promise<GoalState>;
+    recordTurn(sessionId: string): Promise<GoalState>;
+    recordUsage(sessionId: string, delta: GoalUsageDelta): Promise<GoalState>;
+    recordEvaluation(sessionId: string, evaluation: GoalEvaluation): Promise<GoalState>;
+    clear(sessionId: string, reason?: string): Promise<void>;
+}

package/dist/ports/logger.d.ts

@@ -0,0 +1,8 @@
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
+export interface Logger {
+    error(message: string, details?: Record<string, unknown>): void;
+    warn(message: string, details?: Record<string, unknown>): void;
+    info(message: string, details?: Record<string, unknown>): void;
+    debug(message: string, details?: Record<string, unknown>): void;
+    trace(message: string, details?: Record<string, unknown>): void;
+}

package/dist/ports/media-gateway-client.d.ts

@@ -0,0 +1,54 @@
+import type { GeneratedImage, MediaBinary, VideoOperation } from '../domain/media/media-contract.js';
+export interface MediaRequestOptions {
+    readonly signal?: AbortSignal | undefined;
+}
+export interface ImageGenerationInput {
+    readonly model: string;
+    readonly prompt: string;
+    readonly n?: number | undefined;
+    readonly size?: string | undefined;
+    readonly quality?: 'low' | 'medium' | 'high' | 'auto' | undefined;
+    readonly background?: 'transparent' | 'opaque' | 'auto' | undefined;
+    readonly outputFormat?: 'png' | 'jpeg' | 'webp' | undefined;
+    readonly outputCompression?: number | undefined;
+    readonly moderation?: string | undefined;
+    readonly user?: string | undefined;
+}
+export interface ImageEditInput extends ImageGenerationInput {
+    readonly images: Uint8Array[];
+    readonly mask?: Uint8Array | undefined;
+    readonly inputFidelity?: 'low' | 'high' | undefined;
+}
+export interface SpeechInput {
+    readonly model: string;
+    readonly input: string;
+    readonly voice: string;
+    readonly instructions?: string | undefined;
+    readonly responseFormat?: 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm' | undefined;
+    readonly speed?: number | undefined;
+}
+export interface AudioUploadInput {
+    readonly model: string;
+    readonly file: Uint8Array;
+    readonly filename: string;
+    readonly prompt?: string | undefined;
+    readonly responseFormat?: string | undefined;
+    readonly temperature?: number | undefined;
+    readonly language?: string | undefined;
+    readonly timestampGranularities?: readonly ('word' | 'segment')[] | undefined;
+    readonly include?: readonly string[] | undefined;
+}
+export interface MediaGatewayClient {
+    generateImage(input: ImageGenerationInput, options?: MediaRequestOptions): Promise<readonly GeneratedImage[]>;
+    editImage(input: ImageEditInput, options?: MediaRequestOptions): Promise<readonly GeneratedImage[]>;
+    createSpeech(input: SpeechInput, options?: MediaRequestOptions): Promise<MediaBinary>;
+    transcribe(input: AudioUploadInput, options?: MediaRequestOptions): Promise<string>;
+    translate(input: AudioUploadInput, options?: MediaRequestOptions): Promise<string>;
+    createVideo(input: {
+        model: string;
+        prompt: string;
+        parameters?: Record<string, unknown>;
+    }, options?: MediaRequestOptions): Promise<VideoOperation>;
+    getVideoOperation(id: string, options?: MediaRequestOptions): Promise<VideoOperation>;
+    downloadVideo(id: string, options?: MediaRequestOptions): Promise<MediaBinary>;
+}

package/dist/ports/memory-store.d.ts

@@ -0,0 +1,26 @@
+import type { MemoryBundle, MemoryDraft, MemoryRecord, MemoryState } from '../domain/memory/memory.js';
+import type { MemoryKind } from '../domain/memory/memory-kinds.js';
+import type { MemorySearchHit, MemorySearchQuery, MemorySemanticHit } from '../domain/memory/memory-search.js';
+export interface MemoryListOptions {
+    readonly kind?: MemoryKind;
+    readonly state?: MemoryState;
+}
+export interface MemoryStore {
+    list(cwd: string, options?: MemoryListOptions): Promise<readonly MemoryRecord[]>;
+    search(cwd: string, query: MemorySearchQuery): Promise<readonly MemorySearchHit[]>;
+    ensureSemanticIndex(cwd: string, model: string, embed: (texts: readonly string[], signal?: AbortSignal) => Promise<readonly number[][]>, signal?: AbortSignal): Promise<void>;
+    semanticSearch(cwd: string, model: string, vector: readonly number[], maximum: number): Promise<readonly MemorySemanticHit[]>;
+    get(cwd: string, id: string): Promise<MemoryRecord | undefined>;
+    consolidate(cwd: string, draft: MemoryDraft): Promise<{
+        record: MemoryRecord;
+        action: 'insert' | 'merge' | 'supersede' | 'ignore';
+    }>;
+    forget(cwd: string, id: string): Promise<boolean>;
+    clear(cwd: string): Promise<number>;
+    markRetrieved(cwd: string, ids: readonly string[]): Promise<void>;
+    export(cwd: string): Promise<MemoryBundle>;
+    import(cwd: string, bundle: MemoryBundle): Promise<{
+        imported: number;
+        skipped: number;
+    }>;
+}

package/dist/ports/model-completion-client.d.ts

@@ -0,0 +1,8 @@
+import type { ChatCompletionRequest, ChatCompletionResponse, RequestOptions } from '@lotagate/sdk';
+export interface ModelCompletionClient {
+    readonly chat: {
+        readonly completions: {
+            create(request: ChatCompletionRequest, options?: RequestOptions): Promise<ChatCompletionResponse>;
+        };
+    };
+}

package/dist/ports/model-diagnostics.d.ts

@@ -0,0 +1,17 @@
+import type { ChatUsage } from './chat-model.js';
+export interface ModelCallSummary {
+    model: string;
+    stream: boolean;
+    contentLength: number;
+    toolCallCount: number;
+    toolNames: readonly string[];
+    finishReason?: string | null;
+    usage?: ChatUsage;
+}
+export interface ModelUsageReport {
+    usage: ChatUsage;
+    modelCalls?: number;
+}
+export interface ModelCallObserver {
+    onComplete?: (summary: ModelCallSummary) => void;
+}

package/dist/ports/project-trust-store.d.ts

@@ -0,0 +1,12 @@
+export interface TrustedProject {
+    fingerprint: string;
+    canonicalPath: string;
+    grantedAt: string;
+    grantedBy: 'user';
+}
+export interface ProjectTrustStore {
+    list(): Promise<readonly TrustedProject[]>;
+    get(fingerprint: string): Promise<TrustedProject | undefined>;
+    grant(project: TrustedProject): Promise<void>;
+    revoke(fingerprint: string): Promise<boolean>;
+}