@hassangameryt/freeflow 0.2.0 → 0.4.0

package/plugins/freeflow/router/dist/vault.js

@@ -1,484 +0,0 @@
-import { createHash } from "node:crypto";
-import { mkdir, open, readFile, rename, unlink, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { DEFAULT_VAULT_RETENTION, DEFAULT_VAULT_ROOT } from "./config.js";
-const sessionIndexWriteLocks = new Map();
-const SESSION_INDEX_LOCK_RETRY_MS = 5;
-const SESSION_INDEX_LOCK_TIMEOUT_MS = 5_000;
-export function createVault(options = {}) {
-    return {
-        root: resolveVaultRoot(options.root ?? DEFAULT_VAULT_ROOT),
-        retention: options.retention ?? DEFAULT_VAULT_RETENTION,
-    };
-}
-export function resolveVaultRoot(root) {
-    if (root === "~") {
-        return homedir();
-    }
-    if (root.startsWith("~/")) {
-        return join(homedir(), root.slice(2));
-    }
-    return resolve(root);
-}
-export function commandOutputFingerprints(options) {
-    const combined = options.combined ?? combineOutputSections(options.stdout, options.stderr);
-    return {
-        exactSha256: sha256Json({ stdout: options.stdout, stderr: options.stderr, combined }),
-        normalizedSha256: sha256Json({
-            stdout: normalizeOutputText(options.stdout),
-            stderr: normalizeOutputText(options.stderr),
-            combined: normalizeOutputText(combined),
-        }),
-        commandFingerprintSha256: sha256Json({
-            command: options.command,
-            cwd: options.cwd ?? null,
-            executionStatus: options.executionStatus,
-            exitCode: options.exitCode,
-        }),
-    };
-}
-export function textOutputFingerprints(options) {
-    return {
-        exactSha256: sha256Text(options.raw),
-        normalizedSha256: sha256Text(normalizeOutputText(options.raw)),
-    };
-}
-export async function findExactDuplicateCommandOutput(vault, options) {
-    const index = await readSessionIndex(vault, options.sessionId);
-    for (const outputId of index.outputs) {
-        if (outputId === options.excludeOutputId) {
-            continue;
-        }
-        const entry = index.records[outputId];
-        if (!entry || entry.kind !== "command") {
-            continue;
-        }
-        const fingerprints = entry.fingerprints;
-        if (fingerprints?.exactSha256 === options.fingerprints.exactSha256 &&
-            fingerprints.commandFingerprintSha256 === options.fingerprints.commandFingerprintSha256) {
-            return entry;
-        }
-    }
-    return undefined;
-}
-export async function findExactDuplicateTextOutput(vault, options) {
-    const index = await readSessionIndex(vault, options.sessionId);
-    for (const outputId of index.outputs) {
-        if (outputId === options.excludeOutputId) {
-            continue;
-        }
-        const entry = index.records[outputId];
-        if (!entry || entry.kind !== "text") {
-            continue;
-        }
-        if (entry.fingerprints?.exactSha256 === options.fingerprints.exactSha256) {
-            return entry;
-        }
-    }
-    return undefined;
-}
-export async function storeCommandOutput(vault, options) {
-    const createdAt = options.createdAt ?? new Date().toISOString();
-    const combined = options.combined ?? combineOutputSections(options.stdout, options.stderr);
-    const decisionIds = options.decisionIds ?? [];
-    const fingerprints = commandOutputFingerprints({
-        command: options.command,
-        stdout: options.stdout,
-        stderr: options.stderr,
-        combined,
-        executionStatus: options.executionStatus,
-        exitCode: options.exitCode,
-        ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
-    });
-    const payloadHash = sha256Json({
-        kind: "command",
-        createdAt,
-        command: options.command,
-        cwd: options.cwd,
-        executionStatus: options.executionStatus,
-        exitCode: options.exitCode,
-        durationMs: options.durationMs,
-        stdout: options.stdout,
-        stderr: options.stderr,
-        combined,
-        decisionIds,
-    });
-    const objectId = objectIdFromHash(payloadHash);
-    const outputId = outputIdFromHash(payloadHash);
-    const objectDir = objectDirectory(vault, objectId);
-    const paths = {
-        meta: join(objectDir, "meta.json"),
-        stdout: join(objectDir, "stdout.txt"),
-        stderr: join(objectDir, "stderr.txt"),
-        combined: join(objectDir, "combined.txt"),
-    };
-    const record = {
-        kind: "command",
-        outputId,
-        objectId,
-        command: options.command,
-        createdAt,
-        executionStatus: options.executionStatus,
-        exitCode: options.exitCode,
-        paths,
-        lineCounts: {
-            stdout: countLines(options.stdout),
-            stderr: countLines(options.stderr),
-            combined: countLines(combined),
-        },
-        byteCounts: {
-            stdout: byteLength(options.stdout),
-            stderr: byteLength(options.stderr),
-            combined: byteLength(combined),
-        },
-        hashes: {
-            stdoutSha256: sha256Text(options.stdout),
-            stderrSha256: sha256Text(options.stderr),
-            combinedSha256: sha256Text(combined),
-        },
-        fingerprints,
-        decisionIds,
-        contentHashSha256: payloadHash,
-        retention: vault.retention,
-    };
-    const commandExpiresAt = expiresAt(createdAt, vault.retention);
-    if (commandExpiresAt !== undefined) {
-        record.expiresAt = commandExpiresAt;
-    }
-    if (options.cwd !== undefined) {
-        record.cwd = options.cwd;
-    }
-    if (options.durationMs !== undefined) {
-        record.durationMs = options.durationMs;
-    }
-    await mkdir(objectDir, { recursive: true });
-    await writeFile(paths.stdout, options.stdout, "utf8");
-    await writeFile(paths.stderr, options.stderr, "utf8");
-    await writeFile(paths.combined, combined, "utf8");
-    await writeJson(paths.meta, record);
-    await addRecordToSessionIndex(vault, options.sessionId, record);
-    return record;
-}
-export async function storeTextOutput(vault, options) {
-    const createdAt = options.createdAt ?? new Date().toISOString();
-    const decisionIds = options.decisionIds ?? [];
-    const fingerprints = textOutputFingerprints({ raw: options.raw });
-    const payloadHash = sha256Json({
-        kind: "text",
-        createdAt,
-        sourceKind: options.sourceKind,
-        raw: options.raw,
-        decisionIds,
-    });
-    const objectId = objectIdFromHash(payloadHash);
-    const outputId = outputIdFromHash(payloadHash);
-    const objectDir = objectDirectory(vault, objectId);
-    const paths = {
-        meta: join(objectDir, "meta.json"),
-        raw: join(objectDir, "raw.txt"),
-    };
-    const record = {
-        kind: "text",
-        outputId,
-        objectId,
-        sourceKind: options.sourceKind,
-        createdAt,
-        paths,
-        lineCounts: { raw: countLines(options.raw) },
-        byteCounts: { raw: byteLength(options.raw) },
-        hashes: { rawSha256: sha256Text(options.raw) },
-        fingerprints,
-        decisionIds,
-        contentHashSha256: payloadHash,
-        retention: vault.retention,
-    };
-    const textExpiresAt = expiresAt(createdAt, vault.retention);
-    if (textExpiresAt !== undefined) {
-        record.expiresAt = textExpiresAt;
-    }
-    await mkdir(objectDir, { recursive: true });
-    await writeFile(paths.raw, options.raw, "utf8");
-    await writeJson(paths.meta, record);
-    await addRecordToSessionIndex(vault, options.sessionId, record);
-    return record;
-}
-export async function storeRepoFileReference(vault, options) {
-    const createdAt = options.createdAt ?? new Date().toISOString();
-    const decisionIds = options.decisionIds ?? [];
-    const payloadHash = sha256Json({
-        kind: "repo-file",
-        createdAt,
-        path: options.path,
-        hashSha256: options.hashSha256,
-        decisionIds,
-    });
-    const objectId = objectIdFromHash(payloadHash);
-    const outputId = outputIdFromHash(payloadHash);
-    const objectDir = objectDirectory(vault, objectId);
-    const paths = {
-        meta: join(objectDir, "meta.json"),
-    };
-    const record = {
-        kind: "repo-file",
-        outputId,
-        objectId,
-        path: options.path,
-        paths,
-        decisionIds,
-        createdAt,
-        contentHashSha256: payloadHash,
-        retention: vault.retention,
-    };
-    const repoExpiresAt = expiresAt(createdAt, vault.retention);
-    if (repoExpiresAt !== undefined) {
-        record.expiresAt = repoExpiresAt;
-    }
-    if (options.hashSha256 !== undefined) {
-        record.hashSha256 = options.hashSha256;
-    }
-    await mkdir(objectDir, { recursive: true });
-    await writeJson(paths.meta, record);
-    await addRecordToSessionIndex(vault, options.sessionId, record);
-    return record;
-}
-export async function readVaultRecord(vault, sessionId, outputId) {
-    const index = await readSessionIndex(vault, sessionId);
-    const entry = index.records[outputId];
-    if (!entry) {
-        throw new Error(`No vault output found for ${outputId} in session ${sessionId}.`);
-    }
-    return readJson(join(objectDirectory(vault, entry.objectId), "meta.json"));
-}
-export async function readOutputText(vault, sessionId, outputId, stream) {
-    const record = await readVaultRecord(vault, sessionId, outputId);
-    const path = streamPath(record, stream);
-    return readFile(path, "utf8");
-}
-export async function readOutputLines(vault, options) {
-    if (!Number.isInteger(options.startLine) || !Number.isInteger(options.endLine)) {
-        throw new Error("Line ranges must use integer line numbers.");
-    }
-    if (options.startLine < 1 || options.endLine < options.startLine) {
-        throw new Error("Line ranges must be 1-based and endLine must be greater than or equal to startLine.");
-    }
-    const text = await readOutputText(vault, options.sessionId, options.outputId, options.stream);
-    return splitLines(text).slice(options.startLine - 1, options.endLine).join("\n");
-}
-export async function readSessionIndex(vault, sessionId) {
-    const path = sessionIndexPath(vault, sessionId);
-    try {
-        return (await readJson(path));
-    }
-    catch (error) {
-        const code = typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
-        if (code !== "ENOENT") {
-            throw error;
-        }
-        const now = new Date().toISOString();
-        return emptySessionIndex(sessionId, now);
-    }
-}
-async function addRecordToSessionIndex(vault, sessionId, record) {
-    await withSessionIndexWriteLock(vault, sessionId, async () => {
-        const index = await readSessionIndex(vault, sessionId);
-        const updatedAt = new Date().toISOString();
-        const entry = {
-            outputId: record.outputId,
-            objectId: record.objectId,
-            kind: record.kind,
-            createdAt: record.createdAt,
-        };
-        if (record.kind === "command") {
-            entry.executionStatus = record.executionStatus;
-        }
-        if (record.fingerprints !== undefined) {
-            entry.fingerprints = record.fingerprints;
-        }
-        index.updatedAt = updatedAt;
-        index.records[record.outputId] = entry;
-        addUnique(index.outputs, record.outputId);
-        if (record.kind === "command") {
-            addToExecutionGroup(index, record.executionStatus, record.outputId);
-        }
-        await writeJsonAtomic(sessionIndexPath(vault, sessionId), index);
-    });
-}
-async function withSessionIndexWriteLock(vault, sessionId, operation) {
-    const key = `${vault.root}:${safeSegment(sessionId)}`;
-    const previous = sessionIndexWriteLocks.get(key) ?? Promise.resolve();
-    let releaseCurrent;
-    const current = new Promise((resolve) => {
-        releaseCurrent = resolve;
-    });
-    const chained = previous.catch(() => undefined).then(() => current);
-    sessionIndexWriteLocks.set(key, chained);
-    await previous.catch(() => undefined);
-    try {
-        return await withSessionIndexFileLock(vault, sessionId, operation);
-    }
-    finally {
-        releaseCurrent();
-        if (sessionIndexWriteLocks.get(key) === chained) {
-            sessionIndexWriteLocks.delete(key);
-        }
-    }
-}
-async function withSessionIndexFileLock(vault, sessionId, operation) {
-    const path = sessionIndexLockPath(vault, sessionId);
-    await mkdir(dirname(path), { recursive: true });
-    const startedAt = Date.now();
-    let handle;
-    while (handle === undefined) {
-        try {
-            handle = await open(path, "wx");
-            await handle.writeFile(`${process.pid}\n${new Date().toISOString()}\n`, "utf8");
-        }
-        catch (error) {
-            const code = typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
-            if (code !== "EEXIST") {
-                throw error;
-            }
-            if (Date.now() - startedAt > SESSION_INDEX_LOCK_TIMEOUT_MS) {
-                throw new Error(`Timed out waiting for vault session index lock for ${safeSegment(sessionId)}.`);
-            }
-            await sleep(SESSION_INDEX_LOCK_RETRY_MS);
-        }
-    }
-    try {
-        return await operation();
-    }
-    finally {
-        await handle.close().catch(() => undefined);
-        await unlink(path).catch(() => undefined);
-    }
-}
-function addToExecutionGroup(index, status, outputId) {
-    if (status === "success") {
-        addUnique(index.successful, outputId);
-    }
-    else if (status === "failed") {
-        addUnique(index.failed, outputId);
-    }
-    else if (status === "timed_out") {
-        addUnique(index.timedOut, outputId);
-    }
-    else if (status === "cancelled") {
-        addUnique(index.cancelled, outputId);
-    }
-}
-function emptySessionIndex(sessionId, now) {
-    return {
-        version: 1,
-        sessionId: safeSegment(sessionId),
-        createdAt: now,
-        updatedAt: now,
-        outputs: [],
-        records: {},
-        successful: [],
-        failed: [],
-        timedOut: [],
-        cancelled: [],
-    };
-}
-function streamPath(record, stream) {
-    if (record.kind === "command") {
-        if (stream === "raw") {
-            throw new Error("Command records do not have a raw stream. Use stdout, stderr, or combined.");
-        }
-        return record.paths[stream];
-    }
-    if (record.kind === "text") {
-        if (stream !== "raw") {
-            throw new Error("Text records only have a raw stream.");
-        }
-        return record.paths.raw;
-    }
-    throw new Error("Repo file reference records store metadata only and have no raw stream.");
-}
-function sessionIndexPath(vault, sessionId) {
-    return join(vault.root, "sessions", safeSegment(sessionId), "index.json");
-}
-function sessionIndexLockPath(vault, sessionId) {
-    return `${sessionIndexPath(vault, sessionId)}.lock`;
-}
-function objectDirectory(vault, objectId) {
-    return join(vault.root, "objects", objectId);
-}
-function objectIdFromHash(hash) {
-    return `sha256_${hash}`;
-}
-function outputIdFromHash(hash) {
-    return `ffout_${hash.slice(0, 24)}`;
-}
-function combineOutputSections(stdout, stderr) {
-    if (stdout.length === 0) {
-        return stderr;
-    }
-    if (stderr.length === 0) {
-        return stdout;
-    }
-    return `[stdout]\n${stdout}\n[stderr]\n${stderr}`;
-}
-function countLines(text) {
-    if (text.length === 0) {
-        return 0;
-    }
-    return splitLines(text).length;
-}
-function splitLines(text) {
-    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
-}
-function byteLength(text) {
-    return Buffer.byteLength(text, "utf8");
-}
-function sha256Text(text) {
-    return createHash("sha256").update(text).digest("hex");
-}
-function normalizeOutputText(text) {
-    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trimEnd();
-}
-function sha256Json(value) {
-    return sha256Text(JSON.stringify(value));
-}
-function expiresAt(createdAt, retention) {
-    if (retention.strategy !== "ttl") {
-        return undefined;
-    }
-    const createdTime = new Date(createdAt).getTime();
-    if (!Number.isFinite(createdTime)) {
-        return undefined;
-    }
-    return new Date(createdTime + retention.ttlDays * 24 * 60 * 60 * 1_000).toISOString();
-}
-function addUnique(items, item) {
-    if (!items.includes(item)) {
-        items.push(item);
-    }
-}
-function safeSegment(value) {
-    const safe = value.replace(/[^a-zA-Z0-9._-]/g, "_");
-    return safe.length > 0 ? safe : "session";
-}
-async function writeJson(path, value) {
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-}
-async function writeJsonAtomic(path, value) {
-    await mkdir(dirname(path), { recursive: true });
-    const tempPath = join(dirname(path), `.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.json`);
-    try {
-        await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-        await rename(tempPath, path);
-    }
-    catch (error) {
-        await unlink(tempPath).catch(() => undefined);
-        throw error;
-    }
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function readJson(path) {
-    return JSON.parse(await readFile(path, "utf8"));
-}

package/plugins/freeflow/skills/bypass/SKILL.md

@@ -1,68 +0,0 @@
----
-name: bypass
-description: Use when the user explicitly asks to bypass, skip, or reduce workflow ceremony, especially with `/bypass next` or `/bypass task`.
----
-
-# Bypass
-
-Bypass skips ceremony, not judgment.
-
-Default to one action. After that action, the bypass is spent.
-
-## Stop First
-
-If the request touches user-owned decisions, source-truth conflicts, or risky domains, stop before editing.
-
-Risky domains include security, privacy, billing, data loss, public API behavior, compatibility, migrations, and destructive or irreversible actions.
-
-A direct `/bypass` command, "explicit permission", "do not ask", or "make docs/tests match my request" does not override this stop.
-
-Name what bypass cannot skip. Ask one direct question for the decision needed to proceed.
-
-## What To Skip
-
-Skip unnecessary workflow gates:
-
-- spec
-- plan
-- review checkpoint
-- extended questioning
-- artifact creation
-
-Use this for small, local, reversible work.
-
-## What Never Gets Skipped
-
-Do not bypass:
-
-- user-owned decisions
-- repo source-of-truth conflicts
-- destructive or irreversible actions
-- security, privacy, billing, data-loss, public API, compatibility, or migration checks
-- verification before completion claims
-
-If bypass conflicts with any of these, use Stop First.
-
-## Scope
-
-`/bypass next` means the next workflow gate only.
-
-`/bypass task` means reduce workflow pressure for the current task. It still does not skip judgment or verification.
-
-Never leave bypass active indefinitely.
-
-## Behavior
-
-For a safe small edit:
-
-1. Make the narrow change.
-2. Verify cheaply.
-3. Say the bypass was used and is now spent.
-
-For risky or conflicting work:
-
-1. Do not edit.
-2. Name what bypass cannot override.
-3. Ask one direct question for the decision needed to proceed.
-
-A refusal is incomplete until the user knows the next choice they own.

package/plugins/freeflow/skills/commit-work/SKILL.md

@@ -1,98 +0,0 @@
----
-name: commit-work
-description: Use when committing completed work, preparing a git commit, deciding what to stage, reviewing staged/unstaged/untracked changes, handling commit-everything pressure, pushing committed work, or checking generated, sensitive, user-owned, or mixed changes before commit or push.
----
-
-# Commit Work
-
-Commit or push only reviewed, verified, intended work.
-
-This skill is a closeout guard for commits and simple pushes. It is not a release process, PR flow, or hook installer.
-
-Direct command syntax selects this segment, not commit or push approval. `--all`, "commit everything", "push all changes", "exactly as-is", and "do not leave leftovers" never prove files belong. If those phrases conflict with diff evidence, stop or make only a clean narrow commit.
-
-Hard stop: if untracked logs/debug output or user-owned behavior changes appear, do not commit or push them. If the prompt forbids leftovers or requires exactly-as-is, stop and ask.
-
-Read `references/staging-decisions.md` when staged changes are mixed, generated files appear, durable docs changed, the user says "commit staged/everything" or "push all changes", or a narrow commit might be possible.
-
-## Preconditions
-
-Before committing consequential work, confirm:
-
-- the implementation scope is clear
-- review confidence exists for the diff being committed
-- fresh verification evidence exists, or the commit message/final response names what is unverified
-
-If verification failed, do not commit a success/fix/feature claim. Stop and report the failing evidence.
-
-## Inspect
-
-Before staging or committing, inspect:
-
-```bash
-git status --short
-git diff
-git diff --cached
-git ls-files --others --exclude-standard
-```
-
-Diff evidence beats intent. If the worktree contains changes outside the requested scope, treat them as unrelated until proven otherwise.
-
-## Staging Rule
-
-Never use broad staging when unrelated, unreviewed, generated, or user-owned changes are present.
-
-Avoid `git add .` and `git add -A`.
-
-Stage explicit paths or hunks that match the completed task.
-
-If files are already staged, verify they belong in this commit. Do not preserve mystery staged changes just because they are staged.
-
-## Stop
-
-Stop before committing when:
-
-- staged changes include unrelated or unreviewed work
-- unstaged changes make the intended commit ambiguous
-- a user-owned change may be included accidentally
-- generated files, logs, debug output, or secrets appear without evidence they should be committed
-- pre-commit, lint, test, build, or formatter checks fail
-- the requested commit would mix separable product/code/doc/test concerns in a way that hurts review or rollback
-
-Name the blocker and ask which path to follow. If a clean narrow commit is possible without touching unrelated work, make it and leave unrelated changes untouched.
-
-## Commit Shape
-
-Keep commits small enough to review, debug, and roll back.
-
-Use the repo's existing commit style. If none is obvious, use a short imperative subject:
-
-```text
-Fix settings title typo
-```
-
-Add a body only when it helps future readers understand why.
-
-Reference specs, plans, ADRs, issues, or decisions when they materially explain the commit. Do not invent mandatory `Refs:` lines for repos that do not require them.
-
-## Push Rule
-
-Push only commits you inspected. Before pushing, inspect branch, upstream, remote, and ahead/behind state.
-Do not push to protected/shared branches, set upstream, use `--force`, or rewrite remote history unless explicitly requested and branch evidence supports it. Use `--force-with-lease` only for an intended rewrite of the user's own branch.
-If branch state is stale, diverged, missing upstream, or likely needs PR/CI/release judgment, stop and ask.
-
-## After Commit Or Push
-
-Verify what landed:
-
-```bash
-git show --stat --oneline --name-only HEAD
-git status --branch --short
-```
-
-Final response should state:
-
-- commit SHA, subject, and push result if pushed
-- what was committed
-- what verification supports it
-- any remaining uncommitted, unpushed, or unverified changes

package/plugins/freeflow/skills/commit-work/references/staging-decisions.md

@@ -1,51 +0,0 @@
-# Staging Decisions
-
-Use this for mixed staged sets, generated files, durable docs, or broad commit/push pressure.
-
-## Evidence First
-
-Read staged, unstaged, and untracked state before deciding what to commit or push:
-
-- `git status --short`
-- `git diff --cached`
-- `git diff`
-- `git ls-files --others --exclude-standard`
-
-Diff evidence beats "staged means ready", "commit everything", "push all changes", and "include all leftovers".
-
-## Mixed Staged Sets
-
-Staged changes can still be wrong.
-
-Stop or make a narrow commit when the staged set mixes separable concerns, such as:
-
-- release note or copy edits plus product behavior
-- source code plus local debug output
-- generated files plus hand edits
-- source-truth docs plus implementation changes that have not been confirmed
-- security, billing, permissions, privacy, migration, or public API behavior with unrelated work
-
-If a sensitive staged change conflicts with docs, tests, policy, or contracts, do not commit it just because it is staged.
-
-## Narrow Commit Rule
-
-Make a narrow commit only when:
-
-- the intended scope is clear
-- the included files are all part of that scope
-- excluded changes can remain staged or dirty without being lost
-- the final response reports remaining staged/dirty/untracked work
-
-If excluding files would require unstaging or rearranging user-owned work, ask first unless the repo clearly supports a safe path.
-
-## Generated Files
-
-Do not commit generated files, logs, snapshots, lockfiles, build outputs, or formatter churn unless the task or repo convention makes them part of the intended change.
-
-If generated output is required, name the generator or verification that produced it.
-
-## Durable Docs
-
-Durable specs, ADRs, policies, handoffs, and runbooks are source truth. Commit them with code only when they describe the same confirmed change.
-
-If a durable doc changes policy, status, ownership, public API behavior, billing, privacy, security, data loss, migration, or compatibility, treat that as a user-owned decision unless already confirmed.