@zq-silk/yui 0.15.11 → 0.16.0

package/dist/resources/autoResourceGc.js

@@ -10,7 +10,7 @@
  * so every safety guarantee (live-ref re-scan, cleanliness proof, fail-closed
  * sources) applies identically.
  */
-import { applyResourceGc, planResourceGc } from "./resourceGc.js";
+import { applyResourceGc, planResourceGc, readResourceGcState, } from "./resourceGc.js";
 import { resolveResourcesGcAutoQuarantine, resolveResourcesGcMode, resolveResourcesQuarantineTtlHours } from "../config/yuiConfig.js";
 /**
  * Create the Controller's automatic Resource GC hook. The hook self-skips
@@ -25,22 +25,16 @@ export function createResourceAutoGc(options) {
             return { skipped: true, applied: 0, failed: 0, restored: 0 };
         }
         const now = new Date();
-        const projects = store.listProjects();
-        const managedWorkspaces = collectManagedWorkspaces(store);
-        const taskStatusById = collectTaskStatuses(store);
         const input = {
             home,
-            projects,
-            managedWorkspaces,
-            taskStatusById,
+            ...readResourceGcState(store),
             mode: "quarantine",
             now,
             quarantineTtlHours: resolveResourcesQuarantineTtlHours(config.resourcesQuarantineTtlHours),
-            environment,
-            activeWorkspaceOwnerPaths: collectActiveWorkspaceOwnerPaths(store)
+            environment
         };
         const plan = await planResourceGc(input);
-        const result = await applyResourceGc(input, plan);
+        const result = await applyResourceGc(input, plan, store);
         return {
             skipped: false,
             applied: result.applied.length,
@@ -49,70 +43,3 @@ export function createResourceAutoGc(options) {
         };
     };
 }
-/**
- * Run one automatic GC pass. Returns `ran: false` when auto-GC is disabled or
- * the GC mode is not `quarantine`. The pass never purges: permanent deletion
- * is always manual.
- */
-export async function runAutoResourceGc(store, options = {}) {
-    const config = store.getConfig();
-    const autoQuarantine = resolveResourcesGcAutoQuarantine(config.resourcesGcAutoQuarantine);
-    if (!autoQuarantine) {
-        return { ran: false, reason: "auto-quarantine is disabled" };
-    }
-    const gcMode = resolveResourcesGcMode(config.resourcesGcMode);
-    if (gcMode !== "quarantine") {
-        return { ran: false, reason: "resources.gcMode is not quarantine" };
-    }
-    const now = options.now ?? new Date();
-    const home = store.rootDirectory();
-    const projects = store.listProjects();
-    const managedWorkspaces = collectManagedWorkspaces(store);
-    const taskStatusById = collectTaskStatuses(store);
-    const input = {
-        home,
-        projects,
-        managedWorkspaces,
-        taskStatusById,
-        mode: "quarantine",
-        now,
-        quarantineTtlHours: resolveResourcesQuarantineTtlHours(config.resourcesQuarantineTtlHours),
-        activeWorkspaceOwnerPaths: collectActiveWorkspaceOwnerPaths(store)
-    };
-    const plan = await planResourceGc(input);
-    const result = await applyResourceGc(input, plan);
-    return { ran: true, result };
-}
-function collectManagedWorkspaces(store) {
-    const workspaces = [];
-    for (const task of store.listTasks()) {
-        workspaces.push(...store.listManagedWorkspaces(task.id));
-    }
-    return workspaces;
-}
-function collectTaskStatuses(store) {
-    const statuses = new Map();
-    for (const task of store.listTasks()) {
-        statuses.set(task.id, task.status);
-    }
-    return statuses;
-}
-/**
- * Workspace paths claimed by active durable Jobs. An active AgentRun still
- * holds its workspace even after the managed workspace record is gone, so
- * those paths stay protected until the AgentRun finishes.
- */
-function collectActiveWorkspaceOwnerPaths(store) {
-    const paths = [];
-    for (const task of store.listTasks()) {
-        for (const run of store.listRuns(task.id)) {
-            if (run.status !== "active")
-                continue;
-            const workspace = run.workspace;
-            if (workspace === undefined)
-                continue;
-            paths.push(workspace.root, ...workspace.entries.map((entry) => entry.path));
-        }
-    }
-    return paths;
-}

package/dist/resources/liveReferences.js

