@deftai/directive-core 0.103.0 → 0.105.0

package/dist/policy/index.js

@@ -1,25 +1,31 @@
 import { FIELD_HOST_SKILL_DISCOVERY, FIELD_HOST_SKILL_DISCOVERY_CLI_ALIAS, inspectHostSkillDiscovery, } from "../init-deposit/skill-discovery-hosts.js";
 import { FIELD_OPENCLAW_PRODUCT_COMMANDS, FIELD_OPENCLAW_PRODUCT_COMMANDS_CLI_ALIAS, inspectOpenClawProductCommands, } from "../slash/openclaw-deposit.js";
 import { FIELD_AC_PASS_BANKING, FIELD_AC_PASS_BANKING_CLI_ALIAS, inspectAcPassBanking, } from "./ac-pass-banking.js";
+import { FIELD_BASE_BRANCH, FIELD_BASE_BRANCH_CLI_ALIAS, inspectBaseBranch, } from "./base-branch.js";
 import { FIELD_CEREMONY_DIAL, FIELD_CEREMONY_DIAL_CLI_ALIAS, inspectCeremonyDial, } from "./ceremony-dial.js";
 import { FIELD_CHECK_RESUME, FIELD_CHECK_RESUME_CLI_ALIAS, inspectCheckResume, } from "./check-resume.js";
 import { FIELD_COVERAGE_DEBT, FIELD_COVERAGE_DEBT_CLI_ALIAS, inspectCoverageDebt, } from "./coverage-debt.js";
 import { FIELD_DELIVERY_BRANCH, FIELD_DELIVERY_BRANCH_CLI_ALIAS, inspectDeliveryBranch, } from "./delivery-branch.js";
+import { FIELD_FORGE_OUTAGE_RETRY_MINUTES, FIELD_FORGE_OUTAGE_RETRY_MINUTES_CLI_ALIAS, inspectForgeOutageRetryMinutes, } from "./forge-outage-retry.js";
 import { FIELD_HOST_HOOKS, FIELD_HOST_HOOKS_CLI_ALIAS, inspectHostHooks } from "./host-hooks.js";
 import { FIELD_HOST_SLASH_COMMANDS, FIELD_HOST_SLASH_COMMANDS_CLI_ALIAS, inspectHostSlashCommands, } from "./host-slash-commands.js";
 import { FIELD_HOTFIX_CRITERIA, FIELD_HOTFIX_CRITERIA_CLI_ALIAS, inspectHotfixCriteria, } from "./hotfix-criteria.js";
 import { FIELD_MIN_GREPTILE_CONFIDENCE, FIELD_MIN_GREPTILE_CONFIDENCE_CLI_ALIAS, inspectMinGreptileConfidence, } from "./min-greptile-confidence.js";
 import { readPlanPolicy } from "./plan-extensions.js";
 import { FIELD_PRODUCT_SIGNAL, FIELD_PRODUCT_SIGNAL_CLI_ALIAS, inspectProductSignal, } from "./product-signal.js";
+import { FIELD_PROJECT_INVARIANTS, FIELD_PROJECT_INVARIANTS_CLI_ALIAS, inspectProjectInvariants, } from "./project-invariants.js";
 import { FIELD_REQUIRE_HUMAN_MERGE, FIELD_REQUIRE_HUMAN_MERGE_CLI_ALIAS, inspectRequireHumanMerge, } from "./require-human-merge.js";
 import { coerceLegacyNarrative, LEGACY_NARRATIVE_KEY, loadProjectDefinition } from "./resolve.js";
 import { FIELD_RUNTIME_AUTHORITY, FIELD_RUNTIME_AUTHORITY_CLI_ALIAS, inspectRuntimeAuthority, } from "./runtime-authority.js";
 import { FIELD_STALENESS_TICKLER, FIELD_STALENESS_TICKLER_CLI_ALIAS, inspectStalenessTickler, } from "./staleness-tickler.js";
+import { FIELD_SYNC_MAX_FILES, FIELD_SYNC_MAX_FILES_CLI_ALIAS, inspectSyncMaxFiles, } from "./sync-max-files.js";
 import { FIELD_VALUE_FEEDBACK, FIELD_VALUE_FEEDBACK_CLI_ALIAS, inspectValueFeedback, } from "./value-feedback.js";
 import { DEFAULT_WIP_CAP } from "./wip.js";
 export * from "./ac-pass-banking.js";
 export * from "./agents-md-advisory.js";
 export * from "./autonomy.js";
