@iducky/media-agent 1.1.0 → 1.1.1

package/src/media_agent/platforms/douyin/douyin_publish.py

@@ -29,7 +29,6 @@ from pathlib import Path
 
 # ─── Paths ───────────────────────────────────────────────────────────────────
 BASE = runtime_home()
-DEFAULT_PROFILE_ID = 'douyin_creator_mengjun_ecommerce'
 LOCKS_DIR = BASE / 'locks'
 LEDGER_DIR = BASE / 'tasks' / 'douyin_publish'
 LEDGER_FILE = LEDGER_DIR / 'publish-ledger.jsonl'
@@ -58,11 +57,11 @@ def _close_file(profile_id):
 
 
 # ─── Constants ───────────────────────────────────────────────────────────────
-DEDUP_STATES = {'submitted', 'scheduled', 'reviewing', 'published'}
+DEDUP_STATES = {'submitted', 'scheduled', 'reviewing', 'published', 'indeterminate', 'confirming'}
 SUPPORTED_VIDEO_FORMATS = {'.mp4', '.mov', '.avi', '.wmv', '.flv', '.mkv', '.webm', '.m4v', '.3gp'}
 SUPPORTED_IMAGE_FORMATS = {'.jpg', '.jpeg', '.png', '.webp', '.bmp', '.gif'}
-SUPPORTED_FORMATS = SUPPORTED_VIDEO_FORMATS | SUPPORTED_IMAGE_FORMATS
-DEFAULT_SCHEDULED_AT = '2026-08-04T23:50:00+08:00'
+SUPPORTED_FORMATS = SUPPORTED_VIDEO_FORMATS
+DEFAULT_SCHEDULED_AT = None
 TZ_SHANGHAI = timezone(timedelta(hours=8))
 
 
@@ -82,7 +81,6 @@ def sha256_file(path):
 
 def load_ledger():
     """Load all ledger entries as a list of dicts."""
-    LEDGER_DIR.mkdir(parents=True, exist_ok=True)
     if not LEDGER_FILE.exists():
         return []
     entries = []
@@ -92,7 +90,7 @@ def load_ledger():
             try:
                 entries.append(json.loads(line))
             except json.JSONDecodeError:
-                pass
+                die(1, _kwargs(error='INVALID_LEDGER', path=str(LEDGER_FILE)))
     return entries
 
 
@@ -107,10 +105,11 @@ def find_ledger_entry(sha256):
 
 def check_duplicate(sha256):
     """Return (is_blocked, existing_entry) — True if SHA-256 is in a terminal dedup state."""
-    entry = find_ledger_entry(sha256)
-    if entry and entry.get('state') in DEDUP_STATES:
-        return True, entry
-    return False, entry
+    matching = [e for e in load_ledger() if e.get('sha256') == sha256]
+    for entry in reversed(matching):
+        if entry.get('state') in DEDUP_STATES:
+            return True, entry
+    return False, matching[-1] if matching else None
 
 
 def append_ledger(entry):
@@ -120,31 +119,24 @@ def append_ledger(entry):
         f.write(json.dumps(entry, ensure_ascii=False) + '\n')
 
 
+_owned_locks = {}
+
+
 def acquire_lock(profile_id, task_id):
-    """Acquire the profile lock. Returns (ok, existing_owner)."""
-    lf = _lock_file(profile_id)
-    LOCKS_DIR.mkdir(parents=True, exist_ok=True)
-    if lf.exists():
-        try:
-            old = json.loads(lf.read_text())
-            os.kill(old.get('pid', 0), 0)
-            return False, old
-        except (OSError, json.JSONDecodeError):
-            lf.unlink()
-    lf.write_text(json.dumps({
-        'task_id': task_id,
-        'pid': os.getpid(),
-        'time': datetime.now().isoformat(),
-        'phase': 'publish',
-    }, indent=2))
-    return True, None
+    from media_agent.runtime.locking import acquire
+    def initialize():
+        for signal_file in (_confirm_file(profile_id), _close_file(profile_id)):
+            signal_file.unlink(missing_ok=True)
+    ok = acquire(_lock_file(profile_id), task_id, initialize=initialize, phase='publish')
+    if ok:
+        _owned_locks[profile_id] = task_id
+    return ok, None
 
 
 def release_lock(profile_id):
