@quonfig/cli 0.0.74 → 0.2.0

package/dist/codegen/language-mappers/zod-base-mapper.js

@@ -1,5 +1,12 @@
 import * as introspect from '../zod-introspection.js';
 export class ZodBaseMapper {
+    /**
+     * Resolves the fixed tuple item at `index`. Mappers that emit value accessors override this to
+     * resolve the item at its indexed path rather than at the tuple's own path.
+     */
+    resolveTupleItem(item, _index) {
+        return this.resolveType(item);
+    }
     resolveType(type) {
         // Check for meta description first and allow implementers to handle it
         const metaDescription = introspect.getMetaDescription(type);
@@ -76,6 +83,10 @@ export class ZodBaseMapper {
             const internalType = this.resolveType(innerType);
             return this.optional(internalType);
         }
+        if (introspect.isIntersection(type)) {
+            const { left, right } = introspect.getIntersectionTypes(type);
+            return this.intersection(this.resolveType(left), this.resolveType(right));
+        }
         if (introspect.isRecord(type)) {
             const { keyType, valueType } = introspect.getRecordTypes(type);
             const keyTypeStr = this.resolveType(keyType);
@@ -87,8 +98,9 @@ export class ZodBaseMapper {
         }
         if (introspect.isTuple(type)) {
             const items = introspect.getTupleItems(type);
-            const itemsStr = items.map((item) => this.resolveType(item));
-            return this.tuple(itemsStr);
+            const itemsStr = items.map((item, index) => this.resolveTupleItem(item, index));
+            const rest = introspect.getTupleRest(type);
+            return this.tuple(itemsStr, rest ? this.resolveType(rest) : undefined);
         }
         if (introspect.isUndefined(type)) {
             return this.undefined();

package/dist/codegen/language-mappers/zod-to-string-mapper.d.ts

@@ -9,6 +9,7 @@ export declare class ZodToStringMapper extends ZodBaseMapper {
     function(input: string, output: string): string;
     functionArguments(value?: $ZodFunctionArgs): string;
     functionReturns(value: $ZodFunctionOut): string;
+    intersection(left: string, right: string): string;
     literal(value: string | number | boolean | null): string;
     never(): string;
     null(): string;
@@ -18,7 +19,7 @@ export declare class ZodToStringMapper extends ZodBaseMapper {
     record(keyType: string, valueType: string): string;
     renderField(type: z.ZodTypeAny, key?: string): string;
     string(): string;
-    tuple(wrappedTypes: string[]): string;
+    tuple(wrappedTypes: string[], rest?: string): string;
     undefined(): string;
     union(wrappedTypes: string[]): string;
     unknown(): string;

package/dist/codegen/language-mappers/zod-to-string-mapper.js

@@ -31,6 +31,9 @@ export class ZodToStringMapper extends ZodBaseMapper {
         const mapper = new ZodToStringMapper();
         return mapper.resolveType(value);
     }
+    intersection(left, right) {
+        return `z.intersection(${left}, ${right})`;
+    }
     literal(value) {
         return `z.literal(${JSON.stringify(value)})`;
     }
@@ -72,8 +75,9 @@ export class ZodToStringMapper extends ZodBaseMapper {
     string() {
         return 'z.string()';
     }
-    tuple(wrappedTypes) {
-        return `z.tuple([${wrappedTypes.join(', ')}])`;
+    tuple(wrappedTypes, rest) {
+        const base = `z.tuple([${wrappedTypes.join(', ')}])`;
+        return rest === undefined ? base : `${base}.rest(${rest})`;
     }
     undefined() {
         return 'z.undefined()';

package/dist/codegen/language-mappers/zod-to-typescript-mapper.d.ts

@@ -1,9 +1,11 @@
 import { z } from 'zod';
+import { $ZodType } from 'zod/v4/core';
 import { ZodTypeSupported } from '../types.js';
 import { ZodBaseMapper } from './zod-base-mapper.js';
 export type ZodToTypescriptMapperTarget = 'accessor' | 'raw';
 export declare class ZodToTypescriptMapper extends ZodBaseMapper {
     private fieldName;
+    private metaCaptureOpen;
     private metaDescription;
     private optionalProperty;
     private target;
@@ -18,6 +20,7 @@ export declare class ZodToTypescriptMapper extends ZodBaseMapper {
     function(args: string, returns: string): string;
     functionArguments(value?: z.ZodTuple): string;
     functionReturns(value: z.ZodTypeAny): string;
+    intersection(left: string, right: string): string;
     literal(value: string | number | boolean | null): string;
     never(): string;
     null(): string;
@@ -26,10 +29,11 @@ export declare class ZodToTypescriptMapper extends ZodBaseMapper {
     optional(wrappedType: string): string;
     record(keyType: string, valueType: string): string;
     renderField(type: ZodTypeSupported): string;
+    resolveType(type: $ZodType): string;
     string(): string;
-    tuple(wrappedTypes: string[]): string;
+    tuple(wrappedTypes: string[], rest?: string): string;
     undefined(): string;
     union(wrappedTypes: string[]): string;
     unknown(): string;
-    protected withMeta(description: string, resolveType: () => string): string;
+    protected withMeta(_description: string, resolveType: () => string): string;
 }

package/dist/codegen/language-mappers/zod-to-typescript-mapper.js

@@ -1,6 +1,10 @@
+import * as introspect from '../zod-introspection.js';
 import { ZodBaseMapper } from './zod-base-mapper.js';
 export class ZodToTypescriptMapper extends ZodBaseMapper {
     fieldName;
+    // A field's comment comes from its own meta, looking through optional/nullable/default wrappers only.
+    // Meta deeper inside (a union branch title, an array item description) must not become the field's comment.
+    metaCaptureOpen = true;
     metaDescription = undefined;
     optionalProperty;
     target;
@@ -41,6 +45,9 @@ export class ZodToTypescriptMapper extends ZodBaseMapper {
         const mapper = new ZodToTypescriptMapper();
         return mapper.resolveType(value);
     }
+    intersection(left, right) {
+        return [left, right].map((t) => (t.includes(' | ') || t.includes('=>') ? `(${t})` : t)).join(' & ');
+    }
     literal(value) {
         return JSON.stringify(value);
     }
@@ -102,11 +109,34 @@ export class ZodToTypescriptMapper extends ZodBaseMapper {
         result += `"${this.fieldName}"${this.optionalProperty ? '?' : ''}: ${resolved}`;
         return result;
     }
+    resolveType(type) {
+        const wasOpen = this.metaCaptureOpen;
+        if (wasOpen) {
+            const description = introspect.getMetaDescription(type);
+            if (description) {
+                this.metaDescription = description;
+            }
+        }
+        this.metaCaptureOpen =
+            wasOpen && (introspect.isOptional(type) || introspect.isNullable(type) || introspect.isDefault(type));
+        try {
+            return super.resolveType(type);
+        }
+        finally {
+            this.metaCaptureOpen = wasOpen;
+        }
+    }
     string() {
         return 'string';
     }
-    tuple(wrappedTypes) {
-        return `[${wrappedTypes.join(', ')}]`;
+    tuple(wrappedTypes, rest) {
+        const items = [...wrappedTypes];
+        if (rest !== undefined) {
+            // `...A | B[]` would parse as `...(A | (B[]))`, so wrap anything that isn't a simple type
+            const restType = /^[\w ,<>]+$/.test(rest) ? rest : `(${rest})`;
+            items.push(`...${restType}[]`);
+        }
+        return `[${items.join(', ')}]`;
     }
     undefined() {
         return 'undefined';
@@ -125,9 +155,8 @@ export class ZodToTypescriptMapper extends ZodBaseMapper {
     unknown() {
         return 'unknown';
     }
-    withMeta(description, resolveType) {
-        // Store the description to be used when rendering the field
-        this.metaDescription = description;
+    withMeta(_description, resolveType) {
+        // The description is captured in resolveType, which knows whether it belongs to this field
         return resolveType();
     }
 }

package/dist/codegen/language-mappers/zod-to-typescript-return-value-mapper.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { $ZodType } from 'zod/v4/core';
 import { ZodTypeSupported } from '../types.js';
 import { ZodBaseMapper } from './zod-base-mapper.js';
 export declare class ZodToTypescriptReturnValueMapper extends ZodBaseMapper {
@@ -6,9 +7,9 @@ export declare class ZodToTypescriptReturnValueMapper extends ZodBaseMapper {
     private FUNCTION_ARGUMENTS_NAME;
     private metaDescription;
     private returnTypePropertyPath;
-    constructor({ fieldName, returnTypePropertyPath }?: {
+    constructor({ fieldName, returnTypePropertyPath, }?: {
         fieldName?: string;
-        returnTypePropertyPath?: string[];
+        returnTypePropertyPath?: (number | string)[];
     });
     any(): string;
     array(): string;
@@ -17,6 +18,7 @@ export declare class ZodToTypescriptReturnValueMapper extends ZodBaseMapper {
     function(args: string, returns: string): string;
     functionArguments(value?: z.ZodTuple): string;
     functionReturns(): string;
+    intersection(): string;
     literal(): string;
     never(): string;
     null(): string;
@@ -25,8 +27,9 @@ export declare class ZodToTypescriptReturnValueMapper extends ZodBaseMapper {
     optional(wrappedType: string): string;
     record(): string;
     renderField(type: ZodTypeSupported): string;
+    protected resolveTupleItem(item: $ZodType, index: number): string;
     string(): string;
-    tuple(wrappedTypes: string[]): string;
+    tuple(wrappedTypes: string[], rest?: string): string;
     undefined(): string;
     union(wrappedTypes: string[]): string;
     unknown(): string;

package/dist/codegen/language-mappers/zod-to-typescript-return-value-mapper.js

@@ -3,8 +3,9 @@ export class ZodToTypescriptReturnValueMapper extends ZodBaseMapper {
     fieldName;
     FUNCTION_ARGUMENTS_NAME = 'params';
     metaDescription = undefined;
+    // Strings are property names, numbers are tuple indexes
     returnTypePropertyPath;
-    constructor({ fieldName, returnTypePropertyPath } = {}) {
+    constructor({ fieldName, returnTypePropertyPath, } = {}) {
         super();
         this.fieldName = fieldName;
         this.returnTypePropertyPath = returnTypePropertyPath ?? [];
@@ -36,6 +37,10 @@ export class ZodToTypescriptReturnValueMapper extends ZodBaseMapper {
     functionReturns() {
         return `Mustache.render(raw${this.printPropertyPath()} ?? "", ${this.FUNCTION_ARGUMENTS_NAME})`;
     }
+    intersection() {
+        // Explicitly not supporting navigation into intersections, pass the raw value through
+        return `raw${this.printPropertyPath()}`;
+    }
     literal() {
         return `raw${this.printPropertyPath()}`;
     }
@@ -102,18 +107,24 @@ export class ZodToTypescriptReturnValueMapper extends ZodBaseMapper {
         this.metaDescription = undefined;
         return result;
     }
+    resolveTupleItem(item, index) {
+        const mapper = new ZodToTypescriptReturnValueMapper({
+            returnTypePropertyPath: [...this.returnTypePropertyPath, index],
+        });
+        return mapper.resolveType(item);
+    }
     string() {
         return `raw${this.printPropertyPath()}`;
     }
-    tuple(wrappedTypes) {
-        const tupleNavigation = wrappedTypes.map((wt, index) => {
-            let massagedWrappedType = wt;
-            if (massagedWrappedType !== 'raw') {
-                // Remove trailing ! from the wrapped type
-                massagedWrappedType = massagedWrappedType.replace(/!$/, '');
-            }
-            return `${massagedWrappedType}?.[${index}]!`;
-        });
+    tuple(wrappedTypes, rest) {
+        // Each fixed item was already resolved at its own index by resolveTupleItem
+        const tupleNavigation = [...wrappedTypes];
+        if (rest !== undefined) {
+            // Pass the remaining items through untouched; truncating to the fixed items would drop data at runtime.
+            // Mustache is never extracted inside arrays, so the rest needs no per-item mapping.
+            const path = this.printPropertyPath().replace(/!$/, '');
+            tupleNavigation.push(`...(raw${path}?.slice(${wrappedTypes.length}) ?? [])`);
+        }
         return `[${tupleNavigation.join(`, `)}]`;
     }
     undefined() {
@@ -140,7 +151,7 @@ export class ZodToTypescriptReturnValueMapper extends ZodBaseMapper {
             return '';
         }
         // Always safe navigate the path to ensure we don't throw an error if the property doesn't exist
-        const path = paths.reduce((acc, part) => `${acc}?.['${part}']`, '');
+        const path = paths.reduce((acc, part) => (typeof part === 'number' ? `${acc}?.[${part}]` : `${acc}?.['${part}']`), '');
         // To satisfy TypeScript's type system, tell it the value is always defined
         return `${path}!`;
     }

package/dist/codegen/zod-introspection.d.ts

@@ -12,6 +12,7 @@ export declare function isAny(schema: $ZodType): schema is z.ZodAny;
 export declare function isArray(schema: $ZodType): schema is z.ZodArray<z.ZodTypeAny>;
 export declare function isObject(schema: $ZodType): schema is z.ZodObject<z.ZodRawShape>;
 export declare function isTuple(schema: $ZodType): schema is z.ZodTuple;
+export declare function isIntersection(schema: $ZodType): schema is z.ZodIntersection<z.ZodTypeAny, z.ZodTypeAny>;
 export declare function isRecord(schema: $ZodType): schema is z.ZodRecord;
 export declare function isEnum(schema: $ZodType): schema is z.ZodEnum<util.EnumLike>;
 export declare function isUnion(schema: $ZodType): schema is z.ZodUnion<[z.ZodTypeAny, ...z.ZodTypeAny[]]>;
@@ -31,6 +32,17 @@ export declare function getObjectShape(schema: z.ZodObject<z.ZodRawShape>): z.Zo
  * Gets the items from a tuple schema
  */
 export declare function getTupleItems(schema: z.ZodTuple): readonly $ZodType[];
+/**
+ * Gets the rest element from a tuple schema (`z.tuple([...]).rest(x)`), or undefined when it has none
+ */
+export declare function getTupleRest(schema: z.ZodTuple): $ZodType | undefined;
+/**
+ * Gets both sides of an intersection schema
+ */
+export declare function getIntersectionTypes(schema: z.ZodIntersection<z.ZodTypeAny, z.ZodTypeAny>): {
+    left: $ZodType;
+    right: $ZodType;
+};
 /**
  * Gets the key and value types from a record schema
  */

package/dist/codegen/zod-introspection.js

@@ -38,6 +38,9 @@ export function isObject(schema) {
 export function isTuple(schema) {
     return schema instanceof z.ZodTuple;
 }
+export function isIntersection(schema) {
+    return schema instanceof z.ZodIntersection;
+}
 export function isRecord(schema) {
     return schema instanceof z.ZodRecord;
 }
@@ -83,6 +86,18 @@ export function getObjectShape(schema) {
 export function getTupleItems(schema) {
     return schema.def.items;
 }
+/**
+ * Gets the rest element from a tuple schema (`z.tuple([...]).rest(x)`), or undefined when it has none
+ */
+export function getTupleRest(schema) {
+    return schema.def.rest ?? undefined;
+}
+/**
+ * Gets both sides of an intersection schema
+ */
+export function getIntersectionTypes(schema) {
+    return { left: schema.def.left, right: schema.def.right };
+}
 /**
  * Gets the key and value types from a record schema
  */

package/dist/commands/push.js

@@ -334,7 +334,7 @@ export function buildRealDeps(cmd, orgSlug) {
         },
         async validate(dir) {
             const { validateWorkspace } = await import('../verify/validate.js');
-            const result = validateWorkspace(dir);
+            const result = validateWorkspace(dir, { validateValues: true });
             const errors = result.issues.filter((i) => i.severity === 'error').map((i) => i.message);
             return { errors };
         },

package/dist/commands/verify.js

@@ -23,7 +23,7 @@ export default class Verify extends BaseCommand {
     async run() {
         const { args, flags } = await this.parse(Verify);
         const dir = args.path;
-        const result = validateWorkspace(dir);
+        const result = validateWorkspace(dir, { validateValues: true });
         if (flags.strict) {
             // Promote warnings to errors
             for (const issue of result.issues) {

package/dist/commands/workspace/bootstrap.d.ts

@@ -9,12 +9,4 @@ export default class WorkspaceBootstrap extends BaseCommand {
         'skip-validate': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };
     run(): Promise<JsonObj | void>;
-    /**
-     * Stage, commit, and push the `quonfig.json` pin. Runs after the main
-     * bootstrap push so the pin lands as a committed+pushed change rather than
-     * an uncommitted local edit. We stage only `quonfig.json` (not `-A`) so we
-     * don't accidentally sweep in unrelated user edits.
-     */
-    private commitAndPushPin;
-    private remoteHasCommits;
 }

package/dist/commands/workspace/bootstrap.js

@@ -4,9 +4,16 @@ import { Flags } from '@oclif/core';
 import { BaseCommand } from '../../index.js';
 import { getActiveProfile, loadAuthConfig } from '../../util/token-storage.js';
 import { mintGiteaToken } from '../../util/gitea-api.js';
-import { readWorkspaceSlug, tryParseWorkspacePin, writeWorkspaceSlug } from '../../util/quonfig-json.js';
+import { bootstrapPinMismatch, describeBootstrapTarget } from '../../util/bootstrap-target.js';
+import { readWorkspaceSlug } from '../../util/quonfig-json.js';
 import { resolveWorkspaceUuid } from '../../util/resolve-workspace.js';
-import { isGitRepo, hasAtLeastOneCommit, gitSetRemote, gitPushForceLease, gitPushForce, getRemoteUrl, displayUrl, runGit, } from '../../util/git-ops.js';
+import { isGitRepo, hasAtLeastOneCommit, gitSetRemote, gitFetch, workspaceDocumentsAtRef, rebaseOntoOriginAndPush, getRemoteUrl, getOriginMainSha, displayUrl, } from '../../util/git-ops.js';
+/**
+ * How the customer points their clone at the workspace after bootstrap.
+ * `pre-bootstrap` keeps their original history; the reset is safe because the
+ * pushed tree was proven equal to their tree before the push.
+ */
+const LOCAL_RESET_RECIPE = 'git branch pre-bootstrap && git fetch origin && git reset --hard origin/main';
 export default class WorkspaceBootstrap extends BaseCommand {
     static description = "Push a local git repo to Gitea as this workspace's config repository";
     static examples = [
@@ -21,7 +28,7 @@ export default class WorkspaceBootstrap extends BaseCommand {
         }),
         force: Flags.boolean({
             default: false,
-            description: 'Force push even if remote already has commits',
+            description: 'Accepted and ignored (no-op). Bootstrap never rewrites the workspace history.',
         }),
         'skip-validate': Flags.boolean({
             default: false,
@@ -33,13 +40,34 @@ export default class WorkspaceBootstrap extends BaseCommand {
         // Resolve target directory
         const dir = flags.dir || process.env.QUONFIG_DIR || process.cwd();
         const resolvedDir = path.resolve(dir);
-        const { workspaceId, orgSlug } = await resolveWorkspaceUuid(this);
-        // The display name is best-effort; we still want it for the confirmation
-        // prompt. Fall back through saved profile → workspaceId UUID.
+        // `--force` is kept so pinned scripts don't die on an unknown flag, but a
+        // workspace's `main` is append-only: nothing here ever rewrites it.
+        if (flags.force) {
+            this.log('Note: --force is accepted for compatibility and ignored — bootstrap never rewrites the workspace.\n');
+        }
+        // The target is resolved like push/pull/sync resolve theirs: QUONFIG_WORKSPACE,
+        // then the directory's quonfig.json pin, then the active profile.
+        const { workspaceId, orgSlug } = await resolveWorkspaceUuid(this, undefined, resolvedDir);
+        // The pin is read again here for the prompt and for the mismatch guard
+        // below. A legacy bare-slug pin reads as "no pin", as it does for push.
+        let pin;
+        try {
+            pin = await readWorkspaceSlug(resolvedDir);
+        }
+        catch {
+            pin = undefined;
+        }
+        // The prompt names whichever source chose the target; the profile only
+        // when it IS the resolved workspace (qfg-8p8i).
         const authConfig = await loadAuthConfig();
         const activeProfile = getActiveProfile();
         const profile = authConfig?.profiles[activeProfile] || authConfig?.profiles[authConfig?.defaultProfile || 'default'];
-        const workspaceName = profile?.workspaceSlug || profile?.workspaceName || workspaceId;
+        const workspaceName = describeBootstrapTarget({
+            envOverride: process.env.QUONFIG_WORKSPACE,
+            pin,
+            profile,
+            workspaceId,
+        });
         this.verboseLog('WorkspaceBootstrap', { workspaceId, orgSlug, dir: resolvedDir });
         // Validate: must be a git repo with at least one commit
         const isRepo = await isGitRepo(resolvedDir);
@@ -55,7 +83,7 @@ export default class WorkspaceBootstrap extends BaseCommand {
             this.log('Verifying config files...');
             try {
                 const { validateWorkspace } = await import('../../verify/validate.js');
-                const result = validateWorkspace(resolvedDir);
+                const result = validateWorkspace(resolvedDir, { validateValues: true });
                 const errors = result.issues.filter((i) => i.severity === 'error');
                 if (errors.length > 0) {
                     this.log(`\nFound ${errors.length} validation error(s):\n`);
@@ -101,16 +129,11 @@ export default class WorkspaceBootstrap extends BaseCommand {
         }
         const { repoUrl, workspaceSlug: backendSlug } = tokenData;
         this.verboseLog('WorkspaceBootstrap', { repoUrl: displayUrl(repoUrl), backendSlug });
-        // Idempotency: check if remote already has commits
-        if (!flags.force) {
-            const remoteHasCommits = await this.remoteHasCommits(repoUrl);
-            if (remoteHasCommits) {
-                this.log(`\nThe remote repository already has commits.`);
-                this.log(`Run \`qfg pull --dir ${resolvedDir}\` to sync, then re-run bootstrap.`);
-                this.log(`Or run with --force to overwrite the remote.\n`);
-                return this.err('Remote is not empty.');
-            }
-        }
+        // Guard, as `qfg push` has: a directory pinned to one workspace is not
+        // pushed to another. Checked before the remote is touched.
+        const mismatch = bootstrapPinMismatch(pin, backendSlug);
+        if (mismatch)
+            return this.err(mismatch);
         // Set remote
         if (existingRemote) {
             this.log(`Updating remote origin...`);
@@ -119,96 +142,65 @@ export default class WorkspaceBootstrap extends BaseCommand {
             this.log(`Setting remote origin...`);
         }
         await gitSetRemote(resolvedDir, repoUrl);
-        // Push
+        await gitFetch(resolvedDir);
+        // Every workspace repo is provisioned with `main`; no `main` means the
+        // workspace is half-created, and the pre-receive hook rejects creating it
+        // by push (plan 5.6 item 1).
+        if ((await getOriginMainSha(resolvedDir)) === undefined) {
+            return this.err('The workspace repository is not provisioned (it has no `main` branch).\nFinish creating the workspace in the Quonfig app, then run bootstrap again.');
+        }
+        // Bootstrap is for a FRESH workspace only. "Fresh" is "holds no documents",
+        // NOT "has no commits": provisioning seeds README.md and quonfig.json, so
+        // every real workspace arrives with two commits (plan
+        // 2026-09-17-tree-derived-cache.md 5.6, 13.2 risk 5).
+        const documents = await workspaceDocumentsAtRef(resolvedDir, 'origin/main');
+        if (documents.length > 0) {
+            const sample = documents.slice(0, 3).join(', ') + (documents.length > 3 ? ', ...' : '');
+            this.log(`\nThis workspace already holds ${documents.length} document(s): ${sample}`);
+            this.log(`Bootstrap lands your local history UNDER what is already there, so it is for fresh workspaces only.`);
+            this.log(`To send local changes to a workspace that is already in use, run:`);
+            this.log(`  qfg push --dir ${resolvedDir}\n`);
+            return this.err('Workspace is not empty.');
+        }
+        // Push. The history is replayed onto the workspace's own head on a
+        // temporary worktree and pushed plainly: `main` is append-only, and a
+        // force-push silently wedges config delivery (plan 5.6).
         this.log('Pushing to Gitea...');
+        let pushResult;
         try {
-            if (flags.force) {
-                await gitPushForce(resolvedDir);
-            }
-            else {
-                await gitPushForceLease(resolvedDir);
-            }
+            // Validation runs again against the tree that is actually pushed (which
+            // carries the WORKSPACE's quonfig.json, not the local one), so content
+            // the server would reject fails here.
+            pushResult = await rebaseOntoOriginAndPush(resolvedDir, { validate: !flags['skip-validate'] });
         }
         catch (error) {
             return this.err(`Push failed: ${String(error)}`);
         }
-        // Write the workspace pin into `quonfig.json` (Guard 1 in
-        // project/plans/cli-git-sync.md). If the pin already exists and disagrees,
-        // we keep what is there — bootstrap is for fresh cases, not re-pinning.
-        // If we do write it, commit and push so the bootstrap leaves no
-        // uncommitted changes behind.
-        //
-        // The pin is stored as `<org-slug>/<workspace-slug>`. The backend's
-        // `workspaceSlug` is just the workspace component today; until the
-        // server returns the slash form, we skip the write rather than
-        // emitting a bare slug.
-        const backendPin = tryParseWorkspacePin(backendSlug);
-        try {
-            const existingPin = await readWorkspaceSlug(resolvedDir);
-            const existingFormatted = existingPin ? `${existingPin.orgSlug}/${existingPin.workspaceSlug}` : undefined;
-            if (!backendPin) {
-                this.verboseLog('WorkspaceBootstrap', `Backend workspaceSlug "${backendSlug}" is not in <org>/<ws> form; skipping pin write.`);
-            }
-            else if (existingPin &&
-                (existingPin.orgSlug !== backendPin.orgSlug || existingPin.workspaceSlug !== backendPin.workspaceSlug)) {
-                const backendFormatted = `${backendPin.orgSlug}/${backendPin.workspaceSlug}`;
-                this.log('');
-                this.log(`Warning: quonfig.json already pins workspace "${existingFormatted}", but the backend says this workspace is "${backendFormatted}".`);
-                this.log('Leaving the existing pin in place. If this is wrong, edit quonfig.json manually and re-run.');
-            }
-            else if (existingPin) {
-                this.verboseLog('WorkspaceBootstrap', `quonfig.json already pinned to ${existingFormatted}; no-op.`);
-            }
-            else {
-                const backendFormatted = `${backendPin.orgSlug}/${backendPin.workspaceSlug}`;
-                this.log('');
-                this.log(`Pinning quonfig.json to workspace "${backendFormatted}"...`);
-                await writeWorkspaceSlug(resolvedDir, backendPin);
-                await this.commitAndPushPin(resolvedDir, backendFormatted, flags.force);
-            }
-        }
-        catch (error) {
-            // The main push has already succeeded, so don't fail the whole command.
-            // Surface the issue clearly so the user knows to follow up.
-            this.log('');
-            this.log(`Warning: could not write the workspace pin to quonfig.json: ${String(error)}`);
-            this.log('The workspace is connected, but you should re-run `qfg pull` to backfill the pin.');
+        this.log(`Landed ${pushResult.commitsRebased} commit(s) on the workspace's history.`);
+        if (pushResult.reconcileSubject !== null) {
+            this.log(`Added one commit ("${pushResult.reconcileSubject}") so the workspace tree matches your local files.`);
         }
         this.log(`\nBootstrap complete.`);
-        this.log(`Workspace "${workspaceName}" is now connected to your local directory.`);
-        this.log(`\nTo keep it in sync locally, run:`);
-        this.log(`  qfg sync --watch --dir ${resolvedDir}`);
+        this.log(`Workspace "${workspaceName}" now holds the history from ${resolvedDir}.`);
+        // The customer's branch is never touched, on success or failure, so it
+        // still points at the pre-bootstrap history — which shares no commit with
+        // what was just pushed (the replayed commits have new ids). `qfg pull` and
+        // `qfg sync` both refuse that state ("diverge" / STALE_HEAD), so the only
+        // honest advice is a reset onto the workspace.
+        //
+        // If we ever move the local branch ourselves (option A: save
+        // refs/quonfig/pre-bootstrap and fast-forward `main` to pushedSha once
+        // tree equality is proven), this block is what it replaces.
+        this.log(`\nYour local branch was not moved. The workspace has the same content under new commit ids.`);
+        this.log(`To point this clone at the workspace, keeping your old history on a branch:`);
+        this.log(`  ${LOCAL_RESET_RECIPE}`);
         return {
+            commitsRebased: pushResult.commitsRebased,
             dir: resolvedDir,
+            localResetRecipe: LOCAL_RESET_RECIPE,
+            reconciled: pushResult.reconcileSubject !== null,
             repoUrl: displayUrl(repoUrl),
             workspaceId,
         };
     }
-    /**
-     * Stage, commit, and push the `quonfig.json` pin. Runs after the main
-     * bootstrap push so the pin lands as a committed+pushed change rather than
-     * an uncommitted local edit. We stage only `quonfig.json` (not `-A`) so we
-     * don't accidentally sweep in unrelated user edits.
-     */
-    async commitAndPushPin(dir, slug, force) {
-        // Stage just quonfig.json so we don't accidentally commit other dirty files.
-        await runGit(['-C', dir, 'add', 'quonfig.json']);
-        // If `git add` produced no staged change (e.g. content matched an earlier
-        // version on disk), `git commit` would fail. Check the index first.
-        const { stdout: diffStat } = await runGit(['-C', dir, 'diff', '--cached', '--name-only']);
-        if (!diffStat.trim()) {
-            this.verboseLog('WorkspaceBootstrap', 'quonfig.json pin matches HEAD; no commit needed.');
-            return;
-        }
-        await runGit(['-C', dir, 'commit', '-m', `chore: pin quonfig.json to workspace "${slug}"`]);
-        // Push the new commit using the same force semantics as the main push.
-        const pushArgs = ['-C', dir, 'push', 'origin', 'main'];
-        pushArgs.push(force ? '--force' : '--force-with-lease');
-        await runGit(pushArgs);
-        this.log(`Pushed pin commit.`);
-    }
-    async remoteHasCommits(repoUrl) {
-        const { stdout } = await runGit(['ls-remote', '--heads', repoUrl]);
-        return stdout.trim().length > 0;
-    }
 }

package/dist/migrate/push-to-cloud.js

@@ -47,7 +47,7 @@ const verifyOnDisk = (dir) => {
     // qfg-52qg: client-side verify against the cumulative tree before commit
     // lands. The Gitea pre-receive hook runs against the final HEAD; failing
     // here matches what the server would reject and avoids a wasted push.
-    const verifyResult = validateWorkspace(dir);
+    const verifyResult = validateWorkspace(dir, { validateValues: true });
     if (!verifyResult.valid)
         throw new MigratorVerifyError(verifyResult);
 };