@git.zone/cli 3.2.1 → 4.0.0

package/dist_ts/mod_services/classes.servicemanager.js

@@ -3,191 +3,339 @@ import * as helpers from './helpers.js';
 import { ServiceConfiguration, getS3BucketNameValidationError, } from './classes.serviceconfiguration.js';
 import { DockerContainer, matchDockerUlimits, } from './classes.dockercontainer.js';
 import { GlobalRegistry } from './classes.globalregistry.js';
-import { getServiceContainerLabels, recordServiceDataDirectory, serviceImages, } from './classes.servicedatamarker.js';
+import { getLegacyMinioDataDirectory, getServiceContainerLabels, getServiceDataDirectory, hasExactServiceContainerLabels, markerProvesServiceDataDirectory, objectStorageImage, readServiceDataMarker, recordServiceDataDirectory, serviceBindOperation, serviceImages, serviceNames, serviceOperationLabel, serviceToolLabel, } from './classes.servicedatamarker.js';
+import { readPersistedServiceConfiguration } from './classes.servicenames.js';
+import { withServiceDataOperationLock } from './classes.interprocesslock.js';
+import { runServiceMigrations, } from '../../dist_ts_migration/index.js';
 import { logger } from '../gitzone.logging.js';
+import { readSmartconfigFile, setCliConfigValueInData, writeSmartconfigFile, } from '../helpers.smartconfig.js';
+export const getServiceManagerMigrationScopes = (operationArg) => [
+    'global-registry',
+    'service-selection',
+    'runtime-config',
+    ...(['start', 'restart', 'reconfigure', 'clean'].includes(operationArg)
+        ? ['service-data-marker']
+        : []),
+];
 export const mongoServiceUlimits = {
     nofile: {
         soft: 65_536,
         hard: 65_536,
     },
 };