@@ -112,7 +112,7 @@ export async function scanLiveReferences(input) {
     diagnostics.push(...runtimeClaims.diagnostics);
     const activeReleaseClaims = readActiveReleaseClaims(home);
     diagnostics.push(...activeReleaseClaims.diagnostics);
-    const sessionOwnerClaims = readSessionOwnerClaims(home);
+    const sessionOwnerClaims = readSessionOwnerClaims(input.sessionOwners);
     diagnostics.push(...sessionOwnerClaims.diagnostics);
     for (const claim of [
         ...runtimeClaims.claims,
@@ -231,62 +231,15 @@ function readActiveReleaseClaims(home) {
         });
     }
 }
-/**
- * Read Session owner records (`runtime/session-owners/<pid-startIdentity>.json`). A
- * record whose Provider root is physically alive with a matching start
- * identity protects its runtime root. A dead PID is stale (reconciliation
- * removes those records); an identity conflict or unreadable record fails
- * closed because liveness can no longer be proven.
- */
-function readSessionOwnerClaims(home) {
-    const directory = join(home, "runtime", "session-owners");
-    let entries;
-    try {
-        entries = readdirSync(directory, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            return Object.freeze({ claims: Object.freeze([]), diagnostics: Object.freeze([]) });
-        }
-        return Object.freeze({
-            claims: Object.freeze([]),
-            diagnostics: Object.freeze([{
-                    source: "controller",
-                    severity: "error",
-                    message: `session owner records are unreadable: ${error instanceof Error ? error.message : "unknown error"}`
-                }])
-        });
-    }
+/** SQLite supplies durable custody; exact OS generation proves current life.
+ * The same check is used during scanning and under the GC writer fence. */
+export function readSessionOwnerClaims(records) {
     const claims = [];
     const diagnostics = [];
-    for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith(".json"))
-            continue;
-        const path = join(directory, entry.name);
-        let record;
-        try {
-            record = JSON.parse(readFileSync(path, "utf8"));
-        }
-        catch (error) {
-            diagnostics.push({
-                source: "controller",
-                severity: "error",
-                message: `session owner record is unreadable at ${path}: ${error instanceof Error ? error.message : "unknown error"}`
-            });
-            continue;
-        }
-        const pid = record.providerRoot?.pid;
-        const startIdentity = record.providerRoot?.startIdentity;
-        if (typeof pid !== "number" || pid <= 0 || typeof startIdentity !== "string") {
-            diagnostics.push({
-                source: "controller",
-                severity: "error",
-                message: `session owner record at ${path} has no valid provider root identity`
-            });
-            continue;
-        }
+    for (const record of records) {
+        const { pid, startIdentity } = record.providerRoot;
         if (!isProcessAlive(pid)) {
-            // Dead Provider root: the record is stale; reconciliation removes it.
+            // The normal reconciliation owner releases dead custody records.
             continue;
         }
         const currentIdentity = readLinuxProcessStartIdentity(pid);

package/dist/resources/resourceDiscovery.js

@@ -2,12 +2,12 @@
  * Read-only resource discovery for Resource GC (Issue 10).
  *
  * Discovery enumerates the disk objects Yui created — managed Git worktrees,
- * legacy deployments, and runtime artifacts — and attributes each one to an
+ * and runtime artifacts — and attributes each one to an
  * owner. Only precisely attributable resources become cleanup candidates;
  * anything else is reported and retained.
  */
 import { execFile } from "node:child_process";
-import { existsSync, lstatSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { managedProjectPath } from "../repository/project.js";
@@ -121,44 +121,7 @@ export async function discoverResources(input) {
             });
         }
     }
-    // 2. Legacy deployments (historical runtime; no current-master creator).
-    for (const kind of ["deployment", "deployment-backup"]) {
-        const directory = kind === "deployment"
-            ? join(home, "runtime", "deployments")
-            : join(home, "runtime", "deploy-backups");
-        if (!existsSync(directory))
-            continue;
-        for (const entry of safeReaddir(directory)) {
-            const path = join(directory, entry.name);
-            if (isReleaseNamespacePath(home, path))
-                continue;
-            if (isResourceQuarantinePath(home, path))
-                continue;
-            const owner = attributeDeploymentOwner(home, entry.name, input.taskStatusById);
-            const isGit = existsSync(join(path, ".git"));
-            const cleanliness = isGit ? await gitWorktreeCleanliness(path) : "n/a";
-            const gitMetadata = isGit ? readDeploymentGitMetadata(path) : undefined;
-            const taskStatus = owner.taskId === undefined
-                ? undefined
-                : input.taskStatusById.get(owner.taskId);
-            discovered.push({
-                record: createResourceRecord({
-                    kind: "deployment",
-                    path: resolve(path),
-                    owner,
-                    ...(gitMetadata !== undefined ? { git: gitMetadata } : {}),
-                    ...(sizeOf(path) === undefined ? {} : { sizeBytes: sizeOf(path) }),
-                    cleanliness,
-                    activeRefs: [],
-                    disposition: "active"
-                }, input.now),
-                ownerTerminal: owner.taskId === undefined
-                    ? false
-                    : isTerminalTaskStatus(taskStatus)
-            });
-        }
-    }
-    // 3. Runtime artifacts.
+    // 2. Runtime artifacts created by the current runtime.
     discovered.push(...discoverRuntimeArtifacts(home, input));
     return discovered;
 }
