@datename/fastcode-termux 0.1.6-beta → 0.1.8-beta.0

package/src/session/projection.ts

@@ -18,6 +18,18 @@ export interface ProjectionFingerprint {
     compactionSource: "local" | "server" | "none";
 }
 
+export interface ProjectionManifest {
+    version: 1;
+    algorithm: "sha256";
+    savedAt: string;
+    /** Hash of the projection content (messages/meta/files). */
+    contentHash: string;
+    /** Hash of the source JSONL facts at save time, when available. */
+    sessionHash?: string;
+    /** Highest fact sequence covered by this projection. */
+    lastFactSeq?: number;
+}
+
 export interface Projection {
     version: 1;
     kind: "projection";
@@ -28,6 +40,17 @@ export interface Projection {
     messages: ChatMessage[];
     activeFiles: ActiveFile[];
     lastFactSeq: number;
+    /** Integrity data written at save/prune time; never re-derived from facts. */
+    manifest?: ProjectionManifest;
+}
+
+export type ProjectionReadStatus = "ok" | "legacy" | "hash_mismatch" | "corrupt" | "missing";
+
+export interface ProjectionReadResult {
+    status: ProjectionReadStatus;
+    projection?: Projection;
+    expectedHash?: string;
+    actualHash?: string;
 }
 
 export interface ResumeState {
@@ -40,8 +63,9 @@ export interface ResumeState {
 
 const READ_ONLY_TOOLS = new Set(["read_file", "read_many", "grep", "list_files", "stat_path", "pwd"]);
 const IDEMPOTENT_TOOLS = new Set(["write_file"]);
-const MAX_MESSAGE_CHARS = 4000;
-const MAX_PROJECTION_BYTES = 19_000;
+const MAX_MESSAGE_CHARS = 8_000;
+const MAX_PROJECTION_BYTES = 200_000;
+const TOOL_FOLD_CHARS = 600;
 
 export function unpairedToolNotice(tool: string): string {
     if (READ_ONLY_TOOLS.has(tool))
@@ -73,8 +97,21 @@ export function sessionMetaFromFacts(facts: any[]): SessionMeta {
     let cwd = "";
     let providerId = "";
     let model = "";
+    let sawStart = false;
     for (const fact of facts) {
-        if (fact?.type === "session_start" || fact?.type === "checkpoint") {
+        // Only the first session_start defines the session. A resume appends
+        // another session_start with the current cwd/model, which must not
+        // change the fingerprint of the stored projection.
+        if (fact?.type === "session_start" && !sawStart) {
+            sawStart = true;
+            if (typeof fact.cwd === "string" && fact.cwd)
+                cwd = fact.cwd;
+            if (typeof fact.providerId === "string" && fact.providerId)
+                providerId = fact.providerId;
+            if (typeof fact.model === "string" && fact.model)
+                model = fact.model;
+        }
+        else if (fact?.type === "checkpoint") {
             if (typeof fact.cwd === "string" && fact.cwd)
                 cwd = fact.cwd;
             if (typeof fact.providerId === "string" && fact.providerId)
@@ -86,6 +123,14 @@ export function sessionMetaFromFacts(facts: any[]): SessionMeta {
     return { cwd, providerId, model };
 }
 
+function factsAfterClear(facts: any[]): any[] {
+    for (let index = facts.length - 1; index >= 0; index -= 1) {
+        if (facts[index]?.type === "cleared")
+            return facts.slice(index + 1);
+    }
+    return facts;
+}
+
 export function sessionMetaFromFile(file: string): SessionMeta {
     return sessionMetaFromFacts(readSession(file));
 }
@@ -132,6 +177,10 @@ export function factsToMessages(facts: any[]): ChatMessage[] {
         else if (fact.type === "tool_call") {
             calls.set(String(fact.id ?? ""), fact.args ?? { tool: fact.tool });
         }
+        else if (fact.type === "notice") {
+            if (typeof fact.content === "string" && fact.content)
+                messages.push({ role: "system", content: fact.content });
+        }
         else if (fact.type === "tool_result") {
             const id = String(fact.id ?? "");
             const call = calls.get(id) ?? { tool: fact.tool ?? "unknown" };
@@ -147,6 +196,11 @@ export function factsToMessages(facts: any[]): ChatMessage[] {
                 });
             }
         }
+        else if (fact.type === "egress_denied") {
+            const target = fact.target ? ` target=${JSON.stringify(fact.target)}` : "";
+            const content = `[egress] ${fact.mode ?? "audit"} rule=${fact.rule ?? "unknown"}${target} would_block=${Boolean(fact.wouldBlock)}\n${fact.reason ?? ""}`;
+            messages.push({ role: "system", content });
+        }
     }
     flush();
     if (messages.length === 0)
@@ -186,10 +240,98 @@ function applySummary(messages: ChatMessage[], facts: any[]): ChatMessage[] {
         return [marker, ...tail];
     }
     catch {
-        return messages;
+        return [
+            ...messages,
+            { role: "system", content: "[projection] Summary file could not be read; resumed without the summary marker." },
+        ];
     }
 }
 
+export function projectionContentHash(projection: Projection): string {
+    const core = {
+        version: projection.version,
+        kind: projection.kind,
+        cwd: projection.cwd,
+        providerId: projection.providerId,
+        model: projection.model,
+        fingerprint: projection.fingerprint,
+        messages: projection.messages,
+        activeFiles: projection.activeFiles,
+        lastFactSeq: projection.lastFactSeq,
+    };
+    return createHash("sha256").update(JSON.stringify(core)).digest("hex");
+}
+
+export function factsContentHash(facts: any[]): string {
+    return createHash("sha256").update(JSON.stringify(facts)).digest("hex");
+}
+
+function lastFactSeqOf(facts: any[]): number {
+    let seq = 0;
+    for (const fact of facts) {
+        if (typeof fact?.seq === "number" && fact.seq > seq)
+            seq = fact.seq;
+    }
+    return seq;
+}
+
+function withManifest(projection: Projection, facts?: any[]): Projection {
+    return {
+        ...projection,
+        manifest: {
+            version: 1,
+            algorithm: "sha256",
+            savedAt: new Date().toISOString(),
+            contentHash: projectionContentHash(projection),
+            ...(facts ? { sessionHash: factsContentHash(facts), lastFactSeq: lastFactSeqOf(facts) } : {}),
+        },
+    };
+}
+
+function emptyProjection(meta: SessionMeta): Projection {
+    return buildProjection([], meta);
+}
+
+/**
+ * Keep native tool_call/tool_result pairs complete. Orphan tool messages left
+ * behind by projection truncation are dropped; missing results are synthesized
+ * with the existing "execution unknown" notice so a resumed model never waits
+ * for a result that cannot arrive.
+ */
+export function pairToolMessages(messages: ChatMessage[]): { messages: ChatMessage[]; repaired: boolean } {
+    const out: ChatMessage[] = [];
+    const expected = new Map<string, string>();
+    let repaired = false;
+    const synthesize = () => {
+        for (const [id, tool] of expected)
+            out.push({ role: "tool", toolCallId: id, content: unpairedToolNotice(tool) });
+        if (expected.size > 0)
+            repaired = true;
+        expected.clear();
+    };
+    for (const message of messages) {
+        if (message.role === "tool") {
+            if (!message.toolCallId || !expected.has(message.toolCallId)) {
+                repaired = true;
+                continue;
+            }
+            expected.delete(message.toolCallId);
+            out.push(message);
+            continue;
+        }
+        synthesize();
+        out.push(message);
+        if (message.role === "assistant" && Array.isArray(message.toolCalls)) {
+            for (const call of message.toolCalls) {
+                if (call?.id)
+                    expected.set(String(call.id), String(call.name ?? "unknown"));
+            }
+        }
+    }
+    synthesize();
+    return { messages: out, repaired };
+}
+
 export function buildProjection(facts: any[], metaOverride?: Partial<SessionMeta>): Projection {
     const detected = sessionMetaFromFacts(facts);
     const meta: SessionMeta = {
@@ -197,13 +339,17 @@ export function buildProjection(facts: any[], metaOverride?: Partial<SessionMeta
         providerId: metaOverride?.providerId || detected.providerId,
         model: metaOverride?.model || detected.model,
     };
-    const messages = clampMessages(applySummary(factsToMessages(facts), facts));
-    const source = compactionSourceFromFacts(facts);
+    const threadFacts = factsAfterClear(facts);
+    const folded = foldToolMessages(applySummary(factsToMessages(threadFacts), threadFacts));
+    const messages = pairToolMessages(clampMessages(folded)).messages;
+    const source = compactionSourceFromFacts(threadFacts);
     let activeFiles: ActiveFile[] = [];
     let lastFactSeq = 0;
     for (const fact of facts) {
         if (typeof fact?.seq === "number" && fact.seq > lastFactSeq)
             lastFactSeq = fact.seq;
+    }
+    for (const fact of threadFacts) {
         if (fact?.type === "checkpoint" && Array.isArray(fact.activeFiles))
             activeFiles = fact.activeFiles;
     }
@@ -221,44 +367,172 @@ export function buildProjection(facts: any[], metaOverride?: Partial<SessionMeta
     return projection;
 }
 
+function clipProjection(text: string, max: number): string {
+    const oneLine = String(text).replace(/\s+/g, " ").trim();
+    return oneLine.length > max ? oneLine.slice(0, Math.max(1, max - 1)) + "…" : oneLine;
+}
+
+function toolTarget(args: any): string {
+    if (!args || typeof args !== "object")
+        return "";
+    const value = args.path ?? args.from ?? args.to ?? args.command ?? args.pattern;
+    return typeof value === "string" ? clipProjection(value, 160) : "";
+}
+
+function firstImportantLine(text: string): string {
+    const lines = String(text)
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !/^```/.test(line) && line !== "output:");
+    const important = lines.find((line) => /error|failed|not found|denied|timed out|exit/i.test(line)) ?? lines[0] ?? "";
+    return clipProjection(important, 200);
+}
+
+/** Keep the edit fact (tool + target + outcome), not the full tool payload. */
+function foldToolMessages(messages: ChatMessage[]): ChatMessage[] {
+    const calls = new Map<string, { name: string; args: any }>();
+    const out: ChatMessage[] = [];
+    for (const message of messages) {
+        if (message.role === "assistant" && Array.isArray(message.toolCalls)) {
+            for (const call of message.toolCalls) {
+                let args: any = {};
+                try {
+                    args = JSON.parse(call.arguments || "{}");
+                }
+                catch {
+                    args = {};
+                }
+                calls.set(String(call.id), { name: String(call.name ?? "tool"), args });
+            }
+            out.push(message);
+            continue;
+        }
+        if (message.role === "tool") {
+            const call = message.toolCallId ? calls.get(String(message.toolCallId)) : undefined;
+            const target = toolTarget(call?.args);
+            const status = /error|failed|not found|denied|timed out/i.test(message.content) ? "error" : "ok";
+            const detail = firstImportantLine(message.content);
+            out.push({
+                ...message,
+                content: clipProjection(`${call?.name ?? "tool"}${target ? ` ${target}` : ""} → ${status}${detail ? `: ${detail}` : ""}`, TOOL_FOLD_CHARS),
+            });
+            continue;
+        }
+        if (message.role === "user" && message.content.startsWith("FastCode executed the requested local tools.")) {
+            out.push({ ...message, content: foldLegacyToolResults(message.content) });
+            continue;
+        }
+        out.push(message);
+    }
+    return out;
+}
+
+function foldLegacyToolResults(content: string): string {
+    const header = "FastCode executed the requested local tools.";
+    const body = content.slice(content.indexOf(header) + header.length).trim();
+    const blocks = body.split(/\n\n(?=Tool result \d+ \()/);
+    const folded: string[] = [header];
+    for (const block of blocks) {
+        const statusMatch = block.match(/^Tool result \d+ \((ok|error)\)/);
+        if (!statusMatch)
+            continue;
+        const callMatch = block.match(/^call:\s*(\{.*\})$/m);
+        let call: any = {};
+        try {
+            call = callMatch ? JSON.parse(callMatch[1]) : {};
+        }
+        catch {
+            call = {};
+        }
+        const output = block.includes("output:") ? block.slice(block.indexOf("output:") + "output:".length) : block;
+        const target = toolTarget(call);
+        const detail = firstImportantLine(output);
+        folded.push(`- ${String(call.tool ?? "tool")}${target ? ` ${target}` : ""} → ${statusMatch[1]}${detail ? `: ${detail}` : ""}`);
+    }
+    return folded.length > 1 ? folded.join("\n") : clipProjection(content, TOOL_FOLD_CHARS);
+}
+
+function truncateMessageContent(content: string): string {
+    if (content.length <= MAX_MESSAGE_CHARS)
+        return content;
+    const head = Math.floor(MAX_MESSAGE_CHARS * 0.6);
+    const tail = Math.max(0, MAX_MESSAGE_CHARS - head);
+    return `${content.slice(0, head)}\n[...truncated in projection...]\n${content.slice(-tail)}`;
+}
+
+function protectedMessage(message: ChatMessage): boolean {
+    return message.role === "system" && /^\[(context summary|context compacted|projection)/.test(message.content);
+}
+
 function clampMessages(messages: ChatMessage[]): ChatMessage[] {
-    const list = messages.map((message) => {
-        const content = message.content.length > MAX_MESSAGE_CHARS
-            ? message.content.slice(0, MAX_MESSAGE_CHARS) + "\n[...truncated in projection...]"
-            : message.content;
-        return {
-            role: message.role,
-            content,
-            ...(message.toolCalls ? { toolCalls: message.toolCalls } : {}),
-            ...(message.toolCallId ? { toolCallId: message.toolCallId } : {}),
+    const list = messages.map((message) => ({
+        role: message.role,
+        content: truncateMessageContent(message.content),
+        ...(message.toolCalls ? { toolCalls: message.toolCalls } : {}),
+        ...(message.toolCallId ? { toolCallId: message.toolCallId } : {}),
+    }));
+    let dropped = 0;
+    const overBudget = () => list.length > 1 && Buffer.byteLength(JSON.stringify(list), "utf8") > MAX_PROJECTION_BYTES;
+    const dropOldest = (marker?: ChatMessage): boolean => {
+        for (let index = 0; index < list.length; index += 1) {
+            const message = list[index];
+            if (index === 0 && message.role === "user")
+                continue;
+            if (message === marker || protectedMessage(message))
+                continue;
+            list.splice(index, 1);
+            dropped += 1;
+            return true;
+        }
+        return false;
+    };
+    while (overBudget() && dropOldest())
+        ;
+    if (dropped > 0) {
+        const marker: ChatMessage = {
+            role: "system",
+            content: `[projection] ${dropped} earlier message(s) dropped to fit ${MAX_PROJECTION_BYTES} bytes.`,
         };
-    });
-    while (list.length > 1 && Buffer.byteLength(JSON.stringify(list), "utf8") > MAX_PROJECTION_BYTES) {
-        if (list.length > 2 && list[0].role === "user")
-            list.splice(1, 1);
-        else
-            list.shift();
+        const insertAt = list[0]?.role === "user" ? 1 : 0;
+        list.splice(insertAt, 0, marker);
+        while (overBudget() && dropOldest(marker)) {
+            marker.content = `[projection] ${dropped} earlier message(s) dropped to fit ${MAX_PROJECTION_BYTES} bytes.`;
+        }
     }
     return list;
 }
 
-export function readProjection(file: string): Projection | undefined {
+export function readProjectionResult(file: string): ProjectionReadResult {
+    let raw: any;
     try {
-        const raw = JSON.parse(readFileSync(projectionPath(file), "utf8"));
-        if (!raw || raw.version !== 1 || !Array.isArray(raw.messages) || !raw.fingerprint)
-            return undefined;
-        return raw as Projection;
+        raw = JSON.parse(readFileSync(projectionPath(file), "utf8"));
     }
-    catch {
-        return undefined;
+    catch (err: any) {
+        if (err?.code === "ENOENT")
+            return { status: "missing" };
+        return { status: "corrupt" };
     }
+    if (!raw || raw.version !== 1 || !Array.isArray(raw.messages) || !raw.fingerprint)
+        return { status: "corrupt" };
+    const projection = raw as Projection;
+    if (!raw.manifest || typeof raw.manifest.contentHash !== "string")
+        return { status: "legacy", projection };
+    const actualHash = projectionContentHash(projection);
+    if (actualHash !== raw.manifest.contentHash)
+        return { status: "hash_mismatch", projection, expectedHash: raw.manifest.contentHash, actualHash };
+    return { status: "ok", projection, expectedHash: raw.manifest.contentHash, actualHash };
 }
 
-export function writeProjection(file: string, projection: Projection): void {
+export function readProjection(file: string): Projection | undefined {
+    const result = readProjectionResult(file);
+    return result.status === "ok" || result.status === "legacy" ? result.projection : undefined;
+}
+
+export function writeProjection(file: string, projection: Projection, facts?: any[]): void {
     const target = projectionPath(file);
     const tmp = target + "." + process.pid + ".tmp";
     try {
-        writeFileSync(tmp, JSON.stringify(projection, null, 2), "utf8");
+        writeFileSync(tmp, JSON.stringify(withManifest(projection, facts), null, 2), "utf8");
         renameSync(tmp, target);
     }
     catch (err) {
@@ -274,35 +548,74 @@ export function writeProjection(file: string, projection: Projection): void {
 
 export function resumeSession(file: string, currentCwd = process.cwd()): ResumeState {
     const facts = readSession(file);
+    const hasFacts = facts.length > 0;
     const detected = sessionMetaFromFacts(facts);
+    const read = readProjectionResult(file);
+    const stored = read.projection;
     const meta: SessionMeta = {
-        cwd: detected.cwd || currentCwd,
-        providerId: detected.providerId,
-        model: detected.model,
+        cwd: detected.cwd || stored?.cwd || currentCwd,
+        providerId: detected.providerId || stored?.providerId || "",
+        model: detected.model || stored?.model || "",
     };
-    const expected = projectionFingerprint(meta, compactionSourceFromFacts(facts));
-    const stored = readProjection(file);
+    const expected = projectionFingerprint(
+        meta,
+        hasFacts ? compactionSourceFromFacts(factsAfterClear(facts)) : (stored?.fingerprint.compactionSource ?? "none"),
+    );
     const warnings: string[] = [];
-    let projection: Projection;
+    let projection: Projection | undefined;
     let rebuilt = false;
-    if (stored && sameFingerprint(stored.fingerprint, expected)) {
+    const currentSessionHash = hasFacts ? factsContentHash(facts) : undefined;
+    const sessionChanged = hasFacts && Boolean(stored?.manifest?.sessionHash) &&
+        stored!.manifest!.sessionHash !== currentSessionHash;
+    const coveredSeq = stored?.manifest?.lastFactSeq ?? stored?.lastFactSeq ?? 0;
+    const factsNotCovered = hasFacts && coveredSeq < lastFactSeqOf(facts);
+
+    if (stored && (read.status === "ok" || read.status === "legacy") &&
+        sameFingerprint(stored.fingerprint, expected) && !sessionChanged && !factsNotCovered) {
         projection = stored;
+        if (read.status === "legacy")
+            warnings.push("Projection has no manifest; integrity could not be verified.");
     }
     else {
-        projection = buildProjection(facts, meta);
-        rebuilt = true;
-        if (stored)
+        if (read.status === "hash_mismatch")
+            warnings.push("Projection manifest hash does not match its contents; ignoring the stored copy.");
+        else if (read.status === "corrupt")
+            warnings.push("Projection file is corrupt; rebuilding from session facts.");
+        else if (sessionChanged || factsNotCovered)
+            warnings.push("Session facts changed since the projection was saved; rebuilt from facts.");
+        else if (stored)
             warnings.push("Projection fingerprint changed (tools/model/cwd); rebuilt from facts.");
-        else
-            warnings.push("No projection found; rebuilt from facts.");
-        try {
-            writeProjection(file, projection);
+
+        if (hasFacts) {
+            projection = buildProjection(facts, meta);
+            rebuilt = true;
+            if (!stored)
+                warnings.push("No projection found; rebuilt from facts.");
+            try {
+                writeProjection(file, projection, facts);
+            }
+            catch {
+                warnings.push("Could not write the projection (filesystem is read-only?); using the in-memory rebuild.");
+            }
         }
-        catch {
-            warnings.push("Could not write the projection (filesystem is read-only?); using the in-memory rebuild.");
+        else if (stored && read.status !== "hash_mismatch" && read.status !== "corrupt") {
+            // The original JSONL was pruned. The verified projection is the
+            // only remaining evidence, so use it rather than re-deriving trust
+            // from facts that no longer exist.
+            projection = stored;
+            warnings.push("Session facts were pruned; using the stored projection.");
+        }
+        else {
+            projection = emptyProjection(meta);
+            warnings.push("Session content is unavailable or unverifiable; resumed history is empty.");
         }
     }
+
+    const repaired = pairToolMessages(projection.messages);
+    if (repaired.repaired)
+        warnings.push("Tool call/result pairing was repaired during resume.");
+    const finalProjection: Projection = { ...projection, messages: repaired.messages };
     if (detected.cwd && detected.cwd !== currentCwd)
         warnings.push(`Session was recorded in ${detected.cwd}; current directory is ${currentCwd}.`);
-    return { projection, messages: projection.messages, meta, warnings, rebuilt };
+    return { projection: finalProjection, messages: finalProjection.messages, meta, warnings, rebuilt };
 }