-    """Release the profile lock."""
-    lf = _lock_file(profile_id)
-    if lf.exists():
-        lf.unlink(missing_ok=True)
+    from media_agent.runtime.locking import release
+    task_id = _owned_locks.get(profile_id)
+    return release(_lock_file(profile_id), task_id) if task_id else False
 
 
 def now_iso():
@@ -608,6 +600,7 @@ def phase_prepare(profile_id, media_path, scheduled_at, title=None, description=
     if not ok:
         die(3, _kwargs(phase='prepare', error='PROFILE_LOCKED', owner=owner))
 
+    confirmation_used = False
     log(_kwargs(phase='prepare', step='launch_browser', task_id=task_id))
 
     try:
@@ -702,9 +695,6 @@ def phase_prepare(profile_id, media_path, scheduled_at, title=None, description=
         SIGNAL_DIR.mkdir(parents=True, exist_ok=True)
         cf = _confirm_file(profile_id)
         clf = _close_file(profile_id)
-        for f in [cf, clf]:
-            if f.exists():
-                f.unlink(missing_ok=True)
 
         log(_kwargs(
             phase='prepare', step='awaiting_confirm', task_id=task_id,
@@ -713,32 +703,26 @@ def phase_prepare(profile_id, media_path, scheduled_at, title=None, description=
 
         while True:
             if cf.exists():
-                cf.unlink(missing_ok=True)
+                from media_agent.runtime.publish_control import consume_confirmation
+                valid = consume_confirmation(cf, profile_id, task_id, sha)
+                if not valid or confirmation_used:
+                    log(_kwargs(step='confirmation_rejected', task_id=task_id))
+                    continue
+                confirmation_used = True
+                ledger_entry['state'] = 'confirming'
+                append_ledger(ledger_entry)
                 log(_kwargs(phase='prepare', step='confirm_received'))
 
-                clicked = page.evaluate('''() => {
-                    for (const el of document.querySelectorAll('button')) {
-                        const text = (el.textContent || '').trim();
-                        if (text === '发布' && el.offsetParent !== null) {
-                            // Dispatch full mouse event sequence for React button
-                            el.dispatchEvent(new MouseEvent('mousedown', {bubbles: true, cancelable: true}));
-                            el.dispatchEvent(new MouseEvent('mouseup', {bubbles: true, cancelable: true}));
-                            el.dispatchEvent(new MouseEvent('click', {bubbles: true, cancelable: true}));
-                            return 'clicked:button:' + text;
-                        }
-                    }
-                    for (const el of document.querySelectorAll('div, span')) {
-                        const text = (el.textContent || '').trim();
-                        if (text === '发布' && el.offsetParent !== null) {
-                            el.dispatchEvent(new MouseEvent('mousedown', {bubbles: true, cancelable: true}));
-                            el.dispatchEvent(new MouseEvent('mouseup', {bubbles: true, cancelable: true}));
-                            el.dispatchEvent(new MouseEvent('click', {bubbles: true, cancelable: true}));
-                            return 'clicked:' + el.tagName + ':' + text;
-                        }
-                    }
-                    return 'not_found';
-                }''')
-                log(_kwargs(step='publish_click', result=clicked))
+                from media_agent.runtime.publish_control import click_publish_once
+                clicked = click_publish_once(page)
+                if not clicked:
+                    confirmation_used = False
+                    ledger_entry['state'] = 'prepared'
+                    append_ledger(ledger_entry)
+                    log(_kwargs(step='publish_button_not_ready', task_id=task_id))
+                    continue
+                ledger_entry['click_count'] = 1
+                log(_kwargs(step='publish_click', result='clicked', click_count=1))
                 time.sleep(5)
 
                 # Wait for platform auto-navigation (up to 3 minutes)
@@ -834,7 +818,7 @@ def phase_prepare(profile_id, media_path, scheduled_at, title=None, description=
                         append_ledger(ledger_entry)
                         log(_kwargs(phase='prepare', step='submitted_after_poll', task_id=task_id))
                     else:
-                        ledger_entry['state'] = 'failed'
+                        ledger_entry['state'] = 'indeterminate'
                         ledger_entry['failed_at'] = now_iso()
                         ledger_entry['failed_reason'] = 'work_not_found_in_manage'
                         append_ledger(ledger_entry)
@@ -842,9 +826,11 @@ def phase_prepare(profile_id, media_path, scheduled_at, title=None, description=
                 break
 
             if clf.exists():
-                clf.unlink(missing_ok=True)
+                from media_agent.runtime.publish_control import consume_close
+                if not consume_close(clf, task_id):
+                    continue
                 log(_kwargs(phase='prepare', step='close_received', task_id=task_id))
-                ledger_entry['state'] = 'indeterminate'
+                ledger_entry['state'] = 'indeterminate' if confirmation_used else 'aborted'
                 ledger_entry['closed_at'] = now_iso()
                 append_ledger(ledger_entry)
                 break
@@ -856,7 +842,7 @@ def phase_prepare(profile_id, media_path, scheduled_at, title=None, description=
         try:
             append_ledger(_kwargs(
                 task_id=task_id, sha256=sha, path=str(path),
-                state='failed', timestamp=now_iso(),
+                state='indeterminate' if confirmation_used else 'failed', timestamp=now_iso(),
                 error=str(e)[:200], profile_id=profile_id,
             ))
         except Exception:
@@ -872,112 +858,22 @@ def phase_prepare(profile_id, media_path, scheduled_at, title=None, description=
 
 # ─── Phase: confirm-submit ───────────────────────────────────────────────────
 
-def phase_confirm_submit(profile_id):
-    """Send confirm signal to a running prepare process, or launch browser and click submit."""
-    SIGNAL_DIR.mkdir(parents=True, exist_ok=True)
-    lf = _lock_file(profile_id)
-    cf = _confirm_file(profile_id)
-
-    if lf.exists():
-        try:
-            lock_data = json.loads(lf.read_text())
-            pid = lock_data.get('pid')
-            if pid:
-                os.kill(pid, 0)
-                cf.write_text(json.dumps({
-                    'action': 'confirm',
-                    'timestamp': now_iso(),
-                }))
-                log(_kwargs(phase='confirm-submit', step='signal_sent', target_pid=pid))
-                time.sleep(10)
-                if not cf.exists():
-                    log(_kwargs(phase='confirm-submit', step='signal_consumed', status='ok'))
-                else:
-                    log(_kwargs(phase='confirm-submit', step='signal_pending', status='waiting'))
-                return
-        except (OSError, json.JSONDecodeError):
-            log(_kwargs(phase='confirm-submit', step='process_dead', action='launch_new'))
-
-    log(_kwargs(phase='confirm-submit', step='launch_browser'))
-
+def phase_confirm_submit(profile_id, task_id=None):
+    from media_agent.runtime.publish_control import send_confirmation
     try:
-        ctx, cfg = launch_browser(profile_id)
-        page = ctx.pages[0] if ctx.pages else ctx.new_page()
-    except Exception as e:
-        die(1, _kwargs(phase='confirm-submit', error='BROWSER_LAUNCH_FAILED', detail=str(e)[:200]))
-
-    try:
-        page.goto(UPLOAD_URL, wait_until='load', timeout=60000)
-        time.sleep(5)
-
-        current_url = page.url
-        if 'login' in current_url.lower() or 'passport' in current_url.lower():
-            ctx.close()
-            die(2, _kwargs(phase='confirm-submit', error='LOGIN_REQUIRED', current_url=current_url[:120]))
-
-        time.sleep(3)
-        inspect = page.evaluate('''() => {
-            const buttons = [];
-            for (const el of document.querySelectorAll('button, div[role="button"], span')) {
-                const text = (el.textContent || '').trim();
-                if ((text === '发布' || text.includes('发布') || text === '提交') && el.offsetParent !== null) {
-                    const rect = el.getBoundingClientRect();
-                    buttons.push({
-                        text: text.substring(0, 20),
-                        tag: el.tagName,
-                        bounds: {x: Math.round(rect.x), y: Math.round(rect.y),
-                                 w: Math.round(rect.width), h: Math.round(rect.height)},
-                    });
-                }
-            }
-            return {button_count: buttons.length, buttons: buttons.slice(0, 5)};
-        }''')
-        log(_kwargs(step='inspect', **inspect))
-
-        if inspect.get('button_count', 0) == 0:
-            log(_kwargs(step='no_publish_button', warning='Upload page may not have a prepared video. Run prepare first.'))
-
-        clicked = page.evaluate('''() => {
-            for (const el of document.querySelectorAll('button, div, span')) {
-                const text = (el.textContent || '').trim();
-                if ((text === '发布' || text === '确认发布' || text === '提交') &&
-                    el.offsetParent !== null) {
-                    el.click();
-                    return 'clicked:' + text;
-                }
-            }
-            return 'not_found';
-        }''')
-        log(_kwargs(step='publish_click', result=clicked))
-        time.sleep(5)
-
-        url_after = page.url
-        log(_kwargs(step='post_submit', url=url_after[:120], title=page.title()))
-
-        entries = load_ledger()
-        if entries:
-            latest = entries[-1]
-            latest['state'] = 'submitted'
-            latest['submitted_at'] = now_iso()
-            append_ledger(latest)
-            log(_kwargs(step='ledger_updated', task_id=latest.get('task_id')))
-
-    except Exception as e:
-        log(_kwargs(phase='confirm-submit', error=str(e)[:300]))
-    finally:
-        try:
-            ctx.close()
-        except Exception:
-            pass
-        release_lock(profile_id)
-        log(_kwargs(phase='confirm-submit', step='browser_closed'))
+        send_confirmation(_lock_file(profile_id), _confirm_file(profile_id),
+                          load_ledger(), profile_id, task_id)
+    except ValueError as exc:
+        die(1, _kwargs(phase='confirm-submit', error=str(exc)))
+    log(_kwargs(phase='confirm-submit', step='signal_sent', task_id=task_id,
+                status='pending', hint='Query task status; a signal is not a publication result'))
 
 
 # ─── Phase: status ───────────────────────────────────────────────────────────
 
 def phase_status(profile_id, task_id=None):
     """Query publish status from the ledger."""
-    entries = load_ledger()
+    entries = [e for e in load_ledger() if e.get('profile_id') == profile_id]
 
     if task_id:
         matching = [e for e in entries if e.get('task_id') == task_id]
@@ -1019,61 +915,12 @@ def phase_status(profile_id, task_id=None):
 # ─── Phase: close ────────────────────────────────────────────────────────────
 
 def phase_close(profile_id):
-    """Close the browser and release the lock."""
-    SIGNAL_DIR.mkdir(parents=True, exist_ok=True)
-    lf = _lock_file(profile_id)
-    clf = _close_file(profile_id)
-
-    result = _kwargs(phase='close', action='none')
-
-    if lf.exists():
-        try:
-            lock_data = json.loads(lf.read_text())
-            pid = lock_data.get('pid')
-            if pid:
-                try:
-                    os.kill(pid, 0)
-                    clf.write_text(json.dumps({
-                        'action': 'close',
-                        'timestamp': now_iso(),
-                    }))
-                    result['action'] = 'signal_sent'
-                    result['pid'] = pid
-                    log(result)
-
-                    for _ in range(15):
-                        time.sleep(2)
-                        if not lf.exists():
-                            result['lock_released'] = True
-                            break
-                        try:
-                            os.kill(pid, 0)
-                        except OSError:
-                            result['lock_released'] = True
-                            release_lock(profile_id)
-                            break
-
-                    if not result.get('lock_released'):
-                        try:
-                            os.kill(pid, signal.SIGTERM)
-                            time.sleep(2)
-                        except OSError:
-                            pass
-                        release_lock(profile_id)
-                        result['action'] = 'force_killed'
-                        result['lock_released'] = True
-
-                    log(result)
-                    return
-                except OSError:
-                    pass
-        except (json.JSONDecodeError, ValueError):
-            pass
-
-    release_lock(profile_id)
-    result['action'] = 'lock_released'
-    result['lock_released'] = True
-    log(result)
+    from media_agent.runtime.publish_control import request_close
+    try:
+        request_close(_lock_file(profile_id), _close_file(profile_id))
+    except ValueError as exc:
+        die(1, _kwargs(phase='close', error=str(exc), lock_released=False))
+    log(_kwargs(phase='close', action='signal_sent', lock_released=False))
 
 
 # ─── CLI ─────────────────────────────────────────────────────────────────────
@@ -1101,7 +948,7 @@ Examples:
     parser.add_argument('--media-path', help='Path to media file (required for --dry-run, --prepare)')
     parser.add_argument('--scheduled-at', help=f'Scheduled publish time (default: {DEFAULT_SCHEDULED_AT})')
     parser.add_argument('--task-id', default=None, help='Task ID for status query')
-    parser.add_argument('--profile-id', default=DEFAULT_PROFILE_ID, help='Profile ID')
+    parser.add_argument('--profile-id', required=True, help='Profile ID')
     parser.add_argument('--title', default=None, help='Video title')
     parser.add_argument('--description', default=None, help='Video description')
     args = parser.parse_args()
@@ -1118,7 +965,7 @@ Examples:
         phase_prepare(profile_id, args.media_path, args.scheduled_at, args.title, args.description)
 
     elif args.confirm_submit:
-        phase_confirm_submit(profile_id)
+        phase_confirm_submit(profile_id, args.task_id)
 
     elif args.status:
         phase_status(profile_id, args.task_id)

package/src/media_agent/platforms/douyin/enterprise_login.py

@@ -23,17 +23,12 @@ def main():
     SCREENSHOTS_DIR.mkdir(parents=True, exist_ok=True)
 
     # ===== Lock =====
-    LOCK_FILE.parent.mkdir(parents=True, exist_ok=True)
-    if LOCK_FILE.exists():
-        try:
-            d = json.loads(LOCK_FILE.read_text()); pid = d.get('pid')
-            if pid:
-                try: os.kill(pid, 0); print(f'STATUS|PROFILE_LOCKED|pid={pid}', flush=True); sys.exit(3)
-                except OSError: LOCK_FILE.unlink()
-        except: LOCK_FILE.unlink()
-
     TASK_ID = f'login_{SITE}_{ALIAS}_{datetime.now().strftime("%Y%m%d_%H%M%S")}'
-    LOCK_FILE.write_text(json.dumps({'task_id': TASK_ID, 'locked_at': datetime.now(timezone.utc).isoformat(), 'pid': os.getpid(), 'site': SITE}, indent=2))
+    from media_agent.runtime.locking import acquire, release
+    if not acquire(LOCK_FILE, TASK_ID):
+        print('PROFILE_LOCKED')
+        raise SystemExit(3)
+
     print(f'LOCK|acquired|{TASK_ID}', flush=True)
 
     # ===== Launch =====
@@ -120,7 +115,7 @@ def main():
     # Close
     ctx.close()
     print('CLOSED', flush=True)
-    LOCK_FILE.unlink(missing_ok=True)
+    release(LOCK_FILE, TASK_ID)
     print('LOCK_RELEASED', flush=True)
     print('DONE', flush=True)
 

package/src/media_agent/platforms/douyin/export_short_video.py

@@ -1,6 +1,15 @@
 """Legacy operation, executed only through main()."""
 
 def main():
+    import json
+    import sys
+    print(json.dumps({'state': 'IMPLEMENTATION_REQUIRED',
+                      'operation': 'export_short_video',
+                      'reason': 'Legacy browser flow cannot yet verify all requested parameters; use the documented Skill workflow.'}))
+    raise SystemExit(6)
+
+
+def _legacy_reference():
     #!/usr/bin/env python3
     """Export short video detail data. Usage: python3 export_short_video.py <profile_id> <date>"""
     from media_agent.runtime.paths import runtime_home
@@ -22,7 +31,7 @@ def main():
         try:
             os.kill(json.loads(LOCK_FILE.read_text()).get('pid', 0), 0)
             print('PROFILE_LOCKED'); sys.exit(3)
-        except:
+        except Exception:
             LOCK_FILE.unlink()
     LOCK_FILE.write_text(json.dumps({'task_id': 'export-short-video', 'pid': os.getpid()}, indent=2))
 

package/src/media_agent/platforms/douyin/login_controller.py

@@ -33,23 +33,12 @@ class LoginController:
         self._resp_queues = {}
 
     def acquire_lock(self):
-        self.lock_file.parent.mkdir(parents=True, exist_ok=True)
-        if self.lock_file.exists():
-            try:
-                old = json.loads(self.lock_file.read_text())
-                os.kill(old.get('pid', 0), 0)
-                return False
-            except (OSError, json.JSONDecodeError):
-                self.lock_file.unlink()
-        self.lock_file.write_text(json.dumps({
-            'task_id': self.task_id, 'pid': self.controller_pid,
-            'time': datetime.now().isoformat(), 'controller': True
-        }, indent=2))
-        return True
+        from media_agent.runtime.locking import acquire
+        return acquire(self.lock_file, self.task_id, controller=True)
 
     def release_lock(self):
-        if self.lock_file.exists():
-            self.lock_file.unlink()
+        from media_agent.runtime.locking import release
+        return release(self.lock_file, self.task_id)
 
     def launch_browser(self):
         cfg = json.loads((self.profile_dir / 'config.json').read_text())

package/src/media_agent/platforms/toutiao/toutiao_login_controller.py

@@ -65,30 +65,12 @@ class ToutiaoLoginController:
             return False
 
     def acquire_lock(self) -> bool:
-        self.lock_path.parent.mkdir(parents=True, exist_ok=True)
-        if self.lock_path.exists():
-            try:
-                current = json.loads(self.lock_path.read_text())
-            except (OSError, json.JSONDecodeError):
-                return False
-            if self._alive(current.get("pid")):
-                return False
-            self.lock_path.unlink()
-        self.lock_path.write_text(json.dumps({"pid": self.pid, "task_id": self.task_id,
-                                              "created_at": datetime.now(timezone.utc).isoformat()}))
-        return True
+        from media_agent.runtime.locking import acquire
+        return acquire(self.lock_path, self.task_id, controller=True)
 
     def release_owned_lock(self) -> bool:
-        if not self.lock_path.exists():
-            return True
-        try:
-            current = json.loads(self.lock_path.read_text())
-        except (OSError, json.JSONDecodeError):
-            return False
-        if current.get("pid") != self.pid or current.get("task_id") != self.task_id:
-            return False
-        self.lock_path.unlink()
-        return True
+        from media_agent.runtime.locking import release
+        return release(self.lock_path, self.task_id)
 
     def launch(self, config: dict) -> None:
         if self.launcher is None:

package/src/media_agent/platforms/xiaohongshu/xiaohongshu_check_login.py

@@ -23,15 +23,12 @@ def main():
     cfg = json.loads((PROFILE_DIR / 'config.json').read_text())
     state = json.loads((PROFILE_DIR / 'state.json').read_text()) if (PROFILE_DIR / 'state.json').exists() else {}
 
-    LOCK_FILE.parent.mkdir(parents=True, exist_ok=True)
-    if LOCK_FILE.exists():
-        try:
-            os.kill(json.loads(LOCK_FILE.read_text()).get('pid', 0), 0)
-            print(json.dumps({'profile_id': ALIAS, 'login_status': 'locked', 'lock_status': 'locked'}, indent=2))
-            sys.exit(3)
-        except:
-            LOCK_FILE.unlink()
-    LOCK_FILE.write_text(json.dumps({'task_id': 'xhs-check-login', 'pid': os.getpid(), 'time': datetime.now().isoformat()}, indent=2))
+    TASK_ID = 'xhs-check-login'
+    from media_agent.runtime.locking import acquire, release
+    if not acquire(LOCK_FILE, TASK_ID):
+        print('PROFILE_LOCKED')
+        raise SystemExit(3)
+
 
     ctx = None
     try:
@@ -143,7 +140,7 @@ def main():
         dashboard = status == 'logged_in' or dom['dashboard_detected']
 
         ctx.close()
-        LOCK_FILE.unlink(missing_ok=True)
+        release(LOCK_FILE, TASK_ID)
 
         # Update state
         site_state = state.setdefault('xiaohongshu', {})
@@ -180,7 +177,7 @@ def main():
                 ctx.close()
         except Exception:
             pass
-        LOCK_FILE.unlink(missing_ok=True)
+        release(LOCK_FILE, TASK_ID)
         print(json.dumps({'profile_id': ALIAS, 'login_status': 'check_failed', 'error': str(e)[:100]}, indent=2))
         sys.exit(1)
 

package/src/media_agent/platforms/xiaohongshu/xiaohongshu_login_controller.py

@@ -68,25 +68,13 @@ def process_alive(pid):
         raise
 
 def acquire_lock():
-    if LOCK_FILE.exists():
-        try:
-            old = json.loads(LOCK_FILE.read_text())
-        except (OSError, json.JSONDecodeError):
-            return False
-        if process_alive(old.get('pid')):
-            return False
-        try:
-            LOCK_FILE.unlink()
-        except OSError:
-            return False
-    LOCK_FILE.write_text(json.dumps({'pid': os.getpid(), 'time': now_iso(), 'task_id': task_id}))
-    return True
+    from media_agent.runtime.locking import acquire
+    return acquire(LOCK_FILE, task_id, controller=True)
+
 
 def release_lock():
-    try:
-        LOCK_FILE.unlink(missing_ok=True)
-    except:
-        pass
+    from media_agent.runtime.locking import release
+    return release(LOCK_FILE, task_id)
 
 def check_logged_in():
     """Check if current page shows dashboard."""