@hassangameryt/freeflow 0.7.3 → 0.9.0

package/pi-extension/dist/provider-support/{astra → openai}/session-state.js

@@ -1,5 +1,6 @@
-import { activeReadOnlySessionBranch, readOnlySessionSnapshot } from "../../session-sources/read-only-session.js";
+import { persistedBranchMatches } from "../../host/read-only-session.js";
 import { ENTRY_TYPE, parseAttempt } from "./history.js";
+import { cachedBranch } from "../../host/branch.js";
 export class SessionState {
   pi;
   reader;
@@ -10,35 +11,33 @@ export class SessionState {
     this.reader = reader;
   }
   branch() {
-    const entries = this.reader.getBranch();
+    const entries = cachedBranch(this.reader);
     let parent = null;
     const seen = new Set();
     for (const entry of entries) {
       if (!entry.id || seen.has(entry.id) || entry.parentId !== parent)
-        throw new Error("Invalid Astra session ancestry");
+        throw new Error("Invalid OpenAI effort session ancestry");
       seen.add(entry.id);
       parent = entry.id;
     }
-    if (parent !== this.reader.getLeafId()) throw new Error("Astra session leaf changed");
+    if (parent !== this.reader.getLeafId()) throw new Error("OpenAI effort session leaf changed");
     return entries;
   }
   async records() {
     if (this.fault) throw new Error(this.fault);
     const branch = this.branch();
-    // Model visits are not history replacement. Derive both identities from the
-    // selected native ancestry so old v1 records remain readable without rewriting them.
-    const boundaries = new Map();
+    // Model visits and branch summaries preserve compatible history; compaction does not. A branch summary
+    // follows its branch point, leaving the path before it unchanged. Records written while branch summaries
+    // still started a generation carry that earlier boundary and stay readable.
+    const boundaries = new Map(),
+      earlier = new Map();
     let epoch = "root",
-      legacy = "root",
-      model;
+      earlierEpoch = "root";
     for (const entry of branch) {
-      if (entry.type === "compaction" || entry.type === "branch_summary") epoch = legacy = entry.id;
-      if (entry.type === "model_change") {
-        const next = `${entry.provider}/${entry.modelId}`;
-        if (model !== next) legacy = entry.id;
-        model = next;
-      }
-      boundaries.set(entry.id, { epoch, legacy });
+      if (entry.type === "compaction") epoch = entry.id;
+      if (entry.type === "compaction" || entry.type === "branch_summary") earlierEpoch = entry.id;
+      boundaries.set(entry.id, epoch);
+      earlier.set(entry.id, earlierEpoch);
     }
     const entries = branch.filter((e) => e.type === "custom" && e.customType === ENTRY_TYPE);
     const records = entries.map((e) => {
@@ -47,13 +46,12 @@ export class SessionState {
         record.basis !== e.parentId &&
         !(this.reader.getHeader?.()?.parentSession && !branch.some((entry) => entry.id === record.basis))
       )
-        throw new Error("Astra attempt anchor mismatch");
-      const boundary = boundaries.get(e.id);
-      if (record.generation !== boundary.epoch && record.generation !== boundary.legacy)
-        throw new Error("Astra history generation unavailable");
-      return { ...record, generation: boundary.epoch };
+        throw new Error("OpenAI effort attempt anchor mismatch");
+      if (record.generation !== boundaries.get(e.id) && record.generation !== earlier.get(e.id))
+        throw new Error("OpenAI effort history generation unavailable");
+      return record;
     });
-    if (new Set(records.map((r) => r.id)).size !== records.length) throw new Error("Duplicate Astra attempt");
+    if (new Set(records.map((r) => r.id)).size !== records.length) throw new Error("Duplicate OpenAI effort attempt");
     const parents = new Map();
     for (const record of records) {
       const parent = record.parent === null ? undefined : parents.get(record.parent);
@@ -66,25 +64,18 @@ export class SessionState {
           parent.baseline !== record.baseline ||
           parent.length > record.length)
       )
-        throw new Error("Invalid Astra history parent");
+        throw new Error("Invalid OpenAI effort history parent");
       const expected = record.update?.effort ?? parent?.effective ?? record.baseline;
       if (record.effective !== expected || (record.update && record.update.at < (parent?.length ?? 0)))
-        throw new Error("Invalid Astra effective effort");
+        throw new Error("Invalid OpenAI effective effort");
       parents.set(record.id, record);
     }
     const unknown = entries.some((e) => this.acknowledged.get(e.id) !== JSON.stringify(e));
     const file = this.reader.getSessionFile();
     if (unknown && file && branch.some((e) => e.type === "message" && e.message?.role === "assistant")) {
-      const sessionId = this.reader.getSessionId(),
-        leaf = this.reader.getLeafId();
-      const snapshot = await readOnlySessionSnapshot(file);
-      const persisted = activeReadOnlySessionBranch(snapshot, leaf);
-      if (
-        snapshot.sessionId !== sessionId ||
-        this.reader.getLeafId() !== leaf ||
-        JSON.stringify(persisted) !== JSON.stringify(branch)
-      )
-        throw new Error("Astra persisted ancestry differs");
+      const leaf = this.reader.getLeafId();
+      if (!(await persistedBranchMatches(this.reader, leaf, branch)) || this.reader.getLeafId() !== leaf)
+        throw new Error("OpenAI effort persisted ancestry differs");
     }
     for (const entry of entries) this.acknowledged.set(entry.id, JSON.stringify(entry));
     return records;
@@ -92,22 +83,22 @@ export class SessionState {
   generation() {
     let generation = "root";
     for (const entry of this.branch()) {
-      if (entry.type === "compaction" || entry.type === "branch_summary") generation = entry.id;
+      if (entry.type === "compaction") generation = entry.id;
     }
     return generation;
   }
   append(record) {
     try {
-      if (this.reader.getLeafId() !== record.basis) throw new Error("Astra request ancestry changed");
+      if (this.reader.getLeafId() !== record.basis) throw new Error("OpenAI effort request ancestry changed");
       this.pi.appendEntry(ENTRY_TYPE, record);
       const entry = this.branch().find(
         (e) => e.type === "custom" && e.customType === ENTRY_TYPE && e.data?.id === record.id,
       );
       if (!entry || entry.parentId !== record.basis || JSON.stringify(entry.data) !== JSON.stringify(record))
-        throw new Error("Astra append not acknowledged");
+        throw new Error("OpenAI effort append not acknowledged");
       this.acknowledged.set(entry.id, JSON.stringify(entry));
     } catch (error) {
-      this.fault = "Astra append uncertain; native effort retained until session recovery";
+      this.fault = "OpenAI effort append uncertain; native effort retained until session recovery";
       throw error;
     }
   }

package/pi-extension/dist/provider-support/routes.js

@@ -0,0 +1,17 @@
+const OPENAI_API = "https://api.openai.com/v1";
+/**
+ * OpenAI's Sign in with ChatGPT (Pi 0.99): the openai provider's Responses API at api.openai.com with a ChatGPT
+ * credential instead of an API key. It reaches the ChatGPT backend. Live on gpt-6-luna and gpt-6.1-sol (2026-09-30) it
+ * rejected prompt_cache_breakpoint, max_output_tokens and configuration_update items with HTTP 400, and reused the
+ * whole cached prefix after 25 appended message endings without breakpoints. Freeflow sends its requests as Pi
+ * built them.
+ */
+export function isChatGPTSignIn(model, ctx) {
+  if (model?.provider !== "openai" || model.api !== "openai-responses") return false;
+  if ((model.baseUrl ?? OPENAI_API).replace(/\/+$/, "") !== OPENAI_API) return false;
+  try {
+    return ctx?.modelRegistry?.isUsingOAuth?.(model) === true;
+  } catch {
+    return false;
+  }
+}

package/pi-extension/dist/task-memory/config.js

@@ -0,0 +1,49 @@
+export const DEFAULT_TASK_MEMORY_ENABLED = false;
+/** The keys `taskMemory` accepts; `autoApprove` holds one switch per group. The settings test checks each has a row. */
+export const TASK_MEMORY_KEYS = ["enabled", "autoApprove"];
+/** The groups of proposed actions that can skip the confirmation dialog, and the task_memory actions in each. */
+export const AUTO_APPROVE_GROUPS = {
+  attach: ["attach", "confirm"],
+  create: ["create", "child"],
+  env: ["env"],
+  fanout: ["fanout"],
+  projects: ["project_new", "project_link", "import"],
+};
+const GROUP_NAMES = Object.keys(AUTO_APPROVE_GROUPS);
+/** The group a proposed action belongs to. */
+export function autoApproveGroup(action) {
+  return GROUP_NAMES.find((group) => AUTO_APPROVE_GROUPS[group].includes(action));
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function validateTaskMemoryConfig(value) {
+  if (!record(value)) return "taskMemory must be an object";
+  const unknown = Object.keys(value).find((key) => !TASK_MEMORY_KEYS.includes(key));
+  if (unknown) return `taskMemory has unsupported key: ${unknown}`;
+  if (value.enabled !== undefined && typeof value.enabled !== "boolean") return "taskMemory.enabled must be a boolean";
+  if (value.autoApprove !== undefined) {
+    if (!record(value.autoApprove)) return "taskMemory.autoApprove must be an object";
+    for (const [key, on] of Object.entries(value.autoApprove)) {
+      if (!GROUP_NAMES.includes(key))
+        return `taskMemory.autoApprove has unsupported key: ${key}; use ${GROUP_NAMES.join(", ")}`;
+      if (typeof on !== "boolean") return `taskMemory.autoApprove.${key} must be a boolean`;
+    }
+  }
+  return null;
+}
+export function resolveTaskMemoryConfig(repository, local, freeflowEnabled) {
+  const repositoryConfig = record(repository.taskMemory) ? repository.taskMemory : {};
+  const localConfig = record(local.taskMemory) ? local.taskMemory : {};
+  const value = Object.hasOwn(localConfig, "enabled") ? localConfig.enabled : repositoryConfig.enabled;
+  const enabled = value === undefined ? DEFAULT_TASK_MEMORY_ENABLED : value === true;
+  const repositoryApprove = record(repositoryConfig.autoApprove) ? repositoryConfig.autoApprove : {};
+  const localApprove = record(localConfig.autoApprove) ? localConfig.autoApprove : {};
+  const autoApprove = Object.fromEntries(
+    GROUP_NAMES.map((group) => [
+      group,
+      (Object.hasOwn(localApprove, group) ? localApprove[group] : repositoryApprove[group]) === true,
+    ]),
+  );
+  return { enabled, effective: freeflowEnabled && enabled, autoApprove };
+}

package/pi-extension/dist/task-memory/registry.js

@@ -0,0 +1,119 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+/** The Freeflow home, read synchronously for the write gate; the library resolves it the same way. */
+export function freeflowHome() {
+  return process.env.FREEFLOW_HOME || join(homedir(), ".freeflow");
+}
+export class Registry {
+  packageRoot;
+  home;
+  impl;
+  constructor(packageRoot, home = freeflowHome()) {
+    this.packageRoot = packageRoot;
+    this.home = home;
+  }
+  // Loaded on first use, so the extension never touches Track Work's library while task memory is unused.
+  async call(name, ...args) {
+    this.impl ??= import(pathToFileURL(join(this.packageRoot, "skills/track-work/scripts/lib/registry.mjs")).href).then(
+      (lib) => new lib.Registry(this.home),
+    );
+    return (await this.impl)[name](...args);
+  }
+  read() {
+    return this.call("read");
+  }
+  update(change) {
+    return this.call("update", change);
+  }
+  repoRoot(cwd) {
+    return this.call("repoRoot", cwd);
+  }
+  projectFor(cwd) {
+    return this.call("projectFor", cwd);
+  }
+  project(name) {
+    return this.call("project", name);
+  }
+  /** The command a user pastes into a new terminal to start an agent in a directory (see Track Work's library). */
+  async startCommand(path, agent) {
+    const lib = await import(pathToFileURL(join(this.packageRoot, "skills/track-work/scripts/lib/registry.mjs")).href);
+    return lib.startCommand(path, agent);
+  }
+  createProject(name, cwd, worktrees) {
+    return this.call("createProject", name, cwd, worktrees);
+  }
+  linkProject(name, cwd, worktrees) {
+    return this.call("linkProject", name, cwd, worktrees);
+  }
+  createTask(slug, title, goal, parent, primary) {
+    return this.call("createTask", slug, title, goal, parent, primary);
+  }
+  importRecord(projectName, record) {
+    return this.call("importRecord", projectName, record);
+  }
+  task(id) {
+    return this.call("task", id);
+  }
+  byRecord(record) {
+    return this.call("byRecord", record);
+  }
+  children(id) {
+    return this.call("children", id);
+  }
+  projectTasks(slug) {
+    return this.call("projectTasks", slug);
+  }
+  own(id, owner, takeover) {
+    return this.call("own", id, owner, takeover);
+  }
+  release(id, session) {
+    return this.call("release", id, session);
+  }
+  setEnvironment(id, change) {
+    return this.call("setEnvironment", id, change);
+  }
+  environment(id) {
+    return this.call("environment", id);
+  }
+  /** The project link for cwd's repository, made if missing; undefined when it belongs to no project (Task 004 D-003). */
+  linkHere(cwd) {
+    return this.call("linkHere", cwd);
+  }
+  /** What removing a task (with its children) or a project would take (Task 006). */
+  removal(target) {
+    return this.call("removal", target);
+  }
+  removeTask(id) {
+    return this.call("removeTask", id);
+  }
+  removeProject(name) {
+    return this.call("removeProject", name);
+  }
+  trashEntries() {
+    return this.call("trashEntries");
+  }
+  /** Only the user's /freeflow trash empty calls this. */
+  emptyTrash() {
+    return this.call("emptyTrash");
+  }
+  async trashPath() {
+    this.impl ??= import(pathToFileURL(join(this.packageRoot, "skills/track-work/scripts/lib/registry.mjs")).href).then(
+      (lib) => new lib.Registry(this.home),
+    );
+    return (await this.impl).trash;
+  }
+  async removalText(result) {
+    const lib = await import(pathToFileURL(join(this.packageRoot, "skills/track-work/scripts/lib/registry.mjs")).href);
+    return lib.removalText(result, await this.trashPath());
+  }
+  here(cwd) {
+    return this.call("here", cwd);
+  }
+  fanout(parent, title, goal, options) {
+    return this.call("fanout", parent, title, goal, options);
+  }
+  scope(id, scope) {
+    return this.call("scope", id, scope);
+  }
+}

package/pi-extension/dist/task-memory/render.js

@@ -0,0 +1,107 @@
+import { Text } from "@earendil-works/pi-tui";
+import { briefOf } from "./runtime.js";
+const paint = (theme, color, text) => (theme?.fg ? theme.fg(color, text) : text);
+const strong = (theme, text) => (theme?.bold ? theme.bold(text) : text);
+const quoted = (value) => (typeof value === "string" && value.trim() ? `"${value.trim()}"` : "");
+const named = (value, fallback) => (typeof value === "string" && value.trim() ? value.trim() : fallback);
+/** What a call does, in a few words. */
+export function callTitle(args = {}) {
+  const record = named(args.record, "a record");
+  switch (args.action) {
+    case "projects":
+      return "List projects";
+    case "list":
+      return typeof args.project === "string" && args.project.trim()
+        ? `List tasks in ${args.project.trim()}`
+        : "List tasks";
+    case "attach":
+      return `Attach ${record}`;
+    case "focus":
+      return `Focus ${record}`;
+    case "detach":
+      return `Detach ${record}`;
+    case "create":
+      return `Create task ${quoted(args.title)}`.trim();
+    case "child":
+      return `Create child task ${quoted(args.title)}`.trim();
+    case "fanout":
+      return `Fan out ${quoted(args.title)}`.trim();
+    case "view":
+      return `Read ${record}${typeof args.entry === "string" && args.entry.trim() ? ` ${args.entry.trim()}` : ""}`;
+    case "search":
+      return `Search ${named(args.scope, "task")} for ${quoted(args.query) || "…"}`;
+    case "project_new":
+      return `Create project ${quoted(args.name)}`.trim();
+    case "project_link":
+      return `Link this repository to ${quoted(args.name)}`.trim();
+    case "import":
+      return `Import ${record} into ${named(args.project, "a project")}`;
+    case "confirm":
+      return `Make ${typeof args.record === "string" && args.record.trim() ? args.record.trim() : "held records"} writable`;
+    case "env":
+      return args.primary || args.add_dir || args.remove_dir
+        ? `Change directories of ${record}`
+        : `Directories of ${record}`;
+    case "remove":
+      return `Remove ${record}`;
+    case "project_remove":
+      return `Remove project ${quoted(args.name)}`.trim();
+    default:
+      return "Task memory";
+  }
+}
+export function renderTaskCall(args, theme) {
+  return new Text(
+    `${strong(theme, paint(theme, "toolTitle", "Task memory"))} ${paint(theme, "muted", "·")} ${callTitle(args)}`,
+    0,
+    0,
+  );
+}
+const textOf = (result) =>
+  (result?.content ?? [])
+    .filter((part) => part?.type === "text")
+    .map((part) => part.text ?? "")
+    .join("\n");
+/** One line for a result whose operation gave no headline. */
+function fallbackHeadline(action, text) {
+  const lines = text.split("\n").filter((line) => line.trim());
+  const items = lines.filter((line) => line.startsWith("- ")).length;
+  if (action === "search")
+    return lines[0]?.startsWith("No match")
+      ? lines[0]
+      : `${lines.length} matching line${lines.length === 1 ? "" : "s"}`;
+  if (action === "list") return items ? `${items} record${items === 1 ? "" : "s"}` : (lines[0] ?? "No records");
+  if (action === "view") return `${lines.length} lines`;
+  return lines[0] ?? "Done";
+}
+export function renderTaskResult(result, options, theme, context = {}) {
+  if (options.isPartial) return new Text(paint(theme, "muted", "Working…"), 0, 0);
+  const details = result?.details ?? {};
+  const text = textOf(result);
+  const failed = context.isError === true || result?.isError === true;
+  const headline = failed
+    ? (details.headline ?? (text.split("\n")[0] || "Refused"))
+    : (details.headline ?? fallbackHeadline(context.args?.action ?? details.action, text));
+  const lines = [failed ? paint(theme, "error", headline) : paint(theme, "success", headline)];
+  if (details.next) lines.push(paint(theme, "muted", `next: ${details.next}`));
+  // The command is the point of a fan-out: shown even when collapsed, ready to copy.
+  if (details.command)
+    lines.push("", paint(theme, "muted", "Run in a new terminal:"), `  ${paint(theme, "accent", details.command)}`);
+  if (options.expanded && text && text !== headline) lines.push("", text);
+  else if (!options.expanded && !failed && text.split("\n").length > 1)
+    lines.push(paint(theme, "dim", "(expand for details)"));
+  return new Text(lines.join("\n"), 0, 0);
+}
+/** The delivered resume view: one line collapsed, the whole view expanded. */
+export function renderSnapshotMessage(message, options, theme) {
+  const content = typeof message?.content === "string" ? message.content : textOf(message);
+  const task = /Focused task: (.+?) \(\//.exec(content)?.[1] ?? "task";
+  const unavailable = /The record is unavailable|cannot be read as a Schema 4/.test(content);
+  const brief = briefOf(content);
+  const label = strong(theme, paint(theme, "customMessageLabel", "Task memory"));
+  const summary = unavailable
+    ? paint(theme, "warning", `${task}: record unavailable`)
+    : `${task} ${paint(theme, "muted", `· ${brief.state}${brief.next ? ` · next: ${brief.next}` : ""}`)}`;
+  const head = `${label} ${summary}`;
+  return new Text(options.expanded ? `${head}\n\n${content}` : head, 0, 0);
+}