@@ -274,21 +237,12 @@ function attributeWorktreeOwner(home, project, worktree, managedWorkspaces) {
     }
     return { home, projectId: project.id, basis: "unattributed" };
 }
-function attributeDeploymentOwner(home, name, taskStatusById) {
-    const taskId = extractTaskIdFromPath(name);
-    if (taskId !== undefined && taskStatusById.has(taskId)) {
-        return { home, taskId, basis: "naming-convention" };
-    }
-    return { home, basis: "unattributed" };
-}
 /** Extract a `task-N` id from a path or name segment. */
 export function extractTaskIdFromPath(value) {
-    // Match both `task-N` (managed workspace convention) and `taskN` (legacy
-    // deployment naming such as `combined-task18-<sha>`).
-    const match = value.match(/(?:^|[/_-])(task-?\d+)(?:-[a-f0-9]{8})?(?:[/_$-]|$)/u);
+    const match = value.match(/(?:^|[/_-])(task-\d+)(?:-[a-f0-9]{8})?(?:[/_$-]|$)/u);
     if (match === null || match[1] === undefined)
         return undefined;
-    return match[1].includes("-") ? match[1] : `task-${match[1].slice(4)}`;
+    return match[1];
 }
 function projectRepositoryPath(home, project) {
     if (project.ownership === "managed") {
@@ -297,62 +251,6 @@ function projectRepositoryPath(home, project) {
     }
     return existsSync(project.path) ? project.path : undefined;
 }
-/**
- * Read Git metadata for a deployment that is a linked worktree. The .git
- * file points to the worktree's gitdir, which records the common dir and
- * the original branch/head needed for a controlled restore.
- */
-function readDeploymentGitMetadata(path) {
-    try {
-        const gitFile = join(path, ".git");
-        const gitStat = lstatSync(gitFile);
-        let gitDir;
-        if (gitStat.isFile()) {
-            const content = readFileSync(gitFile, "utf8").trim();
-            if (!content.startsWith("gitdir: "))
-                return { repositoryPath: path };
-            gitDir = content.slice("gitdir: ".length);
-        }
-        else if (gitStat.isDirectory()) {
-            gitDir = gitFile;
-        }
-        else {
-            return { repositoryPath: path };
-        }
-        const resolvedGitDir = resolve(gitDir);
-        const commonDirFile = join(resolvedGitDir, "commondir");
-        let commonDir;
-        if (existsSync(commonDirFile)) {
-            const raw = readFileSync(commonDirFile, "utf8").trim();
-            commonDir = resolve(resolvedGitDir, raw);
-        }
-        const headFile = join(resolvedGitDir, "HEAD");
-        let head;
-        let branch;
-        if (existsSync(headFile)) {
-            const headContent = readFileSync(headFile, "utf8").trim();
-            if (headContent.startsWith("ref: refs/heads/")) {
-                branch = headContent.slice("ref: ".length);
-                const refPath = join(commonDir ?? resolvedGitDir, headContent.slice("ref: ".length));
-                if (existsSync(refPath)) {
-                    head = readFileSync(refPath, "utf8").trim();
-                }
-            }
-            else if (/^[0-9a-f]{40}$/u.test(headContent)) {
-                head = headContent;
-            }
-        }
-        return {
-            repositoryPath: path,
-            ...(commonDir === undefined ? {} : { commonDir }),
-            ...(branch === undefined ? {} : { branch }),
-            ...(head === undefined ? {} : { head })
-        };
-    }
-    catch {
-        return { repositoryPath: path };
-    }
-}
 function readTaskRuntimeMarker(runtimeRoot) {
     try {
         const marker = JSON.parse(readFileSync(join(runtimeRoot, ".yui-task-runtime-owner.json"), "utf8"));
@@ -368,17 +266,6 @@ function readTaskRuntimeMarker(runtimeRoot) {
         return undefined;
     }
 }
-function readJsonFile(path) {
-    try {
-        const value = JSON.parse(readFileSync(path, "utf8"));
-        return typeof value === "object" && value !== null
-            ? value
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 function safeReaddir(path) {
     try {
         return readdirSync(path, { withFileTypes: true });