-export const minioReconciliationTimeoutMs = 30_000;
-const minioProbeTimeoutCapMs = 2_000;
-const minioProbeIntervalMs = 250;
-const minioRollbackTimeoutMs = 5_000;
-const minioAlias = 'gitzone-local';
-const minioAliasSetupScript = 'mc alias set gitzone-local http://127.0.0.1:9000 "$MINIO_ROOT_USER" "$MINIO_ROOT_PASSWORD" >/dev/null';
-const defaultMinioClock = {
+export const objectStorageReconciliationTimeoutMs = 30_000;
+const objectStorageProbeTimeoutCapMs = 2_000;
+const objectStorageProbeIntervalMs = 250;
+const objectStorageRollbackTimeoutMs = 5_000;
+const defaultObjectStorageClock = {
     now: () => Date.now(),
     delay: async (millisecondsArg) => plugins.smartdelay.delayFor(millisecondsArg),
 };
-class MinioStageError extends Error {
+class ObjectStorageStageError extends Error {
     constructor(stageArg, timedOutArg, causeArg) {
         const message = timedOutArg
-            ? `MinIO ${stageArg} did not complete before the shared reconciliation deadline.`
-            : `MinIO ${stageArg} failed.`;
+            ? `ObjectStorage ${stageArg} did not complete before the shared reconciliation deadline.`
+            : `ObjectStorage ${stageArg} failed.`;
         super(message, causeArg === undefined ? undefined : { cause: causeArg });
-        this.name = 'MinioStageError';
+        this.name = 'ObjectStorageStageError';
     }
 }
-const minioStageError = (stageArg, timedOutArg, causeArg) => {
-    return new MinioStageError(stageArg, timedOutArg, causeArg);
+const objectStorageStageError = (stageArg, timedOutArg, causeArg) => {
+    return new ObjectStorageStageError(stageArg, timedOutArg, causeArg);
 };
-const minioStageCause = (errorArg) => {
-    if (errorArg instanceof MinioStageError && errorArg.cause !== undefined) {
-        return errorArg.cause;
-    }
-    return errorArg;
-};
-const normalizeMinioLifecycleError = (errorArg) => {
+const normalizeObjectStorageLifecycleError = (errorArg) => {
     return errorArg instanceof Error
         ? errorArg
-        : new Error('MinIO lifecycle failed with a non-Error rejection.');
+        : new Error('ObjectStorage lifecycle failed with a non-Error rejection.');
 };
 const isUnknownRecord = (valueArg) => {
     return typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
 };
-const parseMinioInspection = (stdoutArg, expectedContainerNameArg) => {
+export const objectStorageExpectedEntrypoint = ['/usr/bin/tini', '--'];
+export const objectStorageExpectedCommand = [
+    'deno',
+    'run',
+    '--allow-all',
+    'mod.ts',
+    'server',
+];
+export const objectStorageExpectedHealthcheck = {
+    test: [
+        'CMD-SHELL',
+        `deno eval "const response = await fetch('http://127.0.0.1:3000/readyz'); Deno.exit(response.ok ? 0 : 1);"`,
+    ],
+    interval: 30_000_000_000,
+    timeout: 5_000_000_000,
+    startPeriod: 10_000_000_000,
+    retries: 3,
+};
+const parseObjectStorageIdentity = (stdoutArg, expectedContainerNameArg) => {
     let parsed;
     try {
         parsed = JSON.parse(stdoutArg);
     }
     catch {
-        throw new Error(`Docker returned an invalid MinIO inspection for ${expectedContainerNameArg}.`);
+        throw new Error(`Docker returned an invalid ObjectStorage identity for ${expectedContainerNameArg}.`);
     }
     if (!Array.isArray(parsed) || parsed.length !== 1 || !isUnknownRecord(parsed[0])) {
-        throw new Error(`Docker returned an invalid MinIO inspection for ${expectedContainerNameArg}.`);
+        throw new Error(`Docker returned an invalid ObjectStorage identity for ${expectedContainerNameArg}.`);
+    }
+    const inspected = parsed[0];
+    const state = inspected.State;
+    const config = inspected.Config;
+    const normalizedName = typeof inspected.Name === 'string' ? inspected.Name.replace(/^\//u, '') : undefined;
+    if (typeof inspected.Id !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(inspected.Id) ||
+        normalizedName !== expectedContainerNameArg ||
+        !isUnknownRecord(state) ||
+        typeof state.Running !== 'boolean' ||
+        typeof state.Status !== 'string' ||
+        !isUnknownRecord(config) ||
+        (config.Labels !== null && config.Labels !== undefined && !isUnknownRecord(config.Labels))) {
+        throw new Error(`Docker returned an invalid ObjectStorage identity for ${expectedContainerNameArg}.`);
+    }
+    const labels = {};
+    for (const [keyArg, valueArg] of Object.entries(config.Labels || {})) {
+        if (typeof valueArg !== 'string') {
+            throw new Error(`Docker returned an invalid ObjectStorage identity for ${expectedContainerNameArg}.`);
+        }
+        labels[keyArg] = valueArg;
+    }
+    return {
+        id: inspected.Id,
+        name: normalizedName,
+        running: state.Running,
+        status: state.Status,
+        labels,
+    };
+};
+const parseObjectStorageInspection = (stdoutArg, expectedContainerNameArg) => {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdoutArg);
+    }
+    catch {
+        throw new Error(`Docker returned an invalid ObjectStorage inspection for ${expectedContainerNameArg}.`);
+    }
+    if (!Array.isArray(parsed) || parsed.length !== 1 || !isUnknownRecord(parsed[0])) {
+        throw new Error(`Docker returned an invalid ObjectStorage inspection for ${expectedContainerNameArg}.`);
     }
     const inspected = parsed[0];
     const state = inspected.State;
     const config = inspected.Config;
     const hostConfig = inspected.HostConfig;
+    const healthcheck = isUnknownRecord(config) ? config.Healthcheck : undefined;
+    const restartPolicy = isUnknownRecord(hostConfig) ? hostConfig.RestartPolicy : undefined;
     const normalizedName = typeof inspected.Name === 'string' ? inspected.Name.replace(/^\//u, '') : undefined;
     if (typeof inspected.Id !== 'string' ||
         !/^[a-f0-9]{64}$/u.test(inspected.Id) ||
         normalizedName !== expectedContainerNameArg ||
         !isUnknownRecord(state) ||
         typeof state.Running !== 'boolean' ||
+        typeof state.Status !== 'string' ||
         !isUnknownRecord(config) ||
+        typeof config.Image !== 'string' ||
+        typeof config.User !== 'string' ||
+        !Array.isArray(config.Cmd) ||
+        !config.Cmd.every((entryArg) => typeof entryArg === 'string') ||
+        !Array.isArray(config.Entrypoint) ||
+        !config.Entrypoint.every((entryArg) => typeof entryArg === 'string') ||
         !isUnknownRecord(hostConfig) ||
         !isUnknownRecord(hostConfig.PortBindings) ||
+        !isUnknownRecord(restartPolicy) ||
+        typeof restartPolicy.Name !== 'string' ||
         !Array.isArray(config.Env) ||
-        !config.Env.every((entryArg) => typeof entryArg === 'string')) {
-        throw new Error(`Docker returned an invalid MinIO inspection for ${expectedContainerNameArg}.`);
+        !config.Env.every((entryArg) => typeof entryArg === 'string') ||
+        !isUnknownRecord(config.Labels) ||
+        !isUnknownRecord(healthcheck) ||
+        !Array.isArray(healthcheck.Test) ||
+        !healthcheck.Test.every((entryArg) => typeof entryArg === 'string') ||
+        typeof healthcheck.Interval !== 'number' ||
+        typeof healthcheck.Timeout !== 'number' ||
+        typeof healthcheck.StartPeriod !== 'number' ||
+        typeof healthcheck.Retries !== 'number' ||
+        !Array.isArray(inspected.Mounts)) {
+        throw new Error(`Docker returned an invalid ObjectStorage inspection for ${expectedContainerNameArg}.`);
     }
     const labels = {};
-    if (config.Labels !== null && config.Labels !== undefined) {
-        if (!isUnknownRecord(config.Labels)) {
-            throw new Error(`Docker returned an invalid MinIO inspection for ${expectedContainerNameArg}.`);
-        }
-        for (const [key, value] of Object.entries(config.Labels)) {
-            if (typeof value !== 'string') {
-                throw new Error(`Docker returned an invalid MinIO inspection for ${expectedContainerNameArg}.`);
-            }
-            labels[key] = value;
+    for (const [key, value] of Object.entries(config.Labels)) {
+        if (typeof value !== 'string') {
+            throw new Error(`Docker returned an invalid ObjectStorage inspection for ${expectedContainerNameArg}.`);
         }
+        labels[key] = value;
     }
+    const mounts = inspected.Mounts.map((mountArg) => {
+        if (!isUnknownRecord(mountArg) ||
+            mountArg.Type !== 'bind' ||
+            typeof mountArg.Source !== 'string' ||
+            typeof mountArg.Destination !== 'string' ||
+            typeof mountArg.RW !== 'boolean') {
+            throw new Error(`Docker returned an invalid ObjectStorage inspection for ${expectedContainerNameArg}.`);
+        }
+        return {
+            source: plugins.path.resolve(mountArg.Source),
+            destination: mountArg.Destination,
+            readWrite: mountArg.RW,
+        };
+    });
     return {
         id: inspected.Id,
         name: normalizedName,
         running: state.Running,
+        status: state.Status,
+        image: config.Image,
         portBindings: hostConfig.PortBindings,
         environmentEntries: config.Env,
         labels,
+        mounts,
+        restartPolicy: restartPolicy.Name,
+        command: [...config.Cmd],
+        entrypoint: [...config.Entrypoint],
+        user: config.User,
+        healthcheck: {
+            test: [...healthcheck.Test],
+            interval: healthcheck.Interval,
+            timeout: healthcheck.Timeout,
+            startPeriod: healthcheck.StartPeriod,
+            retries: healthcheck.Retries,
+        },
     };
 };
-const minioPortMatches = (portBindingsArg, containerPortArg, expectedHostPortArg) => {
+const objectStoragePortMatches = (portBindingsArg, containerPortArg, expectedHostPortArg) => {
     const bindings = portBindingsArg[containerPortArg];
     return (Array.isArray(bindings) &&
-        bindings.some((bindingArg) => isUnknownRecord(bindingArg) && bindingArg.HostPort === expectedHostPortArg));
+        bindings.length === 1 &&
+        isUnknownRecord(bindings[0]) &&
+        bindings[0].HostIp === '127.0.0.1' &&
+        bindings[0].HostPort === expectedHostPortArg);
 };
-/** Converge a running MinIO container to an authenticated, verified bucket. */
-export const reconcileMinioBucket = async (optionsArg) => {
-    if (!/^[a-f0-9]{64}$/u.test(optionsArg.containerId)) {
-        throw new Error('MinIO reconciliation requires a full immutable Docker container id.');
-    }
-    const clock = optionsArg.clock || defaultMinioClock;
-    const deadlineAt = optionsArg.deadlineAt ?? clock.now() + minioReconciliationTimeoutMs;
-    if (!Number.isFinite(deadlineAt)) {
-        throw new Error('MinIO reconciliation deadline must be finite');
+const isS3BucketNotFound = (errorArg) => {
+    if (!isUnknownRecord(errorArg)) {
+        return false;
     }
+    const metadata = errorArg.$metadata;
+    return (errorArg.name === 'NoSuchBucket' ||
+        errorArg.name === 'NotFound' ||
+        (isUnknownRecord(metadata) && metadata.httpStatusCode === 404));
+};
+/** Create the configured bucket only after an authenticated 404, then verify by HEAD. */
+export const reconcileObjectStorageBucket = async (optionsArg) => {
+    const clock = optionsArg.clock || defaultObjectStorageClock;
+    const deadlineAt = optionsArg.deadlineAt ?? clock.now() + objectStorageReconciliationTimeoutMs;
     const remainingMs = () => Math.floor(deadlineAt - clock.now());
-    const execOnce = async (stageArg, argvArg, timeoutCapMsArg) => {
+    const sendWithDeadline = async (stageArg, commandArg) => {
         const remaining = remainingMs();
         if (remaining <= 0) {
-            throw minioStageError(stageArg, true);
-        }
+            throw objectStorageStageError(stageArg, true);
+        }
+        const controller = new AbortController();
+        let timedOut = false;
+        const timeoutPromise = new Promise((_resolve, reject) => {
+            const timer = setTimeout(() => {
+                timedOut = true;
+                controller.abort();
+                reject(objectStorageStageError(stageArg, true));
+            }, remaining);
+            controller.signal.addEventListener('abort', () => clearTimeout(timer), { once: true });
+        });
         try {
-            return await optionsArg.docker.execArgv(argvArg, {
-                timeoutMs: Math.max(1, timeoutCapMsArg === undefined ? remaining : Math.min(timeoutCapMsArg, remaining)),
-            });
+            await Promise.race([
+                optionsArg.smartBucket.storageClient.send(commandArg, {
+                    abortSignal: controller.signal,
+                }),
+                timeoutPromise,
+            ]);
         }
         catch (error) {
-            throw minioStageError(stageArg, remainingMs() <= 0, error);
+            if (timedOut || error instanceof ObjectStorageStageError) {
+                throw objectStorageStageError(stageArg, true);
+            }
+            throw error;
+        }
+        finally {
+            controller.abort();
         }
     };
-    const execUntilReady = async (stageArg, argvArg) => {
-        let lastCause;
-        while (true) {
+    let primaryError;
+    try {
+        if (!Number.isFinite(deadlineAt)) {
+            throw new Error('ObjectStorage reconciliation deadline must be finite.');
+        }
+        let bucketMissing = false;
+        try {
+            await sendWithDeadline('authenticated bucket lookup', new plugins.s3.HeadBucketCommand({ Bucket: optionsArg.bucket }));
+        }
+        catch (error) {
+            if (error instanceof ObjectStorageStageError) {
+                throw error;
+            }
+            if (!isS3BucketNotFound(error)) {
+                throw objectStorageStageError('authenticated bucket lookup', false);
+            }
+            bucketMissing = true;
+        }
+        let createFailed = false;
+        if (bucketMissing) {
             try {
-                return await execOnce(stageArg, argvArg, minioProbeTimeoutCapMs);
+                await sendWithDeadline('bucket creation', new plugins.s3.CreateBucketCommand({ Bucket: optionsArg.bucket }));
             }
-            catch (error) {
-                const currentCause = minioStageCause(error);
-                if (currentCause !== undefined) {
-                    lastCause = currentCause;
-                }
-                const remaining = remainingMs();
-                if (remaining <= 0) {
-                    throw minioStageError(stageArg, true, lastCause);
-                }
-                await clock.delay(Math.min(minioProbeIntervalMs, remaining));
-                if (remainingMs() <= 0) {
-                    throw minioStageError(stageArg, true, lastCause);
-                }
+            catch {
+                // A timed-out or disconnected create can still have reached the server.
+                createFailed = true;
             }
         }
-    };
-    await execUntilReady('container readiness', ['exec', optionsArg.containerId, 'true']);
-    // The fixed script reads credentials only from the container environment.
-    await execUntilReady('alias configuration', [
-        'exec',
-        optionsArg.containerId,
-        'sh',
-        '-c',
-        minioAliasSetupScript,
-    ]);
-    await execUntilReady('authenticated readiness', [
-        'exec',
-        optionsArg.containerId,
-        'mc',
-        'ready',
-        '--json',
-        minioAlias,
-    ]);
-    const bucketTarget = `${minioAlias}/${optionsArg.bucket}`;
-    await execOnce('bucket creation', [
-        'exec',
-        optionsArg.containerId,
-        'mc',
-        'mb',
-        '--ignore-existing',
-        bucketTarget,
-    ]);
-    await execOnce('bucket verification', [
-        'exec',
-        optionsArg.containerId,
-        'mc',
-        'stat',
-        bucketTarget,
-    ]);
+        const verificationTimeout = Math.min(30_000, remainingMs());
+        if (verificationTimeout <= 0) {
+            throw objectStorageStageError('bucket verification', true);
+        }
+        let verification;
+        try {
+            verification = await optionsArg.smartBucket.checkReadiness(optionsArg.bucket, {
+                timeoutMs: verificationTimeout,
+            });
+        }
+        catch {
+            throw objectStorageStageError('bucket verification', false);
+        }
+        if (!verification.ready) {
+            throw objectStorageStageError(createFailed ? 'bucket creation and verification' : 'bucket verification', verification.reason === 'timeout');
+        }
+    }
+    catch (error) {
+        primaryError = normalizeObjectStorageLifecycleError(error);
+    }
+    let closeError;
+    try {
+        await optionsArg.smartBucket.close();
+    }
+    catch {
+        closeError = objectStorageStageError('S3 client cleanup', false);
+    }
+    if (primaryError && closeError) {
+        throw new AggregateError([primaryError, closeError], 'ObjectStorage bucket reconciliation failed and S3 client cleanup could not be confirmed.');
+    }
+    if (primaryError) {
+        throw primaryError;
+    }
+    if (closeError) {
+        throw closeError;
+    }
 };
 export class ServiceManager {
     config;
     docker;
     enabledServices = null;
     globalRegistry;
-    minioClock = defaultMinioClock;
+    objectStorageClock = defaultObjectStorageClock;
+    fetchImplementation = globalThis.fetch;
+    smartBucketFactory = (configArg) => new plugins.smartbucket.SmartBucket({
+        endpoint: '127.0.0.1',
+        port: parseInt(configArg.S3_PORT),
+        useSsl: false,
+        region: configArg.S3_REGION,
+        accessKey: configArg.S3_ACCESSKEY,
+        accessSecret: configArg.S3_SECRETKEY,
+    });
     constructor() {
         this.config = new ServiceConfiguration();
         this.docker = new DockerContainer();
@@ -196,7 +344,11 @@ export class ServiceManager {
     /**
      * Initialize the service manager
      */
-    async init() {
+    async init(operationArg) {
+        await runServiceMigrations({
+            projectPath: process.cwd(),
+            scopes: getServiceManagerMigrationScopes(operationArg),
+        });
         // Check Docker availability
         if (!(await this.docker.checkDocker())) {
             logger.log('error', 'Error: Docker is not installed. Please install Docker first.');
@@ -220,7 +372,7 @@ export class ServiceManager {
         // Any services command run in a project counts as activity. Without this
         // lastActive only advanced on start, so an actively used project could look
         // stale to the reaper.
-        await this.globalRegistry.touchProject(process.cwd());
+        await this.withProjectServiceLocks(process.cwd(), () => this.globalRegistry.touchProject(process.cwd()));
     }
     /**
      * Human phrasing for where the auth mode came from. A declared auth-off is
@@ -247,10 +399,9 @@ export class ServiceManager {
      * Load service configuration from .smartconfig.json
      */
     async loadServiceConfiguration() {
-        const smartconfigInstance = new plugins.smartconfig.Smartconfig(process.cwd());
-        const gitzoneConfig = smartconfigInstance.dataFor('@git.zone/cli', {});
+        const persistedServices = await readPersistedServiceConfiguration(process.cwd());
         // Check if services array exists
-        if (!gitzoneConfig.services || !Array.isArray(gitzoneConfig.services) || gitzoneConfig.services.length === 0) {
+        if (persistedServices.length === 0) {
             // Prompt user to select services
             const smartinteract = new plugins.smartinteract.SmartInteract();
             const response = await smartinteract.askQuestion({
@@ -259,43 +410,28 @@ export class ServiceManager {
                 message: 'Which services do you want to enable for this project?',
                 choices: [
                     { name: 'MongoDB', value: 'mongodb' },
-                    { name: 'MinIO (S3)', value: 'minio' },
+                    { name: 'ObjectStorage (S3)', value: 'objectstorage' },
                     { name: 'Elasticsearch', value: 'elasticsearch' }
                 ],
-                default: ['mongodb', 'minio', 'elasticsearch']
+                default: ['mongodb', 'objectstorage', 'elasticsearch']
             });
-            const enabledServices = response.value || ['mongodb', 'minio', 'elasticsearch'];
+            const enabledServices = response.value || ['mongodb', 'objectstorage', 'elasticsearch'];
             this.enabledServices = enabledServices;
             // Save to .smartconfig.json
             await this.saveServiceConfiguration(enabledServices);
         }
         else {
-            const enabledServices = gitzoneConfig.services;
-            this.enabledServices = enabledServices;
-            logger.log('info', `🔧 Enabled services: ${enabledServices.join(', ')}`);
+            this.enabledServices = persistedServices;
+            logger.log('info', `🔧 Enabled services: ${persistedServices.join(', ')}`);
         }
     }
     /**
      * Save service configuration to .smartconfig.json
      */
     async saveServiceConfiguration(services) {
-        const smartconfigPath = plugins.path.join(process.cwd(), '.smartconfig.json');
-        let smartconfigData = {};
-        // Read existing .smartconfig.json if it exists
-        if (await plugins.smartfs.file(smartconfigPath).exists()) {
-            const content = await plugins.smartfs.file(smartconfigPath).encoding('utf8').read();
-            smartconfigData = JSON.parse(content);
-        }
-        // Update @git.zone/cli.services
-        if (!smartconfigData['@git.zone/cli']) {
-            smartconfigData['@git.zone/cli'] = {};
-        }
-        smartconfigData['@git.zone/cli'].services = services;
-        // Write back to .smartconfig.json
-        await plugins.smartfs
-            .file(smartconfigPath)
-            .encoding('utf8')
-            .write(JSON.stringify(smartconfigData, null, 2));
+        const smartconfigData = await readSmartconfigFile(process.cwd());
+        setCliConfigValueInData(smartconfigData, 'services', services);
+        await writeSmartconfigFile(smartconfigData, process.cwd());
         logger.log('ok', `✅ Saved service configuration to .smartconfig.json`);
         logger.log('info', `🔧 Enabled services: ${services.join(', ')}`);
     }
@@ -315,14 +451,24 @@ export class ServiceManager {
      * prove the directory is reclaimable instead of guessing from its path.
      */
     async prepareDataDirectory(serviceArg, dataPathArg) {
-        await plugins.smartfs.directory(dataPathArg).recursive().create();
-        await recordServiceDataDirectory(process.cwd(), serviceArg);
+        if (await plugins.smartfs.directory(dataPathArg).exists()) {
+            await recordServiceDataDirectory(process.cwd(), serviceArg);
+        }
+        else {
+            // Publish ownership first: interruption can leave an absent directory with
+            // a harmless claim, but never an unmarked directory that blocks recovery.
+            await recordServiceDataDirectory(process.cwd(), serviceArg);
+            await this.createDataDirectory(dataPathArg);
+        }
         return getServiceContainerLabels({
             projectPath: process.cwd(),
             service: serviceArg,
             dataPath: dataPathArg,
         });
     }
+    async createDataDirectory(dataPathArg) {
+        await plugins.smartfs.directory(dataPathArg).recursive().create();
+    }
     /**
      * Register this project with the global registry.
      *
@@ -338,16 +484,16 @@ export class ServiceManager {
             projectName: config.PROJECT_NAME,
             containers: {
                 mongo: containers.mongo,
-                minio: containers.minio,
+                objectstorage: containers.objectstorage,
                 elasticsearch: containers.elasticsearch,
             },
             ports: {
                 mongo: parseInt(config.MONGODB_PORT),
                 s3: parseInt(config.S3_PORT),
-                s3Console: parseInt(config.S3_CONSOLE_PORT),
+                s3Ui: parseInt(config.S3_UI_PORT),
                 elasticsearch: parseInt(config.ELASTICSEARCH_PORT),
             },
-            enabledServices: this.enabledServices || ['mongodb', 'minio', 'elasticsearch'],
+            enabledServices: this.enabledServices || ['mongodb', 'objectstorage', 'elasticsearch'],
         });
     }
     /**
@@ -361,10 +507,10 @@ export class ServiceManager {
             await this.startMongoDB();
             first = false;
         }
-        if (this.isServiceEnabled('minio')) {
+        if (this.isServiceEnabled('objectstorage')) {
             if (!first)
                 console.log();
-            await this.startMinIO();
+            await this.startObjectStorage();
             first = false;
         }
         if (this.isServiceEnabled('elasticsearch')) {
@@ -385,7 +531,7 @@ export class ServiceManager {
     async stopAll() {
         await this.stopMongoDB();
         console.log();
-        await this.stopMinIO();
+        await this.stopObjectStorage();
         console.log();
         await this.stopElasticsearch();
     }
@@ -398,6 +544,19 @@ export class ServiceManager {
      * (localhost:MONGODB_PORT) is reachable from host and container alike.
      */
     async startMongoDB() {
+        await withServiceDataOperationLock(process.cwd(), 'mongodb', () => this.startMongoDBLocked());
+    }
+    async assertNoPendingDataDeletion(serviceArg) {
+        const pendingPath = await this.docker.getPendingDataDeletionPath(process.cwd(), serviceArg);
+        if (pendingPath) {
+            throw new Error(`Pending ${serviceArg} data deletion must finish before startup: ${pendingPath}. ` +
+                'Run `gitzone services clean --yes` to resume the recorded cleanup.');
+        }
+    }
+    async startMongoDBLocked() {
+        await this.config.reloadFromDisk();
+        await this.assertNoPendingDataDeletion('mongodb');
+        await this.globalRegistry.touchProject(process.cwd());
         logger.log('note', '📦 MongoDB:');
         const config = this.config.getConfig();
         const containers = this.config.getContainerNames();
@@ -646,228 +805,442 @@ export class ServiceManager {
         logger.log('error', '  Replica set not ready after 30s — transactions unavailable');
         return false;
     }
-    async inspectMinioContainer(containerReferenceArg, expectedContainerNameArg, dockerTimeoutArg) {
+    async inspectObjectStorageContainer(containerReferenceArg, expectedContainerNameArg, dockerTimeoutArg) {
         const result = await this.docker.execArgv(['inspect', containerReferenceArg], dockerTimeoutArg());
-        return parseMinioInspection(result.stdout, expectedContainerNameArg);
-    }
-    async assertMinioOwnership(inspectionArg, expectedLabelsArg, allowLegacyRegistryArg) {
-        const actualGitZoneLabels = Object.entries(inspectionArg.labels).filter(([key]) => key.startsWith('git.zone.'));
-        const expectedEntries = Object.entries(expectedLabelsArg);
-        const hasExactCurrentLabels = actualGitZoneLabels.length === expectedEntries.length &&
-            expectedEntries.every(([key, value]) => inspectionArg.labels[key] === value);
-        if (hasExactCurrentLabels) {
-            return;
-        }
-        const refusal = () => new Error(`Refusing to use MinIO container ${inspectionArg.name}: ` +
-            'its ownership is not proven for the current project.');
-        if (!allowLegacyRegistryArg) {
-            throw refusal();
-        }
-        // Any ownership label is authoritative. A partial, stale, or foreign set
-        // must never be reinterpreted through the legacy registry fallback.
-        if (actualGitZoneLabels.length > 0 || Object.keys(inspectionArg.labels).length > 0) {
-            throw refusal();
-        }
-        // Containers created before labels were introduced may be reclaimed only
-        // when the old global registry has one unambiguous claim for this exact
-        // name and the current resolved project path.
-        const currentProjectPath = plugins.path.resolve(process.cwd());
-        const registryProjects = await this.globalRegistry.getAllProjects();
-        const claims = Object.entries(registryProjects).filter(([, project]) => project.containers.minio === inspectionArg.name);
-        if (claims.length !== 1) {
-            throw refusal();
+        return parseObjectStorageInspection(result.stdout, expectedContainerNameArg);
+    }
+    async inspectObjectStorageIdentity(containerReferenceArg, expectedContainerNameArg, dockerTimeoutArg) {
+        const result = await this.docker.execArgv(['inspect', containerReferenceArg], dockerTimeoutArg());
+        const identity = parseObjectStorageIdentity(result.stdout, expectedContainerNameArg);
+        if (/^[a-f0-9]{64}$/u.test(containerReferenceArg) && identity.id !== containerReferenceArg) {
+            throw new Error(`Refusing ObjectStorage container ${expectedContainerNameArg}: its immutable id changed.`);
         }
-        const [registryPath, project] = claims[0];
-        if (plugins.path.resolve(registryPath) !== currentProjectPath ||
-            plugins.path.resolve(project.projectPath) !== currentProjectPath) {
-            throw refusal();
+        return identity;
+    }
+    async discoverContainerIdByExactName(containerNameArg, dockerTimeoutArg) {
+        const result = await this.docker.execArgv([
+            'container',
+            'ls',
+            '-a',
+            '--no-trunc',
+            '--filter',
+            `name=^/${containerNameArg}$`,
+            '--format',
+            '{{.ID}}',
+        ], dockerTimeoutArg());
+        const ids = result.stdout
+            .split(/\r?\n/u)
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+        if (ids.length === 0) {
+            return undefined;
+        }
+        if (ids.length !== 1 || !/^[a-f0-9]{64}$/u.test(ids[0])) {
+            throw new Error(`Docker returned ambiguous identity for container ${containerNameArg}.`);
+        }
+        return ids[0];
+    }
+    assertObjectStorageOwnership(inspectionArg, expectedLabelsArg) {
+        if (!hasExactServiceContainerLabels(inspectionArg.labels, expectedLabelsArg)) {
+            throw new Error(`Refusing to use ObjectStorage container ${inspectionArg.name}: ` +
+                'its ownership is not proven for the current project.');
         }
     }
-    async revalidateMinioContainer(containerIdArg, expectedContainerNameArg, expectedLabelsArg, allowLegacyRegistryArg, dockerTimeoutArg) {
-        const inspection = await this.inspectMinioContainer(containerIdArg, expectedContainerNameArg, dockerTimeoutArg);
+    async revalidateObjectStorageContainer(containerIdArg, expectedContainerNameArg, expectedLabelsArg, dockerTimeoutArg) {
+        const inspection = await this.inspectObjectStorageContainer(containerIdArg, expectedContainerNameArg, dockerTimeoutArg);
         if (inspection.id !== containerIdArg) {
-            throw new Error(`Refusing to use MinIO container ${expectedContainerNameArg}: ` +
+            throw new Error(`Refusing to use ObjectStorage container ${expectedContainerNameArg}: ` +
                 'its immutable id changed during reconciliation.');
         }
-        await this.assertMinioOwnership(inspection, expectedLabelsArg, allowLegacyRegistryArg);
+        this.assertObjectStorageOwnership(inspection, expectedLabelsArg);
         return inspection;
     }
-    /**
-     * Start MinIO service
-     */
-    async startMinIO() {
-        logger.log('note', '📦 S3/MinIO:');
+    objectStorageConfigurationMatches(inspectionArg, expectedLabelsArg) {
         const config = this.config.getConfig();
-        const containers = this.config.getContainerNames();
         const directories = this.config.getDataDirectories();
-        // Validation lives on the mutating path so recovery commands remain usable.
+        const expectedEnvironment = {
+            OBJST_PORT: '9000',
+            UI_PORT: '3000',
+            OBJST_STORAGE_DIR: '/data',
+            OBJST_ACCESS_KEY: config.S3_ACCESSKEY,
+            OBJST_SECRET_KEY: config.S3_SECRETKEY,
+            OBJST_ADMIN_PASSWORD: config.S3_ADMIN_PASSWORD,
+            OBJST_REGION: config.S3_REGION,
+        };
+        const controlledEnvironmentEntries = inspectionArg.environmentEntries.filter((entryArg) => {
+            const separatorIndex = entryArg.indexOf('=');
+            const name = separatorIndex === -1 ? entryArg : entryArg.slice(0, separatorIndex);
+            return name === 'UI_PORT' || name.startsWith('OBJST_');
+        });
+        const readEnvironment = (nameArg) => {
+            const prefix = `${nameArg}=`;
+            const matches = inspectionArg.environmentEntries.filter((entry) => entry.startsWith(prefix));
+            return matches.length === 1 ? matches[0].slice(prefix.length) : undefined;
+        };
+        const portKeys = Object.keys(inspectionArg.portBindings).sort();
+        const expectedPortKeys = ['3000/tcp', '9000/tcp'];
+        const healthcheckMatches = inspectionArg.healthcheck.test.length === objectStorageExpectedHealthcheck.test.length &&
+            inspectionArg.healthcheck.test.every((entry, index) => entry === objectStorageExpectedHealthcheck.test[index]) &&
+            inspectionArg.healthcheck.interval === objectStorageExpectedHealthcheck.interval &&
+            inspectionArg.healthcheck.timeout === objectStorageExpectedHealthcheck.timeout &&
+            inspectionArg.healthcheck.startPeriod === objectStorageExpectedHealthcheck.startPeriod &&
+            inspectionArg.healthcheck.retries === objectStorageExpectedHealthcheck.retries;
+        return (inspectionArg.image === objectStorageImage &&
+            portKeys.length === expectedPortKeys.length &&
+            portKeys.every((entry, index) => entry === expectedPortKeys[index]) &&
+            objectStoragePortMatches(inspectionArg.portBindings, '9000/tcp', config.S3_PORT) &&
+            objectStoragePortMatches(inspectionArg.portBindings, '3000/tcp', config.S3_UI_PORT) &&
+            inspectionArg.mounts.length === 1 &&
+            inspectionArg.mounts[0].source === plugins.path.resolve(directories.objectstorage) &&
+            inspectionArg.mounts[0].destination === '/data' &&
+            inspectionArg.mounts[0].readWrite &&
+            controlledEnvironmentEntries.length === Object.keys(expectedEnvironment).length &&
+            Object.entries(expectedEnvironment).every(([name, value]) => readEnvironment(name) === value) &&
+            hasExactServiceContainerLabels(inspectionArg.labels, expectedLabelsArg) &&
+            inspectionArg.restartPolicy === 'unless-stopped' &&
+            inspectionArg.command.length === objectStorageExpectedCommand.length &&
+            inspectionArg.command.every((entry, index) => entry === objectStorageExpectedCommand[index]) &&
+            inspectionArg.entrypoint.length === objectStorageExpectedEntrypoint.length &&
+            inspectionArg.entrypoint.every((entry, index) => entry === objectStorageExpectedEntrypoint[index]) &&
+            inspectionArg.user === 'objectstorage' &&
+            healthcheckMatches);
+    }
+    async assertNoSymlinkedObjectStoragePath(dataPathArg) {
+        const projectPath = plugins.path.resolve(process.cwd());
+        const expectedPath = getServiceDataDirectory(projectPath, 'objectstorage');
+        if (plugins.path.resolve(dataPathArg) !== expectedPath) {
+            throw new Error(`Refusing non-canonical ObjectStorage data path: ${dataPathArg}`);
+        }
+        for (const candidate of [projectPath, plugins.path.join(projectPath, '.nogit'), expectedPath]) {
+            try {
+                if ((await plugins.fs.lstat(candidate)).isSymbolicLink()) {
+                    throw new Error(`Refusing symbolic-link ObjectStorage path component: ${candidate}`);
+                }
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+            }
+        }
+    }
+    async prepareObjectStorageDataDirectory(dockerTimeoutArg) {
+        const projectPath = plugins.path.resolve(process.cwd());
+        const dataPath = this.config.getDataDirectories().objectstorage;
+        await this.assertNoSymlinkedObjectStoragePath(dataPath);
+        const exists = await plugins.smartfs.directory(dataPath).exists();
+        const marker = await readServiceDataMarker(projectPath);
+        if (exists && !markerProvesServiceDataDirectory(marker, projectPath, 'objectstorage')) {
+            throw new Error(`Refusing existing ObjectStorage data directory with unproven ownership: ${dataPath}`);
+        }
+        if (!exists) {
+            await recordServiceDataDirectory(projectPath, 'objectstorage');
+            await this.createDataDirectory(dataPath);
+        }
+        const labels = getServiceContainerLabels({
+            projectPath,
+            service: 'objectstorage',
+            dataPath,
+        });
+        await this.docker.runFencedBindOperation({
+            image: objectStorageImage,
+            hostPath: dataPath,
+            containerPath: '/data',
+            entrypoint: '/bin/chown',
+            command: ['-R', 'objectstorage:objectstorage', '/data'],
+            labels: {
+                'git.zone.tool': serviceToolLabel,
+                'git.zone.service': 'objectstorage',
+                'git.zone.project-path': projectPath,
+                'git.zone.data-path': plugins.path.resolve(dataPath),
+                'git.zone.safe-to-prune': 'false',
+                [serviceOperationLabel]: serviceBindOperation,
+            },
+            executionOptions: dockerTimeoutArg,
+            rollbackTimeoutMs: objectStorageRollbackTimeoutMs,
+        });
+        return labels;
+    }
+    async repairObjectStorageMarkerFromOwnedContainer(dataPathArg) {
+        const projectPath = plugins.path.resolve(process.cwd());
+        await this.assertNoSymlinkedObjectStoragePath(dataPathArg);
+        if (!(await plugins.smartfs.directory(dataPathArg).exists())) {
+            throw new Error(`Refusing owned ObjectStorage container with a missing data directory: ${dataPathArg}`);
+        }
+        const marker = await readServiceDataMarker(projectPath);
+        if (!markerProvesServiceDataDirectory(marker, projectPath, 'objectstorage')) {
+            // recordServiceDataDirectory rejects an invalid/foreign marker, so only an
+            // absent or valid mergeable claim is repaired from exact container labels.
+            await recordServiceDataDirectory(projectPath, 'objectstorage');
+        }
+    }
+    async assertNoLegacyMinioResources(dockerTimeoutArg) {
+        const projectPath = plugins.path.resolve(process.cwd());
+        const containers = this.config.getContainerNames();
+        const projects = await this.globalRegistry.getAllProjects();
+        const registryEntry = Object.entries(projects).find(([registeredPath]) => plugins.path.resolve(registeredPath) === projectPath)?.[1];
+        const candidateNames = new Set([containers.legacyMinio]);
+        if (registryEntry?.legacy?.minioContainer) {
+            candidateNames.add(registryEntry.legacy.minioContainer);
+        }
+        const existingContainers = [];
+        for (const candidateName of candidateNames) {
+            if (await this.discoverContainerIdByExactName(candidateName, dockerTimeoutArg)) {
+                existingContainers.push(candidateName);
+            }
+        }
+        const legacyDataPath = getLegacyMinioDataDirectory(projectPath);
+        const legacyDataExists = await plugins.smartfs.directory(legacyDataPath).exists();
+        if (existingContainers.length === 0 && !legacyDataExists) {
+            return;
+        }
+        const evidence = [
+            ...existingContainers.map((name) => `container ${name}`),
+            ...(legacyDataExists ? [`data directory ${legacyDataPath}`] : []),
+        ].join(', ');
+        throw new Error(`Legacy MinIO state blocks ObjectStorage startup: ${evidence}. ` +
+            'GitZone will not start, stop, remove, or reuse these resources because their disk layout is not compatible with SmartStorage. ' +
+            'Recovery: (1) export the required bucket data with your existing legacy tooling; ' +
+            '(2) stop and rename the legacy container and move .nogit/miniodata to a preserved backup location; ' +
+            '(3) run `gitzone services start s3`; ' +
+            '(4) import the backup with an external S3 client and verify every required object before disposing of the legacy backup.');
+    }
+    /** Read-only preflight used before restart or reconfigure may stop anything. */
+    async assertObjectStorageStartupAllowed() {
+        this.assertObjectStorageConfigurationSafe();
+        await this.assertNoLegacyMinioResources(() => ({ timeoutMs: 60_000 }));
+    }
+    assertObjectStorageConfigurationSafe() {
+        const config = this.config.getConfig();
         const bucketValidationError = getS3BucketNameValidationError(config.S3_BUCKET);
         if (bucketValidationError) {
             throw new Error(`Invalid S3_BUCKET in .nogit/env.json: ${bucketValidationError}. ` +
                 'Choose a valid custom bucket name or remove the field to regenerate the project default.');
         }
-        // Ensure data directory exists and is marked as tool-owned
-        const minioLabels = await this.prepareDataDirectory('minio', directories.minio);
-        const deadlineAt = this.minioClock.now() + minioReconciliationTimeoutMs;
+        this.config.assertObjectStorageCredentialsAreSafe();
+    }
+    async waitForObjectStorageReadiness(configArg, deadlineAtArg) {
+        while (true) {
+            const remaining = Math.floor(deadlineAtArg - this.objectStorageClock.now());
+            if (remaining <= 0) {
+                throw objectStorageStageError('management readiness', true);
+            }
+            const controller = new AbortController();
+            const probeTimeoutMs = Math.max(1, Math.min(objectStorageProbeTimeoutCapMs, remaining));
+            let probeTimedOut = false;
+            let timer;
+            const fetchPromise = this.fetchImplementation(`http://127.0.0.1:${configArg.S3_UI_PORT}/readyz`, { signal: controller.signal });
+            const timeoutPromise = new Promise((_resolve, reject) => {
+                timer = setTimeout(() => {
+                    probeTimedOut = true;
+                    controller.abort();
+                    reject(objectStorageStageError('management readiness', true));
+                }, probeTimeoutMs);
+            });
+            try {
+                const response = await Promise.race([fetchPromise, timeoutPromise]);
+                const ready = response.ok;
+                controller.abort();
+                if (response.body) {
+                    void response.body.cancel().catch(() => { });
+                }
+                if (ready) {
+                    return;
+                }
+            }
+            catch {
+                // Startup commonly refuses connections before the management listener binds.
+            }
+            finally {
+                if (timer) {
+                    clearTimeout(timer);
+                }
+                controller.abort();
+                if (probeTimedOut) {
+                    // A non-cooperative fetch may resolve after the timeout race. Consume
+                    // that late response as well so its body cannot retain a connection.
+                    void fetchPromise.then((responseArg) => {
+                        if (responseArg.body) {
+                            void responseArg.body.cancel().catch(() => { });
+                        }
+                    }, () => { });
+                }
+            }
+            const afterProbe = Math.floor(deadlineAtArg - this.objectStorageClock.now());
+            if (afterProbe <= 0) {
+                throw objectStorageStageError('management readiness', true);
+            }
+            await this.objectStorageClock.delay(Math.min(objectStorageProbeIntervalMs, afterProbe));
+        }
+    }
+    async createObjectStorageContainer(labelsArg, dockerTimeoutArg) {
+        const config = this.config.getConfig();
+        const containers = this.config.getContainerNames();
+        const directories = this.config.getDataDirectories();
+        const creationResult = await this.docker.createArgv({
+            name: containers.objectstorage,
+            image: objectStorageImage,
+            ports: {
+                [`127.0.0.1:${config.S3_PORT}`]: '9000',
+                [`127.0.0.1:${config.S3_UI_PORT}`]: '3000',
+            },
+            volumes: { [directories.objectstorage]: '/data' },
+            environment: {
+                OBJST_PORT: '9000',
+                UI_PORT: '3000',
+                OBJST_STORAGE_DIR: '/data',
+                OBJST_ACCESS_KEY: config.S3_ACCESSKEY,
+                OBJST_SECRET_KEY: config.S3_SECRETKEY,
+                OBJST_ADMIN_PASSWORD: config.S3_ADMIN_PASSWORD,
+                OBJST_REGION: config.S3_REGION,
+            },
+            labels: labelsArg,
+            restart: 'unless-stopped',
+        }, dockerTimeoutArg());
+        const containerId = creationResult.stdout.trim();
+        if (!/^[a-f0-9]{64}$/u.test(containerId)) {
+            throw new Error(`Docker returned an invalid id while creating ${containers.objectstorage}.`);
+        }
+        const inspection = await this.revalidateObjectStorageContainer(containerId, containers.objectstorage, labelsArg, dockerTimeoutArg);
+        if (inspection.running || inspection.status !== 'created') {
+            throw new Error(`ObjectStorage container ${containers.objectstorage} was not created stopped.`);
+        }
+        if (!this.objectStorageConfigurationMatches(inspection, labelsArg)) {
+            throw new Error(`ObjectStorage container ${containers.objectstorage} does not match the required runtime configuration.`);
+        }
+        return inspection;
+    }
+    /** Start or reconcile the canonical ObjectStorage service. */
+    async startObjectStorage() {
+        await withServiceDataOperationLock(process.cwd(), 'objectstorage', () => this.startObjectStorageLocked());
+    }
+    async startObjectStorageLocked() {
+        await this.config.reloadFromDisk();
+        await this.assertNoPendingDataDeletion('objectstorage');
+        await this.globalRegistry.touchProject(process.cwd());
+        logger.log('note', '📦 S3/ObjectStorage:');
+        const config = this.config.getConfig();
+        const containers = this.config.getContainerNames();
+        const directories = this.config.getDataDirectories();
+        this.assertObjectStorageConfigurationSafe();
+        const deadlineAt = this.objectStorageClock.now() + objectStorageReconciliationTimeoutMs;
         const dockerTimeout = () => {
-            const remaining = Math.floor(deadlineAt - this.minioClock.now());
+            const remaining = Math.floor(deadlineAt - this.objectStorageClock.now());
             if (remaining <= 0) {
-                throw new Error('MinIO container setup did not complete before the shared reconciliation deadline.');
+                throw objectStorageStageError('container setup', true);
             }
             return { timeoutMs: Math.max(1, remaining) };
         };
+        const expectedLabels = getServiceContainerLabels({
+            projectPath: process.cwd(),
+            service: 'objectstorage',
+            dataPath: directories.objectstorage,
+        });
         const startedContainerIds = [];
-        const startById = async (containerIdArg) => {
+        const startById = async (containerIdArg, ownedByInvocationArg) => {
             const executionOptions = dockerTimeout();
-            // Record ownership of the lifecycle before awaiting Docker: a timed-out
-            // start may still have reached the daemon and must be rolled back.
-            startedContainerIds.push(containerIdArg);
+            if (ownedByInvocationArg) {
+                startedContainerIds.push(containerIdArg);
+            }
             await this.docker.execArgv(['start', containerIdArg], executionOptions);
+            if (!ownedByInvocationArg) {
+                startedContainerIds.push(containerIdArg);
+            }
         };
         let outcome;
         try {
-            const listResult = await this.docker.execArgv([
-                'container',
-                'ls',
-                '-a',
-                '--filter',
-                `name=${containers.minio}`,
-                '--format',
-                '{{.Names}}',
-            ], dockerTimeout());
-            const containerExists = listResult.stdout
-                .split(/\r?\n/u)
-                .map((lineArg) => lineArg.trim())
-                .includes(containers.minio);
+            await this.assertNoLegacyMinioResources(dockerTimeout);
+            const existingId = await this.discoverContainerIdByExactName(containers.objectstorage, dockerTimeout);
             let initialInspection;
-            if (containerExists) {
-                initialInspection = await this.inspectMinioContainer(containers.minio, containers.minio, dockerTimeout);
-                // No existing container is started or receives an in-container command
-                // until it proves current or unambiguous legacy ownership.
-                await this.assertMinioOwnership(initialInspection, minioLabels, true);
+            if (existingId) {
+                initialInspection = await this.inspectObjectStorageContainer(existingId, containers.objectstorage, dockerTimeout);
+                this.assertObjectStorageOwnership(initialInspection, expectedLabels);
+                await this.repairObjectStorageMarkerFromOwnedContainer(directories.objectstorage);
             }
-            let needsRecreate = false;
-            let credentialsChanged = false;
-            if (initialInspection) {
-                const apiMatches = minioPortMatches(initialInspection.portBindings, '9000/tcp', config.S3_PORT);
-                const consoleMatches = minioPortMatches(initialInspection.portBindings, '9001/tcp', config.S3_CONSOLE_PORT);
-                const readExactEnvironmentValue = (nameArg) => {
-                    const prefix = `${nameArg}=`;
-                    const matches = initialInspection.environmentEntries.filter((entryArg) => entryArg.startsWith(prefix));
-                    return matches.length === 1 ? matches[0].slice(prefix.length) : undefined;
-                };
-                credentialsChanged =
-                    readExactEnvironmentValue('MINIO_ROOT_USER') !== config.S3_ACCESSKEY ||
-                        readExactEnvironmentValue('MINIO_ROOT_PASSWORD') !== config.S3_SECRETKEY;
-                needsRecreate = !apiMatches || !consoleMatches || credentialsChanged;
+            else {
+                await this.config.validateObjectStoragePorts();
             }
+            const needsRecreate = !!initialInspection &&
+                !this.objectStorageConfigurationMatches(initialInspection, expectedLabels);
             let activeInspection;
-            let activeAllowsLegacyRegistry;
-            if (initialInspection && needsRecreate) {
-                logger.log('note', credentialsChanged
-                    ? '  Credential configuration changed, recreating container...'
-                    : '  Port configuration changed, recreating container...');
-                await this.revalidateMinioContainer(initialInspection.id, containers.minio, minioLabels, true, dockerTimeout);
-                await this.docker.execArgv(['rm', '-f', initialInspection.id], dockerTimeout());
-                activeInspection = await this.createMinioContainer(minioLabels, dockerTimeout);
-                activeAllowsLegacyRegistry = false;
-                await startById(activeInspection.id);
-                outcome = 'Recreated with configured ports and reconciled';
+            if (!initialInspection || needsRecreate) {
+                const labels = await this.prepareObjectStorageDataDirectory(dockerTimeout);
+                if (initialInspection) {
+                    logger.log('note', '  Runtime configuration changed, recreating container...');
+                    await this.revalidateObjectStorageContainer(initialInspection.id, containers.objectstorage, expectedLabels, dockerTimeout);
+                    await this.docker.execArgv(['rm', '-f', initialInspection.id], dockerTimeout());
+                }
+                else {
+                    logger.log('note', '  Creating container...');
+                }
+                activeInspection = await this.createObjectStorageContainer(labels, dockerTimeout);
+                await startById(activeInspection.id, true);
+                outcome = initialInspection
+                    ? 'Recreated with canonical configuration and reconciled'
+                    : 'Created, started, and reconciled';
             }
-            else if (initialInspection && !initialInspection.running) {
+            else if (!initialInspection.running) {
                 logger.log('note', '  Starting existing container...');
                 activeInspection = initialInspection;
-                activeAllowsLegacyRegistry = true;
-                await startById(activeInspection.id);
+                await startById(activeInspection.id, false);
                 outcome = 'Started and reconciled';
             }
-            else if (!initialInspection) {
-                logger.log('note', '  Creating container...');
-                activeInspection = await this.createMinioContainer(minioLabels, dockerTimeout);
-                activeAllowsLegacyRegistry = false;
-                await startById(activeInspection.id);
-                outcome = 'Created, started, and reconciled';
-            }
             else {
                 logger.log('note', '  Already running; reconciling bucket...');
                 activeInspection = initialInspection;
-                activeAllowsLegacyRegistry = true;
                 outcome = 'Already running and reconciled';
             }
-            const reconciliationInspection = await this.revalidateMinioContainer(activeInspection.id, containers.minio, minioLabels, activeAllowsLegacyRegistry, dockerTimeout);
-            await reconcileMinioBucket({
-                docker: this.docker,
-                containerId: reconciliationInspection.id,
+            await this.revalidateObjectStorageContainer(activeInspection.id, containers.objectstorage, expectedLabels, dockerTimeout);
+            await this.waitForObjectStorageReadiness(config, deadlineAt);
+            await reconcileObjectStorageBucket({
+                smartBucket: this.smartBucketFactory(config),
                 bucket: config.S3_BUCKET,
                 deadlineAt,
-                clock: this.minioClock,
+                clock: this.objectStorageClock,
             });
+            const finalInspection = await this.revalidateObjectStorageContainer(activeInspection.id, containers.objectstorage, expectedLabels, dockerTimeout);
+            if (!finalInspection.running) {
+                throw new Error(`ObjectStorage container ${containers.objectstorage} stopped during reconciliation.`);
+            }
         }
         catch (error) {
-            const originalError = normalizeMinioLifecycleError(error);
+            const originalError = normalizeObjectStorageLifecycleError(error);
             const rollbackErrors = [];
             for (let index = startedContainerIds.length - 1; index >= 0; index--) {
                 try {
-                    await this.docker.execArgv(['stop', startedContainerIds[index]], {
-                        timeoutMs: minioRollbackTimeoutMs,
-                    });
+                    const rollbackInspection = await this.revalidateObjectStorageContainer(startedContainerIds[index], containers.objectstorage, expectedLabels, () => ({ timeoutMs: objectStorageRollbackTimeoutMs }));
+                    if (rollbackInspection.running) {
+                        await this.docker.execArgv(['stop', startedContainerIds[index]], {
+                            timeoutMs: objectStorageRollbackTimeoutMs,
+                        });
+                    }
                 }
                 catch (rollbackError) {
-                    rollbackErrors.push(normalizeMinioLifecycleError(rollbackError));
+                    rollbackErrors.push(normalizeObjectStorageLifecycleError(rollbackError));
                 }
             }
             if (rollbackErrors.length > 0) {
-                throw new AggregateError([originalError, ...rollbackErrors], 'MinIO startup failed and rollback could not stop every container started by this invocation.');
+                throw new AggregateError([originalError, ...rollbackErrors], 'ObjectStorage startup failed and rollback could not stop every container started by this invocation.');
             }
             throw originalError;
         }
         logger.log('ok', `  ${outcome} ✓`);
         logger.log('ok', `  Bucket '${config.S3_BUCKET}' exists and is authenticated ✓`);
-        logger.log('info', `  Container: ${containers.minio}`);
-        logger.log('info', `  Port: ${config.S3_PORT}`);
+        logger.log('info', `  Container: ${containers.objectstorage}`);
+        logger.log('info', `  S3 API: http://127.0.0.1:${config.S3_PORT}`);
         logger.log('info', `  Bucket: ${config.S3_BUCKET}`);
-        logger.log('info', `  API: http://${config.S3_HOST}:${config.S3_PORT}`);
-        logger.log('info', `  Console: http://${config.S3_HOST}:${config.S3_CONSOLE_PORT} (credentials: ***)`);
-    }
-    /** Create stopped MinIO, inspect its id, and prove exact current labels. */
-    async createMinioContainer(labelsArg, dockerTimeoutArg) {
-        const config = this.config.getConfig();
-        const containers = this.config.getContainerNames();
-        const directories = this.config.getDataDirectories();
-        const creationResult = await this.docker.createArgv({
-            name: containers.minio,
-            image: 'minio/minio',
-            ports: {
-                [config.S3_PORT]: '9000',
-                [config.S3_CONSOLE_PORT]: '9001',
-            },
-            volumes: {
-                [directories.minio]: '/data',
-            },
-            environment: {
-                MINIO_ROOT_USER: config.S3_ACCESSKEY,
-                MINIO_ROOT_PASSWORD: config.S3_SECRETKEY,
-            },
-            labels: labelsArg,
-            restart: 'unless-stopped',
-            command: ['server', '/data', '--console-address', ':9001'],
-        }, dockerTimeoutArg());
-        const containerId = creationResult.stdout.trim();
-        if (!/^[a-f0-9]{64}$/u.test(containerId)) {
-            throw new Error(`Docker returned an invalid id while creating ${containers.minio}.`);
-        }
-        const inspection = await this.inspectMinioContainer(containerId, containers.minio, dockerTimeoutArg);
-        if (inspection.id !== containerId) {
-            throw new Error(`Refusing to start MinIO container ${containers.minio}: ` +
-                'Docker inspection did not return the created immutable id.');
-        }
-        await this.assertMinioOwnership(inspection, labelsArg, false);
-        return inspection;
+        logger.log('info', `  Management UI: http://127.0.0.1:${config.S3_UI_PORT}`);
     }
     /**
      * Start Elasticsearch service
      */
     async startElasticsearch() {
+        await withServiceDataOperationLock(process.cwd(), 'elasticsearch', () => this.startElasticsearchLocked());
+    }
+    async startElasticsearchLocked() {
+        await this.config.reloadFromDisk();
+        await this.assertNoPendingDataDeletion('elasticsearch');
+        await this.globalRegistry.touchProject(process.cwd());
         logger.log('note', '📦 Elasticsearch:');
         const config = this.config.getConfig();
         const containers = this.config.getContainerNames();
@@ -959,6 +1332,10 @@ export class ServiceManager {
      * Stop MongoDB service
      */
     async stopMongoDB() {
+        await withServiceDataOperationLock(process.cwd(), 'mongodb', () => this.stopMongoDBLocked());
+    }
+    async stopMongoDBLocked() {
+        await this.config.reloadFromDisk();
         logger.log('note', '📦 MongoDB:');
         const containers = this.config.getContainerNames();
         const status = await this.docker.getStatus(containers.mongo);
@@ -974,29 +1351,42 @@ export class ServiceManager {
             logger.log('note', '  Not running');
         }
     }
-    /**
-     * Stop MinIO service
-     */
-    async stopMinIO() {
-        logger.log('note', '📦 S3/MinIO:');
+    /** Stop only an exactly owned canonical ObjectStorage container. */
+    async stopObjectStorage() {
+        await withServiceDataOperationLock(process.cwd(), 'objectstorage', () => this.stopObjectStorageLocked());
+    }
+    async stopObjectStorageLocked() {
+        await this.config.reloadFromDisk();
+        logger.log('note', '📦 S3/ObjectStorage:');
         const containers = this.config.getContainerNames();
-        const status = await this.docker.getStatus(containers.minio);
-        if (status === 'running') {
-            if (await this.docker.stop(containers.minio)) {
-                logger.log('ok', '  Stopped ✓');
-            }
-            else {
-                logger.log('error', '  Failed to stop');
-            }
+        const directories = this.config.getDataDirectories();
+        const labels = getServiceContainerLabels({
+            projectPath: process.cwd(),
+            service: 'objectstorage',
+            dataPath: directories.objectstorage,
+        });
+        const timeout = () => ({ timeoutMs: 60_000 });
+        const id = await this.discoverContainerIdByExactName(containers.objectstorage, timeout);
+        if (!id) {
+            logger.log('note', '  Not running');
+            return;
         }
-        else {
+        const inspection = await this.revalidateObjectStorageContainer(id, containers.objectstorage, labels, timeout);
+        if (!inspection.running) {
             logger.log('note', '  Not running');
+            return;
         }
+        await this.docker.execArgv(['stop', inspection.id], timeout());
+        logger.log('ok', '  Stopped ✓');
     }
     /**
      * Stop Elasticsearch service
      */
     async stopElasticsearch() {
+        await withServiceDataOperationLock(process.cwd(), 'elasticsearch', () => this.stopElasticsearchLocked());
+    }
+    async stopElasticsearchLocked() {
+        await this.config.reloadFromDisk();
         logger.log('note', '📦 Elasticsearch:');
         const containers = this.config.getContainerNames();
         const status = await this.docker.getStatus(containers.elasticsearch);
@@ -1041,16 +1431,62 @@ export class ServiceManager {
         const mongo = await describe('mongodb', containers.mongo, directories.mongo, config.MONGODB_PORT, this.config.getMongoConnectionString());
         mongo.authEnabled = this.config.isMongoAuthEnabled();
         mongo.authSource = this.config.getMongoAuthSource();
-        const minio = await describe('minio', containers.minio, directories.minio, config.S3_PORT, `http://${config.S3_HOST}:${config.S3_PORT}`);
+        const objectStorageDataExists = await plugins.smartfs.directory(directories.objectstorage).exists();
+        const objectStorageLabels = getServiceContainerLabels({
+            projectPath: process.cwd(),
+            service: 'objectstorage',
+            dataPath: directories.objectstorage,
+        });
+        const objectStorageId = await this.discoverContainerIdByExactName(containers.objectstorage, () => ({ timeoutMs: 60_000 }));
+        let objectStorageStatus = 'not_exists';
+        let objectStorageOwnership = 'absent';
+        if (objectStorageId) {
+            const inspection = await this.inspectObjectStorageIdentity(objectStorageId, containers.objectstorage, () => ({ timeoutMs: 60_000 }));
+            objectStorageStatus = inspection.running ? 'running' : 'stopped';
+            objectStorageOwnership = hasExactServiceContainerLabels(inspection.labels, objectStorageLabels)
+                ? 'owned'
+                : 'conflict';
+        }
+        const objectstorage = {
+            service: 'objectstorage',
+            enabled: this.isServiceEnabled('objectstorage'),
+            container: containers.objectstorage,
+            status: objectStorageStatus,
+            port: config.S3_PORT,
+            connectionString: `http://127.0.0.1:${config.S3_PORT}`,
+            managementUi: `http://127.0.0.1:${config.S3_UI_PORT}`,
+            dataDirectory: directories.objectstorage,
+            dataSizeBytes: objectStorageDataExists
+                ? await helpers.getDirectorySize(directories.objectstorage)
+                : 0,
+            portAvailable: objectStorageStatus === 'not_exists'
+                ? await helpers.isPortAvailable(parseInt(config.S3_PORT))
+                : null,
+            ownership: objectStorageOwnership,
+        };
         const elasticsearch = await describe('elasticsearch', containers.elasticsearch, directories.elasticsearch, config.ELASTICSEARCH_PORT, config.ELASTICSEARCH_URL);
+        const projectPath = plugins.path.resolve(process.cwd());
+        const registryProjects = await this.globalRegistry.getAllProjects();
+        const registryProject = Object.entries(registryProjects).find(([registeredPath]) => plugins.path.resolve(registeredPath) === projectPath)?.[1];
+        const legacyDataDirectory = getLegacyMinioDataDirectory(projectPath);
+        const legacyContainerExists = await this.discoverContainerIdByExactName(containers.legacyMinio, () => ({ timeoutMs: 60_000 }));
         return {
             project: {
                 name: config.PROJECT_NAME,
                 path: process.cwd(),
                 enabledServices: this.enabledServices || [],
             },
-            services: { mongodb: mongo, minio, elasticsearch },
-            totalDataBytes: mongo.dataSizeBytes + minio.dataSizeBytes + elasticsearch.dataSizeBytes,
+            services: { mongodb: mongo, objectstorage, elasticsearch },
+            legacy: {
+                ...(registryProject?.legacy?.minioContainer
+                    ? { minioContainer: registryProject.legacy.minioContainer }
+                    : legacyContainerExists
+                        ? { minioContainer: containers.legacyMinio }
+                        : {}),
+                minioDataDirectory: legacyDataDirectory,
+                minioDataExists: await plugins.smartfs.directory(legacyDataDirectory).exists(),
+            },
+            totalDataBytes: mongo.dataSizeBytes + objectstorage.dataSizeBytes + elasticsearch.dataSizeBytes,
         };
     }
     /**
@@ -1060,6 +1496,7 @@ export class ServiceManager {
         helpers.printHeader('Service Status');
         const config = this.config.getConfig();
         const containers = this.config.getContainerNames();
+        const structuredStatus = await this.collectStatus();
         logger.log('info', `Project: ${config.PROJECT_NAME}`);
         console.log();
         // MongoDB status
@@ -1096,48 +1533,56 @@ export class ServiceManager {
                 }
                 break;
         }
-        // MinIO status
-        const minioStatus = await this.docker.getStatus(containers.minio);
-        switch (minioStatus) {
-            case 'running':
-                logger.log('ok', '📦 S3/MinIO: 🟢 Running');
-                logger.log('info', `   ├─ Container: ${containers.minio}`);
-                logger.log('info', `   ├─ API: http://${config.S3_HOST}:${config.S3_PORT}`);
-                logger.log('info', `   ├─ Console: http://${config.S3_HOST}:${config.S3_CONSOLE_PORT}`);
-                logger.log('info', `   └─ Bucket: ${config.S3_BUCKET}`);
-                break;
-            case 'stopped':
-                logger.log('note', '📦 S3/MinIO: 🟡 Stopped');
-                logger.log('info', `   ├─ Container: ${containers.minio}`);
-                logger.log('info', `   ├─ API Port: ${config.S3_PORT}`);
-                logger.log('info', `   └─ Console Port: ${config.S3_CONSOLE_PORT}`);
-                break;
-            case 'not_exists':
-                logger.log('info', '📦 S3/MinIO: ⚪ Not installed');
-                // Check port availability
-                const s3Port = parseInt(config.S3_PORT);
-                const s3ConsolePort = parseInt(config.S3_CONSOLE_PORT);
-                const s3Available = await helpers.isPortAvailable(s3Port);
-                const consoleAvailable = await helpers.isPortAvailable(s3ConsolePort);
-                if (!s3Available || !consoleAvailable) {
-                    if (!s3Available) {
-                        logger.log('error', `   ├─ ⚠️  API Port ${s3Port} is in use`);
+        // ObjectStorage status
+        const objectstorage = structuredStatus.services.objectstorage;
+        if (objectstorage.ownership === 'conflict') {
+            logger.log('error', `📦 S3/ObjectStorage: ownership conflict for ${objectstorage.container}; refusing to treat it as managed`);
+        }
+        else
+            switch (objectstorage.status) {
+                case 'running':
+                    logger.log('ok', '📦 S3/ObjectStorage: 🟢 Running');
+                    logger.log('info', `   ├─ Container: ${containers.objectstorage}`);
+                    logger.log('info', `   ├─ API: http://127.0.0.1:${config.S3_PORT}`);
+                    logger.log('info', `   ├─ Management UI: http://127.0.0.1:${config.S3_UI_PORT}`);
+                    logger.log('info', `   └─ Bucket: ${config.S3_BUCKET}`);
+                    break;
+                case 'stopped':
+                    logger.log('note', '📦 S3/ObjectStorage: 🟡 Stopped');
+                    logger.log('info', `   ├─ Container: ${containers.objectstorage}`);
+                    logger.log('info', `   ├─ API Port: ${config.S3_PORT}`);
+                    logger.log('info', `   └─ Management UI Port: ${config.S3_UI_PORT}`);
+                    break;
+                case 'not_exists':
+                    logger.log('info', '📦 S3/ObjectStorage: ⚪ Not installed');
+                    // Check port availability
+                    const s3Port = parseInt(config.S3_PORT);
+                    const s3UiPort = parseInt(config.S3_UI_PORT);
+                    const s3Available = await helpers.isPortAvailable(s3Port);
+                    const uiAvailable = await helpers.isPortAvailable(s3UiPort);
+                    if (!s3Available || !uiAvailable) {
+                        if (!s3Available) {
+                            logger.log('error', `   ├─ ⚠️  API Port ${s3Port} is in use`);
+                        }
+                        else {
+                            logger.log('info', `   ├─ API Port ${s3Port} is available`);
+                        }
+                        if (!uiAvailable) {
+                            logger.log('error', `   └─ ⚠️  Management UI Port ${s3UiPort} is in use`);
+                        }
+                        else {
+                            logger.log('info', `   └─ Management UI Port ${s3UiPort} is available`);
+                        }
                     }
                     else {
                         logger.log('info', `   ├─ API Port ${s3Port} is available`);
+                        logger.log('info', `   └─ Management UI Port ${s3UiPort} is available`);
                     }
-                    if (!consoleAvailable) {
-                        logger.log('error', `   └─ ⚠️  Console Port ${s3ConsolePort} is in use`);
-                    }
-                    else {
-                        logger.log('info', `   └─ Console Port ${s3ConsolePort} is available`);
-                    }
-                }
-                else {
-                    logger.log('info', `   ├─ API Port ${s3Port} is available`);
-                    logger.log('info', `   └─ Console Port ${s3ConsolePort} is available`);
-                }
-                break;
+                    break;
+            }
+        if (structuredStatus.legacy.minioContainer ||
+            structuredStatus.legacy.minioDataExists) {
+            logger.log('note', '   Legacy MinIO resources are preserved and block automatic ObjectStorage startup; run `gitzone services start s3` for exact migration instructions.');
         }
         // Elasticsearch status
         const esStatus = await this.docker.getStatus(containers.elasticsearch);
@@ -1179,7 +1624,7 @@ export class ServiceManager {
         const directories = this.config.getDataDirectories();
         const entries = [
             { label: 'MongoDB', path: directories.mongo },
-            { label: 'S3/MinIO', path: directories.minio },
+            { label: 'S3/ObjectStorage', path: directories.objectstorage },
             { label: 'Elasticsearch', path: directories.elasticsearch },
         ];
         console.log();
@@ -1193,11 +1638,20 @@ export class ServiceManager {
             total += size;
             logger.log('info', `  ${entry.label}: ${helpers.formatBytes(size)}  (${entry.path})`);
         }
+        const legacyDataPath = getLegacyMinioDataDirectory(process.cwd());
+        const legacyDataExists = await plugins.smartfs.directory(legacyDataPath).exists();
         if (total === 0) {
-            logger.log('info', '  No service data directories present');
+            logger.log('info', '  No canonical service data directories present');
+        }
+        else {
+            logger.log('info', `  Total: ${helpers.formatBytes(total)}`);
+        }
+        if (legacyDataExists) {
+            logger.log('note', `  Legacy MinIO data is preserved and excluded from cleanup: ${legacyDataPath}`);
+        }
+        if (total === 0 && !legacyDataExists) {
             return;
         }
-        logger.log('info', `  Total: ${helpers.formatBytes(total)}`);
         logger.log('note', '  Remove containers but keep data: `gitzone services remove`; remove data too: `gitzone services clean`');
     }
     /**
@@ -1217,18 +1671,20 @@ export class ServiceManager {
         logger.log('info', `  Data: ${this.config.getDataDirectories().mongo}`);
         logger.log('info', `  Connection: ${this.config.getMongoConnectionString()}`);
         console.log();
-        logger.log('note', 'S3/MinIO:');
+        logger.log('note', 'S3/ObjectStorage:');
         logger.log('info', `  Host: ${config.S3_HOST}`);
         logger.log('info', `  API Port: ${config.S3_PORT}`);
-        logger.log('info', `  Console Port: ${config.S3_CONSOLE_PORT}`);
+        logger.log('info', `  Management UI Port: ${config.S3_UI_PORT}`);
         logger.log('info', '  Access Key: ***');
         logger.log('info', '  Secret Key: ***');
+        logger.log('info', '  Admin Password: ***');
         logger.log('info', `  Bucket: ${config.S3_BUCKET}`);
         logger.log('info', `  Use SSL: ${config.S3_USESSL}`);
-        logger.log('info', `  Container: ${this.config.getContainerNames().minio}`);
-        logger.log('info', `  Data: ${this.config.getDataDirectories().minio}`);
+        logger.log('info', `  Region: ${config.S3_REGION}`);
+        logger.log('info', `  Container: ${this.config.getContainerNames().objectstorage}`);
+        logger.log('info', `  Data: ${this.config.getDataDirectories().objectstorage}`);
         logger.log('info', `  Endpoint: ${config.S3_ENDPOINT}`);
-        logger.log('info', `  Console URL: http://${config.S3_HOST}:${config.S3_CONSOLE_PORT}`);
+        logger.log('info', `  Management UI: http://127.0.0.1:${config.S3_UI_PORT}`);
         console.log();
         logger.log('note', 'Elasticsearch:');
         logger.log('info', `  Host: ${config.ELASTICSEARCH_HOST}:${config.ELASTICSEARCH_PORT}`);
@@ -1278,15 +1734,35 @@ export class ServiceManager {
                     logger.log('note', 'MongoDB container is not running');
                 }
                 break;
-            case 'minio':
+            case 'objectstorage':
             case 's3':
-                if (await this.docker.isRunning(containers.minio)) {
-                    helpers.printHeader(`S3/MinIO Logs (last ${lines} lines)`);
-                    const logs = await this.docker.logs(containers.minio, lines);
-                    console.log(logs);
-                }
-                else {
-                    logger.log('note', 'S3/MinIO container is not running');
+                {
+                    const directories = this.config.getDataDirectories();
+                    const labels = getServiceContainerLabels({
+                        projectPath: process.cwd(),
+                        service: 'objectstorage',
+                        dataPath: directories.objectstorage,
+                    });
+                    const timeout = () => ({ timeoutMs: 60_000 });
+                    const id = await this.discoverContainerIdByExactName(containers.objectstorage, timeout);
+                    if (!id) {
+                        logger.log('note', 'S3/ObjectStorage container does not exist');
+                        break;
+                    }
+                    await this.revalidateObjectStorageContainer(id, containers.objectstorage, labels, timeout);
+                    helpers.printHeader(`S3/ObjectStorage Logs (last ${lines} lines)`);
+                    const result = await this.docker.execArgv(['logs', '--tail', String(lines), id], timeout());
+                    const config = this.config.getConfig();
+                    let output = `${result.stdout}${result.stderr}`;
+                    const secrets = Array.from(new Set([
+                        config.S3_ACCESSKEY,
+                        config.S3_SECRETKEY,
+                        config.S3_ADMIN_PASSWORD,
+                    ].filter(Boolean))).sort((secretA, secretB) => secretB.length - secretA.length);
+                    for (const secret of secrets) {
+                        output = output.split(secret).join('***');
+                    }
+                    console.log(output);
                 }
                 break;
             case 'elasticsearch':
@@ -1304,7 +1780,7 @@ export class ServiceManager {
             case '':
                 await this.showLogs('mongo', lines);
                 console.log();
-                await this.showLogs('minio', lines);
+                await this.showLogs('objectstorage', lines);
                 console.log();
                 await this.showLogs('elasticsearch', lines);
                 break;
@@ -1317,36 +1793,132 @@ export class ServiceManager {
      * Remove containers
      */
     async removeContainers() {
+        await this.withProjectServiceLocks(process.cwd(), () => this.removeContainersLocked());
+    }
+    async removeContainersLocked() {
+        await this.config.reloadFromDisk();
         const containers = this.config.getContainerNames();
-        let removed = false;
-        if (await this.docker.exists(containers.mongo)) {
-            if (await this.docker.remove(containers.mongo, true)) {
-                logger.log('ok', '  MongoDB container removed ✓');
-                removed = true;
+        const directories = this.config.getDataDirectories();
+        const projectPath = plugins.path.resolve(process.cwd());
+        const registryProjects = await this.globalRegistry.getAllProjects();
+        const registryProject = Object.entries(registryProjects).find(([registeredPathArg]) => plugins.path.resolve(registeredPathArg) === projectPath)?.[1];
+        const targets = new Map();
+        const addTarget = (serviceArg, nameArg, registeredArg) => {
+            if (!nameArg)
+                return;
+            const existing = targets.get(nameArg);
+            if (existing && existing.service !== serviceArg) {
+                throw new Error(`Refusing ambiguous service container name: ${nameArg}`);
             }
-        }
-        if (await this.docker.exists(containers.minio)) {
-            if (await this.docker.remove(containers.minio, true)) {
-                logger.log('ok', '  S3/MinIO container removed ✓');
-                removed = true;
+            targets.set(nameArg, {
+                service: serviceArg,
+                name: nameArg,
+                registered: registeredArg || existing?.registered === true,
+            });
+        };
+        addTarget('mongodb', containers.mongo, false);
+        addTarget('objectstorage', containers.objectstorage, false);
+        addTarget('elasticsearch', containers.elasticsearch, false);
+        addTarget('mongodb', registryProject?.containers.mongo, true);
+        addTarget('objectstorage', registryProject?.containers.objectstorage, true);
+        addTarget('elasticsearch', registryProject?.containers.elasticsearch, true);
+        const plannedRemovals = [];
+        for (const target of targets.values()) {
+            const id = await this.discoverContainerIdByExactName(target.name, () => ({ timeoutMs: 60_000 }));
+            if (!id)
+                continue;
+            const inspections = await this.docker.inspectMany([id]);
+            const inspection = inspections[0];
+            if (!inspection || inspection.id !== id || inspection.name !== target.name) {
+                throw new Error(`Refusing ambiguous service container identity: ${target.name}`);
             }
-        }
-        if (await this.docker.exists(containers.elasticsearch)) {
-            if (await this.docker.remove(containers.elasticsearch, true)) {
-                logger.log('ok', '  Elasticsearch container removed ✓');
-                removed = true;
+            const expectedLabels = getServiceContainerLabels({
+                projectPath,
+                service: target.service,
+                dataPath: target.service === 'mongodb'
+                    ? directories.mongo
+                    : target.service === 'objectstorage'
+                        ? directories.objectstorage
+                        : directories.elasticsearch,
+            });
+            const labelOwned = hasExactServiceContainerLabels(inspection.labels, expectedLabels);
+            const hasGitZoneLabels = Object.keys(inspection.labels).some((keyArg) => keyArg.startsWith('git.zone.'));
+            const registryClaims = Object.entries(registryProjects).flatMap(([registeredPathArg, projectArg]) => {
+                const claims = [];
+                if (projectArg.containers.mongo === target.name) {
+                    claims.push({ projectPath: plugins.path.resolve(registeredPathArg), service: 'mongodb' });
+                }
+                if (projectArg.containers.objectstorage === target.name) {
+                    claims.push({
+                        projectPath: plugins.path.resolve(registeredPathArg),
+                        service: 'objectstorage',
+                    });
+                }
+                if (projectArg.containers.elasticsearch === target.name) {
+                    claims.push({
+                        projectPath: plugins.path.resolve(registeredPathArg),
+                        service: 'elasticsearch',
+                    });
+                }
+                return claims;
+            });
+            const registryOwned = !hasGitZoneLabels &&
+                target.registered &&
+                target.service !== 'objectstorage' &&
+                registryClaims.length === 1 &&
+                registryClaims[0].projectPath === projectPath &&
+                registryClaims[0].service === target.service;
+            if (!labelOwned && !registryOwned) {
+                throw new Error(`Refusing to remove container with unproven ownership: ${target.name}`);
             }
-        }
-        if (!removed) {
+            plannedRemovals.push({ service: target.service, name: target.name, inspection });
+        }
+        if (plannedRemovals.some((removalArg) => removalArg.service === 'objectstorage') &&
+            (await plugins.smartfs.directory(directories.objectstorage).exists())) {
+            await this.repairObjectStorageMarkerFromOwnedContainer(directories.objectstorage);
+        }
+        for (const removal of plannedRemovals) {
+            await this.docker.execArgv(['rm', '-f', removal.inspection.id], { timeoutMs: 60_000 });
+            const label = removal.service === 'mongodb'
+                ? 'MongoDB'
+                : removal.service === 'objectstorage'
+                    ? 'S3/ObjectStorage'
+                    : 'Elasticsearch';
+            logger.log('ok', `  ${label} container removed ✓`);
+        }
+        if (plannedRemovals.length === 0) {
             logger.log('note', '  No containers to remove');
         }
-        // Check if all containers are gone, then unregister from global registry
-        const mongoExists = await this.docker.exists(containers.mongo);
-        const minioExists = await this.docker.exists(containers.minio);
-        const esExists = await this.docker.exists(containers.elasticsearch);
-        if (!mongoExists && !minioExists && !esExists) {
-            await this.globalRegistry.unregisterProject(process.cwd());
+        // Re-read and prove every current claim absent while all service locks are
+        // still held. A concurrent internal start cannot appear between this check
+        // and the compare-delete registry transaction.
+        const currentProjects = await this.globalRegistry.getAllProjects();
+        const currentProject = Object.entries(currentProjects).find(([registeredPathArg]) => plugins.path.resolve(registeredPathArg) === projectPath)?.[1];
+        const legacyDataExists = await plugins.smartfs.directory(getLegacyMinioDataDirectory(projectPath)).exists();
+        if (currentProject && !currentProject.legacy?.minioContainer && !legacyDataExists) {
+            const labeledIds = await this.docker.listIds([
+                `label=git.zone.project-path=${projectPath}`,
+            ]);
+            let registeredContainerExists = labeledIds.length > 0;
+            for (const containerName of Object.values(currentProject.containers)) {
+                if (!containerName)
+                    continue;
+                if (await this.discoverContainerIdByExactName(containerName, () => ({ timeoutMs: 60_000 }))) {
+                    registeredContainerExists = true;
+                    break;
+                }
+            }
+            if (!registeredContainerExists) {
+                await this.globalRegistry.unregisterProject(process.cwd(), currentProject);
+            }
+        }
+    }
+    async withProjectServiceLocks(projectPathArg, actionArg, serviceIndexArg = 0) {
+        const service = serviceNames[serviceIndexArg];
+        if (!service) {
+            return actionArg();
         }
+        return withServiceDataOperationLock(projectPathArg, service, () => this.withProjectServiceLocks(projectPathArg, actionArg, serviceIndexArg + 1));
     }
     /**
      * Clean data directories
@@ -1355,23 +1927,28 @@ export class ServiceManager {
         const directories = this.config.getDataDirectories();
         const targets = [
             { label: 'MongoDB', service: 'mongodb', path: directories.mongo },
-            { label: 'S3/MinIO', service: 'minio', path: directories.minio },
+            { label: 'S3/ObjectStorage', service: 'objectstorage', path: directories.objectstorage },
             { label: 'Elasticsearch', service: 'elasticsearch', path: directories.elasticsearch },
         ];
         let cleaned = false;
         for (const target of targets) {
-            if (!(await plugins.smartfs.directory(target.path).exists())) {
+            const removed = await this.docker.removeDataDirectory(target.path, serviceImages[target.service], {
+                projectPath: process.cwd(),
+                service: target.service,
+            });
+            if (!removed) {
                 continue;
             }
-            // Escalates to a privileged one-off container when needed; throws rather
-            // than leaving a partially deleted (and for MongoDB, corrupt) directory.
-            await this.docker.removeDataDirectory(target.path, serviceImages[target.service]);
             logger.log('ok', `  ${target.label} data removed ✓`);
             cleaned = true;
         }
         if (!cleaned) {
             logger.log('note', '  No data to clean');
         }
+        const legacyDataPath = getLegacyMinioDataDirectory(process.cwd());
+        if (await plugins.smartfs.directory(legacyDataPath).exists()) {
+            logger.log('note', `  Legacy MinIO data was preserved and not modified: ${legacyDataPath}`);
+        }
     }
     /**
      * Configure which services are enabled
@@ -1379,7 +1956,7 @@ export class ServiceManager {
     async configureServices() {
         logger.log('note', 'Select which services to enable for this project:');
         console.log();
-        const currentServices = this.enabledServices || ['mongodb', 'minio', 'elasticsearch'];
+        const currentServices = this.enabledServices || ['mongodb', 'objectstorage', 'elasticsearch'];
         const smartinteract = new plugins.smartinteract.SmartInteract();
         const response = await smartinteract.askQuestion({
             name: 'services',
@@ -1387,12 +1964,12 @@ export class ServiceManager {
             message: 'Which services do you want to enable?',
             choices: [
                 { name: 'MongoDB', value: 'mongodb' },
-                { name: 'MinIO (S3)', value: 'minio' },
+                { name: 'ObjectStorage (S3)', value: 'objectstorage' },
                 { name: 'Elasticsearch', value: 'elasticsearch' }
             ],
             default: currentServices
         });
-        const enabledServices = response.value || ['mongodb', 'minio', 'elasticsearch'];
+        const enabledServices = response.value || ['mongodb', 'objectstorage', 'elasticsearch'];
         this.enabledServices = enabledServices;
         // Save to .smartconfig.json
         await this.saveServiceConfiguration(enabledServices);
@@ -1403,24 +1980,9 @@ export class ServiceManager {
      */
     async reconfigure() {
         helpers.printHeader('Reconfiguring Services');
-        const containers = this.config.getContainerNames();
-        // Stop existing containers
-        logger.log('note', '🛑 Stopping existing containers...');
-        if (await this.docker.exists(containers.mongo)) {
-            await this.docker.stop(containers.mongo);
-            logger.log('ok', '  MongoDB stopped ✓');
-        }
-        if (await this.docker.exists(containers.minio)) {
-            await this.docker.stop(containers.minio);
-            logger.log('ok', '  S3/MinIO stopped ✓');
-        }
-        if (await this.docker.exists(containers.elasticsearch)) {
-            await this.docker.stop(containers.elasticsearch);
-            logger.log('ok', '  Elasticsearch stopped ✓');
-        }
-        // Reconfigure ports
-        await this.config.reconfigurePorts();
-        // Ask if user wants to restart services
+        await this.withProjectServiceLocks(process.cwd(), () => this.reconfigureLocked());
+        // Ask if user wants to restart services after releasing the reconfiguration
+        // locks; startAll acquires the same locks one service at a time.
         const smartinteract = new plugins.smartinteract.SmartInteract();
         const response = await smartinteract.askQuestion({
             name: 'restart',
@@ -1431,7 +1993,19 @@ export class ServiceManager {
         if (response.value) {
             console.log();
             await this.startAll();
+            await this.registerWithGlobalRegistry();
         }
     }
+    async reconfigureLocked() {
+        await this.config.reloadFromDisk();
+        await this.assertNoLegacyMinioResources(() => ({ timeoutMs: 60_000 }));
+        // Stop existing containers
+        logger.log('note', '🛑 Stopping existing containers...');
+        await this.stopMongoDBLocked();
+        await this.stopObjectStorageLocked();
+        await this.stopElasticsearchLocked();
+        // Reconfigure ports
+        await this.config.reconfigurePorts();
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.servicemanager.js","sourceRoot":"","sources":["../../ts/mod_services/classes.servicemanager.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.servicemanager.js","sourceRoot":"","sources":["../../../ts/mod_services/classes.servicemanager.ts"],"names":[],"mappings":"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"}