+export * from "./base-branch.js";
+export * from "./branch-sync.js";
 export * from "./capacity.js";
 export * from "./ceremony-dial.js";
 export * from "./ceremony-dial-escalation.js";
@@ -29,6 +35,8 @@ export * from "./decisions.js";
 export * from "./deft-directive-disable.js";
 export * from "./delivery-branch.js";
 export * from "./disclosure.js";
+export * from "./file-size-thresholds.js";
+export * from "./forge-outage-retry.js";
 export * from "./host-hooks.js";
 export * from "./host-slash-commands.js";
 export * from "./hotfix-criteria.js";
@@ -40,10 +48,13 @@ export * from "./org-force-on-migration.js";
 export * from "./plan-extensions.js";
 export * from "./policy-invocation.js";
 export * from "./product-signal.js";
+export * from "./project-invariants.js";
 export * from "./require-human-merge.js";
 export * from "./resolve.js";
 export * from "./runtime-authority.js";
 export * from "./staleness-tickler.js";
+export * from "./sync-default.js";
+export * from "./sync-max-files.js";
 export * from "./value-feedback.js";
 export * from "./value-feedback-autoenable.js";
 export * from "./wip.js";
@@ -404,6 +415,15 @@ function inspectDeliveryBranchField(data, projectRoot) {
         source: field.source,
     };
 }
+function inspectBaseBranchField(data, projectRoot) {
+    const field = inspectBaseBranch(data, projectRoot);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 function inspectMinGreptileConfidenceField(data, projectRoot) {
     const field = inspectMinGreptileConfidence(data, projectRoot);
     return {
@@ -431,6 +451,33 @@ function inspectAcPassBankingField(data, projectRoot) {
         source: field.source,
     };
 }
+function inspectSyncMaxFilesField(data, projectRoot) {
+    const field = inspectSyncMaxFiles(data, projectRoot);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
+function inspectForgeOutageRetryMinutesField(data, projectRoot) {
+    const field = inspectForgeOutageRetryMinutes(data, projectRoot);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
+function inspectProjectInvariantsField(data, projectRoot) {
+    const field = inspectProjectInvariants(data, projectRoot);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 const REGISTERED_POLICIES = [
     inspectAllowDirectCommits,
     inspectWipCap,
@@ -445,6 +492,7 @@ const REGISTERED_POLICIES = [
     inspectTriageLabelMirrorField,
     inspectSwarmSubagentBackend,
     inspectDeliveryBranchField,
+    inspectBaseBranchField,
     inspectMinGreptileConfidenceField,
     inspectHostHooksField,
     inspectHostSlashCommandsField,
@@ -460,6 +508,9 @@ const REGISTERED_POLICIES = [
     inspectHotfixCriteriaField,
     inspectCeremonyDialField,
     inspectAcPassBankingField,
+    inspectSyncMaxFilesField,
+    inspectForgeOutageRetryMinutesField,
+    inspectProjectInvariantsField,
 ];
 /** Walk registered inspectors and return one row per field (#1148). */
 export function inspectAllPolicies(projectRoot) {
@@ -494,13 +545,21 @@ export function inspectOnePolicy(name, projectRoot) {
                                                     ? FIELD_HOTFIX_CRITERIA
                                                     : name === FIELD_DELIVERY_BRANCH_CLI_ALIAS
                                                         ? FIELD_DELIVERY_BRANCH
-                                                        : name === FIELD_MIN_GREPTILE_CONFIDENCE_CLI_ALIAS
-                                                            ? FIELD_MIN_GREPTILE_CONFIDENCE
-                                                            : name === FIELD_CEREMONY_DIAL_CLI_ALIAS
-                                                                ? FIELD_CEREMONY_DIAL
-                                                                : name === FIELD_AC_PASS_BANKING_CLI_ALIAS
-                                                                    ? FIELD_AC_PASS_BANKING
-                                                                    : name;
+                                                        : name === FIELD_BASE_BRANCH_CLI_ALIAS
+                                                            ? FIELD_BASE_BRANCH
+                                                            : name === FIELD_MIN_GREPTILE_CONFIDENCE_CLI_ALIAS
+                                                                ? FIELD_MIN_GREPTILE_CONFIDENCE
+                                                                : name === FIELD_CEREMONY_DIAL_CLI_ALIAS
+                                                                    ? FIELD_CEREMONY_DIAL
+                                                                    : name === FIELD_AC_PASS_BANKING_CLI_ALIAS
+                                                                        ? FIELD_AC_PASS_BANKING
+                                                                        : name === FIELD_SYNC_MAX_FILES_CLI_ALIAS
+                                                                            ? FIELD_SYNC_MAX_FILES
+                                                                            : name === FIELD_FORGE_OUTAGE_RETRY_MINUTES_CLI_ALIAS
+                                                                                ? FIELD_FORGE_OUTAGE_RETRY_MINUTES
+                                                                                : name === FIELD_PROJECT_INVARIANTS_CLI_ALIAS
+                                                                                    ? FIELD_PROJECT_INVARIANTS
+                                                                                    : name;
     for (const field of inspectAllPolicies(projectRoot)) {
         if (field.name === normalized)
             return field;

package/dist/policy/project-invariants.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Typed plan.policy.projectInvariants (#3425 Story A).
+ *
+ * Authored project-level must-not-break contracts. Empty or absent list is a
+ * no-op. Parse/validate only — preflight fail-closed is Story B.
+ */
+export declare const FIELD_PROJECT_INVARIANTS = "plan.policy.projectInvariants";
+export declare const FIELD_PROJECT_INVARIANTS_CLI_ALIAS = "projectInvariants";
+export interface ProjectInvariantContractSurface {
+    readonly paths: readonly string[];
+    readonly moduleIds: readonly string[];
+}
+export interface ProjectInvariant {
+    readonly id: string;
+    readonly statement: string;
+    readonly contractSurface: ProjectInvariantContractSurface;
+}
+export type ProjectInvariantsSource = "typed" | "default" | "default-on-error";
+export interface ProjectInvariantsParseResult {
+    readonly invariants: readonly ProjectInvariant[];
+    readonly errors: readonly string[];
+}
+export interface ProjectInvariantsResolved {
+    readonly invariants: readonly ProjectInvariant[];
+    readonly source: ProjectInvariantsSource;
+    readonly error: string | null;
+}
+export interface ProjectInvariantsPolicyField {
+    readonly name: typeof FIELD_PROJECT_INVARIANTS;
+    readonly current: readonly ProjectInvariant[];
+    readonly default: readonly ProjectInvariant[];
+    readonly source: string;
+}
+/** Parse a raw projectInvariants value. Absent/null → empty list, no errors. */
+export declare function parseProjectInvariants(raw: unknown): ProjectInvariantsParseResult;
+/**
+ * Map codeStructure.modules[] id → pathGlobs for applicability intersection.
+ * Pure: pass PROJECT-DEFINITION (or plan) data, no disk IO.
+ */
+export declare function extractModulePathGlobs(projectDefinition: unknown): Record<string, string[]>;
+/**
+ * Resolve projectInvariants from PROJECT-DEFINITION data already in memory.
+ * Absent/null → default empty. Present invalid → default-on-error + message.
+ */
+export declare function resolveProjectInvariantsFromData(data: Record<string, unknown> | null): ProjectInvariantsResolved;
+/** Resolve from a project root via the PROJECT-DEFINITION IO path. */
+export declare function resolveProjectInvariants(projectRoot: string): ProjectInvariantsResolved;
+/** Inspector row for `task policy:show --field=projectInvariants`. */
+export declare function inspectProjectInvariants(data: Record<string, unknown> | null, projectRoot?: string): ProjectInvariantsPolicyField;
+//# sourceMappingURL=project-invariants.d.ts.map

package/dist/policy/project-invariants.js

@@ -0,0 +1,205 @@
+/**
+ * Typed plan.policy.projectInvariants (#3425 Story A).
+ *
+ * Authored project-level must-not-break contracts. Empty or absent list is a
+ * no-op. Parse/validate only — preflight fail-closed is Story B.
+ */
+import { readPlanPolicy } from "./plan-extensions.js";
+import { loadProjectDefinition } from "./resolve.js";
+export const FIELD_PROJECT_INVARIANTS = "plan.policy.projectInvariants";
+export const FIELD_PROJECT_INVARIANTS_CLI_ALIAS = "projectInvariants";
+const EMPTY = [];
+function asRecord(value) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function asStrList(value) {
+    if (value === null || value === undefined)
+        return [];
+    if (typeof value === "string")
+        return value.trim().length > 0 ? [value.trim()] : [];
+    if (Array.isArray(value)) {
+        return value.map((item) => String(item).trim()).filter((s) => s.length > 0);
+    }
+    return [];
+}
+function pythonTypeName(value) {
+    if (value === null)
+        return "None";
+    if (Array.isArray(value))
+        return "list";
+    if (typeof value === "boolean")
+        return "bool";
+    if (typeof value === "number")
+        return Number.isInteger(value) ? "int" : "float";
+    if (typeof value === "string")
+        return "str";
+    if (typeof value === "object")
+        return "dict";
+    return typeof value;
+}
+function parseContractSurface(body, loc) {
+    const nested = asRecord(body.contractSurface) ?? asRecord(body.contract_surface) ?? asRecord(body.contract);
+    const pathSource = nested ?? body;
+    const moduleSource = nested ?? body;
+    const pathsRaw = pathSource.paths ?? pathSource.pathGlobs ?? pathSource.path_globs ?? body.paths;
+    const moduleRaw = moduleSource.moduleIds ??
+        moduleSource.module_ids ??
+        moduleSource.modules ??
+        body.moduleIds ??
+        body.module_ids;
+    // Shorthand: contractSurface / contract_surface as a string list of paths.
+    const shorthand = body.contractSurface ?? body.contract_surface ?? body.contract;
+    const paths = [...asStrList(pathsRaw), ...(nested === null ? asStrList(shorthand) : [])];
+    const moduleIds = asStrList(moduleRaw);
+    if (paths.length === 0 && moduleIds.length === 0) {
+        return {
+            surface: null,
+            errors: [
+                `${loc}: contract surface requires paths[] and/or moduleIds[] ` +
+                    `(must-not-break module/contract)`,
+            ],
+        };
+    }
+    return {
+        surface: { paths, moduleIds },
+        errors: [],
+    };
+}
+/** Parse a raw projectInvariants value. Absent/null → empty list, no errors. */
+export function parseProjectInvariants(raw) {
+    if (raw === null || raw === undefined) {
+        return { invariants: EMPTY, errors: [] };
+    }
+    if (!Array.isArray(raw)) {
+        return {
+            invariants: EMPTY,
+            errors: [`${FIELD_PROJECT_INVARIANTS} must be an array; got ${pythonTypeName(raw)}`],
+        };
+    }
+    const invariants = [];
+    const errors = [];
+    const seen = new Set();
+    for (let i = 0; i < raw.length; i += 1) {
+        const loc = `${FIELD_PROJECT_INVARIANTS}[${i}]`;
+        const item = raw[i];
+        const rec = asRecord(item);
+        if (rec === null) {
+            errors.push(`${loc}: entry must be an object`);
+            continue;
+        }
+        const id = rec.id;
+        const statement = rec.statement ?? rec.Statement;
+        if (!isNonEmptyString(id)) {
+            errors.push(`${loc}: id is required`);
+            continue;
+        }
+        const trimmedId = id.trim();
+        if (seen.has(trimmedId)) {
+            errors.push(`${loc}: duplicate id '${trimmedId}'`);
+            continue;
+        }
+        if (!isNonEmptyString(statement)) {
+            errors.push(`${loc}: statement is required`);
+            continue;
+        }
+        const { surface, errors: surfaceErrors } = parseContractSurface(rec, loc);
+        errors.push(...surfaceErrors);
+        if (surface === null)
+            continue;
+        seen.add(trimmedId);
+        invariants.push({
+            id: trimmedId,
+            statement: String(statement).trim(),
+            contractSurface: surface,
+        });
+    }
+    return { invariants, errors };
+}
+/**
+ * Map codeStructure.modules[] id → pathGlobs for applicability intersection.
+ * Pure: pass PROJECT-DEFINITION (or plan) data, no disk IO.
+ */
+export function extractModulePathGlobs(projectDefinition) {
+    const root = asRecord(projectDefinition);
+    if (root === null)
+        return {};
+    const plan = asRecord(root.plan) ?? root;
+    const architecture = asRecord(plan.architecture);
+    if (architecture === null)
+        return {};
+    const codeStructure = asRecord(architecture.codeStructure ?? architecture.code_structure);
+    if (codeStructure === null)
+        return {};
+    const modules = codeStructure.modules;
+    if (!Array.isArray(modules))
+        return {};
+    const out = {};
+    for (const item of modules) {
+        const rec = asRecord(item);
+        if (rec === null || !isNonEmptyString(rec.id))
+            continue;
+        const globs = asStrList(rec.pathGlobs ?? rec.path_globs ?? rec.paths);
+        if (globs.length === 0)
+            continue;
+        out[rec.id.trim()] = globs;
+    }
+    return out;
+}
+function readPolicyBlock(data) {
+    if (data === null)
+        return null;
+    const policy = readPlanPolicy(data.plan);
+    return asRecord(policy);
+}
+/**
+ * Resolve projectInvariants from PROJECT-DEFINITION data already in memory.
+ * Absent/null → default empty. Present invalid → default-on-error + message.
+ */
+export function resolveProjectInvariantsFromData(data) {
+    const policy = readPolicyBlock(data);
+    if (policy === null || !("projectInvariants" in policy)) {
+        return { invariants: EMPTY, source: "default", error: null };
+    }
+    const raw = policy.projectInvariants;
+    if (raw === null) {
+        return { invariants: EMPTY, source: "default", error: null };
+    }
+    const parsed = parseProjectInvariants(raw);
+    if (parsed.errors.length > 0) {
+        return {
+            invariants: EMPTY,
+            source: "default-on-error",
+            error: parsed.errors.join("; "),
+        };
+    }
+    return { invariants: parsed.invariants, source: "typed", error: null };
+}
+/** Resolve from a project root via the PROJECT-DEFINITION IO path. */
+export function resolveProjectInvariants(projectRoot) {
+    const [data, err] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return { invariants: EMPTY, source: "default", error: err };
+    }
+    return resolveProjectInvariantsFromData(data);
+}
+/** Inspector row for `task policy:show --field=projectInvariants`. */
+export function inspectProjectInvariants(data, projectRoot) {
+    const resolved = data !== null
+        ? resolveProjectInvariantsFromData(data)
+        : projectRoot !== undefined && projectRoot.length > 0
+            ? resolveProjectInvariants(projectRoot)
+            : { invariants: EMPTY, source: "default", error: null };
+    return {
+        name: FIELD_PROJECT_INVARIANTS,
+        current: resolved.invariants,
+        default: EMPTY,
+        source: resolved.source,
+    };
+}
+//# sourceMappingURL=project-invariants.js.map

package/dist/policy/sync-default.d.ts

@@ -0,0 +1,129 @@
+/**
+ * scm:sync-default (#3391 / #3377 Wave 3).
+ *
+ * Consumes the shared #3388 detector and #3390 syncMaxFiles. Opens dest-targeted
+ * sync PRs. Over the file limit, cut at merge commits when possible so each
+ * dest-based leg is at or under the threshold. Each leg is a new branch and a
+ * new PR. Never retarget or reuse an oversized PR.
+ */
+import { type GitRunner } from "../session/git.js";
+import { type BranchSyncDetection } from "./branch-sync.js";
+import { type SyncMaxFilesProvenance } from "./sync-max-files.js";
+export declare const SYNC_DEFAULT_VERB = "scm:sync-default";
+export declare const FORBIDDEN_SYNC_PR_RETARGET = "gh pr edit --base";
+export type SyncDefaultAction = "noop" | "single" | "staged";
+export type SyncDefaultNoopReason = "not-sync" | "already-synced" | "zero-files" | "fetch-failed" | "diff-failed";
+export type SyncDefaultCutKind = "merge" | "commit" | "tip";
+export interface SyncDefaultCommit {
+    readonly sha: string;
+    readonly isMerge: boolean;
+}
+export interface SyncDefaultLeg {
+    readonly index: number;
+    readonly sha: string;
+    readonly fileCount: number;
+    readonly cutKind: SyncDefaultCutKind;
+    readonly branchName: string;
+}
+export interface SyncDefaultPlan {
+    readonly action: SyncDefaultAction;
+    readonly noopReason: SyncDefaultNoopReason | null;
+    readonly dest: string;
+    readonly source: string;
+    readonly threshold: number;
+    readonly provenance: SyncMaxFilesProvenance;
+    readonly totalCount: number | null;
+    readonly legs: readonly SyncDefaultLeg[];
+    readonly nextLegIndex: number | null;
+    readonly message: string;
+    readonly detectorReason: BranchSyncDetection["reason"];
+}
+export interface SyncDefaultOpenPull {
+    readonly number: number;
+    readonly htmlUrl: string;
+    readonly headRef: string;
+    readonly headSha: string;
+    readonly baseRef: string;
+}
+export interface SyncDefaultForge {
+    listOpenPulls(repo: string, base: string): readonly SyncDefaultOpenPull[];
+    createPull(repo: string, input: {
+        readonly title: string;
+        readonly head: string;
+        readonly base: string;
+        readonly body: string;
+    }): {
+        readonly number: number;
+        readonly htmlUrl: string;
+    };
+}
+export interface SyncDefaultOpened {
+    readonly leg: SyncDefaultLeg;
+    readonly prNumber: number;
+    readonly prUrl: string;
+    readonly branch: string;
+    readonly reusedExisting: boolean;
+}
+export interface SyncDefaultApplyResult {
+    readonly plan: SyncDefaultPlan;
+    readonly opened: readonly SyncDefaultOpened[];
+    readonly retargeted: false;
+}
+export declare function syncDefaultBranchName(dest: string, source: string, index: number, sha: string): string;
+export declare function parseGithubOwnerRepo(remoteUrl: string): string | null;
+export declare function countChangedFilesOnRange(options: {
+    readonly projectRoot: string;
+    readonly left: string;
+    readonly right: string;
+    readonly runGit?: GitRunner;
+}): {
+    readonly count: number | null;
+    readonly error: string | null;
+};
+export declare function listCommitsAfter(options: {
+    readonly projectRoot: string;
+    readonly dest: string;
+    readonly source: string;
+    readonly runGit?: GitRunner;
+}): {
+    readonly commits: readonly SyncDefaultCommit[];
+    readonly error: string | null;
+};
+/**
+ * Cut dest..source into dest-targeted legs whose dest-based file count is at
+ * or under the threshold when a merge (or other) cut exists.
+ */
+export declare function cutSyncLegs(options: {
+    readonly dest: string;
+    readonly source: string;
+    readonly destRef: string;
+    readonly sourceSha: string;
+    readonly commits: readonly SyncDefaultCommit[];
+    readonly threshold: number;
+    readonly countFiles: (left: string, right: string) => number | null;
+    /** When set, later cuts must be descendants of the previous cut. */
+    readonly isAncestor?: (ancestor: string, descendant: string) => boolean;
+}): {
+    readonly legs: readonly SyncDefaultLeg[];
+    readonly error: string | null;
+};
+export declare function planSyncDefault(options: {
+    readonly projectRoot: string;
+    readonly maxFiles?: number | null;
+    readonly destTipSha?: string;
+    readonly runGit?: GitRunner;
+}): SyncDefaultPlan;
+export declare function nextOpenableLeg(legs: readonly SyncDefaultLeg[], destTipSha: string, projectRoot: string, runGit: GitRunner): SyncDefaultLeg | null;
+export declare function applySyncDefault(options: {
+    readonly projectRoot: string;
+    readonly repo: string;
+    readonly plan?: SyncDefaultPlan;
+    readonly maxFiles?: number | null;
+    readonly destTipSha?: string;
+    readonly dryRun?: boolean;
+    readonly runGit?: GitRunner;
+    readonly forge?: SyncDefaultForge;
+}): SyncDefaultApplyResult;
+export declare function syncDefaultPrBody(plan: SyncDefaultPlan, leg: SyncDefaultLeg): string;
+export declare function formatSyncDefaultHuman(result: SyncDefaultApplyResult): string;
+//# sourceMappingURL=sync-default.d.ts.map